appwrite-utils-cli 0.10.85 → 1.0.1

package/dist/interactiveCLI.d.ts

@@ -1,11 +1,13 @@
 export declare class InteractiveCLI {
     private currentDir;
     private controller;
+    private isUsingTypeScriptConfig;
     constructor(currentDir: string);
     run(): Promise<void>;
     private initControllerIfNeeded;
     private selectDatabases;
     private selectCollections;
+    private getTemplateDefaults;
     private createFunction;
     private findFunctionInSubdirectories;
     private deployFunction;
@@ -28,4 +30,7 @@ export declare class InteractiveCLI {
     private getLocalDatabases;
     private reloadConfig;
     private updateFunctionSpec;
+    private detectConfigurationType;
+    private buildChoicesList;
+    private migrateTypeScriptConfig;
 }

package/dist/interactiveCLI.js

@@ -14,9 +14,15 @@ import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeploymen
 import { deployLocalFunction } from "./functions/deployments.js";
 import { join } from "node:path";
 import fs from "node:fs";
-import { SchemaGenerator } from "./migrations/schemaStrings.js";
+import { SchemaGenerator } from "./shared/schemaGenerator.js";
+import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
+import { MessageFormatter } from "./shared/messageFormatter.js";
+import { migrateConfig } from "./utils/configMigration.js";
+import { findAppwriteConfig } from "./utils/loadConfigs.js";
+import { findYamlConfig, addFunctionToYamlConfig } from "./config/yamlConfig.js";
 var CHOICES;
 (function (CHOICES) {
+    CHOICES["MIGRATE_CONFIG"] = "\uD83D\uDD04 Migrate TypeScript config to YAML (.appwrite structure)";
     CHOICES["CREATE_COLLECTION_CONFIG"] = "Create collection config file";
     CHOICES["CREATE_FUNCTION"] = "Create a new function, from scratch or using a template";
     CHOICES["DEPLOY_FUNCTION"] = "Deploy function(s)";
@@ -38,24 +44,37 @@ var CHOICES;
 export class InteractiveCLI {
     currentDir;
     controller;
+    isUsingTypeScriptConfig = false;
     constructor(currentDir) {
         this.currentDir = currentDir;
     }
     async run() {
-        console.log(chalk.green("Welcome to Appwrite Utils CLI Tool by Zach Handley"));
-        console.log(chalk.blue("For more information, visit https://github.com/zachhandley/AppwriteUtils"));
+        MessageFormatter.banner("Appwrite Utils CLI", "Welcome to Appwrite Utils CLI Tool by Zach Handley");
+        MessageFormatter.info("For more information, visit https://github.com/zachhandley/AppwriteUtils");
+        // Detect configuration type
+        try {
+            await this.detectConfigurationType();
+        }
+        catch (error) {
+            // Continue if detection fails
+            this.isUsingTypeScriptConfig = false;
+        }
         while (true) {
+            // Build choices array dynamically based on config type
+            const choices = this.buildChoicesList();
             const { action } = await inquirer.prompt([
                 {
                     type: "list",
                     name: "action",
                     message: chalk.yellow("What would you like to do?"),
-                    choices: Object.values(CHOICES),
+                    choices,
                 },
             ]);
             switch (action) {
+                case CHOICES.MIGRATE_CONFIG:
+                    await this.migrateTypeScriptConfig();
+                    break;
                 case CHOICES.CREATE_COLLECTION_CONFIG:
-                    await this.initControllerIfNeeded();
                     await this.createCollectionConfig();
                     break;
                 case CHOICES.CREATE_FUNCTION:
@@ -117,7 +136,7 @@ export class InteractiveCLI {
                     await this.updateFunctionSpec();
                     break;
                 case CHOICES.EXIT:
-                    console.log(chalk.green("Goodbye!"));
+                    MessageFormatter.success("Goodbye!");
                     process.exit(0);
             }
         }
@@ -145,7 +164,10 @@ export class InteractiveCLI {
             }
             return acc;
         }, [])
-            .filter((db) => db.name.toLowerCase() !== "migrations");
+            .filter((db) => {
+            const useMigrations = this.controller?.config?.useMigrations ?? true;
+            return useMigrations || db.name.toLowerCase() !== "migrations";
+        });
         const hasLocalAndRemote = allDatabases.some((db) => configDatabases.some((c) => c.name === db.name)) &&
             allDatabases.some((db) => !configDatabases.some((c) => c.name === db.name));
         const choices = allDatabases
@@ -159,7 +181,10 @@ export class InteractiveCLI {
                     : ""),
             value: db,
         }))
-            .filter((db) => db.name.toLowerCase() !== "migrations");
+            .filter((db) => {
+            const useMigrations = this.controller?.config?.useMigrations ?? true;
+            return useMigrations || db.name.toLowerCase() !== "migrations";
+        });
         const { selectedDatabases } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -172,11 +197,10 @@ export class InteractiveCLI {
         ]);
         return selectedDatabases;
     }
