@njdamstra/appwrite-utils-cli 1.8.9

package/src/cli/commands/databaseCommands.ts

@@ -0,0 +1,749 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { join } from "node:path";
+import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
+import { SelectionDialogs } from "../../shared/selectionDialogs.js";
+import type { DatabaseSelection, BucketSelection } from "../../shared/selectionDialogs.js";
+import { logger } from "../../shared/logging.js";
+import { fetchAllDatabases } from "../../databases/methods.js";
+import { listBuckets } from "../../storage/methods.js";
+import { getFunction, downloadLatestFunctionDeployment } from "../../functions/methods.js";
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+
+export const databaseCommands = {
+  async syncDb(cli: InteractiveCLI): Promise<void> {
+    MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
+
+    try {
+      // Initialize controller
+      await (cli as any).controller!.init();
+
+      // Get available and configured databases
+      const availableDatabases = await fetchAllDatabases((cli as any).controller!.database!);
+      const configuredDatabases = (cli as any).controller!.config?.databases || [];
+
+      // Get local collections for selection
+      const localCollections = (cli as any).getLocalCollections();
+
+      // Push operations always use local configuration as source of truth
+
+      // Select databases
+      const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+        availableDatabases,
+        configuredDatabases,
+        { showSelectAll: false, allowNewOnly: false, defaultSelected: [] }
+      );
+
+      if (selectedDatabaseIds.length === 0) {
+        MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
+        return;
+      }
+
+      // Select tables/collections for each database using the existing method
+      const tableSelectionsMap = new Map<string, string[]>();
+      const availableTablesMap = new Map<string, any[]>();
+
+      for (const databaseId of selectedDatabaseIds) {
+        const database = availableDatabases.find(db => db.$id === databaseId)!;
+
+        // Use the existing selectCollectionsAndTables method
+        const selectedCollections = await (cli as any).selectCollectionsAndTables(
+          database,
+          (cli as any).controller!.database!,
+          chalk.blue(`Select collections/tables to push to "${database.name}":`),
+          true,  // multiSelect
+          true,  // prefer local
+          true   // shouldFilterByDatabase
+        );
+
+        // Map selected collections to table IDs
+        const selectedTableIds = selectedCollections.map((c: any) => c.$id || c.id);
+
+        // Store selections
+        tableSelectionsMap.set(databaseId, selectedTableIds);
+        availableTablesMap.set(databaseId, selectedCollections);
+
+        if (selectedCollections.length === 0) {
+          MessageFormatter.warning(`No collections selected for database "${database.name}". Skipping.`, { prefix: "Database" });
+          continue;
+        }
+      }
+
+      // Ask if user wants to select buckets
+      const { selectBuckets } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "selectBuckets",
+          message: "Do you want to select storage buckets to sync as well?",
+          default: false,
+        },
+      ]);
+
+      let bucketSelections: BucketSelection[] = [];
+
+      if (selectBuckets) {
+        // Get available and configured buckets
+        try {
+          const availableBucketsResponse = await listBuckets((cli as any).controller!.storage!);
+          const availableBuckets = availableBucketsResponse.buckets || [];
+          const configuredBuckets = (cli as any).controller!.config?.buckets || [];
+
+          if (availableBuckets.length === 0) {
+            MessageFormatter.warning("No storage buckets available in remote instance.", { prefix: "Database" });
+          } else {
+            // Select buckets using SelectionDialogs
+            const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+              selectedDatabaseIds,
+              availableBuckets,
+              configuredBuckets,
+              { showSelectAll: false, groupByDatabase: true, defaultSelected: [] }
+            );
+
+            if (selectedBucketIds.length > 0) {
+              // Create BucketSelection objects
+              bucketSelections = SelectionDialogs.createBucketSelection(
+                selectedBucketIds,
+                availableBuckets,
+                configuredBuckets,
+                availableDatabases
+              );
+
+              MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Database" });
+            }
+          }
+        } catch (error) {
+          MessageFormatter.warning("Failed to fetch storage buckets. Continuing with databases only.", { prefix: "Database" });
+          logger.warn("Storage bucket fetch failed during syncDb", { error: error instanceof Error ? error.message : String(error) });
+        }
+      }
+
+      // Create DatabaseSelection objects
+      const databaseSelections = SelectionDialogs.createDatabaseSelection(
+        selectedDatabaseIds,
+        availableDatabases,
+        tableSelectionsMap,
+        configuredDatabases,
+        availableTablesMap
+      );
+
+      // Show confirmation summary
+      const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+        databaseSelections,
+        bucketSelections
+      );
+
+      const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'push');
+
+      if (!confirmed) {
+        MessageFormatter.info("Push operation cancelled by user", { prefix: "Database" });
+        return;
+      }
+
+      // Perform selective push using the controller
+      MessageFormatter.progress("Starting selective push...", { prefix: "Database" });
+      await (cli as any).controller!.selectivePush(databaseSelections, bucketSelections);
+
+      MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
+
+      // Then handle functions if requested
+      const { syncFunctions } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "syncFunctions",
+          message: "Do you want to push local functions to remote?",
+          default: false,
+        },
+      ]);
+
+      if (syncFunctions && (cli as any).controller!.config?.functions?.length) {
+        const functions = await (cli as any).selectFunctions(
+          chalk.blue("Select local functions to push:"),
+          true,
+          true // prefer local
+        );
+
+        for (const func of functions) {
+          try {
+            await (cli as any).controller!.deployFunction(func.name);
+            MessageFormatter.success(`Function ${func.name} deployed successfully`, { prefix: "Functions" });
+          } catch (error) {
+            MessageFormatter.error(`Failed to deploy function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+          }
+        }
+      }
+
+      MessageFormatter.success("Local configuration push completed successfully!", { prefix: "Database" });
+    } catch (error) {
+      MessageFormatter.error("Failed to push local configuration", error instanceof Error ? error : new Error(String(error)), { prefix: "Database" });
+      throw error;
+    }
+  },
+
+  async synchronizeConfigurations(cli: InteractiveCLI): Promise<void> {
+    MessageFormatter.progress("Synchronizing configurations...", { prefix: "Config" });
+    await (cli as any).controller!.init();
+
+    // Sync databases, collections, and buckets
+    const { syncDatabases } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "syncDatabases",
+        message: "Do you want to synchronize databases, collections, and their buckets?",
+        default: true,
+      },
+    ]);
+
+    if (syncDatabases) {
+      const remoteDatabases = await fetchAllDatabases(
+        (cli as any).controller!.database!
+      );
+
+      // First, prepare the combined database list for bucket configuration
+      const localDatabases = (cli as any).controller!.config?.databases || [];
+      const allDatabases = [
+        ...localDatabases,
+        ...remoteDatabases.filter(
+          (rd: any) => !localDatabases.some((ld: any) => ld.name === rd.name)
+        ),
+      ];
+
+      // Configure buckets FIRST to get user selections before writing config
+      MessageFormatter.progress("Configuring storage buckets...", { prefix: "Buckets" });
+      const configWithBuckets = await (cli as any).configureBuckets({
+        ...(cli as any).controller!.config!,
+        databases: allDatabases,
+      });
+
+      // Update controller config with bucket selections
+      (cli as any).controller!.config = configWithBuckets;
+
+      // Now synchronize configurations with the updated config that includes bucket selections
+      MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
+      await (cli as any).controller!.synchronizeConfigurations(remoteDatabases, configWithBuckets);
+    }
+
+    // Then sync functions
+    const { syncFunctions } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "syncFunctions",
+        message: "Do you want to synchronize functions?",
+        default: true,
+      },
+    ]);
+
+    if (syncFunctions) {
+      const remoteFunctions = await (cli as any).controller!.listAllFunctions();
+      const localFunctions = (cli as any).controller!.config?.functions || [];
+
+      const allFunctions = [
+        ...remoteFunctions,
+        ...localFunctions.filter(
+          (f: any) => !remoteFunctions.some((rf: any) => rf.$id === f.$id)
+        ),
+      ];
+
+      for (const func of allFunctions) {
+        const hasLocal = localFunctions.some((lf: any) => lf.$id === func.$id);
+        const hasRemote = remoteFunctions.some((rf: any) => rf.$id === func.$id);
+
+        if (hasLocal && hasRemote) {
+          // Function exists in both local and remote
+          const { preference } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "preference",
+              message: `Function "${func.name}" exists both locally and remotely. What would you like to do?`,
+              choices: [
+                { name: "Keep local version (deploy to remote)", value: "local" },
+                { name: "Use remote version (download)", value: "remote" },
+                { name: "Update config only", value: "config" },
+                { name: "Skip this function", value: "skip" },
+              ],
+            },
+          ]);
+
+          if (preference === "local") {
+            await (cli as any).controller!.deployFunction(func.name);
+          } else if (preference === "remote") {
+            await downloadLatestFunctionDeployment(
+              (cli as any).controller!.appwriteServer!,
+              func.$id,
+              join((cli as any).controller!.getAppwriteFolderPath()!, "functions")
+            );
+          } else if (preference === "config") {
+            // Update config with remote function details
+            const remoteFunction = await getFunction(
+              (cli as any).controller!.appwriteServer!,
+              func.$id
+            );
+
+            const newFunction = {
+              $id: remoteFunction.$id,
+              name: remoteFunction.name,
+              runtime: remoteFunction.runtime,
+              execute: remoteFunction.execute || [],
+              events: remoteFunction.events || [],
+              schedule: remoteFunction.schedule || "",
+              timeout: remoteFunction.timeout || 15,
+              enabled: remoteFunction.enabled !== false,
+              logging: remoteFunction.logging !== false,
+              entrypoint: remoteFunction.entrypoint || "src/index.ts",
+              commands: remoteFunction.commands || "npm install",
+              scopes: remoteFunction.scopes || [],
+              installationId: remoteFunction.installationId,
+              providerRepositoryId: remoteFunction.providerRepositoryId,
+              providerBranch: remoteFunction.providerBranch,
+              providerSilentMode: remoteFunction.providerSilentMode,
+              providerRootDirectory: remoteFunction.providerRootDirectory,
+              specification: remoteFunction.specification,
+            };
+
+            const existingIndex = (cli as any).controller!.config!.functions!.findIndex(
+              (f: any) => f.$id === remoteFunction.$id
+            );
+
+            if (existingIndex >= 0) {
+              (cli as any).controller!.config!.functions![existingIndex] = newFunction;
+            } else {
+              (cli as any).controller!.config!.functions!.push(newFunction);
+            }
+            MessageFormatter.success(`Updated config for function: ${func.name}`, { prefix: "Functions" });
+          }
+        } else if (hasLocal) {
+          // Function exists only locally
+          const { action } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "action",
+              message: `Function "${func.name}" exists only locally. What would you like to do?`,
+              choices: [
+                { name: "Deploy to remote", value: "deploy" },
+                { name: "Skip this function", value: "skip" },
+              ],
+            },
+          ]);
+
+          if (action === "deploy") {
+            await (cli as any).controller!.deployFunction(func.name);
+          }
+        } else if (hasRemote) {
+          // Function exists only remotely
+          const { action } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "action",
+              message: `Function "${func.name}" exists only remotely. What would you like to do?`,
+              choices: [
+                { name: "Update config only", value: "config" },
+                { name: "Download locally", value: "download" },
+                { name: "Skip this function", value: "skip" },
+              ],
+            },
+          ]);
+
+          if (action === "download") {
+            await downloadLatestFunctionDeployment(
+              (cli as any).controller!.appwriteServer!,
+              func.$id,
+              join((cli as any).controller!.getAppwriteFolderPath()!, "functions")
+            );
+          } else if (action === "config") {
+            const remoteFunction = await getFunction(
+              (cli as any).controller!.appwriteServer!,
+              func.$id
+            );
+
+            const newFunction = {
+              $id: remoteFunction.$id,
+              name: remoteFunction.name,
+              runtime: remoteFunction.runtime,
+              execute: remoteFunction.execute || [],
+              events: remoteFunction.events || [],
+              schedule: remoteFunction.schedule || "",
+              timeout: remoteFunction.timeout || 15,
+              enabled: remoteFunction.enabled !== false,
+              logging: remoteFunction.logging !== false,
+              entrypoint: remoteFunction.entrypoint || "src/index.ts",
+              commands: remoteFunction.commands || "npm install",
+              scopes: remoteFunction.scopes || [],
+              installationId: remoteFunction.installationId,
+              providerRepositoryId: remoteFunction.providerRepositoryId,
+              providerBranch: remoteFunction.providerBranch,
+              providerSilentMode: remoteFunction.providerSilentMode,
+              providerRootDirectory: remoteFunction.providerRootDirectory,
+              specification: remoteFunction.specification,
+            };
+
+            (cli as any).controller!.config!.functions =
+              (cli as any).controller!.config!.functions || [];
+            (cli as any).controller!.config!.functions.push(newFunction);
+            MessageFormatter.success(`Added config for remote function: ${func.name}`, { prefix: "Functions" });
+          }
+        }
+      }
+    }
+
+    MessageFormatter.success("✨ Configurations synchronized successfully!", { prefix: "Config" });
+  },
+
+  async backupDatabase(cli: InteractiveCLI): Promise<void> {
+    if (!(cli as any).controller!.database || !(cli as any).controller!.storage) {
+      throw new Error(
+        "Database or Storage is not initialized, is the config file correct & created?"
+      );
+    }
+
+    try {
+      // STEP 1: Select tracking database
+      MessageFormatter.info("Step 1/5: Select tracking database", { prefix: "Backup" });
+      const trackingDb = await this.selectTrackingDatabase(cli);
+
+      // STEP 2: Ensure backup tracking table exists
+      MessageFormatter.info("Step 2/5: Initializing backup tracking", { prefix: "Backup" });
+      await this.ensureBackupTrackingTable(cli, trackingDb);
+
+      // STEP 3: Select backup scope
+      MessageFormatter.info("Step 3/5: Select backup scope", { prefix: "Backup" });
+      const scope = await this.selectBackupScope(cli);
+
+      // STEP 4: Show confirmation
+      MessageFormatter.info("Step 4/5: Confirm backup plan", { prefix: "Backup" });
+      const confirmed = await this.confirmBackupPlan(scope);
+      if (!confirmed) {
+        MessageFormatter.info("Backup cancelled by user", { prefix: "Backup" });
+        return;
+      }
+
+      // STEP 5: Execute unified backup
+      MessageFormatter.info("Step 5/5: Executing backup", { prefix: "Backup" });
+      await this.executeUnifiedBackup(cli, trackingDb, scope);
+
+      MessageFormatter.success("Backup operation completed successfully", { prefix: "Backup" });
+    } catch (error) {
+      MessageFormatter.error(
+        "Backup operation failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Backup" }
+      );
+      throw error;
+    }
+  },
+
+  // Helper method: Select tracking database
+  async selectTrackingDatabase(cli: InteractiveCLI): Promise<string> {
+    const databases = await fetchAllDatabases((cli as any).controller!.database);
+
+    const { trackingDatabaseId } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "trackingDatabaseId",
+        message: "Select database to store backup metadata:",
+        choices: databases.map(db => ({
+          name: `${db.name} (${db.$id})`,
+          value: db.$id
+        }))
+      }
+    ]);
+
+    MessageFormatter.info(`Using ${trackingDatabaseId} for backup tracking`, { prefix: "Backup" });
+    return trackingDatabaseId;
+  },
+
+  // Helper method: Ensure backup tracking table exists
+  async ensureBackupTrackingTable(cli: InteractiveCLI, trackingDatabaseId: string): Promise<void> {
+    const { createCentralizedBackupTrackingTable } = await import("../../backups/tracking/centralizedTracking.js");
+    const adapter = (cli as any).controller!.adapter;
+
+    await createCentralizedBackupTrackingTable(adapter, trackingDatabaseId);
+    MessageFormatter.success("Backup tracking table ready", { prefix: "Backup" });
+  },
+
+  // Helper method: Select backup scope
+  async selectBackupScope(cli: InteractiveCLI): Promise<any> {
+    const { scopeType } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "scopeType",
+        message: "What would you like to backup?",
+        choices: [
+          { name: "Comprehensive (ALL databases + ALL buckets)", value: "comprehensive" },
+          { name: "Selective databases (choose specific databases)", value: "selective-databases" },
+          { name: "Selective collections (choose specific collections)", value: "selective-collections" }
+        ]
+      }
+    ]);
+
+    if (scopeType === "comprehensive") {
+      return { type: "comprehensive" };
+    }
+
+    if (scopeType === "selective-databases") {
+      const databases = await fetchAllDatabases((cli as any).controller!.database);
+      const selectedDatabases = await (cli as any).selectDatabases(
+        databases,
+        "Select databases to backup:"
+      );
+
+      const { includeBuckets } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "includeBuckets",
+          message: "Include storage buckets in backup?",
+          default: false
+        }
+      ]);
+
+      let selectedBuckets: string[] = [];
+      if (includeBuckets) {
+        const buckets = await listBuckets((cli as any).controller!.storage);
+        const { bucketIds } = await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "bucketIds",
+            message: "Select buckets to backup:",
+            choices: buckets.buckets.map((b: any) => ({
+              name: `${b.name} (${b.$id})`,
+              value: b.$id
+            }))
+          }
+        ]);
+        selectedBuckets = bucketIds;
+      }
+
+      return {
+        type: "selective-databases",
+        databases: selectedDatabases,
+        buckets: selectedBuckets
+      };
+    }
+
+    if (scopeType === "selective-collections") {
+      const databases = await fetchAllDatabases((cli as any).controller!.database);
+      const selectedDatabase = await (cli as any).selectDatabases(
+        databases,
+        "Select database containing collections:",
+        false // single selection
+      );
+
+      if (!selectedDatabase || selectedDatabase.length === 0) {
+        throw new Error("No database selected");
+      }
+
+      const db = selectedDatabase[0];
+      const collections = await (cli as any).selectCollectionsAndTables(
+        db,
+        (cli as any).controller!.database!,
+        "Select collections to backup:",
+        true,
+        true,
+        true
+      );
+
+      return {
+        type: "selective-collections",
+        databaseId: db.$id,
+        databaseName: db.name,
+        collections: collections
+      };
+    }
+
+    throw new Error("Invalid backup scope selected");
+  },
+
+  // Helper method: Confirm backup plan
+  async confirmBackupPlan(scope: any): Promise<boolean> {
+    let summary = "\n" + chalk.bold("Backup Plan Summary:") + "\n";
+
+    if (scope.type === "comprehensive") {
+      summary += "  • ALL databases\n";
+      summary += "  • ALL storage buckets\n";
+    } else if (scope.type === "selective-databases") {
+      summary += `  • ${scope.databases.length} selected databases\n`;
+      if (scope.buckets.length > 0) {
+        summary += `  • ${scope.buckets.length} selected buckets\n`;
+      }
+    } else if (scope.type === "selective-collections") {
+      summary += `  • Database: ${scope.databaseName}\n`;
+      summary += `  • ${scope.collections.length} selected collections\n`;
+    }
+
+    console.log(summary);
+
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: "Proceed with backup?",
+        default: true
+      }
+    ]);
+
+    return confirmed;
+  },
+
+  // Helper method: Execute unified backup
+  async executeUnifiedBackup(cli: InteractiveCLI, trackingDatabaseId: string, scope: any): Promise<void> {
+    if (scope.type === "comprehensive") {
+      const { comprehensiveBackup } = await import("../../backups/operations/comprehensiveBackup.js");
+
+      await comprehensiveBackup(
+        (cli as any).controller!.config,
+        (cli as any).controller!.database,
+        (cli as any).controller!.storage,
+        (cli as any).controller!.adapter,
+        {
+          trackingDatabaseId,
+          backupFormat: 'zip',
+          parallelDownloads: 10,
+          onProgress: (message: string) => {
+            MessageFormatter.progress(message, { prefix: "Backup" });
+          }
+        }
+      );
+    } else if (scope.type === "selective-databases") {
+      // Backup each selected database
+      for (const db of scope.databases) {
+        MessageFormatter.progress(`Backing up database: ${db.name}`, { prefix: "Backup" });
+        await (cli as any).controller!.backupDatabase(db);
+      }
+
+      // Backup selected buckets if any
+      for (const bucketId of scope.buckets) {
+        MessageFormatter.progress(`Backing up bucket: ${bucketId}`, { prefix: "Backup" });
+        const { backupBucket } = await import("../../backups/operations/bucketBackup.js");
+        await backupBucket(
+          (cli as any).controller!.storage,
+          bucketId,
+          "appwrite-backups",
+          { parallelDownloads: 10 }
+        );
+      }
+    } else if (scope.type === "selective-collections") {
+      const { backupCollections } = await import("../../backups/operations/collectionBackup.js");
+
+      await backupCollections(
+        (cli as any).controller!.config,
+        (cli as any).controller!.database,
+        (cli as any).controller!.storage,
+        (cli as any).controller!.adapter,
+        {
+          trackingDatabaseId,
+          databaseId: scope.databaseId,
+          collectionIds: scope.collections.map((c: any) => c.$id || c.id),
+          backupFormat: 'zip',
+          onProgress: (message: string) => {
+            MessageFormatter.progress(message, { prefix: "Backup" });
+          }
+        }
+      );
+    }
+  },
+
+  async wipeDatabase(cli: InteractiveCLI): Promise<void> {
+    if (!(cli as any).controller!.database || !(cli as any).controller!.storage) {
+      throw new Error(
+        "Database or Storage is not initialized, is the config file correct & created?"
+      );
+    }
+    const databases = await fetchAllDatabases((cli as any).controller!.database);
+    const storage = await listBuckets((cli as any).controller!.storage);
+
+    const selectedDatabases = await (cli as any).selectDatabases(
+      databases,
+      "Select databases to wipe:"
+    );
+
+    const { selectedStorage } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "selectedStorage",
+        message: "Select storage buckets to wipe:",
+        choices: storage.buckets.map((s: any) => ({ name: s.name, value: s.$id })),
+      },
+    ]);
+
+    const { wipeUsers } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "wipeUsers",
+        message: "Do you want to wipe users as well?",
+        default: false,
+      },
+    ]);
+
+    const databaseNames = selectedDatabases.map((db: any) => db.name);
+    const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(databaseNames, {
+      includeStorage: selectedStorage.length > 0,
+      includeUsers: wipeUsers
+    });
+
+    if (confirmed) {
+      MessageFormatter.info("Starting wipe operation...", { prefix: "Wipe" });
+      for (const db of selectedDatabases) {
+        await (cli as any).controller!.wipeDatabase(db);
+      }
+      for (const bucketId of selectedStorage) {
+        await (cli as any).controller!.wipeDocumentStorage(bucketId);
+      }
+      if (wipeUsers) {
+        await (cli as any).controller!.wipeUsers();
+      }
+      MessageFormatter.success("Wipe operation completed", { prefix: "Wipe" });
+    } else {
+      MessageFormatter.info("Wipe operation cancelled", { prefix: "Wipe" });
+    }
+  },
+
+  async wipeCollections(cli: InteractiveCLI): Promise<void> {
+    if (!(cli as any).controller!.database) {
+      throw new Error(
+        "Database is not initialized, is the config file correct & created?"
+      );
+    }
+    const databases = await fetchAllDatabases((cli as any).controller!.database);
+    const selectedDatabases = await (cli as any).selectDatabases(
+      databases,
+      "Select the database(s) containing the collections to wipe:",
+      true
+    );
+
+    for (const database of selectedDatabases) {
+      const collections = await (cli as any).selectCollectionsAndTables(
+        database,
+        (cli as any).controller!.database,
+        `Select collections/tables to wipe from ${database.name}:`,
+        true,
+        undefined,
+        true
+      );
+
+      const collectionNames = collections.map((c: any) => c.name);
+      const confirmed = await ConfirmationDialogs.confirmCollectionWipe(
+        database.name,
+        collectionNames
+      );
+
+      if (confirmed) {
+        MessageFormatter.info(
+          `Wiping selected collections from ${database.name}...`,
+          { prefix: "Wipe" }
+        );
+        for (const collection of collections) {
+          await (cli as any).controller!.wipeCollection(database, collection);
+          MessageFormatter.success(
+            `Collection ${collection.name} wiped successfully`,
+            { prefix: "Wipe" }
+          );
+        }
+      } else {
+        MessageFormatter.info(
+          `Wipe operation cancelled for ${database.name}`,
+          { prefix: "Wipe" }
+        );
+      }
+    }
+    MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
+  }
+};