appwrite-utils-cli 0.9.993 → 0.9.994

package/src/utils/loadConfigs.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import { type AppwriteConfig, type Collection } 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.
@@ -73,3 +74,26 @@ export const loadConfig = async (
     unregister(); // Unregister tsx when done
   }
 };
+
+export const findFunctionsDir = (dir: string): string | null => {
+  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/src/utils/schemaStrings.ts

@@ -9,6 +9,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";
 // import { getClientFromConfig } from "./getClientFromConfig.js";
 
 interface RelationshipDetail {
@@ -33,7 +35,9 @@ export class SchemaGenerator {
 
   public updateTsSchemas(): void {
     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";
@@ -51,6 +55,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/src/utilsController.ts

@@ -1,6 +1,6 @@
 import { Client, Databases, Query, Storage, type Models } from "node-appwrite";
-import { type AppwriteConfig, type Specification } from "appwrite-utils";
-import { loadConfig, findAppwriteConfig } from "./utils/loadConfigs.js";
+import { type AppwriteConfig, type AppwriteFunction, type Specification } from "appwrite-utils";
+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";
@@ -42,8 +42,10 @@ import {
 } 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 interface SetupOptions {
   databases?: Models.Database[];
@@ -181,6 +183,64 @@ export class UtilsController {
     );
   }
 
+  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<string, string>();
+    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: string, functionPath?: string, functionConfig?: AppwriteFunction) {
+    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: Models.Database, wipeBucket: boolean = false) {
     await this.init();
     if (!this.database) throw new Error("Database not initialized");

package/tsconfig.json

@@ -33,5 +33,12 @@
     "declaration": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/appwrite", "src/_test/appwrite", "example/*"]
+  "exclude": [
+    "node_modules",
+    "dist",
+    "src/appwrite",
+    "src/functions/templates",
+    "src/_test/appwrite",
+    "example/*"
+  ]
 }