-    async selectCollections(database, databasesClient, message, multiSelect = true, preferLocal = false) {
+    async selectCollections(database, databasesClient, message, multiSelect = true, preferLocal = false, shouldFilterByDatabase = false) {
         await this.initControllerIfNeeded();
         const configCollections = this.getLocalCollections();
         let remoteCollections = [];
-        let shouldFilterByDatabase = true;
         const dbExists = await databasesClient.list([
             Query.equal("name", database.name),
         ]);
@@ -226,6 +250,34 @@ export class InteractiveCLI {
         ]);
         return selectedCollections;
     }
+    getTemplateDefaults(template) {
+        const defaults = {
+            "typescript-node": {
+                runtime: "node-21.0",
+                entrypoint: "src/index.ts",
+                commands: "npm install && npm run build",
+                specification: "s-0.5vcpu-512mb",
+            },
+            "uv": {
+                runtime: "python-3.12",
+                entrypoint: "src/index.py",
+                commands: "uv sync && uv build",
+                specification: "s-0.5vcpu-512mb",
+            },
+            "count-docs-in-collection": {
+                runtime: "node-21.0",
+                entrypoint: "src/main.ts",
+                commands: "npm install && npm run build",
+                specification: "s-1vcpu-512mb",
+            },
+        };
+        return defaults[template] || {
+            runtime: "node-21.0",
+            entrypoint: "",
+            commands: "",
+            specification: "s-0.5vcpu-512mb",
+        };
+    }
     async createFunction() {
         const { name } = await inquirer.prompt([
             {
@@ -241,19 +293,22 @@ export class InteractiveCLI {
                 name: "template",
                 message: "Select a template:",
                 choices: [
-                    "typescript-node",
-                    "poetry",
-                    "count-docs-in-collection",
-                    "none",
+                    { name: "TypeScript Node.js", value: "typescript-node" },
+                    { name: "Python with UV", value: "uv" },
+                    { name: "Count Documents in Collection", value: "count-docs-in-collection" },
+                    { name: "None (Empty Function)", value: "none" },
                 ],
             },
         ]);
+        // Get template defaults
+        const templateDefaults = this.getTemplateDefaults(template);
         const { runtime } = await inquirer.prompt([
             {
                 type: "list",
                 name: "runtime",
                 message: "Select runtime:",
                 choices: Object.values(RuntimeSchema.Values),
+                default: templateDefaults.runtime,
             },
         ]);
         const specifications = await listSpecifications(this.controller.appwriteServer);
@@ -269,6 +324,7 @@ export class InteractiveCLI {
                         value: s.slug,
                     })),
                 ],
