appwrite-utils-cli 0.9.992 → 0.9.994

package/dist/interactiveCLI.js

@@ -4,20 +4,27 @@ import { createEmptyCollection, setupDirsFiles } from "./utils/setupFiles.js";
 import { fetchAllDatabases } from "./databases/methods.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import { listBuckets, createBucket } from "./storage/methods.js";
-import { Databases, Storage, Client, Compression, Query, } from "node-appwrite";
+import { Databases, Storage, Client, Compression, Query, Functions, } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
-import { parseAttribute, PermissionToAppwritePermission, } from "appwrite-utils";
+import { AppwriteFunctionSchema, parseAttribute, PermissionToAppwritePermission, RuntimeSchema, permissionSchema, } from "appwrite-utils";
 import { ulid } from "ulidx";
 import chalk from "chalk";
 import { DateTime } from "luxon";
-import { listFunctions, listSpecifications } from "./functions/methods.js";
+import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, listFunctions, listSpecifications, } from "./functions/methods.js";
+import { deployLocalFunction } from "./functions/deployments.js";
+import { join } from "node:path";
+import fs from "node:fs";
+import { SchemaGenerator } from "./migrations/schemaStrings.js";
 var CHOICES;
 (function (CHOICES) {
     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";
+    CHOICES["DELETE_FUNCTION"] = "Delete function";
     CHOICES["SETUP_DIRS_FILES"] = "Setup directories and files";
     CHOICES["SETUP_DIRS_FILES_WITH_EXAMPLE_DATA"] = "Setup directories and files with example data";
     CHOICES["SYNC_DB"] = "Push local config to Appwrite";
-    CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "Synchronize configurations";
+    CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "Synchronize configurations - Pull from Appwrite and write to local config";
     CHOICES["TRANSFER_DATA"] = "Transfer data";
     CHOICES["BACKUP_DATABASE"] = "Backup database";
     CHOICES["WIPE_DATABASE"] = "Wipe database";
@@ -51,6 +58,18 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await this.createCollectionConfig();
                     break;
+                case CHOICES.CREATE_FUNCTION:
+                    await this.initControllerIfNeeded();
+                    await this.createFunction();
+                    break;
+                case CHOICES.DEPLOY_FUNCTION:
+                    await this.initControllerIfNeeded();
+                    await this.deployFunction();
+                    break;
+                case CHOICES.DELETE_FUNCTION:
+                    await this.initControllerIfNeeded();
+                    await this.deleteFunction();
+                    break;
                 case CHOICES.SETUP_DIRS_FILES:
                     await setupDirsFiles(false, this.currentDir);
                     break;
@@ -202,6 +221,283 @@ export class InteractiveCLI {
         ]);
         return selectedCollections;
     }
