feat(cli): d4fdbbfad4a53b5b711696b7f30034c3c478e7c6

Author: serverpod_cloud

ground_control_client/lib/src/protocol/client.dart

@@ -683,6 +683,14 @@ class EndpointDatabase extends _i1.EndpointRef {
     'cloudCapsuleId': cloudCapsuleId,
     'username': username,
   });
+
+  /// Wipes the database by deleting and recreating it.
+  /// This will drop all tables and data in the database.
+  /// The deployment will error until a redeploy is performed.
+  _i2.Future<void> wipeDatabase({required String cloudCapsuleId}) =>
+      caller.callServerEndpoint<void>('database', 'wipeDatabase', {
+        'cloudCapsuleId': cloudCapsuleId,
+      });
 }
 
 /// Endpoint for infrastructure resource provisioning.

serverpod_cloud_cli/lib/command_runner/commands/categories.dart

@@ -2,4 +2,5 @@ abstract final class CommandCategories {
   static const String gettingStarted = 'Getting started';
   static const String manage = 'Management';
   static const String control = 'Mission Control';
+  static const String dangerZone = 'Danger Zone';
 }

serverpod_cloud_cli/lib/command_runner/commands/db_command.dart

@@ -1,5 +1,6 @@
 import 'package:config/config.dart';
 import 'package:serverpod_cloud_cli/command_runner/cloud_cli_command.dart';
+import 'package:serverpod_cloud_cli/commands/db/db.dart';
 import 'package:serverpod_cloud_cli/shared/exceptions/exit_exceptions.dart';
 import 'package:serverpod_cloud_cli/command_runner/helpers/command_options.dart';
 
@@ -18,6 +19,7 @@ class CloudDbCommand extends CloudCliCommand {
   CloudDbCommand({required super.logger}) {
     addSubcommand(CloudDbConnectionDetailsCommand(logger: logger));
     addSubcommand(CloudDbUserCommand(logger: logger));
+    addSubcommand(CloudDbWipeCommand(logger: logger));
   }
 }
 
@@ -192,3 +194,42 @@ $password''');
     }
   }
 }
+
+enum DbWipeOption<V> implements OptionDefinition<V> {
+  projectId(ProjectIdOption());
+
+  const DbWipeOption(this.option);
+
+  @override
+  final ConfigOptionBase<V> option;
+}
+
+class CloudDbWipeCommand extends CloudCliCommand<DbWipeOption> {
+  @override
+  final name = 'wipe';
+
+  @override
+  final description =
+      'Irreversibly wipe and recreate the database, deleting all data and schema changes.';
+
+  @override
+  String get category => CommandCategories.dangerZone;
+
+  CloudDbWipeCommand({required super.logger})
+    : super(options: DbWipeOption.values);
+
+  @override
+  Future<void> runWithConfig(
+    final Configuration<DbWipeOption> commandConfig,
+  ) async {
+    final projectId = commandConfig.value(DbWipeOption.projectId);
+    final skipConfirmation = globalConfiguration.skipConfirmation;
+
+    await DbCommands.wipeDatabase(
+      runner.serviceProvider.cloudApiClient,
+      logger: logger,
+      projectId: projectId,
+      skipConfirmation: skipConfirmation,
+    );
+  }
+}

serverpod_cloud_cli/lib/commands/db/db.dart

@@ -0,0 +1,44 @@
+import 'package:ground_control_client/ground_control_client.dart';
+import 'package:serverpod_cloud_cli/command_logger/command_logger.dart';
+import 'package:serverpod_cloud_cli/shared/exceptions/exit_exceptions.dart';
+
+abstract class DbCommands {
+  static Future<void> wipeDatabase(
+    final Client cloudApiClient, {
+    required final CommandLogger logger,
+    required final String projectId,
+    required final bool skipConfirmation,
+  }) async {
+    if (!skipConfirmation) {
+      final confirmed = await logger.confirm('''
+WARNING: Deletes all tables and data in the database for project "$projectId".
+This is a NON-REVERSIBLE action.
+The server will error until a redeploy is performed.
+
+Do you want to proceed?''', defaultValue: false);
+
+      if (!confirmed) {
+        logger.info('Database wipe cancelled.');
+        return;
+      }
+    }
+
+    final apiCloudClient = cloudApiClient;
+
+    try {
+      await logger.progress(
+        'Wiping database for project "$projectId"...',
+        newParagraph: true,
+        () async {
+          await apiCloudClient.database.wipeDatabase(cloudCapsuleId: projectId);
+          return true;
+        },
+      );
+
+      logger.success('Database wiped successfully.');
+      logger.info('Redeploy is needed, run: scloud deploy');
+    } on Exception catch (e, stackTrace) {
+      throw FailureException.nested(e, stackTrace, 'Failed to wipe database');
+    }
+  }
+}

serverpod_cloud_cli/test_integration/commands/db_command/db_command_test.dart

@@ -53,6 +53,10 @@ void main() {
     },
   );
 
+  test('Given db wipe command when instantiated then requires login', () {
+    expect(CloudDbWipeCommand(logger: logger).requireLogin, isTrue);
+  });
+
   group('Given unauthenticated', () {
     group('when executing db connection', () {
       setUpAll(() {
@@ -183,6 +187,50 @@ void main() {
         );
       });
     });
+
+    group('when executing db wipe', () {
+      setUpAll(() {
+        when(
+          () => client.database.wipeDatabase(
+            cloudCapsuleId: any(named: 'cloudCapsuleId'),
+          ),
+        ).thenThrow(ServerpodClientUnauthorized());
+      });
+
+      tearDownAll(() {
+        reset(client.database);
+      });
+
+      late Future commandResult;
+      setUp(() {
+        commandResult = cli.run([
+          'db',
+          'wipe',
+          '--project',
+          projectId,
+          '--yes',
+        ]);
+      });
+
+      test('then throws exception', () async {
+        await expectLater(commandResult, throwsA(isA<ExitException>()));
+      });
+
+      test('then logs error', () async {
+        try {
+          await commandResult;
+        } catch (_) {}
+
+        expect(logger.errorCalls, isNotEmpty);
+        expect(
+          logger.errorCalls.first,
+          equalsErrorCall(
+            message:
+                'The credentials for this session seem to no longer be valid.',
+          ),
+        );
+      });
+    });
   });
 
   group('Given authenticated', () {
@@ -330,5 +378,152 @@ DB password is reset. The new password is only shown this once:
 $password''');
       });
     });
