appwrite-utils-cli 0.10.86 → 1.0.2

package/dist/shared/attributeManager.js

@@ -0,0 +1,273 @@
+import {} from "node-appwrite";
+import { parseAttribute, } from "appwrite-utils";
+import { nameToIdMapping, enqueueOperation } from "./operationQueue.js";
+import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import chalk from "chalk";
+import pLimit from "p-limit";
+// Concurrency limits for different operations
+const attributeLimit = pLimit(3); // Low limit for attribute operations
+const queryLimit = pLimit(25); // Higher limit for read operations
+export const attributesSame = (databaseAttribute, configAttribute) => {
+    const attributesToCheck = [
+        "key",
+        "type",
+        "array",
+        "encrypted",
+        "required",
+        "size",
+        "min",
+        "max",
+        "xdefault",
+        "elements",
+        "relationType",
+        "twoWay",
+        "twoWayKey",
+        "onDelete",
+        "relatedCollection",
+    ];
+    return attributesToCheck.every((attr) => {
+        // Special handling for min/max values
+        if (attr === "min" || attr === "max") {
+            const dbValue = databaseAttribute[attr];
+            const configValue = configAttribute[attr];
+            // Use type-specific default values when comparing
+            if (databaseAttribute.type === "integer") {
+                const defaultMin = attr === "min" ? -2147483647 : undefined;
+                const defaultMax = attr === "max" ? 2147483647 : undefined;
+                return (dbValue ?? defaultMin) === (configValue ?? defaultMax);
+            }
+            if (databaseAttribute.type === "double" || databaseAttribute.type === "float") {
+                const defaultMin = attr === "min" ? -2147483647 : undefined;
+                const defaultMax = attr === "max" ? 2147483647 : undefined;
+                return (dbValue ?? defaultMin) === (configValue ?? defaultMax);
+            }
+        }
+        // Check if both objects have the attribute
+        const dbHasAttr = attr in databaseAttribute;
+        const configHasAttr = attr in configAttribute;
+        // If both have the attribute, compare values
+        if (dbHasAttr && configHasAttr) {
+            const dbValue = databaseAttribute[attr];
+            const configValue = configAttribute[attr];
+            // Consider undefined and null as equivalent
+            if ((dbValue === undefined || dbValue === null) &&
+                (configValue === undefined || configValue === null)) {
+                return true;
+            }
+            return dbValue === configValue;
+        }
+        // If neither has the attribute, consider it the same
+        if (!dbHasAttr && !configHasAttr) {
+            return true;
+        }
+        // If one has the attribute and the other doesn't, check if it's undefined or null
+        if (dbHasAttr && !configHasAttr) {
+            const dbValue = databaseAttribute[attr];
+            return dbValue === undefined || dbValue === null;
+        }
+        if (!dbHasAttr && configHasAttr) {
+            const configValue = configAttribute[attr];
+            return configValue === undefined || configValue === null;
+        }
+        // If we reach here, the attributes are different
+        return false;
+    });
+};
+export const createOrUpdateAttribute = async (db, dbId, collection, attribute, options = {}) => {
+    const { updateEnabled = true, useQueue = true, verbose = false } = options;
+    let action = "create";
+    let foundAttribute;
+    let finalAttribute = attribute;
+    try {
+        const collectionAttr = collection.attributes.find(
+        // @ts-expect-error - Appwrite type issues
+        (attr) => attr.key === attribute.key);
+        foundAttribute = parseAttribute(collectionAttr);
+        if (verbose) {
+            console.log(`Found attribute: ${JSON.stringify(foundAttribute)}`);
+        }
+    }
+    catch (error) {
+        foundAttribute = undefined;
+    }
+    if (foundAttribute &&
+        attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
+        if (verbose) {
+            console.log(chalk.green(`✓ Attribute ${attribute.key} is up to date`));
+        }
+        return;
+    }
+    if (foundAttribute) {
+        action = "update";
+        if (verbose) {
+            console.log(chalk.yellow(`⚠ Updating attribute ${attribute.key}`));
+        }
+    }
+    else {
+        if (verbose) {
+            console.log(chalk.blue(`+ Creating attribute ${attribute.key}`));
+        }
+    }
+    // Handle relationship attributes with nameToIdMapping
+    if (attribute.type === "relationship" && attribute.relatedCollection) {
+        const relatedCollectionId = nameToIdMapping.get(attribute.relatedCollection);
+        if (relatedCollectionId) {
+            finalAttribute = {
+                ...attribute,
+                relatedCollection: relatedCollectionId,
+            };
+        }
+    }
+    // Handle BigInt values for integer, double and float types
+    if (attribute.type === "integer" || attribute.type === "double" || attribute.type === "float") {
+        if (typeof finalAttribute.min === "bigint") {
+            finalAttribute.min = Number(finalAttribute.min);
+        }
+        if (typeof finalAttribute.max === "bigint") {
+            finalAttribute.max = Number(finalAttribute.max);
+        }
+    }
+    const queuedOperation = {
+        type: "attribute",
+        collectionId: collection.$id,
+        attribute: finalAttribute,
+        collection,
+    };
+    const executeOperation = async () => {
+        await attributeLimit(async () => {
+            if (action === "update" && foundAttribute) {
+                // Delete existing attribute first
+                await tryAwaitWithRetry(async () => {
+                    await db.deleteAttribute(dbId, collection.$id, attribute.key);
+                });
+                await delay(250);
+            }
+            // Create attribute based on type
+            switch (finalAttribute.type) {
+                case "string":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.size, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array, finalAttribute.encrypted);
+                    });
+                    break;
+                case "integer":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "double":
+                case "float": // Backward compatibility
+                    await tryAwaitWithRetry(async () => {
+                        await db.createFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "boolean":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "datetime":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "email":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "ip":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "url":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "enum":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
+                    });
+                    break;
+                case "relationship":
+                    await tryAwaitWithRetry(async () => {
+                        await db.createRelationshipAttribute(dbId, collection.$id, finalAttribute.relatedCollection, finalAttribute.relationType, finalAttribute.twoWay, finalAttribute.key, finalAttribute.twoWayKey, finalAttribute.onDelete);
+                    });
+                    break;
+                default:
+                    throw new Error(`Unknown attribute type: ${finalAttribute.type}`);
+            }
+        });
+    };
+    if (useQueue) {
+        enqueueOperation(queuedOperation);
+    }
+    else {
+        await executeOperation();
+    }
+};
+export const createUpdateCollectionAttributes = async (db, dbId, collection, collectionConfig, options = {}) => {
+    if (!collectionConfig.attributes)
+        return;
+    const { verbose = false } = options;
+    if (verbose) {
+        console.log(chalk.blue(`Processing ${collectionConfig.attributes.length} attributes for collection ${collection.name}`));
+    }
+    for (const attribute of collectionConfig.attributes) {
+        try {
+            await createOrUpdateAttribute(db, dbId, collection, attribute, options);
+            if (verbose) {
+                console.log(chalk.green(`✓ Processed attribute ${attribute.key}`));
+            }
+            // Add delay between attribute operations to prevent rate limiting
+            await delay(250);
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Failed to process attribute ${attribute.key}:`), error);
+            throw error;
+        }
+    }
+};
+export const deleteObsoleteAttributes = async (db, dbId, collection, collectionConfig, options = {}) => {
+    const { useQueue = true, verbose = false } = options;
+    const configAttributes = collectionConfig.attributes || [];
+    const configAttributeKeys = new Set(configAttributes.map(attr => attr.key));
+    // Find attributes that exist in the database but not in the config
+    const obsoleteAttributes = collection.attributes.filter(
+    // @ts-expect-error - Appwrite type issues
+    (attr) => !configAttributeKeys.has(attr.key));
+    if (obsoleteAttributes.length === 0) {
+        return;
+    }
+    if (verbose) {
+        console.log(chalk.yellow(`🗑️ Removing ${obsoleteAttributes.length} obsolete attributes from collection ${collection.name}`));
+    }
+    for (const attr of obsoleteAttributes) {
+        const queuedOperation = {
+            type: "attribute",
+            collectionId: collection.$id,
+            // @ts-expect-error - Appwrite type issues
+            attribute: { key: attr.key, type: "delete" },
+            collection,
+        };
+        const executeOperation = async () => {
+            await attributeLimit(() => tryAwaitWithRetry(async () => {
+                // @ts-expect-error - Appwrite type issues
+                await db.deleteAttribute(dbId, collection.$id, attr.key);
+            }));
+        };
+        if (useQueue) {
+            enqueueOperation(queuedOperation);
+        }
+        else {
+            await executeOperation();
+            await delay(250);
+        }
+        if (verbose) {
+            // @ts-expect-error - Appwrite type issues
+            console.log(chalk.gray(`🗑️ Deleted obsolete attribute ${attr.key}`));
+        }
+    }
+};

package/dist/shared/confirmationDialogs.d.ts

@@ -0,0 +1,75 @@
+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 declare class ConfirmationDialogs {
+    /**
+     * Shows a confirmation dialog for destructive operations
+     */
+    static confirmDestructiveOperation(options: DestructiveOperationOptions): Promise<boolean>;
+    /**
+     * Prompts user about creating a backup before a destructive operation
+     */
+    static promptForBackup(options: BackupPromptOptions): Promise<'yes' | 'no' | 'skip'>;
+    /**
+     * Shows a final confirmation before proceeding with an operation
+     */
+    static finalConfirmation(operation: string, details?: string[]): Promise<boolean>;
+    /**
+     * Specialized confirmation for database wiping
+     */
+    static confirmDatabaseWipe(databaseNames: string[], options?: {
+        includeStorage?: boolean;
+        includeUsers?: boolean;
+        skipConfirmation?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Specialized confirmation for collection wiping
+     */
+    static confirmCollectionWipe(databaseName: string, collectionNames: string[], options?: {
+        skipConfirmation?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Specialized confirmation for function deployment
+     */
+    static confirmFunctionDeployment(functionNames: string[], options?: {
+        isProduction?: boolean;
+        hasBreakingChanges?: boolean;
+        skipConfirmation?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Shows operation summary and asks for final confirmation
+     */
+    static showOperationSummary(title: string, summary: Record<string, string | number | string[]>, options?: {
+        confirmationRequired?: boolean;
+        warningMessage?: string;
+    }): Promise<boolean>;
+    /**
+     * Interactive selection with confirmation
+     */
+    static selectWithConfirmation<T>(items: T[], options: {
+        message: string;
+        displayProperty?: keyof T;
+        multiSelect?: boolean;
+        confirmMessage?: string;
+        validator?: (selection: T[]) => string | true;
+    }): Promise<T[]>;
+    /**
+     * Confirms overwriting an existing file or directory
+     */
+    static confirmOverwrite(target: string): Promise<boolean>;
+    /**
+     * Confirms removal of a file
+     */
+    static confirmRemoval(target: string): Promise<boolean>;
+}

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:`);
+        console.log(chalk.red.bold(`  Operation: ${options.operation}`));
+        console.log(chalk.yellow(`  Targets: ${options.targets.join(", ")}`));
+        if (options.consequences && options.consequences.length > 0) {
+            console.log(chalk.red("\n  This will:"));
+            options.consequences.forEach(consequence => {
+                console.log(chalk.red(`    • ${consequence}`));
+            });
+        }
+        console.log(chalk.red("\n  ⚠️  THIS ACTION CANNOT BE UNDONE!"));
+        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(", ")}?`;
+        console.log(chalk.blue("\n🛡️  Backup Recommendation"));
+        if (options.recommendBackup !== false) {
+            console.log(chalk.yellow("  It's strongly recommended to create a backup before proceeding."));
+        }
+        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) {
+        console.log(chalk.green(`\n✅ Ready to perform: ${chalk.bold(operation)}`));
+        if (details && details.length > 0) {
+            console.log(chalk.gray("   Details:"));
+            details.forEach(detail => {
+                console.log(chalk.gray(`     • ${detail}`));
+            });
+        }
+        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)) {
+                console.log(`${chalk.gray("●")} ${formattedKey}:`);
+                value.forEach(item => {
+                    console.log(`  ${chalk.gray("•")} ${item}`);
+                });
+            }
+            else {
+                console.log(`${chalk.gray("●")} ${formattedKey}: ${chalk.cyan(String(value))}`);
+            }
+        });
+        if (options.warningMessage) {
+            console.log(chalk.yellow(`\n⚠️  ${options.warningMessage}`));
+        }
+        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/functionManager.d.ts

@@ -0,0 +1,48 @@
+import { Client, type Models } from "node-appwrite";
+import { type AppwriteFunction } from "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[];
+    };
+}