+    async createFunction() {
+        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: [
+                    "typescript-node",
+                    "poetry",
+                    "count-docs-in-collection",
+                    "none",
+                ],
+            },
+        ]);
+        const { runtime } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "runtime",
+                message: "Select runtime:",
+                choices: Object.values(RuntimeSchema.Values),
+            },
+        ]);
+        const specifications = await listSpecifications(this.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,
+                    })),
+                ],
+            },
+        ]);
+        const functionConfig = {
+            $id: ulid(),
+            name,
+            runtime,
+            events: [],
+            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,
+        };
+        if (template !== "none") {
+            await createFunctionTemplate(template, name, "./functions");
+        }
+        // Add to config
+        if (!this.controller.config.functions) {
+            this.controller.config.functions = [];
+        }
+        this.controller.config.functions.push(functionConfig);
+        console.log(chalk.green("✨ Function created successfully!"));
+    }
+    async findFunctionInSubdirectories(basePath, functionName) {
+        const queue = [basePath];
+        while (queue.length > 0) {
+            const currentPath = queue.shift();
+            try {
+                const entries = await fs.promises.readdir(currentPath, {
+                    withFileTypes: true,
+                });
+                // Check if function exists in current directory
+                const functionPath = join(currentPath, functionName);
+                if (fs.existsSync(functionPath)) {
+                    return functionPath;
+                }
+                // Add subdirectories to queue
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        queue.push(join(currentPath, entry.name));
+                    }
+                }
+            }
+            catch (error) {
+                console.log(chalk.yellow(`Skipping inaccessible directory: ${currentPath}`));
+            }
+        }
+        return null;
+    }
+    async deployFunction() {
+        await this.initControllerIfNeeded();
+        if (!this.controller?.config) {
+            console.log(chalk.red("Failed to initialize controller or load config"));
+            return;
+        }
+        const functions = await this.selectFunctions("Select function to deploy:", false, true);
+        if (!functions?.length) {
+            console.log(chalk.red("No function selected"));
+            return;
+        }
+        const functionConfig = functions[0];
+        if (!functionConfig) {
+            console.log(chalk.red("Invalid function configuration"));
+            return;
+        }
+        let functionPath = join(this.controller.getAppwriteFolderPath(), "functions", functionConfig.name);
+        if (!fs.existsSync(functionPath)) {
+            console.log(chalk.yellow(`Function not found in primary location, searching subdirectories...`));
+            const foundPath = await this.findFunctionInSubdirectories(this.controller.getAppwriteFolderPath(), functionConfig.name);
+            if (foundPath) {
+                console.log(chalk.green(`Found function at: ${foundPath}`));
+                functionPath = foundPath;
+                functionConfig.dirPath = foundPath;
+            }
+            else {
+                console.log(chalk.yellow(`Function ${functionConfig.name} not found locally in any subdirectory`));
+                const { shouldDownload } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "shouldDownload",
+                        message: "Would you like to download the latest deployment?",
+                        default: true,
+                    },
+                ]);
+                if (shouldDownload) {
+                    try {
+                        console.log(chalk.blue("Downloading latest deployment..."));
+                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(this.controller.appwriteServer, functionConfig.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
+                        console.log(chalk.green(`✨ Function downloaded to ${downloadedPath}`));
+                        // Update the config and functions array safely
+                        this.controller.config.functions =
+                            this.controller.config.functions || [];
+                        const newFunction = {
+                            $id: remoteFunction.$id,
+                            name: remoteFunction.name,
+                            runtime: remoteFunction.runtime,
+                            execute: remoteFunction.execute || [],
+                            events: remoteFunction.events || [],
+                            schedule: remoteFunction.schedule || "",
+                            timeout: remoteFunction.timeout || 15,
+                            enabled: remoteFunction.enabled !== false,
+                            logging: remoteFunction.logging !== false,
+                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
+                            commands: remoteFunction.commands || "npm install",
+                            dirPath: downloadedPath,
+                            scopes: (remoteFunction.scopes || []),
+                            installationId: remoteFunction.installationId,
+                            providerRepositoryId: remoteFunction.providerRepositoryId,
+                            providerBranch: remoteFunction.providerBranch,
+                            providerSilentMode: remoteFunction.providerSilentMode,
+                            providerRootDirectory: remoteFunction.providerRootDirectory,
+                            specification: remoteFunction.specification,
+                        };
+                        const existingIndex = this.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
+                        if (existingIndex >= 0) {
+                            this.controller.config.functions[existingIndex] = newFunction;
+                        }
+                        else {
+                            this.controller.config.functions.push(newFunction);
+                        }
+                        const schemaGenerator = new SchemaGenerator(this.controller.config, this.controller.getAppwriteFolderPath());
+                        schemaGenerator.updateConfig(this.controller.config);
+                        console.log(chalk.green("✨ Updated appwriteConfig.ts with new function"));
+                        await this.controller.reloadConfig();
+                        functionConfig.dirPath = downloadedPath;
+                    }
+                    catch (error) {
+                        console.error(chalk.red("Failed to download function deployment:"), error);
+                        return;
+                    }
+                }
+                else {
+                    console.log(chalk.yellow("Deployment cancelled"));
+                    return;
+                }
+            }
+        }
+        if (!this.controller.appwriteServer) {
+            console.log(chalk.red("Appwrite server not initialized"));
+            return;
+        }
+        await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, functionConfig);
+    }
+    async deleteFunction() {
+        const functions = await this.selectFunctions("Select functions to delete:", true, false);
+        if (!functions.length) {
+            console.log(chalk.red("No functions selected"));
+            return;
+        }
+        for (const func of functions) {
+            try {
+                await deleteFunction(this.controller.appwriteServer, func.$id);
+                console.log(chalk.green(`✨ Function ${func.name} deleted successfully!`));
+            }
+            catch (error) {
+                console.error(chalk.red(`Failed to delete function ${func.name}:`), error);
+            }
+        }
+    }
+    async selectFunctions(message, multiSelect = true, preferLocal = false) {
+        await this.initControllerIfNeeded();
+        const configFunctions = this.getLocalFunctions();
+        let remoteFunctions = [];
+        try {
+            const functions = await this.controller.listAllFunctions();
+            remoteFunctions = functions;
+        }
+        catch (error) {
+            console.log(chalk.yellow(`Note: Remote functions not available, using only local functions`));
+        }
+        // Combine functions based on whether we're deploying or not
+        const allFunctions = preferLocal
+            ? [
+                ...configFunctions,
+                ...remoteFunctions.map((f) => AppwriteFunctionSchema.parse(f)),
+            ]
+            : [
+                ...remoteFunctions.map((f) => AppwriteFunctionSchema.parse(f)),
+                ...configFunctions.filter((f) => !remoteFunctions.some((rf) => rf.name === f.name)),
+            ];
+        if (allFunctions.length === 0) {
+            console.log(chalk.red("No functions available"));
+            return [];
+        }
+        const choices = allFunctions
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((func) => ({
+            name: func.name,
+            value: func,
+        }));
+        const { selectedFunctions } = await inquirer.prompt([
+            {
+                type: multiSelect ? "checkbox" : "list",
+                name: "selectedFunctions",
+                message: chalk.blue(message),
+                choices,
+                loop: true,
+                pageSize: 10,
+            },
+        ]);
+        // For single selection, ensure we return an array
+        if (!multiSelect) {
+            return selectedFunctions ? [selectedFunctions] : [];
+        }
+        return selectedFunctions || [];
+    }
+    getLocalFunctions() {
+        const configFunctions = this.controller.config?.functions || [];
+        return configFunctions.map((f) => ({
+            $id: f.$id || ulid(),
+            $createdAt: DateTime.now().toISO(),
+            $updatedAt: DateTime.now().toISO(),
+            name: f.name,
+            runtime: f.runtime,
+            execute: f.execute || ["any"],
+            events: f.events || [],
+            schedule: f.schedule || "",
+            timeout: f.timeout || 15,
+            enabled: f.enabled !== false,
+            logging: f.logging !== false,
+            entrypoint: f.entrypoint || "src/index.ts",
+            commands: f.commands || "npm install",
+            path: f.dirPath || `functions/${f.name}`,
+            ...(f.specification ? { specification: f.specification } : {}),
+            ...(f.predeployCommands
+                ? { predeployCommands: f.predeployCommands }
+                : {}),
+            ...(f.deployDir ? { deployDir: f.deployDir } : {}),
+        }));
+    }
     async selectBuckets(buckets, message, multiSelect = true) {
         const choices = buckets.map((bucket) => ({
             name: bucket.name,
@@ -306,8 +602,10 @@ export class InteractiveCLI {
                     },
                 ]);
                 if (action === "assign") {
-                    const [selectedBucket] = await this.selectBuckets(allBuckets.buckets.filter((b) => !globalBuckets.some((gb) => gb.$id === b.$id)), `Select a bucket for the database "${database.name}":`, false);
-                    if (selectedBucket) {
+                    const selectedBuckets = await this.selectBuckets(allBuckets.buckets.filter((b) => !globalBuckets.some((gb) => gb.$id === b.$id)), `Select a bucket for the database "${database.name}":`, false // multiSelect = false
+                    );
+                    if (selectedBuckets.length > 0) {
+                        const selectedBucket = selectedBuckets[0];
                         database.bucket = {
                             $id: selectedBucket.$id,
                             name: selectedBucket.name,
@@ -317,6 +615,7 @@ export class InteractiveCLI {
                             compression: selectedBucket.compression,
                             encryption: selectedBucket.encryption,
                             antivirus: selectedBucket.antivirus,
+                            permissions: selectedBucket.$permissions.map((p) => permissionSchema.parse(p)),
                         };
                     }
                 }
@@ -411,23 +710,124 @@ export class InteractiveCLI {
     }
     async syncDb() {
         console.log(chalk.yellow("Syncing database..."));
+        const functionsClient = new Functions(this.controller.appwriteServer);
         const databases = await this.selectDatabases(await fetchAllDatabases(this.controller.database), chalk.blue("Select databases to synchronize:"), true);
         const collections = await this.selectCollections(databases[0], this.controller.database, chalk.blue("Select collections to synchronize:"), true, true // prefer local
         );
-        await this.controller.syncDb(databases, collections);
+        const answer = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "syncFunctions",
+                message: "Do you want to synchronize functions?",
+                default: false,
+            },
+        ]);
+        if (answer.syncFunctions) {
+            const functions = await this.selectFunctions(chalk.blue("Select functions to synchronize:"), true, true // prefer local
+            );
+            await this.controller.syncDb(databases, collections);
+            for (const func of functions) {
+                await deployLocalFunction(this.controller.appwriteServer, func.dirPath || `functions/${func.name}`, func);
+            }
+        }
         console.log(chalk.green("Database sync completed."));
     }
     async synchronizeConfigurations() {
-        if (!this.controller.database) {
-            throw new Error("Database is not initialized. Is the config file correct and created?");
+        console.log(chalk.blue("Synchronizing configurations..."));
+        await this.controller.init();
+        // Sync databases and buckets first
+        const { syncDatabases } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "syncDatabases",
+                message: "Do you want to synchronize databases and their buckets?",
+                default: true,
+            },
+        ]);
+        if (syncDatabases) {
+            const remoteDatabases = await fetchAllDatabases(this.controller.database);
+            const localDatabases = this.controller.config?.databases || [];
+            // Update config with remote databases that don't exist locally
+            const updatedConfig = await this.configureBuckets({
+                ...this.controller.config,
+                databases: [
+                    ...localDatabases,
+                    ...remoteDatabases.filter((rd) => !localDatabases.some((ld) => ld.name === rd.name)),
+                ],
+            });
+            this.controller.config = updatedConfig;
         }