+
+    group('when executing db wipe with --yes', () {
+      setUpAll(() {
+        when(
+          () => client.database.wipeDatabase(
+            cloudCapsuleId: any(named: 'cloudCapsuleId'),
+          ),
+        ).thenAnswer((final _) async => Future.value());
+      });
+
+      tearDownAll(() {
+        reset(client.database);
+      });
+
+      late Future commandResult;
+      setUp(() {
+        commandResult = cli.run([
+          'db',
+          'wipe',
+          '--project',
+          projectId,
+          '--yes',
+        ]);
+      });
+
+      tearDown(() {
+        // Reset mock call count between tests in this group
+        clearInteractions(client.database);
+      });
+
+      test('then succeeds', () async {
+        await expectLater(commandResult, completes);
+      });
+
+      test('then outputs success message', () async {
+        await commandResult;
+
+        expect(logger.successCalls, isNotEmpty);
+        expect(
+          logger.successCalls.single.message,
+          contains('Database wiped successfully.'),
+        );
+        expect(
+          logger.infoCalls.single.message,
+          contains('Redeploy is needed, run: scloud deploy'),
+        );
+      });
+
+      test('then calls wipeDatabase on client', () async {
+        await commandResult;
+
+        verify(
+          () => client.database.wipeDatabase(cloudCapsuleId: projectId),
+        ).called(1);
+      });
+    });
+
+    group('when executing db wipe without --yes', () {
+      setUpAll(() {
+        when(
+          () => client.database.wipeDatabase(
+            cloudCapsuleId: any(named: 'cloudCapsuleId'),
+          ),
+        ).thenAnswer((final _) async => Future.value());
+      });
+
+      tearDownAll(() {
+        reset(client.database);
+      });
+
+      group('and user confirms', () {
+        late Future commandResult;
+        setUp(() {
+          logger.answerNextConfirmWith(true);
+          commandResult = cli.run(['db', 'wipe', '--project', projectId]);
+        });
+
+        tearDown(() {
+          // Reset mock call count between tests in this group
+          clearInteractions(client.database);
+        });
+
+        test('then succeeds', () async {
+          await expectLater(commandResult, completes);
+        });
+
+        test('then prompts for confirmation', () async {
+          await commandResult;
+
+          expect(logger.confirmCalls, isNotEmpty);
+          expect(
+            logger.confirmCalls.first.message,
+            contains('Do you want to proceed?'),
+          );
+        });
+
+        test('then calls wipeDatabase on client', () async {
+          await commandResult;
+
+          verify(
+            () => client.database.wipeDatabase(cloudCapsuleId: projectId),
+          ).called(1);
+        });
+      });
+
+      group('and user declines', () {
+        late Future commandResult;
+        setUp(() {
+          logger.answerNextConfirmWith(false);
+          commandResult = cli.run(['db', 'wipe', '--project', projectId]);
+        });
+
+        test('then succeeds without wiping', () async {
+          await expectLater(commandResult, completes);
+        });
+
+        test('then prompts for confirmation', () async {
+          await commandResult;
+
+          expect(logger.confirmCalls, isNotEmpty);
+          expect(
+            logger.confirmCalls.first.message,
+            contains('Do you want to proceed?'),
+          );
+        });
+
+        test('then does not call wipeDatabase on client', () async {
+          await commandResult;
+
+          verifyNever(
+            () => client.database.wipeDatabase(cloudCapsuleId: projectId),
+          );
+        });
+
+        test('then logs cancellation message', () async {
+          await commandResult;
+
+          expect(logger.infoCalls, isNotEmpty);
+          expect(
+            logger.infoCalls.any(
+              (final call) => call.message.contains('Database wipe cancelled.'),
+            ),
+            isTrue,
+          );
+        });
+      });
+    });
   });
 }