appwrite-utils-cli 1.8.9 → 1.9.2

package/src/main.ts

@@ -41,8 +41,9 @@ if (!(globalThis as any).require) {
   (globalThis as any).require = require;
 }
 
-interface CliOptions {
+interface CliOptions {
   config?: string;
+  appwriteConfig?: boolean;
   it?: boolean;
   dbIds?: string;
   collectionIds?: string;
@@ -86,13 +87,13 @@ interface CliOptions {
   session?: string;
   listBackups?: boolean;
   autoSync?: boolean;
-  selectBuckets?: boolean;
-  // New schema/constant CLI flags
-  generateSchemas?: boolean;
-  schemaFormat?: 'zod' | 'json' | 'pydantic' | 'both' | 'all';
-  schemaOutDir?: string;
-  constantsInclude?: string;
-}
+  selectBuckets?: boolean;
+  // New schema/constant CLI flags
+  generateSchemas?: boolean;
+  schemaFormat?: 'zod' | 'json' | 'pydantic' | 'both' | 'all';
+  schemaOutDir?: string;
+  constantsInclude?: string;
+}
 
 type ParsedArgv = ArgumentsCamelCase<CliOptions>;
 
@@ -185,15 +186,15 @@ async function performEnhancedSync(
     const allowNewOnly = !syncExisting;
 
     // Select databases
-    const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
-      availableDatabases,
-      configuredDatabases,
-      {
-        showSelectAll: false,
-        allowNewOnly,
-        defaultSelected: []
-      }
-    );
+    const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+      availableDatabases,
+      configuredDatabases,
+      {
+        showSelectAll: false,
+        allowNewOnly,
+        defaultSelected: []
+      }
+    );
 
     if (selectedDatabaseIds.length === 0) {
       MessageFormatter.warning("No databases selected for sync", { prefix: "Sync" });
@@ -218,17 +219,17 @@ async function performEnhancedSync(
       const configuredTables = controller.config.collections || [];
 
       // Select tables for this database
-      const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-        databaseId,
-        database.name,
-        availableTables,
-        configuredTables,
-        {
-          showSelectAll: false,
-          allowNewOnly,
-          defaultSelected: []
-        }
-      );
+      const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+        databaseId,
+        database.name,
+        availableTables,
+        configuredTables,
+        {
+          showSelectAll: false,
+          allowNewOnly,
+          defaultSelected: []
+        }
+      );
 
       tableSelectionsMap.set(databaseId, selectedTableIds);
 
@@ -251,17 +252,17 @@ async function performEnhancedSync(
         // you'd fetch this from the Appwrite API
         const availableBuckets = configuredBuckets; // Placeholder
 
-        selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
-          selectedDatabaseIds,
-          availableBuckets,
-          configuredBuckets,
-          {
-            showSelectAll: false,
-            allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
-            groupByDatabase: true,
-            defaultSelected: []
-          }
-        );
+        selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+          selectedDatabaseIds,
+          availableBuckets,
+          configuredBuckets,
+          {
+            showSelectAll: false,
+            allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
+            groupByDatabase: true,
+            defaultSelected: []
+          }
+        );
       } catch (error) {
         MessageFormatter.warning("Could not fetch storage buckets", { prefix: "Sync" });
         logger.warn("Failed to fetch buckets during sync", { error });
@@ -370,6 +371,11 @@ const argv = yargs(hideBin(process.argv))
     type: "string",
     description: "Path to Appwrite configuration file (appwriteConfig.ts)",
   })
+  .option("appwriteConfig", {
+    alias: ["appwrite-config", "use-appwrite-config"],
+    type: "boolean",
+    description: "Prefer loading from appwrite.config.json instead of config.yaml",
+  })
   .option("it", {
     alias: ["interactive", "i"],
     type: "boolean",
@@ -572,30 +578,30 @@ const argv = yargs(hideBin(process.argv))
       "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
     default: "typescript",
   })