-        const databases = await fetchAllDatabases(this.controller.database);
-        const selectedDatabases = await this.selectDatabases(databases, "Select databases to synchronize:");
-        console.log(chalk.yellow("Configuring storage buckets..."));
-        const updatedConfig = await this.configureBuckets(this.controller.config, selectedDatabases);
-        console.log(chalk.yellow("Synchronizing configurations..."));
-        await this.controller.synchronizeConfigurations(selectedDatabases, updatedConfig);
-        console.log(chalk.green("Configuration synchronization completed."));
+        // Then sync functions
+        const { syncFunctions } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "syncFunctions",
+                message: "Do you want to synchronize functions?",
+                default: true,
+            },
+        ]);
+        if (syncFunctions) {
+            const remoteFunctions = await this.controller.listAllFunctions();
+            const localFunctions = this.controller.config?.functions || [];
+            const allFunctions = [
+                ...remoteFunctions,
+                ...localFunctions.filter((f) => !remoteFunctions.some((rf) => rf.$id === f.$id)),
+            ];
+            for (const func of allFunctions) {
+                const hasLocal = localFunctions.some((lf) => lf.$id === func.$id);
+                const hasRemote = remoteFunctions.some((rf) => rf.$id === func.$id);
+                if (hasLocal && hasRemote) {
+                    const { preference } = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "preference",
+                            message: `Function "${func.name}" exists both locally and remotely. What would you like to do?`,
+                            choices: [
+                                {
+                                    name: "Keep local version (deploy to remote)",
+                                    value: "local",
+                                },
+                                { name: "Use remote version (download)", value: "remote" },
+                                { name: "Skip this function", value: "skip" },
+                            ],
+                        },
+                    ]);
+                    if (preference === "local") {
+                        await this.controller.deployFunction(func.name);
+                    }
+                    else if (preference === "remote") {
+                        await downloadLatestFunctionDeployment(this.controller.appwriteServer, func.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
+                    }
+                }
+                else if (hasLocal) {
+                    const { deploy } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "deploy",
+                            message: `Function "${func.name}" exists only locally. Deploy to remote?`,
+                            default: true,
+                        },
+                    ]);
+                    if (deploy) {
+                        await this.controller.deployFunction(func.name);
+                    }
+                }
+                else if (hasRemote) {
+                    const { download } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "download",
+                            message: `Function "${func.name}" exists only remotely. Download locally?`,
+                            default: true,
+                        },
+                    ]);
+                    if (download) {
+                        await downloadLatestFunctionDeployment(this.controller.appwriteServer, func.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
+                    }
+                }
+            }
+        }
+        console.log(chalk.green("✨ Configurations synchronized successfully!"));
     }
     async backupDatabase() {
         if (!this.controller.database) {
@@ -696,32 +1096,37 @@ export class InteractiveCLI {
         }
     }
     async updateFunctionSpec() {
-        const functions = await listFunctions(this.controller.appwriteServer, [
-            Query.limit(1000),
-        ]);
+        const remoteFunctions = await listFunctions(this.controller.appwriteServer, [Query.limit(1000)]);
+        const localFunctions = this.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: functions.functions.map(f => ({
-                    name: `${f.name} (${f.$id})`,
-                    value: f.$id
+                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(this.controller.appwriteServer);
         const { specification } = await inquirer.prompt([
             {
-                type: 'list',
-                name: 'specification',
-                message: 'Select new specification:',
+                type: "list",
+                name: "specification",
+                message: "Select new specification:",
                 choices: specifications.specifications.map((s) => ({
                     name: `${s.slug}`,
-                    value: s.slug
+                    value: s.slug,
                 })),
-            }
+            },
         ]);
         try {
             for (const functionId of functionsToUpdate.functionId) {
@@ -730,7 +1135,7 @@ export class InteractiveCLI {
             }
         }
         catch (error) {
-            console.error(chalk.red('Error updating function specification:'), error);
+            console.error(chalk.red("Error updating function specification:"), error);
         }
     }
 }

package/dist/migrations/appwriteToX.js

@@ -5,6 +5,7 @@ import { fetchAllDatabases } from "./databases.js";
 import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, parseAttribute, } from "appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
 import { listBuckets } from "../storage/methods.js";
+import { listFunctions } from "../functions/methods.js";
 export class AppwriteToX {
     config;
     storage;
@@ -153,7 +154,37 @@ export class AppwriteToX {
             encryption: bucket.encryption,
             antivirus: bucket.antivirus,
         }));
-        this.updatedConfig = updatedConfig;
+        const remoteFunctions = await listFunctions(this.config.appwriteClient, [
+            Query.limit(1000),
+        ]);
+        const functionDeployments = await Promise.all(remoteFunctions.functions.map(async (func) => {
+            const deployments = await this.config.appwriteClient.functions.listDeployments(func.$id, [Query.orderDesc("$createdAt"), Query.limit(1)]);
+            return {
+                function: func,
+                schemaStrings: deployments.deployments[0]?.schemaStrings || [],
+            };
+        }));
+        this.updatedConfig.functions = functionDeployments.map(({ function: func, schemaStrings }) => ({
+            $id: func.$id,
+            name: func.name,
+            runtime: func.runtime,
+            execute: func.execute,
+            events: func.events || [],
+            schedule: func.schedule || "",
+            timeout: func.timeout || 15,
+            enabled: func.enabled !== false,
+            logging: func.logging !== false,
+            entrypoint: func.entrypoint || "src/index.ts",
+            commands: func.commands || "npm install",
+            dirPath: `functions/${func.name}`,
+            specification: func.specification,
+            schemaStrings,
+        }));
+        // Make sure to update the config with all changes
+        this.updatedConfig = {
+            ...updatedConfig,
+            functions: this.updatedConfig.functions,
+        };
     }
     async toSchemas(databases) {
         await this.appwriteSync(this.config, databases);

package/dist/migrations/schemaStrings.d.ts

@@ -5,6 +5,7 @@ export declare class SchemaGenerator {
     private appwriteFolderPath;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
     updateTsSchemas(): void;
+    updateConfig(config: AppwriteConfig): void;
     private extractRelationships;
     private addRelationship;
     generateSchemas(): void;