feat: add DatabaseMaintenanceService (clear all rows, keep schema)

Author: HandyS11

src/RustPlusBot.Persistence/Maintenance/DatabaseMaintenanceService.cs

@@ -0,0 +1,51 @@
+using System.Globalization;
+using Microsoft.EntityFrameworkCore;
+
+namespace RustPlusBot.Persistence.Maintenance;
+
+/// <summary>Clears every table's rows while keeping the schema (a live-safe "factory reset").</summary>
+/// <param name="context">The bot database context.</param>
+public sealed class DatabaseMaintenanceService(BotDbContext context) : IDatabaseMaintenanceService
+{
+    /// <inheritdoc />
+    public async Task ClearAllAsync(CancellationToken cancellationToken = default)
+    {
+        var tables = context.Model.GetEntityTypes()
+            .Select(t => t.GetTableName())
+            .Where(name => !string.IsNullOrEmpty(name))
+            .Distinct(StringComparer.Ordinal)
+            .ToList();
+
+        // Keep one connection open across every statement so the FK pragma persists
+        // (with per-statement connections the pragma would reset before the DELETEs).
+        await context.Database.OpenConnectionAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            await context.Database.ExecuteSqlRawAsync("PRAGMA foreign_keys = OFF", cancellationToken)
+                .ConfigureAwait(false);
+
+            foreach (var table in tables)
+            {
+                // Table names come from the EF model (never user input); the identifier guard keeps
+                // the raw statement demonstrably injection-safe for the Sonar gate.
+                if (!IsSafeIdentifier(table!))
+                {
+                    continue;
+                }
+
+                var sql = string.Create(CultureInfo.InvariantCulture, $"DELETE FROM \"{table}\"");
+                await context.Database.ExecuteSqlRawAsync(sql, cancellationToken).ConfigureAwait(false);
+            }
+
+            await context.Database.ExecuteSqlRawAsync("PRAGMA foreign_keys = ON", cancellationToken)
+                .ConfigureAwait(false);
+        }
+        finally
+        {
+            await context.Database.CloseConnectionAsync().ConfigureAwait(false);
+        }
+    }
+
+    private static bool IsSafeIdentifier(string identifier) =>
+        identifier.All(c => char.IsLetterOrDigit(c) || c == '_');
+}

src/RustPlusBot.Persistence/Maintenance/IDatabaseMaintenanceService.cs

@@ -0,0 +1,10 @@
+namespace RustPlusBot.Persistence.Maintenance;
+
+/// <summary>Database-wide maintenance operations.</summary>
+public interface IDatabaseMaintenanceService
+{
+    /// <summary>Deletes every row in every table across all guilds, preserving the schema.</summary>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when all rows have been deleted.</returns>
+    Task ClearAllAsync(CancellationToken cancellationToken = default);
+}

src/RustPlusBot.Persistence/PersistenceServiceCollectionExtensions.cs

@@ -5,6 +5,7 @@
 using RustPlusBot.Persistence.Commands;
 using RustPlusBot.Persistence.Connections;
 using RustPlusBot.Persistence.Credentials;
+using RustPlusBot.Persistence.Maintenance;
 using RustPlusBot.Persistence.Map;
 using RustPlusBot.Persistence.Servers;
 using RustPlusBot.Persistence.StorageMonitors;
@@ -34,6 +35,7 @@ public static IServiceCollection AddBotPersistence(this IServiceCollection servi
             sp.GetRequiredService<IDbContextFactory<BotDbContext>>().CreateDbContext());
 
         services.AddScoped<IServerService, ServerService>();
+        services.AddScoped<IDatabaseMaintenanceService, DatabaseMaintenanceService>();
         services.AddScoped<ICredentialStore, CredentialStore>();
         services.AddScoped<IFcmRegistrationStore, FcmRegistrationStore>();
         services.AddScoped<IWorkspaceStore, WorkspaceStore>();

tests/RustPlusBot.Persistence.Tests/Maintenance/DatabaseMaintenanceServiceTests.cs

@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore;
+using RustPlusBot.Domain.Guilds;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Persistence.Maintenance;
+
+namespace RustPlusBot.Persistence.Tests.Maintenance;
+
+public sealed class DatabaseMaintenanceServiceTests
+{
+    [Fact]
+    public async Task ClearAllAsync_EmptiesEveryTable_AndKeepsSchema()
+    {
+        var (context, connection) = SqliteContextFixture.Create();
+        await using var _ = context;
+        await using var __ = connection;
+
+        context.RustServers.Add(new RustServer
+        {
+            GuildId = 1, Name = "A", Ip = "a", Port = 1
+        });
+        context.RustServers.Add(new RustServer
+        {
+            GuildId = 2, Name = "B", Ip = "b", Port = 2
+        });
+        context.GuildSettings.Add(new GuildSettings
+        {
+            GuildId = 1, Culture = "en"
+        });
+        context.GuildSettings.Add(new GuildSettings
+        {
+            GuildId = 2, Culture = "fr"
+        });
+        await context.SaveChangesAsync();
+
+        var service = new DatabaseMaintenanceService(context);
+        await service.ClearAllAsync();
+
+        Assert.Empty(await context.RustServers.ToListAsync());
+        Assert.Empty(await context.GuildSettings.ToListAsync());
+
+        // Schema still exists: a fresh insert succeeds.
+        context.GuildSettings.Add(new GuildSettings
+        {
+            GuildId = 3, Culture = "en"
+        });
+        await context.SaveChangesAsync();
+        Assert.Single(await context.GuildSettings.ToListAsync());
+    }
+}