appwrite-utils-cli 1.7.7 → 1.7.8

package/src/shared/selectionDialogs.ts

@@ -0,0 +1,716 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import type { Models } from "node-appwrite";
+import { MessageFormatter } from "./messageFormatter.js";
+import { logger } from "./logging.js";
+
+/**
+ * Interface for sync selection summary
+ */
+export interface SyncSelectionSummary {
+  databases: DatabaseSelection[];
+  buckets: BucketSelection[];
+  totalDatabases: number;
+  totalTables: number;
+  totalBuckets: number;
+  newItems: {
+    databases: number;
+    tables: number;
+    buckets: number;
+  };
+  existingItems: {
+    databases: number;
+    tables: number;
+    buckets: number;
+  };
+}
+
+/**
+ * Database selection with associated tables
+ */
+export interface DatabaseSelection {
+  databaseId: string;
+  databaseName: string;
+  tableIds: string[];
+  tableNames: string[];
+  isNew: boolean;
+}
+
+/**
+ * Bucket selection with associated database
+ */
+export interface BucketSelection {
+  bucketId: string;
+  bucketName: string;
+  databaseId?: string;
+  databaseName?: string;
+  isNew: boolean;
+}
+
+/**
+ * Options for database selection
+ */
+export interface DatabaseSelectionOptions {
+  showSelectAll?: boolean;
+  allowNewOnly?: boolean;
+  defaultSelected?: string[];
+}
+
+/**
+ * Options for table selection
+ */
+export interface TableSelectionOptions {
+  showSelectAll?: boolean;
+  allowNewOnly?: boolean;
+  defaultSelected?: string[];
+  showDatabaseContext?: boolean;
+}
+
+/**
+ * Options for bucket selection
+ */
+export interface BucketSelectionOptions {
+  showSelectAll?: boolean;
+  allowNewOnly?: boolean;
+  defaultSelected?: string[];
+  groupByDatabase?: boolean;
+}
+
+/**
+ * Response from existing config prompt
+ */
+export interface ExistingConfigResponse {
+  syncExisting: boolean;
+  modifyConfiguration: boolean;
+}
+
+/**
+ * Comprehensive selection dialog system for enhanced sync flow
+ *
+ * This class provides interactive dialogs for selecting databases, tables/collections,
+ * and storage buckets during sync operations. It supports both new and existing
+ * configurations with visual indicators and comprehensive confirmation flows.
+ *
+ * @example
+ * ```typescript
+ * import { SelectionDialogs } from './shared/selectionDialogs.js';
+ * import type { Models } from 'node-appwrite';
+ *
+ * // Example usage in a sync command
+ * const availableDatabases: Models.Database[] = await getAvailableDatabases();
+ * const configuredDatabases = config.databases || [];
+ *
+ * // Prompt about existing configuration
+ * const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+ *
+ * if (modifyConfiguration) {
+ *   // Select databases
+ *   const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+ *     availableDatabases,
+ *     configuredDatabases,
+ *     { showSelectAll: true, allowNewOnly: !syncExisting }
+ *   );
+ *
+ *   // For each database, select tables
+ *   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)!;
+ *     const availableTables = await getTablesForDatabase(databaseId);
+ *     const configuredTables = getConfiguredTablesForDatabase(databaseId);
+ *
+ *     availableTablesMap.set(databaseId, availableTables);
+ *
+ *     const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+ *       databaseId,
+ *       database.name,
+ *       availableTables,
+ *       configuredTables,
+ *       { showSelectAll: true, allowNewOnly: !syncExisting }
+ *     );
+ *
+ *     tableSelectionsMap.set(databaseId, selectedTableIds);
+ *   }
+ *
+ *   // Select buckets
+ *   const availableBuckets = await getAvailableBuckets();
+ *   const configuredBuckets = config.buckets || [];
+ *   const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+ *     selectedDatabaseIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     { showSelectAll: true, groupByDatabase: true }
+ *   );
+ *
+ *   // Create selection objects
+ *   const databaseSelections = SelectionDialogs.createDatabaseSelection(
+ *     selectedDatabaseIds,
+ *     availableDatabases,
+ *     tableSelectionsMap,
+ *     configuredDatabases,
+ *     availableTablesMap
+ *   );
+ *
+ *   const bucketSelections = SelectionDialogs.createBucketSelection(
+ *     selectedBucketIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     availableDatabases
+ *   );
+ *
+ *   // Show final confirmation
+ *   const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+ *     databaseSelections,
+ *     bucketSelections
+ *   );
+ *
+ *   const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+ *
+ *   if (confirmed) {
+ *     // Proceed with sync operation
+ *     await performSync(databaseSelections, bucketSelections);
+ *   }
+ * }
+ * ```
+ */
+export class SelectionDialogs {
+  /**
+   * Prompts user about existing configuration
+   */
+  static async promptForExistingConfig(configuredItems: any[]): Promise<ExistingConfigResponse> {
+    if (configuredItems.length === 0) {
+      return { syncExisting: false, modifyConfiguration: true };
+    }
+
+    MessageFormatter.section("Existing Configuration Found");
+    MessageFormatter.info(`Found ${configuredItems.length} configured items.`, { skipLogging: true });
+
+    const { syncExisting } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'syncExisting',
+      message: 'Sync existing configured items?',
+      default: true
+    }]);
+
+    if (!syncExisting) {
+      return { syncExisting: false, modifyConfiguration: true };
+    }
+
+    const { modifyConfiguration } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'modifyConfiguration',
+      message: 'Add/remove items from configuration?',
+      default: false
+    }]);
+
+    return { syncExisting, modifyConfiguration };
+  }
+
+  /**
+   * Shows database selection dialog with indicators for configured vs new databases
+   */
+  static async selectDatabases(
+    availableDatabases: Models.Database[],
+    configuredDatabases: any[],
+    options: DatabaseSelectionOptions = {}
+  ): Promise<string[]> {
+    const {
+      showSelectAll = true,
+      allowNewOnly = false,
+      defaultSelected = []
+    } = options;
+
+    MessageFormatter.section("Database Selection");
+
+    const configuredIds = new Set(configuredDatabases.map(db => db.$id || db.id));
+
+    let choices: any[] = [];
+
+    if (showSelectAll && availableDatabases.length > 1) {
+      choices.push({
+        name: chalk.green.bold('📋 Select All Databases'),
+        value: '__SELECT_ALL__',
+        short: 'All databases'
+      });
+    }
+
+    availableDatabases.forEach(database => {
+      const isConfigured = configuredIds.has(database.$id);
+      const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+      const name = `${status} ${database.name} (${database.$id})`;
+
+      if (allowNewOnly && isConfigured) {
+        return; // Skip configured databases if only allowing new ones
+      }
+
+      choices.push({
+        name,
+        value: database.$id,
+        short: database.name,
+        checked: defaultSelected.includes(database.$id) || (!allowNewOnly && isConfigured)
+      });
+    });
+
+    if (choices.length === 0) {
+      MessageFormatter.warning("No databases available for selection.", { skipLogging: true });
+      return [];
+    }
+
+    const { selectedDatabaseIds } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selectedDatabaseIds',
+      message: 'Select databases to sync:',
+      choices,
+      validate: (input: string[]) => {
+        if (input.length === 0) {
+          return chalk.red('Please select at least one database.');
+        }
+        if (input.includes('__SELECT_ALL__') && input.length > 1) {
+          return chalk.red('Cannot select "Select All" with individual databases.');
+        }
+        return true;
+      }
+    }]);
+
+    // Handle select all
+    if (selectedDatabaseIds.includes('__SELECT_ALL__')) {
+      const allIds = availableDatabases.map(db => db.$id);
+      if (allowNewOnly) {
+        return allIds.filter(id => !configuredIds.has(id));
+      }
+      return allIds;
+    }
+
+    return selectedDatabaseIds;
+  }
+
+  /**
+   * Shows table/collection selection dialog for a specific database
+   */
+  static async selectTablesForDatabase(
+    databaseId: string,
+    databaseName: string,
+    availableTables: any[],
+    configuredTables: any[],
+    options: TableSelectionOptions = {}
+  ): Promise<string[]> {
+    const {
+      showSelectAll = true,
+      allowNewOnly = false,
+      defaultSelected = [],
+      showDatabaseContext = true
+    } = options;
+
+    if (showDatabaseContext) {
+      MessageFormatter.section(`Table Selection for ${databaseName}`);
+    }
+
+    const configuredIds = new Set(configuredTables.map(table => table.$id || table.id));
+
+    let choices: any[] = [];
+
+    if (showSelectAll && availableTables.length > 1) {
+      choices.push({
+        name: chalk.green.bold('📋 Select All Tables'),
+        value: '__SELECT_ALL__',
+        short: 'All tables'
+      });
+    }
+
+    availableTables.forEach(table => {
+      const isConfigured = configuredIds.has(table.$id);
+      const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+      const name = `${status} ${table.name} (${table.$id})`;
+
+      if (allowNewOnly && isConfigured) {
+        return; // Skip configured tables if only allowing new ones
+      }
+
+      choices.push({
+        name,
+        value: table.$id,
+        short: table.name,
+        checked: defaultSelected.includes(table.$id) || (!allowNewOnly && isConfigured)
+      });
+    });
+
+    if (choices.length === 0) {
+      MessageFormatter.warning(`No tables available for database: ${databaseName}`, { skipLogging: true });
+      return [];
+    }
+
+    const { selectedTableIds } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selectedTableIds',
+      message: `Select tables to sync for ${databaseName}:`,
+      choices,
+      validate: (input: string[]) => {
+        if (input.length === 0) {
+          return chalk.red('Please select at least one table.');
+        }
+        if (input.includes('__SELECT_ALL__') && input.length > 1) {
+          return chalk.red('Cannot select "Select All" with individual tables.');
+        }
+        return true;
+      }
+    }]);
+
+    // Handle select all
+    if (selectedTableIds.includes('__SELECT_ALL__')) {
+      const allIds = availableTables.map(table => table.$id);
+      if (allowNewOnly) {
+        return allIds.filter(id => !configuredIds.has(id));
+      }
+      return allIds;
+    }
+
+    return selectedTableIds;
+  }
+
+  /**
+   * Shows bucket selection dialog for selected databases
+   */
+  static async selectBucketsForDatabases(
+    selectedDatabaseIds: string[],
+    availableBuckets: any[],
+    configuredBuckets: any[],
+    options: BucketSelectionOptions = {}
+  ): Promise<string[]> {
+    const {
+      showSelectAll = true,
+      allowNewOnly = false,
+      defaultSelected = [],
+      groupByDatabase = true
+    } = options;
+
+    MessageFormatter.section("Storage Bucket Selection");
+
+    const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
+
+    // Filter buckets that are associated with selected databases
+    const relevantBuckets = availableBuckets.filter(bucket => {
+      if (selectedDatabaseIds.length === 0) return true; // If no databases selected, show all buckets
+      return selectedDatabaseIds.includes(bucket.databaseId) || !bucket.databaseId;
+    });
+
+    if (relevantBuckets.length === 0) {
+      MessageFormatter.warning("No storage buckets available for selected databases.", { skipLogging: true });
+      return [];
+    }
+
+    let choices: any[] = [];
+
+    if (showSelectAll && relevantBuckets.length > 1) {
+      choices.push({
+        name: chalk.green.bold('📋 Select All Buckets'),
+        value: '__SELECT_ALL__',
+        short: 'All buckets'
+      });
+    }
+
+    if (groupByDatabase) {
+      // Group buckets by database
+      const bucketsByDatabase = new Map<string, any[]>();
+
+      relevantBuckets.forEach(bucket => {
+        const dbId = bucket.databaseId || 'ungrouped';
+        if (!bucketsByDatabase.has(dbId)) {
+          bucketsByDatabase.set(dbId, []);
+        }
+        bucketsByDatabase.get(dbId)!.push(bucket);
+      });
+
+      // Add buckets grouped by database
+      selectedDatabaseIds.forEach(dbId => {
+        const buckets = bucketsByDatabase.get(dbId) || [];
+        if (buckets.length > 0) {
+          choices.push(new inquirer.Separator(chalk.cyan(`📁 Database: ${dbId}`)));
+
+          buckets.forEach(bucket => {
+            const isConfigured = configuredIds.has(bucket.$id);
+            const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+            const name = `${status} ${bucket.name} (${bucket.$id})`;
+
+            if (allowNewOnly && isConfigured) {
+              return; // Skip configured buckets if only allowing new ones
+            }
+
+            choices.push({
+              name: `  ${name}`,
+              value: bucket.$id,
+              short: bucket.name,
+              checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+            });
+          });
+        }
+      });
+
+      // Add ungrouped buckets
+      const ungroupedBuckets = bucketsByDatabase.get('ungrouped') || [];
+      if (ungroupedBuckets.length > 0) {
+        choices.push(new inquirer.Separator(chalk.cyan('📁 General Storage')));
+
+        ungroupedBuckets.forEach(bucket => {
+          const isConfigured = configuredIds.has(bucket.$id);
+          const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+          const name = `${status} ${bucket.name} (${bucket.$id})`;
+
+          if (allowNewOnly && isConfigured) {
+            return; // Skip configured buckets if only allowing new ones
+          }
+
+          choices.push({
+            name: `  ${name}`,
+            value: bucket.$id,
+            short: bucket.name,
+            checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+          });
+        });
+      }
+    } else {
+      // Flat list of buckets
+      relevantBuckets.forEach(bucket => {
+        const isConfigured = configuredIds.has(bucket.$id);
+        const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+        const dbContext = bucket.databaseId ? ` [${bucket.databaseId}]` : '';
+        const name = `${status} ${bucket.name} (${bucket.$id})${dbContext}`;
+
+        if (allowNewOnly && isConfigured) {
+          return; // Skip configured buckets if only allowing new ones
+        }
+
+        choices.push({
+          name,
+          value: bucket.$id,
+          short: bucket.name,
+          checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+        });
+      });
+    }
+
+    const { selectedBucketIds } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selectedBucketIds',
+      message: 'Select storage buckets to sync:',
+      choices,
+      validate: (input: string[]) => {
+        if (input.length === 0) {
+          return chalk.yellow('No storage buckets selected. Continue with databases only?') || true;
+        }
+        if (input.includes('__SELECT_ALL__') && input.length > 1) {
+          return chalk.red('Cannot select "Select All" with individual buckets.');
+        }
+        return true;
+      }
+    }]);
+
+    // Handle select all
+    if (selectedBucketIds && selectedBucketIds.includes('__SELECT_ALL__')) {
+      const allIds = relevantBuckets.map(bucket => bucket.$id);
+      if (allowNewOnly) {
+        return allIds.filter(id => !configuredIds.has(id));
+      }
+      return allIds;
+    }
+
+    return selectedBucketIds || [];
+  }
+
+  /**
+   * Shows final confirmation dialog with sync selection summary
+   */
+  static async confirmSyncSelection(selectionSummary: SyncSelectionSummary): Promise<boolean> {
+    MessageFormatter.banner("Sync Selection Summary", "Review your selections before proceeding");
+
+    // Database summary
+    console.log(chalk.bold.cyan("\n📊 Databases:"));
+    console.log(`  Total: ${selectionSummary.totalDatabases}`);
+    console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.databases}`);
+    console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.databases}`);
+
+    if (selectionSummary.databases.length > 0) {
+      console.log(chalk.gray("\n  Selected databases:"));
+      selectionSummary.databases.forEach(db => {
+        const status = db.isNew ? chalk.blue('○') : chalk.green('✅');
+        console.log(`    ${status} ${db.databaseName} (${db.tableNames.length} tables)`);
+      });
+    }
+
+    // Table summary
+    console.log(chalk.bold.cyan("\n📋 Tables/Collections:"));
+    console.log(`  Total: ${selectionSummary.totalTables}`);
+    console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.tables}`);
+    console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.tables}`);
+
+    // Bucket summary
+    console.log(chalk.bold.cyan("\n🪣 Storage Buckets:"));
+    console.log(`  Total: ${selectionSummary.totalBuckets}`);
+    console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.buckets}`);
+    console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.buckets}`);
+
+    if (selectionSummary.buckets.length > 0) {
+      console.log(chalk.gray("\n  Selected buckets:"));
+      selectionSummary.buckets.forEach(bucket => {
+        const status = bucket.isNew ? chalk.blue('○') : chalk.green('✅');
+        const dbContext = bucket.databaseName ? ` [${bucket.databaseName}]` : '';
+        console.log(`    ${status} ${bucket.bucketName}${dbContext}`);
+      });
+    }
+
+    console.log(); // Add spacing
+
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: chalk.green.bold('Proceed with sync operation?'),
+      default: true
+    }]);
+
+    if (confirmed) {
+      MessageFormatter.success("Sync operation confirmed.", { skipLogging: true });
+      logger.info("Sync selection confirmed", {
+        databases: selectionSummary.totalDatabases,
+        tables: selectionSummary.totalTables,
+        buckets: selectionSummary.totalBuckets
+      });
+    } else {
+      MessageFormatter.warning("Sync operation cancelled.", { skipLogging: true });
+      logger.info("Sync selection cancelled by user");
+    }
+
+    return confirmed;
+  }
+
+  /**
+   * Creates a sync selection summary from selected items
+   */
+  static createSyncSelectionSummary(
+    databaseSelections: DatabaseSelection[],
+    bucketSelections: BucketSelection[]
+  ): SyncSelectionSummary {
+    const totalDatabases = databaseSelections.length;
+    const totalTables = databaseSelections.reduce((sum, db) => sum + db.tableIds.length, 0);
+    const totalBuckets = bucketSelections.length;
+
+    const newDatabases = databaseSelections.filter(db => db.isNew).length;
+    const newTables = databaseSelections.reduce((sum, db) =>
+      sum + db.tableIds.length, 0); // TODO: Track which tables are new
+    const newBuckets = bucketSelections.filter(bucket => bucket.isNew).length;
+
+    const existingDatabases = totalDatabases - newDatabases;
+    const existingTables = totalTables - newTables;
+    const existingBuckets = totalBuckets - newBuckets;
+
+    return {
+      databases: databaseSelections,
+      buckets: bucketSelections,
+      totalDatabases,
+      totalTables,
+      totalBuckets,
+      newItems: {
+        databases: newDatabases,
+        tables: newTables,
+        buckets: newBuckets
+      },
+      existingItems: {
+        databases: existingDatabases,
+        tables: existingTables,
+        buckets: existingBuckets
+      }
+    };
+  }
+
+  /**
+   * Helper method to create database selection objects
+   */
+  static createDatabaseSelection(
+    selectedDatabaseIds: string[],
+    availableDatabases: Models.Database[],
+    tableSelectionsMap: Map<string, string[]>,
+    configuredDatabases: any[],
+    availableTablesMap: Map<string, any[]> = new Map()
+  ): DatabaseSelection[] {
+    const configuredIds = new Set(configuredDatabases.map(db => db.$id || db.id));
+
+    return selectedDatabaseIds.map(databaseId => {
+      const database = availableDatabases.find(db => db.$id === databaseId);
+      if (!database) {
+        throw new Error(`Database with ID ${databaseId} not found in available databases`);
+      }
+
+      const tableIds = tableSelectionsMap.get(databaseId) || [];
+      const tables = availableTablesMap.get(databaseId) || [];
+      const tableNames: string[] = tables.map(table => table.name || table.$id || `Table-${table.$id}`);
+
+      return {
+        databaseId,
+        databaseName: database.name,
+        tableIds,
+        tableNames,
+        isNew: !configuredIds.has(databaseId)
+      };
+    });
+  }
+
+  /**
+   * Helper method to create bucket selection objects
+   */
+  static createBucketSelection(
+    selectedBucketIds: string[],
+    availableBuckets: any[],
+    configuredBuckets: any[],
+    availableDatabases: Models.Database[]
+  ): BucketSelection[] {
+    const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
+
+    return selectedBucketIds.map(bucketId => {
+      const bucket = availableBuckets.find(b => b.$id === bucketId);
+      if (!bucket) {
+        throw new Error(`Bucket with ID ${bucketId} not found in available buckets`);
+      }
+
+      const database = bucket.databaseId ?
+        availableDatabases.find(db => db.$id === bucket.databaseId) : undefined;
+
+      return {
+        bucketId,
+        bucketName: bucket.name,
+        databaseId: bucket.databaseId,
+        databaseName: database?.name,
+        isNew: !configuredIds.has(bucketId)
+      };
+    });
+  }
+
+  /**
+   * Shows a progress message during selection operations
+   */
+  static showProgress(message: string): void {
+    MessageFormatter.progress(message, { skipLogging: true });
+  }
+
+  /**
+   * Shows an error message and handles graceful cancellation
+   */
+  static showError(message: string, error?: Error): void {
+    MessageFormatter.error(message, error, { skipLogging: true });
+    logger.error(`Selection dialog error: ${message}`, { error: error?.message });
+  }
+
+  /**
+   * Shows a warning message
+   */
+  static showWarning(message: string): void {
+    MessageFormatter.warning(message, { skipLogging: true });
+    logger.warn(`Selection dialog warning: ${message}`);
+  }
+
+  /**
+   * Shows a success message
+   */
+  static showSuccess(message: string): void {
+    MessageFormatter.success(message, { skipLogging: true });
+    logger.info(`Selection dialog success: ${message}`);
+  }
+}