-  .option("constantsOutput", {
-    type: "string",
-    description:
-      "Output directory for generated constants files (default: config-folder/constants)",
-    default: "auto",
-  })
-  .option("constantsInclude", {
-    type: "string",
-    description:
-      "Comma-separated categories to include: databases,collections,buckets,functions",
-  })
-  .option("generateSchemas", {
-    type: "boolean",
-    description: "Generate schemas/models without interactive prompts",
-  })
-  .option("schemaFormat", {
-    type: "string",
-    choices: ["zod", "json", "pydantic", "both", "all"],
-    description: "Schema format: zod, json, pydantic, both (zod+json), or all",
-  })
-  .option("schemaOutDir", {
-    type: "string",
-    description: "Output directory for generated schemas (absolute path respected)",
-  })
+  .option("constantsOutput", {
+    type: "string",
+    description:
+      "Output directory for generated constants files (default: config-folder/constants)",
+    default: "auto",
+  })
+  .option("constantsInclude", {
+    type: "string",
+    description:
+      "Comma-separated categories to include: databases,collections,buckets,functions",
+  })
+  .option("generateSchemas", {
+    type: "boolean",
+    description: "Generate schemas/models without interactive prompts",
+  })
+  .option("schemaFormat", {
+    type: "string",
+    choices: ["zod", "json", "pydantic", "both", "all"],
+    description: "Schema format: zod, json, pydantic, both (zod+json), or all",
+  })
+  .option("schemaOutDir", {
+    type: "string",
+    description: "Output directory for generated schemas (absolute path respected)",
+  })
   .option("migrateCollectionsToTables", {
     alias: ["migrate-collections"],
     type: "boolean",
@@ -803,7 +809,7 @@ async function main() {
       finalDirectConfig
     );
 
-    // Pass session authentication options to the controller
+    // Pass session authentication and config options to the controller
     const initOptions: any = {};
     if (argv.useSession || argv.sessionCookie) {
       initOptions.useSession = true;
@@ -811,6 +817,9 @@ async function main() {
         initOptions.sessionCookie = argv.sessionCookie;
       }
     }
+    if (argv.appwriteConfig) {
+      initOptions.preferJson = true;
+    }
 
     await controller.init(initOptions);
 
@@ -1364,146 +1373,146 @@ async function main() {
       }
     }
 
-    if (parsedArgv.push) {
-      await controller.init();
-      if (!controller.database || !controller.config) {
-        MessageFormatter.error("Database or config not initialized", undefined, { prefix: "Push" });
-        return;
-      }
-
-      // Fetch available DBs
-      const availableDatabases = await fetchAllDatabases(controller.database);
-      if (availableDatabases.length === 0) {
-        MessageFormatter.warning("No databases found in remote project", { prefix: "Push" });
-        return;
-      }
-
-      // Determine selected DBs
-      let selectedDbIds: string[] = [];
-      if (parsedArgv.dbIds) {
-        selectedDbIds = parsedArgv.dbIds.split(/[,\s]+/).filter(Boolean);
-      } else {
-        selectedDbIds = await SelectionDialogs.selectDatabases(
-          availableDatabases,
-          controller.config.databases || [],
-          { showSelectAll: false, allowNewOnly: false, defaultSelected: [] }
-        );
-      }
-
-      if (selectedDbIds.length === 0) {
-        MessageFormatter.warning("No databases selected for push", { prefix: "Push" });
-        return;
-      }
-
-      // Build DatabaseSelection[] with tableIds per DB
-      const databaseSelections: DatabaseSelection[] = [];
-      const allConfigItems = controller.config.collections || controller.config.tables || [];
-      let lastSelectedTableIds: string[] | null = null;
-
-      for (const dbId of selectedDbIds) {
-        const db = availableDatabases.find(d => d.$id === dbId);
-        if (!db) continue;
-
-        // Filter config items eligible for this DB according to databaseId/databaseIds rule
-        const eligibleConfigItems = (allConfigItems as any[]).filter(item => {
-          const one = item.databaseId as string | undefined;
-          const many = item.databaseIds as string[] | undefined;
-          if (Array.isArray(many) && many.length > 0) return many.includes(dbId);
-          if (one) return one === dbId;
-          return true; // eligible everywhere if unspecified
-        });
-
-        // Fetch available tables from remote for selection context
-        const availableTables = await fetchAllCollections(dbId, controller.database);
-
-        // Determine selected table IDs
-        let selectedTableIds: string[] = [];
-        if (parsedArgv.collectionIds) {
-          // Non-interactive: respect provided table IDs as-is (apply to each selected DB)
-          selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
-        } else {
-          // If we have a previous selection, offer to reuse it
-          if (lastSelectedTableIds && lastSelectedTableIds.length > 0) {
-            const inquirer = (await import("inquirer")).default;
-            const { reuseMode } = await inquirer.prompt([
-              {
-                type: "list",
-                name: "reuseMode",
-                message: `How do you want to select tables for ${db.name}?`,
-                choices: [
-                  { name: `Use same selection as previous (${lastSelectedTableIds.length} items)`, value: "same" },
-                  { name: `Filter by this database (manual select)`, value: "filter" },
-                  { name: `Show all available in this database (manual select)`, value: "all" }
-                ],
-                default: "same"
-              }
-            ]);
-
-            if (reuseMode === "same") {
-              selectedTableIds = [...lastSelectedTableIds];
-            } else if (reuseMode === "all") {
-              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-                dbId,
-                db.name,
-                availableTables,
-                allConfigItems as any[],
-                { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds }
-              );
-            } else {
-              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-                dbId,
-                db.name,
-                availableTables,
-                eligibleConfigItems,
-                { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds }
-              );
-            }
-          } else {
-            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-              dbId,
-              db.name,
-              availableTables,
-              eligibleConfigItems,
-              { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
-            );
-          }
-        }
-
-        databaseSelections.push({
-          databaseId: db.$id,
-          databaseName: db.name,
-          tableIds: selectedTableIds,
-          tableNames: [],
-          isNew: false,
-        });
-        if (!parsedArgv.collectionIds) {
-          lastSelectedTableIds = selectedTableIds;
-        }
-      }
-
-      if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
-        MessageFormatter.warning("No tables/collections selected for push", { prefix: "Push" });
-        return;
-      }
-
-      const pushSummary: Record<string, string | number | string[]> = {
-        databases: databaseSelections.length,
-        collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
-        details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
-      };
-      // Skip confirmation if both dbIds and collectionIds are provided (non-interactive)
-      if (!(parsedArgv.dbIds && parsedArgv.collectionIds)) {
-        const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
-        if (!confirmed) {
-          MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
-          return;
-        }
-      }
-
-      await controller.selectivePush(databaseSelections, []);
-      operationStats.pushedDatabases = databaseSelections.length;
-      operationStats.pushedCollections = databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0);
-    } else if (parsedArgv.sync) {
+    if (parsedArgv.push) {
+      await controller.init();
+      if (!controller.database || !controller.config) {
+        MessageFormatter.error("Database or config not initialized", undefined, { prefix: "Push" });
+        return;
+      }
+
+      // Fetch available DBs
+      const availableDatabases = await fetchAllDatabases(controller.database);
+      if (availableDatabases.length === 0) {
+        MessageFormatter.warning("No databases found in remote project", { prefix: "Push" });
+        return;
+      }
+
+      // Determine selected DBs
+      let selectedDbIds: string[] = [];
+      if (parsedArgv.dbIds) {
+        selectedDbIds = parsedArgv.dbIds.split(/[,\s]+/).filter(Boolean);
+      } else {
+        selectedDbIds = await SelectionDialogs.selectDatabases(
+          availableDatabases,
+          controller.config.databases || [],
+          { showSelectAll: false, allowNewOnly: false, defaultSelected: [] }
+        );
+      }
+
+      if (selectedDbIds.length === 0) {
+        MessageFormatter.warning("No databases selected for push", { prefix: "Push" });
+        return;
+      }
+
+      // Build DatabaseSelection[] with tableIds per DB
+      const databaseSelections: DatabaseSelection[] = [];
+      const allConfigItems = controller.config.collections || controller.config.tables || [];
+      let lastSelectedTableIds: string[] | null = null;
+
+      for (const dbId of selectedDbIds) {
+        const db = availableDatabases.find(d => d.$id === dbId);
+        if (!db) continue;
+
+        // Filter config items eligible for this DB according to databaseId/databaseIds rule
+        const eligibleConfigItems = (allConfigItems as any[]).filter(item => {
+          const one = item.databaseId as string | undefined;
+          const many = item.databaseIds as string[] | undefined;
+          if (Array.isArray(many) && many.length > 0) return many.includes(dbId);
+          if (one) return one === dbId;
+          return true; // eligible everywhere if unspecified
+        });
+
+        // Fetch available tables from remote for selection context
+        const availableTables = await fetchAllCollections(dbId, controller.database);
+
+        // Determine selected table IDs
+        let selectedTableIds: string[] = [];
+        if (parsedArgv.collectionIds) {
+          // Non-interactive: respect provided table IDs as-is (apply to each selected DB)
+          selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
+        } else {
+          // If we have a previous selection, offer to reuse it
+          if (lastSelectedTableIds && lastSelectedTableIds.length > 0) {
+            const inquirer = (await import("inquirer")).default;
+            const { reuseMode } = await inquirer.prompt([
+              {
+                type: "list",
+                name: "reuseMode",
+                message: `How do you want to select tables for ${db.name}?`,
+                choices: [
+                  { name: `Use same selection as previous (${lastSelectedTableIds.length} items)`, value: "same" },
+                  { name: `Filter by this database (manual select)`, value: "filter" },
+                  { name: `Show all available in this database (manual select)`, value: "all" }
+                ],
+                default: "same"
+              }
+            ]);
+
+            if (reuseMode === "same") {
+              selectedTableIds = [...lastSelectedTableIds];
+            } else if (reuseMode === "all") {
+              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+                dbId,
+                db.name,
+                availableTables,
+                allConfigItems as any[],
+                { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds }
+              );
+            } else {
+              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+                dbId,
+                db.name,
+                availableTables,
+                eligibleConfigItems,
+                { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds }
+              );
+            }
+          } else {
+            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+              dbId,
+              db.name,
+              availableTables,
+              eligibleConfigItems,
+              { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
+            );
+          }
+        }
+
+        databaseSelections.push({
+          databaseId: db.$id,
+          databaseName: db.name,
+          tableIds: selectedTableIds,
+          tableNames: [],
+          isNew: false,
+        });
+        if (!parsedArgv.collectionIds) {
+          lastSelectedTableIds = selectedTableIds;
+        }
+      }
+
+      if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
+        MessageFormatter.warning("No tables/collections selected for push", { prefix: "Push" });
+        return;
+      }
+
+      const pushSummary: Record<string, string | number | string[]> = {
+        databases: databaseSelections.length,
+        collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
+        details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
+      };
+      // Skip confirmation if both dbIds and collectionIds are provided (non-interactive)
+      if (!(parsedArgv.dbIds && parsedArgv.collectionIds)) {
+        const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
+        if (!confirmed) {
+          MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
+          return;
+        }
+      }
+
+      await controller.selectivePush(databaseSelections, []);
+      operationStats.pushedDatabases = databaseSelections.length;
+      operationStats.pushedCollections = databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0);
+    } else if (parsedArgv.sync) {
       // Enhanced SYNC: Pull from remote with intelligent configuration detection
       if (parsedArgv.autoSync) {
         // Legacy behavior: sync everything without prompts

package/src/shared/functionManager.ts

@@ -1,5 +1,5 @@
 import { Client, Functions, Runtime, type Models } from "node-appwrite";
-import { type AppwriteFunction } from "appwrite-utils";
+import { type AppwriteFunction, EventTypeSchema } from "appwrite-utils";
 import { join, relative, resolve, basename } from "node:path";
 import fs from "node:fs";
 import chalk from "chalk";
@@ -10,14 +10,26 @@ import { MessageFormatter } from "./messageFormatter.js";
 /**
  * Validates and filters events array for Appwrite functions
  * - Filters out empty/invalid strings
+ * - Validates against EventTypeSchema
  * - Limits to 100 items maximum (Appwrite limit)
  * - Returns empty array if input is invalid
  */
 const validateEvents = (events?: string[]): string[] => {
   if (!events || !Array.isArray(events)) return [];
-  
+
   return events
-    .filter(event => event && typeof event === 'string' && event.trim().length > 0)
+    .filter(event => {
+      if (!event || typeof event !== 'string' || event.trim().length === 0) {
+        return false;
+      }
+      // Validate against EventTypeSchema
+      const result = EventTypeSchema.safeParse(event);
+      if (!result.success) {
+        MessageFormatter.warning(`Invalid event type "${event}" will be filtered out`, { prefix: "Functions" });
+        return false;
+      }
+      return true;
+    })
     .slice(0, 100);
 };
 

package/src/utils/projectConfig.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve, isAbsolute } from "node:path";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import type { AppwriteConfig } from "appwrite-utils";
 
@@ -185,12 +185,17 @@ export function detectApiModeFromProject(projectConfig: AppwriteProjectConfig):
 
 /**
  * Convert project config to AppwriteConfig format
+ * @param projectConfig The project config to convert
+ * @param configPath Optional path to the config file (for resolving relative paths)
+ * @param existingConfig Optional existing config to merge with
  */
 export function projectConfigToAppwriteConfig(
   projectConfig: AppwriteProjectConfig,
+  configPath?: string,
   existingConfig?: Partial<AppwriteConfig>
 ): Partial<AppwriteConfig> {
   const apiMode = detectApiModeFromProject(projectConfig);
+  const configDir = configPath ? dirname(configPath) : process.cwd();
 
   const baseConfig: Partial<AppwriteConfig> = {
     ...existingConfig,
@@ -203,10 +208,22 @@ export function projectConfigToAppwriteConfig(
     baseConfig.appwriteEndpoint = projectConfig.endpoint;
   }
 
-  // Convert databases (works for both legacy and TablesDB)
-  if (projectConfig.databases || projectConfig.tablesDB) {
-    const databases = projectConfig.databases || projectConfig.tablesDB || [];
-    baseConfig.databases = databases.map(db => ({
+  // Merge databases and tablesDB arrays (modern Appwrite may have both)
+  const allDatabases = [
+    ...(projectConfig.databases || []),
+    ...(projectConfig.tablesDB || [])
+  ];
+
+  // Remove duplicates by $id
+  const uniqueDatabasesMap = new Map();
+  for (const db of allDatabases) {
+    if (!uniqueDatabasesMap.has(db.$id)) {
+      uniqueDatabasesMap.set(db.$id, db);
+    }
+  }
+
+  if (uniqueDatabasesMap.size > 0) {
+    baseConfig.databases = Array.from(uniqueDatabasesMap.values()).map(db => ({
       $id: db.$id,
       name: db.name,
       // Add basic bucket configuration if not exists
@@ -235,6 +252,30 @@ export function projectConfigToAppwriteConfig(
     }));
   }
 
+  // Convert functions with path normalization
+  if (projectConfig.functions) {
+    baseConfig.functions = projectConfig.functions.map(func => {
+      const normalizedFunc: any = {
+        $id: func.$id,
+        name: func.name,
+        runtime: func.runtime,
+        entrypoint: func.entrypoint,
+        commands: func.commands,
+        events: func.events,
+      };
+
+      // Convert path to dirPath and make absolute
+      if (func.path) {
+        const expandedPath = func.path;
+        normalizedFunc.dirPath = isAbsolute(expandedPath)
+          ? expandedPath
+          : resolve(configDir, expandedPath);
+      }
+
+      return normalizedFunc;
+    });
+  }
+
   return baseConfig;
 }
 
@@ -251,16 +292,16 @@ export function getCollectionsFromProject(projectConfig: AppwriteProjectConfig):
       documentSecurity: table.rowSecurity || false,
       enabled: table.enabled !== false,
       // Convert columns to attributes for compatibility
-      attributes: table.columns.map(col => ({
-        key: col.key,
-        type: col.type,
-        required: col.required,
-        array: col.array,
-        size: col.size,
-        default: col.default,
-        encrypt: col.encrypt,
-        unique: col.unique,
-      })),
+      attributes: table.columns.map(col => ({
+        key: col.key,
+        type: col.type,
+        required: col.required,
+        array: col.array,
+        size: col.size,
+        default: col.default,
+        encrypt: col.encrypt,
+        unique: col.unique,
+      })),
       indexes: table.indexes || [],
       // Mark as coming from TablesDB for processing
       _isFromTablesDir: true,
@@ -296,4 +337,4 @@ export function isTablesDBProject(projectConfig: AppwriteProjectConfig): boolean
  */
 export function getProjectDirectoryName(projectConfig: AppwriteProjectConfig): "tables" | "collections" {
   return isTablesDBProject(projectConfig) ? "tables" : "collections";
-}
+}