appwrite-utils-cli 1.5.2 → 1.6.1

package/dist/cli/commands/functionCommands.js

@@ -0,0 +1,289 @@
+import inquirer from "inquirer";
+import { join } from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { ulid } from "ulidx";
+import chalk from "chalk";
+import { Query } from "node-appwrite";
+import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, listFunctions, listSpecifications, } from "../../functions/methods.js";
+import { deployLocalFunction } from "../../functions/deployments.js";
+import { addFunctionToYamlConfig, findYamlConfig } from "../../config/yamlConfig.js";
+import { RuntimeSchema } from "appwrite-utils";
+export const functionCommands = {
+    async createFunction(cli) {
+        const { name } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Function name:",
+                validate: (input) => input.length > 0,
+            },
+        ]);
+        const { template } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "template",
+                message: "Select a template:",
+                choices: [
+                    { name: "TypeScript Node.js", value: "typescript-node" },
+                    { name: "TypeScript with Hono Web Framework", value: "hono-typescript" },
+                    { 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 = cli.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(cli.controller.appwriteServer);
+        const { specification } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "specification",
+                message: "Select specification:",
+                choices: [
+                    { name: "None", value: undefined },
+                    ...specifications.specifications.map((s) => ({
+                        name: s.slug,
+                        value: s.slug,
+                    })),
+                ],
+                default: templateDefaults.specification,
+            },
+        ]);
+        const functionConfig = {
+            $id: ulid(),
+            name,
+            runtime,
+            events: [],
+            execute: ["any"],
+            enabled: true,
+            logging: true,
+            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 in-memory config
+        if (!cli.controller.config.functions) {
+            cli.controller.config.functions = [];
+        }
+        cli.controller.config.functions.push(functionConfig);
+        // If using YAML config, also add to YAML file
+        const yamlConfigPath = findYamlConfig(cli.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 deployFunction(cli) {
+        await cli.initControllerIfNeeded();
+        if (!cli.controller?.config) {
+            MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
+            return;
+        }
+        const functions = await cli.selectFunctions("Select function(s) to deploy:", true, true);
+        if (!functions?.length) {
+            MessageFormatter.error("No function selected", undefined, { prefix: "Functions" });
+            return;
+        }
+        for (const functionConfig of functions) {
+            if (!functionConfig) {
+                MessageFormatter.error("Invalid function configuration", undefined, { prefix: "Functions" });
+                return;
+            }
+            // Ensure functions array exists
+            if (!cli.controller.config.functions) {
+                cli.controller.config.functions = [];
+            }
+            const functionNameLower = functionConfig.name
+                .toLowerCase()
+                .replace(/\s+/g, "-");
+            // Debug logging
+            MessageFormatter.info(`🔍 Function deployment debug:`, { prefix: "Functions" });
+            MessageFormatter.info(`  Function name: ${functionConfig.name}`, { prefix: "Functions" });
+            MessageFormatter.info(`  Function ID: ${functionConfig.$id}`, { prefix: "Functions" });
+            MessageFormatter.info(`  Config dirPath: ${functionConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
+            if (functionConfig.dirPath) {
+                const expandedPath = functionConfig.dirPath.startsWith('~/')
+                    ? functionConfig.dirPath.replace('~', os.homedir())
+                    : functionConfig.dirPath;
+                MessageFormatter.info(`  Expanded dirPath: ${expandedPath}`, { prefix: "Functions" });
+            }
+            MessageFormatter.info(`  Appwrite folder: ${cli.controller.getAppwriteFolderPath()}`, { prefix: "Functions" });
+            MessageFormatter.info(`  Current working dir: ${process.cwd()}`, { prefix: "Functions" });
+            // Helper function to expand tilde in paths
+            const expandTildePath = (path) => {
+                if (path.startsWith('~/')) {
+                    return path.replace('~', os.homedir());
+                }
+                return path;
+            };
+            // Check locations in priority order:
+            const priorityLocations = [
+                // 1. Config dirPath if specified (with tilde expansion)
+                functionConfig.dirPath ? expandTildePath(functionConfig.dirPath) : undefined,
+                // 2. Appwrite config folder/functions/name
+                join(cli.controller.getAppwriteFolderPath(), "functions", functionNameLower),
+                // 3. Current working directory/functions/name
+                join(process.cwd(), "functions", functionNameLower),
+                // 4. Current working directory/name
+                join(process.cwd(), functionNameLower),
+            ].filter((val) => val !== undefined);
+            MessageFormatter.info(`🔍 Priority locations to check:`, { prefix: "Functions" });
+            priorityLocations.forEach((loc, i) => {
+                MessageFormatter.info(`  ${i + 1}. ${loc}`, { prefix: "Functions" });
+            });
+            let functionPath = null;
+            // Check each priority location
+            for (const location of priorityLocations) {
+                MessageFormatter.info(`  Checking: ${location} - ${fs.existsSync(location) ? 'EXISTS' : 'NOT FOUND'}`, { prefix: "Functions" });
+                if (fs.existsSync(location)) {
+                    MessageFormatter.success(`✅ Found function at: ${location}`, { prefix: "Functions" });
+                    functionPath = location;
+                    break;
+                }
+            }
+            // If not found in priority locations, do a broader search
+            if (!functionPath) {
+                MessageFormatter.info(`Function not found in primary locations, searching subdirectories...`, { prefix: "Functions" });
+                // Search in both appwrite config directory and current working directory
+                functionPath = await cli.findFunctionInSubdirectories([cli.controller.getAppwriteFolderPath(), process.cwd()], functionNameLower);
+            }
+            if (!functionPath) {
+                const { shouldDownload } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "shouldDownload",
+                        message: "Function not found locally. Would you like to download the latest deployment?",
+                        default: false,
+                    },
+                ]);
+                if (shouldDownload) {
+                    try {
+                        MessageFormatter.progress("Downloading latest deployment...", { prefix: "Functions" });
+                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(cli.controller.appwriteServer, functionConfig.$id, join(cli.controller.getAppwriteFolderPath(), "functions"));
+                        MessageFormatter.success(`✨ Function downloaded to ${downloadedPath}`, { prefix: "Functions" });
+                        functionPath = downloadedPath;
+                        functionConfig.dirPath = downloadedPath;
+                        const existingIndex = cli.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
+                        if (existingIndex >= 0) {
+                            cli.controller.config.functions[existingIndex].dirPath =
+                                downloadedPath;
+                        }
+                        await cli.reloadConfigWithSessionPreservation();
+                    }
+                    catch (error) {
+                        MessageFormatter.error("Failed to download function deployment", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+                        return;
+                    }
+                }
+                else {
+                    MessageFormatter.error(`Function ${functionConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
+                    return;
+                }
+            }
+            if (!cli.controller.appwriteServer) {
+                MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Functions" });
+                return;
+            }
+            try {
+                await deployLocalFunction(cli.controller.appwriteServer, functionConfig.name, {
+                    ...functionConfig,
+                    dirPath: functionPath,
+                }, functionPath);
+                MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
+            }
+            catch (error) {
+                MessageFormatter.error("Failed to deploy function", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+            }
+        }
+    },
+    async deleteFunction(cli) {
+        const functions = await cli.selectFunctions("Select functions to delete:", true, false);
+        if (!functions.length) {
+            MessageFormatter.error("No functions selected", undefined, { prefix: "Functions" });
+            return;
+        }
+        for (const func of functions) {
+            try {
+                await deleteFunction(cli.controller.appwriteServer, func.$id);
+                MessageFormatter.success(`✨ Function ${func.name} deleted successfully!`, { prefix: "Functions" });
+            }
+            catch (error) {
+                MessageFormatter.error(`Failed to delete function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+            }
+        }
+    },
+    async updateFunctionSpec(cli) {
+        const remoteFunctions = await listFunctions(cli.controller.appwriteServer, [Query.limit(1000)]);
+        const localFunctions = cli.getLocalFunctions();
+        const allFunctions = [
+            ...remoteFunctions.functions,
+            ...localFunctions.filter((f) => !remoteFunctions.functions.some((rf) => rf.name === f.name)),
+        ];
+        const functionsToUpdate = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "functionId",
+                message: "Select functions to update:",
+                choices: allFunctions.map((f) => ({
+                    name: `${f.name} (${f.$id})${localFunctions.some((lf) => lf.name === f.name)
+                        ? " (Local)"
+                        : " (Remote)"}`,
+                    value: f.$id,
+                })),
+                loop: true,
+            },
+        ]);
+        const specifications = await listSpecifications(cli.controller.appwriteServer);
+        const { specification } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "specification",
+                message: "Select new specification:",
+                choices: specifications.specifications.map((s) => ({
+                    name: `${s.slug}`,
+                    value: s.slug,
+                })),
+            },
+        ]);
+        try {
+            for (const functionId of functionsToUpdate.functionId) {
+                await cli.controller.updateFunctionSpecifications(functionId, specification);
+                MessageFormatter.success(`Successfully updated function specification to ${specification}`, { prefix: "Functions" });
+            }
+        }
+        catch (error) {
+            MessageFormatter.error("Error updating function specification", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
+        }
+    }
+};

package/dist/cli/commands/schemaCommands.d.ts

@@ -0,0 +1,7 @@
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare const schemaCommands: {
+    generateSchemas(cli: InteractiveCLI): Promise<void>;
+    generateConstants(cli: InteractiveCLI): Promise<void>;
+    importData(cli: InteractiveCLI): Promise<void>;
+    setupDirsFiles(cli: InteractiveCLI, withExampleData?: boolean): Promise<void>;
+};

package/dist/cli/commands/schemaCommands.js

@@ -0,0 +1,134 @@
+import inquirer from "inquirer";
+import path from "path";
+import chalk from "chalk";
+import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { SchemaGenerator } from "../../shared/schemaGenerator.js";
+import { setupDirsFiles } from "../../utils/setupFiles.js";
+import { fetchAllDatabases } from "../../databases/methods.js";
+export const schemaCommands = {
+    async generateSchemas(cli) {
+        MessageFormatter.progress("Generating schemas...", { prefix: "Schemas" });
+        // 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 = cli.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(cli.controller.config, configFolderPath);
+        schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
+        MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
+    },
+    async generateConstants(cli) {
+        MessageFormatter.progress("Generating cross-language constants...", { prefix: "Constants" });
+        if (!cli.controller?.config) {
+            MessageFormatter.error("No configuration found", undefined, { prefix: "Constants" });
+            return;
+        }
+        // Prompt for languages
+        const { languages } = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "languages",
+                message: "Select languages for constants generation:",
+                choices: [
+                    { name: "TypeScript", value: "typescript", checked: true },
+                    { name: "JavaScript", value: "javascript" },
+                    { name: "Python", value: "python" },
+                    { name: "PHP", value: "php" },
+                    { name: "Dart", value: "dart" },
+                    { name: "JSON", value: "json" },
+                    { name: "Environment Variables", value: "env" },
+                ],
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return "Please select at least one language";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        // Determine default output directory based on config location
+        const configPath = cli.controller.getAppwriteFolderPath();
+        const defaultOutputDir = configPath
+            ? path.join(configPath, "constants")
+            : path.join(process.cwd(), "constants");
+        // Prompt for output directory
+        const { outputDir } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "outputDir",
+                message: "Output directory for constants files:",
+                default: defaultOutputDir,
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return "Output directory cannot be empty";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        try {
+            const { ConstantsGenerator } = await import("../../utils/constantsGenerator.js");
+            const generator = new ConstantsGenerator(cli.controller.config);
+            MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
+            await generator.generateFiles(languages, outputDir);
+            MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+        }
+        catch (error) {
+            MessageFormatter.error("Failed to generate constants", error instanceof Error ? error : new Error(String(error)), { prefix: "Constants" });
+        }
+    },
+    async importData(cli) {
+        MessageFormatter.progress("Importing data...", { prefix: "Import" });
+        const { doBackup } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "doBackup",
+                message: "Do you want to perform a backup before importing?",
+                default: true,
+            },
+        ]);
+        const databases = await cli.selectDatabases(await fetchAllDatabases(cli.controller.database), "Select databases to import data into:", true);
+        const collections = await cli.selectCollectionsAndTables(databases[0], cli.controller.database, "Select collections/tables to import data into (leave empty for all):", true);
+        const { shouldWriteFile } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "shouldWriteFile",
+                message: "Do you want to write the imported data to a file?",
+                default: false,
+            },
+        ]);
+        const options = {
+            databases,
+            collections: collections.map((c) => c.name),
+            doBackup,
+            importData: true,
+            shouldWriteFile,
+        };
+        try {
+            await cli.controller.importData(options);
+            MessageFormatter.success("Data import completed successfully", { prefix: "Import" });
+        }
+        catch (error) {
+            MessageFormatter.error("Error importing data", error instanceof Error ? error : new Error(String(error)), { prefix: "Import" });
+        }
+    },
+    async setupDirsFiles(cli, withExampleData = false) {
+        await setupDirsFiles(withExampleData, cli.currentDir);
+    }
+};

package/dist/cli/commands/transferCommands.d.ts

@@ -0,0 +1,5 @@
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare const transferCommands: {
+    transferData(cli: InteractiveCLI): Promise<void>;
+    comprehensiveTransfer(cli: InteractiveCLI): Promise<void>;
+};