@njdamstra/appwrite-utils-cli 1.8.9

package/src/shared/confirmationDialogs.ts

@@ -0,0 +1,327 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { MessageFormatter } from "./messageFormatter.js";
+
+export interface DestructiveOperationOptions {
+  operation: string;
+  targets: string[];
+  consequences?: string[];
+  requireExplicitConfirmation?: boolean;
+  confirmationText?: string;
+  skipConfirmation?: boolean;
+}
+
+export interface BackupPromptOptions {
+  operation: string;
+  targets: string[];
+  recommendBackup?: boolean;
+  backupMessage?: string;
+}
+
+export class ConfirmationDialogs {
+  /**
+   * Shows a confirmation dialog for destructive operations
+   */
+  static async confirmDestructiveOperation(options: DestructiveOperationOptions): Promise<boolean> {
+    if (options.skipConfirmation) {
+      return true;
+    }
+
+    MessageFormatter.warning(`You are about to perform a destructive operation:`, { skipLogging: true });
+    MessageFormatter.error(`Operation: ${options.operation}`, undefined, { skipLogging: true });
+    MessageFormatter.warning(`Targets: ${options.targets.join(", ")}`, { skipLogging: true });
+
+    if (options.consequences && options.consequences.length > 0) {
+      MessageFormatter.error("This will:", undefined, { skipLogging: true });
+      options.consequences.forEach(consequence => {
+        MessageFormatter.error(`  • ${consequence}`, undefined, { skipLogging: true });
+      });
+    }
+
+    MessageFormatter.error("⚠️  THIS ACTION CANNOT BE UNDONE!", undefined, { skipLogging: true });
+
+    if (options.requireExplicitConfirmation && options.confirmationText) {
+      const { confirmation } = await inquirer.prompt([{
+        type: 'input',
+        name: 'confirmation',
+        message: chalk.red(`Type "${options.confirmationText}" to confirm:`),
+        validate: (input: string) => {
+          return input === options.confirmationText || 
+            chalk.red(`Please type exactly: ${options.confirmationText}`);
+        }
+      }]);
+      
+      return confirmation === options.confirmationText;
+    } else {
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: chalk.red('Are you absolutely sure you want to continue?'),
+        default: false
+      }]);
+      
+      return confirmed;
+    }
+  }
+
+  /**
+   * Prompts user about creating a backup before a destructive operation
+   */
+  static async promptForBackup(options: BackupPromptOptions): Promise<'yes' | 'no' | 'skip'> {
+    const message = options.backupMessage ||
+      `Create a backup before performing ${options.operation} on: ${options.targets.join(", ")}?`;
+
+    MessageFormatter.info("🛡️  Backup Recommendation", { skipLogging: true });
+    if (options.recommendBackup !== false) {
+      MessageFormatter.warning("It's strongly recommended to create a backup before proceeding.", { skipLogging: true });
+    }
+    
+    const { choice } = await inquirer.prompt([{
+      type: 'list',
+      name: 'choice',
+      message,
+      choices: [
+        { name: '🛡️  Yes, create backup first', value: 'yes' },
+        { name: '⚠️  No, proceed without backup', value: 'no' },
+        { name: '❌ Cancel operation', value: 'skip' }
+      ],
+      default: 'yes'
+    }]);
+
+    return choice;
+  }
+
+  /**
+   * Shows a final confirmation before proceeding with an operation
+   */
+  static async finalConfirmation(operation: string, details?: string[]): Promise<boolean> {
+    MessageFormatter.success(`Ready to perform: ${operation}`, { skipLogging: true });
+
+    if (details && details.length > 0) {
+      MessageFormatter.debug("Details:", undefined, { skipLogging: true });
+      details.forEach(detail => {
+        MessageFormatter.debug(`  • ${detail}`, undefined, { skipLogging: true });
+      });
+    }
+
+    const { proceed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'proceed',
+      message: 'Proceed with this operation?',
+      default: true
+    }]);
+
+    return proceed;
+  }
+
+  /**
+   * Specialized confirmation for database wiping
+   */
+  static async confirmDatabaseWipe(databaseNames: string[], options: {
+    includeStorage?: boolean;
+    includeUsers?: boolean;
+    skipConfirmation?: boolean;
+  } = {}): Promise<boolean> {
+    const consequences = [
+      "Delete all documents in the specified databases",
+      "Remove all collections and their data",
+    ];
+
+    if (options.includeStorage) {
+      consequences.push("Delete all files in associated storage buckets");
+    }
+
+    if (options.includeUsers) {
+      consequences.push("Delete all user accounts");
+    }
+
+    return this.confirmDestructiveOperation({
+      operation: "Database Wipe",
+      targets: databaseNames,
+      consequences,
+      requireExplicitConfirmation: true,
+      confirmationText: "DELETE ALL DATA",
+      skipConfirmation: options.skipConfirmation,
+    });
+  }
+
+  /**
+   * Specialized confirmation for collection wiping
+   */
+  static async confirmCollectionWipe(
+    databaseName: string, 
+    collectionNames: string[],
+    options: { skipConfirmation?: boolean } = {}
+  ): Promise<boolean> {
+    return this.confirmDestructiveOperation({
+      operation: "Collection Wipe",
+      targets: collectionNames.map(name => `${databaseName}.${name}`),
+      consequences: [
+        "Delete all documents in the specified collections",
+        "Keep the collection structure intact",
+      ],
+      requireExplicitConfirmation: collectionNames.length > 5,
+      confirmationText: "DELETE DOCUMENTS",
+      skipConfirmation: options.skipConfirmation,
+    });
+  }
+
+  /**
+   * Specialized confirmation for function deployment
+   */
+  static async confirmFunctionDeployment(
+    functionNames: string[],
+    options: { 
+      isProduction?: boolean; 
+      hasBreakingChanges?: boolean;
+      skipConfirmation?: boolean;
+    } = {}
+  ): Promise<boolean> {
+    if (options.skipConfirmation) {
+      return true;
+    }
+
+    const consequences = ["Replace existing function code"];
+    
+    if (options.isProduction) {
+      consequences.push("Affect production environment");
+    }
+
+    if (options.hasBreakingChanges) {
+      consequences.push("Potentially break existing integrations");
+    }
+
+    return this.confirmDestructiveOperation({
+      operation: "Function Deployment",
+      targets: functionNames,
+      consequences: consequences.length > 1 ? consequences : undefined,
+      requireExplicitConfirmation: options.isProduction || options.hasBreakingChanges,
+      confirmationText: options.isProduction ? "DEPLOY TO PRODUCTION" : "DEPLOY",
+    });
+  }
+
+  /**
+   * Shows operation summary and asks for final confirmation
+   */
+  static async showOperationSummary(
+    title: string,
+    summary: Record<string, string | number | string[]>,
+    options: { 
+      confirmationRequired?: boolean;
+      warningMessage?: string;
+    } = {}
+  ): Promise<boolean> {
+    MessageFormatter.section(`${title} Summary`);
+    
+    Object.entries(summary).forEach(([key, value]) => {
+      const formattedKey = key.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase());
+
+      if (Array.isArray(value)) {
+        MessageFormatter.info(`● ${formattedKey}:`, { skipLogging: true });
+        value.forEach(item => {
+          MessageFormatter.debug(`  • ${item}`, undefined, { skipLogging: true });
+        });
+      } else {
+        MessageFormatter.info(`● ${formattedKey}: ${String(value)}`, { skipLogging: true });
+      }
+    });
+
+    if (options.warningMessage) {
+      MessageFormatter.warning(`⚠️  ${options.warningMessage}`, { skipLogging: true });
+    }
+
+    if (options.confirmationRequired !== false) {
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Continue with this operation?',
+        default: true
+      }]);
+      
+      return confirmed;
+    }
+
+    return true;
+  }
+
+  /**
+   * Interactive selection with confirmation
+   */
+  static async selectWithConfirmation<T>(
+    items: T[],
+    options: {
+      message: string;
+      displayProperty?: keyof T;
+      multiSelect?: boolean;
+      confirmMessage?: string;
+      validator?: (selection: T[]) => string | true;
+    }
+  ): Promise<T[]> {
+    const choices = items.map((item, index) => ({
+      name: options.displayProperty ? String(item[options.displayProperty]) : String(item),
+      value: item,
+    }));
+
+    const prompt = options.multiSelect ? 'checkbox' : 'list';
+    const { selection } = await inquirer.prompt([{
+      type: prompt,
+      name: 'selection',
+      message: options.message,
+      choices,
+      validate: options.validator ? (input: T[]) => {
+        const result = options.validator!(Array.isArray(input) ? input : [input]);
+        return result;
+      } : undefined,
+    }]);
+
+    const selectedItems = Array.isArray(selection) ? selection : [selection];
+    
+    if (options.confirmMessage) {
+      const confirmMessage = options.confirmMessage.replace(
+        '{count}', 
+        selectedItems.length.toString()
+      );
+      
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: confirmMessage,
+        default: true
+      }]);
+
+      if (!confirmed) {
+        return [];
+      }
+    }
+
+    return selectedItems;
+  }
+
+  /**
+   * Confirms overwriting an existing file or directory
+   */
+  static async confirmOverwrite(target: string): Promise<boolean> {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: chalk.yellow(`${target} already exists. Overwrite?`),
+      default: false
+    }]);
+    
+    return confirmed;
+  }
+
+  /**
+   * Confirms removal of a file
+   */
+  static async confirmRemoval(target: string): Promise<boolean> {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: chalk.red(target),
+      default: false
+    }]);
+    
+    return confirmed;
+  }
+}