+                default: templateDefaults.specification,
             },
         ]);
         const functionConfig = {
@@ -279,22 +335,40 @@ export class InteractiveCLI {
             execute: ["any"],
             enabled: true,
             logging: true,
-            entrypoint: template === "none" ? "src/index.ts" : undefined,
-            specification,
-            predeployCommands: template.includes("typescript")
-                ? ["npm install", "npm run build"]
-                : undefined,
-            deployDir: template.includes("typescript") ? "dist" : undefined,
+            entrypoint: templateDefaults.entrypoint,
+            commands: templateDefaults.commands,
+            specification: specification || templateDefaults.specification,
+            scopes: [],
+            timeout: 15,
+            schedule: "",
+            installationId: "",
+            providerRepositoryId: "",
+            providerBranch: "",
+            providerSilentMode: false,
+            providerRootDirectory: "",
+            templateRepository: "",
+            templateOwner: "",
+            templateRootDirectory: "",
         };
         if (template !== "none") {
             await createFunctionTemplate(template, name, "./functions");
         }
-        // Add to config
+        // Add to in-memory config
         if (!this.controller.config.functions) {
             this.controller.config.functions = [];
         }
         this.controller.config.functions.push(functionConfig);
-        console.log(chalk.green("✨ Function created successfully!"));
+        // If using YAML config, also add to YAML file
+        const yamlConfigPath = findYamlConfig(this.currentDir);
+        if (yamlConfigPath) {
+            try {
+                await addFunctionToYamlConfig(yamlConfigPath, functionConfig);
+            }
+            catch (error) {
+                MessageFormatter.warning(`Function created but failed to update YAML config: ${error instanceof Error ? error.message : error}`, { prefix: "Functions" });
+            }
+        }
+        MessageFormatter.success("Function created successfully!", { prefix: "Functions" });
     }
     async findFunctionInSubdirectories(basePaths, functionName) {
         // Common locations to check first
@@ -456,7 +530,7 @@ export class InteractiveCLI {
                     ...functionConfig,
                     dirPath: functionPath,
                 });
-                console.log(chalk.green("✨ Function deployed successfully!"));
+                MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
             }
             catch (error) {
                 console.error(chalk.red("Failed to deploy function:"), error);
@@ -996,7 +1070,7 @@ export class InteractiveCLI {
             console.log(chalk.yellow(`Backing up database: ${db.name}`));
             await this.controller.backupDatabase(db);
         }
-        console.log(chalk.green("Database backup completed."));
+        MessageFormatter.success("Database backup completed", { prefix: "Backup" });
     }
     async wipeDatabase() {
         if (!this.controller.database || !this.controller.storage) {
@@ -1021,16 +1095,13 @@ export class InteractiveCLI {
                 default: false,
             },
         ]);
-        const { confirm } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "confirm",
-                message: chalk.red("Are you sure you want to wipe the selected items? This action cannot be undone."),
-                default: false,
-            },
-        ]);
-        if (confirm) {
-            console.log(chalk.yellow("Wiping selected items..."));
+        const databaseNames = selectedDatabases.map(db => 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 this.controller.wipeDatabase(db);
             }
@@ -1040,10 +1111,10 @@ export class InteractiveCLI {
             if (wipeUsers) {
                 await this.controller.wipeUsers();
             }
-            console.log(chalk.green("Wipe operation completed."));
+            MessageFormatter.success("Wipe operation completed", { prefix: "Wipe" });
         }
         else {
-            console.log(chalk.blue("Wipe operation cancelled."));
+            MessageFormatter.info("Wipe operation cancelled", { prefix: "Wipe" });
         }
     }
     async wipeCollections() {
@@ -1053,32 +1124,48 @@ export class InteractiveCLI {
         const databases = await fetchAllDatabases(this.controller.database);
         const selectedDatabases = await this.selectDatabases(databases, "Select the database(s) containing the collections to wipe:", true);
         for (const database of selectedDatabases) {
-            const collections = await this.selectCollections(database, this.controller.database, `Select collections to wipe from ${database.name}:`, true);
-            const { confirm } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "confirm",
-                    message: chalk.red(`Are you sure you want to wipe the selected collections from ${database.name}? This action cannot be undone.`),
-                    default: false,
-                },
-            ]);
-            if (confirm) {
-                console.log(chalk.yellow(`Wiping selected collections from ${database.name}...`));
+            const collections = await this.selectCollections(database, this.controller.database, `Select collections to wipe from ${database.name}:`, true, undefined, true);
+            const collectionNames = collections.map(c => 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 this.controller.wipeCollection(database, collection);
-                    console.log(chalk.green(`Collection ${collection.name} wiped successfully.`));
+                    MessageFormatter.success(`Collection ${collection.name} wiped successfully`, { prefix: "Wipe" });
                 }
             }
             else {
-                console.log(chalk.blue(`Wipe operation cancelled for ${database.name}.`));
+                MessageFormatter.info(`Wipe operation cancelled for ${database.name}`, { prefix: "Wipe" });
             }
         }
