@njdamstra/appwrite-utils-cli 1.8.9

package/dist/shared/confirmationDialogs.js

@@ -0,0 +1,236 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { MessageFormatter } from "./messageFormatter.js";
+export class ConfirmationDialogs {
+    /**
+     * Shows a confirmation dialog for destructive operations
+     */
+    static async confirmDestructiveOperation(options) {
+        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) => {
+                        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) {
+        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, details) {
+        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, options = {}) {
+        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, collectionNames, options = {}) {
+        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, options = {}) {
+        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, summary, options = {}) {
+        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(items, options) {
+        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) => {
+                    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) {
+        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) {
+        const { confirmed } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'confirmed',
+                message: chalk.red(target),
+                default: false
+            }]);
+        return confirmed;
+    }
+}

package/dist/shared/errorUtils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 declare function getErrorMessage(error: unknown): string;
+/**
+ * Normalizes unknown error to Error instance
+ * @param error - Error of unknown type
+ * @returns Normalized Error object
+ */
+export declare function normalizeError(error: unknown): 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 declare function isConflictError(error: any): boolean;
+/**
+ * Checks if error is a Cloudflare error (522)
+ * @param error - Error object to check
+ * @returns True if error is from Cloudflare connection timeout
+ */
+export declare function isCloudflareError(error: any): boolean;
+/**
+ * Checks if error is authentication/authorization related
+ * @param error - Error object to check
+ * @returns True if error is auth-related (401, 403)
+ */
+export declare function isAuthError(error: any): boolean;
+/**
+ * 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 declare function isRetryableError(errorMessage: string): boolean;
+/**
+ * Checks if an error indicates bulk operations are not supported
+ * @param errorMessage - Error message to check
+ * @returns True if bulk operations not supported
+ */
+export declare function isBulkNotSupportedError(errorMessage: string): boolean;
+/**
+ * Checks if an error is critical (authentication, authorization, permissions)
+ * @param errorMessage - Error message to check
+ * @returns True if error is critical
+ */
+export declare function isCriticalError(errorMessage: string): boolean;

package/dist/shared/errorUtils.js

@@ -0,0 +1,95 @@
+/**
+ * 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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    const criticalErrors = [
+        "authentication",
+        "authorization",
+        "permission",
+        "forbidden",
+        "401",
+        "403"
+    ];
+    return criticalErrors.some(error => errorMessage.toLowerCase().includes(error));
+}

package/dist/shared/functionManager.d.ts

@@ -0,0 +1,48 @@
+import { Client, type Models } from "node-appwrite";
+import { type AppwriteFunction } from "@njdamstra/appwrite-utils";
+export interface FunctionSearchOptions {
+    searchPaths?: string[];
+    caseSensitive?: boolean;
+    allowFuzzyMatch?: boolean;
+    verbose?: boolean;
+}
+export interface FunctionDeploymentOptions {
+    activate?: boolean;
+    entrypoint?: string;
+    commands?: string;
+    ignored?: string[];
+    verbose?: boolean;
+    forceRedeploy?: boolean;
+}
+export declare class FunctionManager {
+    private client;
+    private functions;
+    constructor(client: Client);
+    /**
+     * Improved function directory detection with multiple strategies
+     */
+    findFunctionDirectory(functionName: string, options?: FunctionSearchOptions): Promise<string | null>;
+    private generateNameVariations;
+    private getStandardFunctionPaths;
+    private recursiveDirectorySearch;
+    private shouldSkipDirectory;
+    private isValidFunctionDirectory;
+    /**
+     * Enhanced function deployment with better error handling and validation
+     */
+    deployFunction(functionConfig: AppwriteFunction, functionPath: string, options?: FunctionDeploymentOptions): Promise<Models.Deployment>;
+    private createFunction;
+    private updateFunction;
+    private executePredeployCommands;
+    private createDeployment;
+    getFunction(functionId: string): Promise<Models.Function>;
+    listFunctions(): Promise<Models.FunctionList>;
+    deleteFunction(functionId: string): Promise<void>;
+    /**
+     * Validate function configuration
+     */
+    validateFunctionConfig(functionConfig: AppwriteFunction): {
+        valid: boolean;
+        errors: string[];
+    };
+}