appwrite-utils-cli 0.9.992 → 0.9.994

package/dist/migrations/schemaStrings.js

@@ -4,6 +4,7 @@ import fs from "fs";
 import path from "path";
 import { dump } from "js-yaml";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
+import { ulid } from "ulidx";
 export class SchemaGenerator {
     relationshipMap = new Map();
     config;
@@ -15,7 +16,9 @@ export class SchemaGenerator {
     }
     updateTsSchemas() {
         const collections = this.config.collections;
+        const functions = this.config.functions || [];
         delete this.config.collections;
+        delete this.config.functions;
         const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
         const configContent = `import { type AppwriteConfig } from "appwrite-utils";
   
@@ -30,8 +33,33 @@ export class SchemaGenerator {
     enableMockData: ${this.config.enableMockData},
     documentBucketId: "${this.config.documentBucketId}",
     usersCollectionName: "${this.config.usersCollectionName}",
-    databases: ${JSON.stringify(this.config.databases)},
-    buckets: ${JSON.stringify(this.config.buckets)}
+    databases: ${JSON.stringify(this.config.databases, null, 4)},
+    buckets: ${JSON.stringify(this.config.buckets, null, 4)},
+    functions: ${JSON.stringify(functions.map((func) => ({
+            functionId: func.$id || ulid(),
+            name: func.name,
+            runtime: func.runtime,
+            path: func.dirPath || `functions/${func.name}`,
+            entrypoint: func.entrypoint || "src/index.ts",
+            execute: func.execute,
+            events: func.events || [],
+            schedule: func.schedule || "",
+            timeout: func.timeout || 15,
+            enabled: func.enabled !== false,
+            logging: func.logging !== false,
+            commands: func.commands || "npm install",
+            scopes: func.scopes || [],
+            installationId: func.installationId,
+            providerRepositoryId: func.providerRepositoryId,
+            providerBranch: func.providerBranch,
+            providerSilentMode: func.providerSilentMode,
+            providerRootDirectory: func.providerRootDirectory,
+            specification: func.specification,
+            ...(func.predeployCommands
+                ? { predeployCommands: func.predeployCommands }
+                : {}),
+            ...(func.deployDir ? { deployDir: func.deployDir } : {}),
+        })), null, 4)}
   };
   
   export default appwriteConfig;
@@ -106,6 +134,50 @@ export class SchemaGenerator {
             console.log(`Collection schema written to ${collectionFilePath}`);
         });
     }
+    updateConfig(config) {
+        const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
+        const configContent = `import { type AppwriteConfig } from "appwrite-utils";
+
+const appwriteConfig: AppwriteConfig = {
+  appwriteEndpoint: "${config.appwriteEndpoint}",
+  appwriteProject: "${config.appwriteProject}",
+  appwriteKey: "${config.appwriteKey}",
+  enableBackups: ${config.enableBackups},
+  backupInterval: ${config.backupInterval},
+  backupRetention: ${config.backupRetention},
+  enableBackupCleanup: ${config.enableBackupCleanup},
+  enableMockData: ${config.enableMockData},
+  documentBucketId: "${config.documentBucketId}",
+  usersCollectionName: "${config.usersCollectionName}",
+  databases: ${JSON.stringify(config.databases, null, 4)},
+  buckets: ${JSON.stringify(config.buckets, null, 4)},
+  functions: ${JSON.stringify(config.functions?.map((func) => ({
+            $id: func.$id || ulid(),
+            name: func.name,
+            runtime: func.runtime,
+            dirPath: func.dirPath || `functions/${func.name}`,
+            entrypoint: func.entrypoint || "src/index.ts",
+            execute: func.execute || [],
+            events: func.events || [],
+            schedule: func.schedule || "",
+            timeout: func.timeout || 15,
+            enabled: func.enabled !== false,
+            logging: func.logging !== false,
+            commands: func.commands || "npm install",
+            scopes: func.scopes || [],
+            installationId: func.installationId,
+            providerRepositoryId: func.providerRepositoryId,
+            providerBranch: func.providerBranch,
+            providerSilentMode: func.providerSilentMode,
+            providerRootDirectory: func.providerRootDirectory,
+            specification: func.specification,
+        })), null, 4)}
+};
+
+export default appwriteConfig;
+`;
+        fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
+    }
     extractRelationships() {
         if (!this.config.collections) {
             return;

package/dist/migrations/transfer.js

@@ -2,8 +2,11 @@ import { tryAwaitWithRetry } from "appwrite-utils";
 import { Client, Databases, IndexType, Query, Storage, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { getAppwriteClient } from "../utils/helperFunctions.js";
-import { createOrUpdateAttribute } from "../collections/attributes.js";
+import { createOrUpdateAttribute, createUpdateCollectionAttributes, } from "../collections/attributes.js";
 import { parseAttribute } from "appwrite-utils";
+import chalk from "chalk";
+import { fetchAllCollections } from "src/collections/methods.js";
+import { createOrUpdateIndex, createOrUpdateIndexes, } from "src/collections/indexes.js";
 export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
     console.log(`Transferring files from ${fromBucketId} to ${toBucketId}`);
     let lastFileId;
@@ -70,6 +73,7 @@ export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucke
             }
             catch (error) {
                 // File already exists, so we can skip it
+                console.log(chalk.yellow(`File ${file.$id} already exists, skipping...`));
                 continue;
             }
             numberOfFiles++;
@@ -107,6 +111,7 @@ export const transferStorageLocalToRemote = async (localStorage, endpoint, proje
         }
         catch (error) {
             // File already exists, so we can skip it
+            console.log(chalk.yellow(`File ${file.$id} already exists, skipping...`));
             continue;
         }
         numberOfFiles++;
@@ -244,146 +249,130 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint
  * @return {Promise<void>} A promise that resolves when the transfer is complete.
  */
 export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId) => {
-    let lastCollectionId;
-    let fromCollections = await tryAwaitWithRetry(async () => await localDb.listCollections(fromDbId, [Query.limit(50)]));
-    const allFromCollections = fromCollections.collections;
-    if (fromCollections.collections.length < 50) {
-        lastCollectionId = undefined;
-    }
-    else {
-        lastCollectionId =
-            fromCollections.collections[fromCollections.collections.length - 1].$id;
-        while (lastCollectionId) {
-            const collections = await localDb.listCollections(fromDbId, [
-                Query.limit(50),
-                Query.cursorAfter(lastCollectionId),
-            ]);
-            allFromCollections.push(...collections.collections);
-            if (collections.collections.length < 50) {
-                break;
-            }
-            lastCollectionId =
-                collections.collections[collections.collections.length - 1].$id;
-        }
-    }
-    lastCollectionId = undefined;
-    let toCollections = await tryAwaitWithRetry(async () => await localDb.listCollections(targetDbId, [Query.limit(50)]));
-    const allToCollections = toCollections.collections;
-    if (toCollections.collections.length < 50) {
-    }
-    else {
-        lastCollectionId =
-            toCollections.collections[toCollections.collections.length - 1].$id;
-        while (lastCollectionId) {
-            const collections = await localDb.listCollections(targetDbId, [
-                Query.limit(50),
-                Query.cursorAfter(lastCollectionId),
-            ]);
-            allToCollections.push(...collections.collections);
-            if (collections.collections.length < 50) {
-                lastCollectionId = undefined;
+    // Get all collections from source database
+    const sourceCollections = await fetchAllCollections(fromDbId, localDb);
+    console.log(chalk.blue(`Found ${sourceCollections.length} collections in source database`));
+    // Process each collection
+    for (const collection of sourceCollections) {
+        console.log(chalk.yellow(`Processing collection: ${collection.name} (${collection.$id})`));
+        try {
+            // Create or update collection in target
+            let targetCollection;
+            const existingCollection = await tryAwaitWithRetry(async () => localDb.listCollections(targetDbId, [
+                Query.equal("$id", collection.$id),
+            ]));
+            if (existingCollection.collections.length > 0) {
+                targetCollection = existingCollection.collections[0];
+                console.log(chalk.green(`Collection ${collection.name} exists in target database`));
+                // Update collection if needed
+                if (targetCollection.name !== collection.name ||
+                    targetCollection.$permissions !== collection.$permissions ||
+                    targetCollection.documentSecurity !== collection.documentSecurity ||
+                    targetCollection.enabled !== collection.enabled) {
+                    targetCollection = await tryAwaitWithRetry(async () => localDb.updateCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+                    console.log(chalk.green(`Collection ${collection.name} updated`));
+                }
             }
             else {
-                lastCollectionId =
-                    collections.collections[collections.collections.length - 1].$id;
+                console.log(chalk.yellow(`Creating collection ${collection.name} in target database...`));
+                targetCollection = await tryAwaitWithRetry(async () => localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-        }
-    }
-    for (const collection of allFromCollections) {
-        const toCollection = allToCollections.find((c) => c.$id === collection.$id);
-        if (toCollection) {
-            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, toCollection.$id);
-        }
-        else {
-            console.log(`Collection ${collection.name} not found in destination database, creating...`);
-            const newCollection = await tryAwaitWithRetry(async () => await localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
-            console.log(`Collection ${newCollection.name} created`);
+            // Handle attributes
+            const existingAttributes = await tryAwaitWithRetry(async () => await localDb.listAttributes(targetDbId, targetCollection.$id));
             for (const attribute of collection.attributes) {
-                await tryAwaitWithRetry(async () => await createOrUpdateAttribute(localDb, targetDbId, newCollection, parseAttribute(attribute)));
+                const parsedAttribute = parseAttribute(attribute);
+                const existingAttribute = existingAttributes.attributes.find((attr) => attr.key === parsedAttribute.key);
+                if (!existingAttribute) {
+                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(localDb, targetDbId, targetCollection, parsedAttribute));
+                    console.log(chalk.green(`Attribute ${parsedAttribute.key} created`));
+                }
+                else {
+                    console.log(chalk.blue(`Attribute ${parsedAttribute.key} exists, checking for updates...`));
+                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(localDb, targetDbId, targetCollection, parsedAttribute));
+                }
             }
+            // Handle indexes
+            const existingIndexes = await tryAwaitWithRetry(async () => await localDb.listIndexes(targetDbId, targetCollection.$id));
             for (const index of collection.indexes) {
-                await tryAwaitWithRetry(async () => await localDb.createIndex(targetDbId, newCollection.$id, index.key, index.type, index.attributes, index.orders));
+                const existingIndex = existingIndexes.indexes.find((idx) => idx.key === index.key);
+                if (!existingIndex) {
+                    await createOrUpdateIndex(targetDbId, localDb, targetCollection.$id, index);
+                    console.log(chalk.green(`Index ${index.key} created`));
+                }
+                else {
+                    console.log(chalk.blue(`Index ${index.key} exists, checking for updates...`));
+                    await createOrUpdateIndex(targetDbId, localDb, targetCollection.$id, index);
+                }
             }
-            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, newCollection.$id);
+            // Transfer documents
+            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, targetCollection.$id);
+        }
+        catch (error) {
+            console.error(chalk.red(`Error processing collection ${collection.name}:`), error);
         }
     }
 };
 export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId) => {
     const client = getAppwriteClient(endpoint, projectId, apiKey);
     const remoteDb = new Databases(client);
-    let lastCollectionId;
-    let fromCollections = await tryAwaitWithRetry(async () => await localDb.listCollections(fromDbId, [Query.limit(50)]));
-    const allFromCollections = fromCollections.collections;
-    if (fromCollections.collections.length >= 50) {
-        lastCollectionId =
-            fromCollections.collections[fromCollections.collections.length - 1].$id;
-        while (lastCollectionId) {
-            const collections = await tryAwaitWithRetry(async () => await localDb.listCollections(fromDbId, [
-                Query.limit(50),
-                Query.cursorAfter(lastCollectionId),
-            ]));
-            allFromCollections.push(...collections.collections);
-            if (collections.collections.length < 50) {
-                break;
-            }
-            lastCollectionId =
-                collections.collections[collections.collections.length - 1].$id;
-        }
-    }
-    for (const collection of allFromCollections) {
-        let toCollection;
-        const toCollectionExists = await tryAwaitWithRetry(async () => await remoteDb.listCollections(toDbId, [
-            Query.equal("$id", collection.$id),
-        ]));
-        if (toCollectionExists.collections.length > 0) {
-            console.log(`Collection ${collection.name} already exists. Updating...`);
-            toCollection = toCollectionExists.collections[0];
-            // Update collection if needed
-            if (toCollection.name !== collection.name ||
-                toCollection.$permissions !== collection.$permissions ||
-                toCollection.documentSecurity !== collection.documentSecurity ||
-                toCollection.enabled !== collection.enabled) {
-                toCollection = await tryAwaitWithRetry(async () => await remoteDb.updateCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
-                console.log(`Collection ${toCollection.name} updated`);
-            }
-        }
-        else {
-            toCollection = await tryAwaitWithRetry(async () => await remoteDb.createCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
-            console.log(`Collection ${toCollection.name} created`);
-        }
-        // Check and update attributes
-        const existingAttributes = await tryAwaitWithRetry(async () => await remoteDb.listAttributes(toDbId, toCollection.$id));
-        for (const attribute of collection.attributes) {
-            const parsedAttribute = parseAttribute(attribute);
-            const existingAttribute = existingAttributes.attributes.find(
-            // @ts-expect-error
-            (attr) => attr.key === parsedAttribute.key);
-            if (!existingAttribute) {
-                await tryAwaitWithRetry(async () => await createOrUpdateAttribute(remoteDb, toDbId, toCollection, parsedAttribute));
-                console.log(`Attribute ${parsedAttribute.key} created`);
+    // Get all collections from source database
+    const sourceCollections = await fetchAllCollections(fromDbId, localDb);
+    console.log(chalk.blue(`Found ${sourceCollections.length} collections in source database`));
+    // Process each collection
+    for (const collection of sourceCollections) {
+        console.log(chalk.yellow(`Processing collection: ${collection.name} (${collection.$id})`));
+        try {
+            // Create or update collection in target
+            let targetCollection;
+            const existingCollection = await tryAwaitWithRetry(async () => remoteDb.listCollections(toDbId, [Query.equal("$id", collection.$id)]));
+            if (existingCollection.collections.length > 0) {
+                targetCollection = existingCollection.collections[0];
+                console.log(chalk.green(`Collection ${collection.name} exists in remote database`));
+                // Update collection if needed
+                if (targetCollection.name !== collection.name ||
+                    targetCollection.$permissions !== collection.$permissions ||
+                    targetCollection.documentSecurity !== collection.documentSecurity ||
+                    targetCollection.enabled !== collection.enabled) {
+                    targetCollection = await tryAwaitWithRetry(async () => remoteDb.updateCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+                    console.log(chalk.green(`Collection ${collection.name} updated`));
+                }
             }
             else {
-                // Check if attribute needs updating
-                // Note: Appwrite doesn't allow updating most attribute properties
-                // You might need to delete and recreate the attribute if significant changes are needed
-                console.log(`Attribute ${parsedAttribute.key} already exists`);
+                console.log(chalk.yellow(`Creating collection ${collection.name} in remote database...`));
+                targetCollection = await tryAwaitWithRetry(async () => remoteDb.createCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-        }
-        // Check and update indexes
-        const existingIndexes = await tryAwaitWithRetry(async () => await remoteDb.listIndexes(toDbId, toCollection.$id));
-        for (const index of collection.indexes) {
-            const existingIndex = existingIndexes.indexes.find((idx) => idx.key === index.key);
-            if (!existingIndex) {
-                await tryAwaitWithRetry(async () => await remoteDb.createIndex(toDbId, toCollection.$id, index.key, index.type, index.attributes, index.orders));
-                console.log(`Index ${index.key} created`);
+            // Handle attributes
+            const existingAttributes = await tryAwaitWithRetry(async () => await remoteDb.listAttributes(toDbId, targetCollection.$id));
+            for (const attribute of collection.attributes) {
+                const parsedAttribute = parseAttribute(attribute);
+                const existingAttribute = existingAttributes.attributes.find((attr) => attr.key === parsedAttribute.key);
+                if (!existingAttribute) {
+                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(remoteDb, toDbId, targetCollection, parsedAttribute));
+                    console.log(chalk.green(`Attribute ${parsedAttribute.key} created`));
+                }
+                else {
+                    console.log(chalk.blue(`Attribute ${parsedAttribute.key} exists, checking for updates...`));
+                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(remoteDb, toDbId, targetCollection, parsedAttribute));
+                }
             }
-            else {
-                // Check if index needs updating
-                // Note: Appwrite doesn't allow updating indexes
-                // You might need to delete and recreate the index if changes are needed
-                console.log(`Index ${index.key} already exists`);
+            // Handle indexes
+            const existingIndexes = await tryAwaitWithRetry(async () => await remoteDb.listIndexes(toDbId, targetCollection.$id));
+            for (const index of collection.indexes) {
+                const existingIndex = existingIndexes.indexes.find((idx) => idx.key === index.key);
+                if (!existingIndex) {
+                    await createOrUpdateIndex(toDbId, remoteDb, targetCollection.$id, index);
+                    console.log(chalk.green(`Index ${index.key} created`));
+                }
+                else {
+                    console.log(chalk.blue(`Index ${index.key} exists, checking for updates...`));
+                    await createOrUpdateIndex(toDbId, remoteDb, targetCollection.$id, index);
+                }
             }
+            // Transfer documents
+            await transferDocumentsBetweenDbsLocalToRemote(localDb, endpoint, projectId, apiKey, fromDbId, toDbId, collection.$id, targetCollection.$id);
+        }
+        catch (error) {
+            console.error(chalk.red(`Error processing collection ${collection.name}:`), error);
         }
-        await transferDocumentsBetweenDbsLocalToRemote(localDb, endpoint, projectId, apiKey, fromDbId, toDbId, collection.$id, toCollection.$id);
     }
 };

package/dist/utils/loadConfigs.d.ts

@@ -11,3 +11,4 @@ export declare const findAppwriteConfig: (dir: string) => string | null;
  * @returns The loaded Appwrite configuration including collections.
  */
 export declare const loadConfig: (configDir: string) => Promise<AppwriteConfig>;
+export declare const findFunctionsDir: (dir: string) => string | null;

package/dist/utils/loadConfigs.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import {} from "appwrite-utils";
 import { register } from "tsx/esm/api"; // Import the register function
 import { pathToFileURL } from "node:url";
+import chalk from "chalk";
 /**
  * Recursively searches for a file named 'appwriteConfig.ts' starting from the given directory.
  * @param dir The directory to start the search from.
@@ -66,3 +67,21 @@ export const loadConfig = async (configDir) => {
         unregister(); // Unregister tsx when done
     }
 };
+export const findFunctionsDir = (dir) => {
+    if (dir === "node_modules") {
+        return null;
+    }
+    const files = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of files) {
+        if (!entry.isDirectory() || entry.name === "node_modules") {
+            continue;
+        }
+        if (entry.name === "functions") {
+            return path.join(dir, entry.name);
+        }
+        const result = findFunctionsDir(path.join(dir, entry.name));
+        if (result)
+            return result;
+    }
+    return null;
+};

package/dist/utils/schemaStrings.js

@@ -4,6 +4,8 @@ import { z } from "zod";
 import fs from "fs";
 import path from "path";
 import { dump } from "js-yaml";
+import { findFunctionsDir } from "./loadConfigs.js";
+import { ulid } from "ulidx";
 export class SchemaGenerator {
     relationshipMap = new Map();
     config;
@@ -15,7 +17,9 @@ export class SchemaGenerator {
     }
     updateTsSchemas() {
         const collections = this.config.collections;
+        const functions = this.config.functions || [];
         delete this.config.collections;
+        delete this.config.functions;
         const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
         const configContent = `import { type AppwriteConfig } from "appwrite-utils";
   
@@ -32,6 +36,29 @@ export class SchemaGenerator {
     usersCollectionName: "${this.config.usersCollectionName}",
     databases: ${JSON.stringify(this.config.databases)},
     buckets: ${JSON.stringify(this.config.buckets)},
+    functions: ${JSON.stringify(functions.map(func => ({
+            functionId: func.$id || ulid(),
+            name: func.name,
+            runtime: func.runtime,
+            path: func.dirPath || `functions/${func.name}`,
+            entrypoint: func.entrypoint || 'src/index.ts',
+            execute: func.execute,
+            events: func.events || [],
+            schedule: func.schedule || '',
+            timeout: func.timeout || 15,
+            enabled: func.enabled !== false,
+            logging: func.logging !== false,
+            commands: func.commands || 'npm install',
+            scopes: func.scopes || [],
+            installationId: func.installationId,
+            providerRepositoryId: func.providerRepositoryId,
+            providerBranch: func.providerBranch,
+            providerSilentMode: func.providerSilentMode,
+            providerRootDirectory: func.providerRootDirectory,
+            specification: func.specification,
+            ...(func.predeployCommands ? { predeployCommands: func.predeployCommands } : {}),
+            ...(func.deployDir ? { deployDir: func.deployDir } : {})
+        })), null, 2)}
   };
   
   export default appwriteConfig;

package/dist/utilsController.d.ts

@@ -1,5 +1,5 @@
 import { Client, Databases, Storage, type Models } from "node-appwrite";
-import { type AppwriteConfig, type Specification } from "appwrite-utils";
+import { type AppwriteConfig, type AppwriteFunction, type Specification } from "appwrite-utils";
 import { type AfterImportActions, type ConverterFunctions, type ValidationRules } from "appwrite-utils";
 import { type TransferOptions } from "./migrations/transfer.js";
 export interface SetupOptions {
@@ -36,6 +36,10 @@ export declare class UtilsController {
     wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;
     wipeUsers(): Promise<void>;
     backupDatabase(database: Models.Database): Promise<void>;
+    listAllFunctions(): Promise<Models.Function[]>;
+    findFunctionDirectories(): Promise<Map<any, any>>;
+    deployFunction(functionName: string, functionPath?: string, functionConfig?: AppwriteFunction): Promise<void>;
+    syncFunctions(): Promise<void>;
     wipeDatabase(database: Models.Database, wipeBucket?: boolean): Promise<void>;
     wipeBucketFromDatabase(database: Models.Database): Promise<void>;
     wipeCollection(database: Models.Database, collection: Models.Collection): Promise<void>;

package/dist/utilsController.js

@@ -1,6 +1,6 @@
 import { Client, Databases, Query, Storage } from "node-appwrite";
 import {} from "appwrite-utils";
-import { loadConfig, findAppwriteConfig } from "./utils/loadConfigs.js";
+import { loadConfig, findAppwriteConfig, findFunctionsDir } from "./utils/loadConfigs.js";
 import { UsersController } from "./migrations/users.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
@@ -14,8 +14,10 @@ import { afterImportActions } from "./migrations/afterImportActions.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, } from "./migrations/transfer.js";
 import { getClient } from "./utils/getClientFromConfig.js";
 import { fetchAllDatabases } from "./migrations/databases.js";
-import { updateFunctionSpecifications } from "./functions/methods.js";
+import { listFunctions, updateFunctionSpecifications } from "./functions/methods.js";
 import chalk from "chalk";
+import { deployLocalFunction } from "./functions/deployments.js";
+import fs from "node:fs";
 export class UtilsController {
     appwriteFolderPath;
     appwriteConfigPath;
@@ -125,6 +127,56 @@ export class UtilsController {
             throw new Error("Database, storage, or config not initialized");
         await backupDatabase(this.config, this.database, database.$id, this.storage);
     }
+    async listAllFunctions() {
+        await this.init();
+        if (!this.appwriteServer)
+            throw new Error("Appwrite server not initialized");
+        const { functions } = await listFunctions(this.appwriteServer, [Query.limit(1000)]);
+        return functions;
+    }
+    async findFunctionDirectories() {
+        const functionsDir = findFunctionsDir(this.appwriteFolderPath);
+        if (!functionsDir)
+            return new Map();
+        const functionDirMap = new Map();
+        const entries = fs.readdirSync(functionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const functionPath = path.join(functionsDir, entry.name);
+                // Match with config functions by name
+                if (this.config?.functions) {
+                    const matchingFunc = this.config.functions.find(f => f.name.toLowerCase() === entry.name.toLowerCase());
+                    if (matchingFunc) {
+                        functionDirMap.set(matchingFunc.name, functionPath);
+                    }
+                }
+            }
+        }
+        return functionDirMap;
+    }
+    async deployFunction(functionName, functionPath, functionConfig) {
+        await this.init();
+        if (!this.appwriteServer)
+            throw new Error("Appwrite server not initialized");
+        if (!functionConfig) {
+            functionConfig = this.config?.functions?.find(f => f.name === functionName);
+        }
+        if (!functionConfig)
+            throw new Error(`Function ${functionName} not found in config`);
+        await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath);
+    }
+    async syncFunctions() {
+        await this.init();
+        if (!this.appwriteServer)
+            throw new Error("Appwrite server not initialized");
+        const localFunctions = this.config?.functions || [];
+        const remoteFunctions = await listFunctions(this.appwriteServer, [Query.limit(1000)]);
+        for (const localFunction of localFunctions) {
+            console.log(chalk.blue(`Syncing function ${localFunction.name}...`));
+            await this.deployFunction(localFunction.name);
+        }
+        console.log(chalk.green("✨ All functions synchronized successfully!"));
+    }
     async wipeDatabase(database, wipeBucket = false) {
         await this.init();
         if (!this.database)