package/src/shared/errorUtils.ts

@@ -0,0 +1,110 @@
+/**
+ * Shared error handling utilities for consistent error processing
+ */
+
+/**
+ * Extracts error message from unknown error type
+ * @param error - Error of unknown type
+ * @returns String error message
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Normalizes unknown error to Error instance
+ * @param error - Error of unknown type
+ * @returns Normalized Error object
+ */
+export function normalizeError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+/**
+ * Checks if error is a conflict error (409)
+ * @param error - Error object to check
+ * @returns True if error is a conflict (duplicate resource)
+ */
+export function isConflictError(error: any): boolean {
+  return error?.code === 409 || (error?.message?.toLowerCase().includes('already exists') ?? false);
+}
+
+/**
+ * Checks if error is a Cloudflare error (522)
+ * @param error - Error object to check
+ * @returns True if error is from Cloudflare connection timeout
+ */
+export function isCloudflareError(error: any): boolean {
+  return error?.code === 522 || error?.code === "522";
+}
+
+/**
+ * Checks if error is authentication/authorization related
+ * @param error - Error object to check
+ * @returns True if error is auth-related (401, 403)
+ */
+export function isAuthError(error: any): boolean {
+  const code = error?.code;
+  return code === 401 || code === 403 || code === "401" || code === "403";
+}
+
+/**
+ * Error categorization helpers for smart fallback logic
+ */
+
+/**
+ * Checks if an error is retryable (network issues, rate limits, etc.)
+ * @param errorMessage - Error message to check
+ * @returns True if error is retryable
+ */
+export function isRetryableError(errorMessage: string): boolean {
+  const retryableErrors = [
+    "rate limit",
+    "timeout",
+    "network",
+    "temporary",
+    "503",
+    "502",
+    "429"
+  ];
+  return retryableErrors.some(error =>
+    errorMessage.toLowerCase().includes(error)
+  );
+}
+
+/**
+ * Checks if an error indicates bulk operations are not supported
+ * @param errorMessage - Error message to check
+ * @returns True if bulk operations not supported
+ */
+export function isBulkNotSupportedError(errorMessage: string): boolean {
+  const notSupportedErrors = [
+    "method not found",
+    "not implemented",
+    "unsupported",
+    "not available",
+    "404"
+  ];
+  return notSupportedErrors.some(error =>
+    errorMessage.toLowerCase().includes(error)
+  );
+}
+
+/**
+ * Checks if an error is critical (authentication, authorization, permissions)
+ * @param errorMessage - Error message to check
+ * @returns True if error is critical
+ */
+export function isCriticalError(errorMessage: string): boolean {
+  const criticalErrors = [
+    "authentication",
+    "authorization",
+    "permission",
+    "forbidden",
+    "401",
+    "403"
+  ];
+  return criticalErrors.some(error =>
+    errorMessage.toLowerCase().includes(error)
+  );
+}