-        console.log(chalk.green("Wipe collections operation completed."));
+        MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
     }
     async generateSchemas() {
         console.log(chalk.yellow("Generating schemas..."));
-        await this.controller.generateSchemas();
-        console.log(chalk.green("Schema generation completed."));
+        // Prompt user for schema type preference
+        const { schemaType } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "schemaType",
+                message: "What type of schemas would you like to generate?",
+                choices: [
+                    { name: "TypeScript (Zod) schemas", value: "zod" },
+                    { name: "JSON schemas", value: "json" },
+                    { name: "Both TypeScript and JSON schemas", value: "both" },
+                ],
+                default: "both",
+            },
+        ]);
+        // Get the config folder path (where the config file is located)
+        const configFolderPath = this.controller.getAppwriteFolderPath();
+        if (!configFolderPath) {
+            MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
+            return;
+        }
+        // Create SchemaGenerator with the correct base path and generate schemas
+        const schemaGenerator = new SchemaGenerator(this.controller.config, configFolderPath);
+        schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
+        MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
     }
     async importData() {
         console.log(chalk.yellow("Importing data..."));
@@ -1295,4 +1382,61 @@ export class InteractiveCLI {
             console.error(chalk.red("Error updating function specification:"), error);
         }
     }
+    async detectConfigurationType() {
+        try {
+            // Check for YAML config first
+            const yamlConfigPath = findYamlConfig(this.currentDir);
+            if (yamlConfigPath) {
+                this.isUsingTypeScriptConfig = false;
+                MessageFormatter.info("Using YAML configuration", { prefix: "Config" });
+                return;
+            }
+            // Then check for TypeScript config
+            const configPath = findAppwriteConfig(this.currentDir);
+            if (configPath && configPath.endsWith('.ts')) {
+                this.isUsingTypeScriptConfig = true;
+                MessageFormatter.info("TypeScript configuration detected", { prefix: "Config" });
+                MessageFormatter.info("Consider migrating to YAML for better organization", { prefix: "Config" });
+                return;
+            }
+            // No config found
+            this.isUsingTypeScriptConfig = false;
+            MessageFormatter.info("No configuration file found", { prefix: "Config" });
+        }
+        catch (error) {
+            // Silently handle detection errors and continue
+            this.isUsingTypeScriptConfig = false;
+        }
+    }
+    buildChoicesList() {
+        const allChoices = Object.values(CHOICES);
+        if (this.isUsingTypeScriptConfig) {
+            // Place migration option at the top when TS config is detected
+            return [
+                CHOICES.MIGRATE_CONFIG,
+                ...allChoices.filter(choice => choice !== CHOICES.MIGRATE_CONFIG)
+            ];
+        }
+        else {
+            // Hide migration option when using YAML config
+            return allChoices.filter(choice => choice !== CHOICES.MIGRATE_CONFIG);
+        }
+    }
+    async migrateTypeScriptConfig() {
+        try {
+            MessageFormatter.info("Starting TypeScript to YAML configuration migration...", { prefix: "Migration" });
+            // Perform the migration
+            await migrateConfig(this.currentDir);
+            // Reset the detection flag
+            this.isUsingTypeScriptConfig = false;
+            // Reset the controller to pick up the new config
+            this.controller = undefined;
+            MessageFormatter.success("Migration completed successfully!", { prefix: "Migration" });
+            MessageFormatter.info("Your configuration has been migrated to the .appwrite directory structure", { prefix: "Migration" });
+            MessageFormatter.info("You can now use YAML configuration for easier management", { prefix: "Migration" });
+        }
+        catch (error) {
+            MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
+        }
+    }
 }