appwrite-utils-cli 1.8.9 → 1.9.2

package/src/config/services/ConfigDiscoveryService.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import { findUp } from "find-up";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { shouldIgnoreDirectory } from "../../utils/directoryUtils.js";
 
@@ -16,16 +17,15 @@ export interface DiscoveryResult {
 /**
  * Service for discovering Appwrite configuration files and collection/table definitions.
  *
+ * Uses find-up for intelligent searching with git repository boundary detection:
+ * 1. Finds .git directory to establish repo root boundary
+ * 2. Searches UP from current directory to repo root
+ * 3. Searches DOWN recursively within repo root
+ *
  * Search Priority:
  * 1. YAML configs (.appwrite/config.yaml, .appwrite/config.yml, etc.)
- * 2. TypeScript configs (appwriteConfig.ts)
- * 3. JSON configs (appwrite.json, appwrite.config.json)
- *
- * Features:
- * - Searches up directory tree (max 5 levels)
- * - Ignores common directories (node_modules, .git, etc.)
- * - Discovers both collections/ and tables/ directories
- * - Recursive subdirectory scanning for .appwrite folders
+ * 2. JSON configs (appwrite.config.json, appwrite.json)
+ * 3. TypeScript configs (appwriteConfig.ts)
  */
 export class ConfigDiscoveryService {
   /**
@@ -40,212 +40,188 @@ export class ConfigDiscoveryService {
     "appwrite.yml",
   ];
 
-  /**
-   * TypeScript configuration file names to search for
-   */
-  private readonly TS_FILENAMES = ["appwriteConfig.ts"];
-
   /**
    * JSON configuration file names to search for
    */
-  private readonly JSON_FILENAMES = ["appwrite.json", "appwrite.config.json"];
+  private readonly JSON_FILENAMES = ["appwrite.config.json", "appwrite.json"];
 
   /**
-   * Maximum levels to search up the directory tree
+   * TypeScript configuration file names to search for
    */
-  private readonly MAX_SEARCH_DEPTH = 5;
+  private readonly TS_FILENAMES = ["appwriteConfig.ts"];
 
   /**
-   * Finds any configuration file with priority: YAML → TypeScript → JSON
+   * Finds the git repository root directory
    * @param startDir The directory to start searching from
-   * @returns Path to the configuration file or null if not found
+   * @returns Path to the repository root, or startDir if no .git found
    */
-  public findConfig(startDir: string): string | null {
-    // Try YAML first (highest priority)
-    const yamlConfig = this.findYamlConfig(startDir);
-    if (yamlConfig) {
-      return yamlConfig;
-    }
-
-    // Try TypeScript second
-    const tsConfig = this.findTypeScriptConfig(startDir);
-    if (tsConfig) {
-      return tsConfig;
-    }
+  private async findRepoRoot(startDir: string): Promise<string> {
+    const gitDir = await findUp(".git", {
+      cwd: startDir,
+      type: "directory",
+    });
 
-    // Try JSON last (lowest priority)
-    const jsonConfig = this.findProjectConfig(startDir);
-    if (jsonConfig) {
-      return jsonConfig;
-    }
-
-    return null;
+    return gitDir ? path.dirname(gitDir) : startDir;
   }
 
   /**
-   * Finds YAML configuration files
-   * Searches current directory, subdirectories, and parent directory
-   * @param startDir The directory to start searching from
-   * @returns Path to the YAML config file or null if not found
+   * Recursively searches downward for files matching patterns
+   * @param dir Directory to search in
+   * @param patterns File patterns to match
+   * @param maxDepth Maximum depth to search
+   * @param currentDepth Current recursion depth
+   * @returns First matching file path or null
    */
-  public findYamlConfig(startDir: string): string | null {
-    // First check current directory for YAML configs
-    for (const fileName of this.YAML_FILENAMES) {
-      const configPath = path.join(startDir, fileName);
-      if (fs.existsSync(configPath)) {
-        return configPath;
-      }
-    }
+  private async searchDownward(
+    dir: string,
+    patterns: string[],
+    maxDepth: number = 5,
+    currentDepth: number = 0
+  ): Promise<string | null> {
+    if (currentDepth > maxDepth) return null;
+    if (shouldIgnoreDirectory(path.basename(dir))) return null;
 
-    // Recursively search subdirectories for .appwrite folders
-    const yamlConfigInSubdirs = this.findYamlConfigRecursive(startDir);
-    if (yamlConfigInSubdirs) {
-      return yamlConfigInSubdirs;
-    }
+    try {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
 
-    // Check one level up to avoid infinite traversal
-    const parentDir = path.dirname(startDir);
-    if (parentDir !== startDir && path.basename(parentDir) !== "node_modules") {
-      for (const fileName of this.YAML_FILENAMES) {
-        const configPath = path.join(parentDir, fileName);
-        if (fs.existsSync(configPath)) {
-          return configPath;
+      // Check current directory for matches
+      for (const pattern of patterns) {
+        const fullPath = path.join(dir, pattern);
+        if (fs.existsSync(fullPath)) {
+          return fullPath;
         }
       }
-    }
-
-    return null;
-  }
-
-  /**
-   * Recursively searches for YAML configs in .appwrite subdirectories
-   * @param dir The directory to search
-   * @param depth Current search depth
-   * @returns Path to YAML config or null
-   */
-  private findYamlConfigRecursive(dir: string, depth: number = 0): string | null {
-    // Limit search depth to prevent infinite recursion
-    if (depth > this.MAX_SEARCH_DEPTH) {
-      return null;
-    }
-
-    if (shouldIgnoreDirectory(path.basename(dir))) {
-      return null;
-    }
-
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
 
+      // Recurse into subdirectories
       for (const entry of entries) {
         if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
-          const fullPath = path.join(dir, entry.name);
-
-          // Check if this is an .appwrite directory
-          if (entry.name === ".appwrite") {
-            const configPaths = [
-              path.join(fullPath, "config.yaml"),
-              path.join(fullPath, "config.yml"),
-              path.join(fullPath, "appwriteConfig.yaml"),
-              path.join(fullPath, "appwriteConfig.yml"),
-            ];
-
-            for (const configPath of configPaths) {
-              if (fs.existsSync(configPath)) {
-                return configPath;
-              }
-            }
-          }
-
-          // Recurse into other directories with increased depth
-          const result = this.findYamlConfigRecursive(fullPath, depth + 1);
+          const result = await this.searchDownward(
+            path.join(dir, entry.name),
+            patterns,
+            maxDepth,
+            currentDepth + 1
+          );
           if (result) return result;
         }
       }
     } catch (error) {
-      // Ignore directory access errors
+      // Ignore permission errors
     }
 
     return null;
   }
 
   /**
-   * Finds TypeScript configuration files (appwriteConfig.ts)
+   * Finds any configuration file with configurable priority
    * @param startDir The directory to start searching from
-   * @returns Path to the TypeScript config file or null if not found
+   * @param preferJson If true, prioritizes appwrite.config.json over YAML (default: false)
+   * @returns Path to the configuration file or null if not found
+   *
+   * Default priority: YAML → JSON → TypeScript
+   * With preferJson=true: JSON → YAML → TypeScript
    */
-  public findTypeScriptConfig(startDir: string): string | null {
-    return this.findTypeScriptConfigRecursive(startDir);
+  public async findConfig(startDir: string, preferJson: boolean = false): Promise<string | null> {
+    // Find repo root to establish boundary
+    const repoRoot = await this.findRepoRoot(startDir);
+
+    if (preferJson) {
+      // Try JSON first when --appwrite-config flag is used
+      const jsonConfig = await this.findProjectConfig(startDir, repoRoot);
+      if (jsonConfig) return jsonConfig;
+
+      // Try YAML second
+      const yamlConfig = await this.findYamlConfig(startDir, repoRoot);
+      if (yamlConfig) return yamlConfig;
+
+      // Try TypeScript last (lowest priority)
+      const tsConfig = await this.findTypeScriptConfig(startDir, repoRoot);
+      if (tsConfig) return tsConfig;
+    } else {
+      // Default priority: YAML → JSON → TypeScript
+      const yamlConfig = await this.findYamlConfig(startDir, repoRoot);
+      if (yamlConfig) return yamlConfig;
+
+      const jsonConfig = await this.findProjectConfig(startDir, repoRoot);
+      if (jsonConfig) return jsonConfig;
+
+      const tsConfig = await this.findTypeScriptConfig(startDir, repoRoot);
+      if (tsConfig) return tsConfig;
+    }
+
+    return null;
   }
 
   /**
-   * Recursively searches for TypeScript configuration files
-   * @param dir The directory to search
-   * @param depth Current search depth
-   * @returns Path to TypeScript config or null
+   * Finds YAML configuration files
+   * Searches UP to repo root, then DOWN from repo root
+   * @param startDir The directory to start searching from
+   * @param repoRoot The repository root boundary
+   * @returns Path to the YAML config file or null if not found
    */
-  private findTypeScriptConfigRecursive(dir: string, depth: number = 0): string | null {
-    // Limit search depth to prevent infinite recursion
-    if (depth > 10) {
-      return null;
-    }
-
-    if (shouldIgnoreDirectory(path.basename(dir))) {
-      return null;
-    }
-
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      // First check current directory for appwriteConfig.ts
-      for (const entry of entries) {
-        if (entry.isFile() && this.TS_FILENAMES.includes(entry.name)) {
-          return path.join(dir, entry.name);
-        }
-      }
-
-      // Then search subdirectories
-      for (const entry of entries) {
-        if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
-          const result = this.findTypeScriptConfigRecursive(
-            path.join(dir, entry.name),
-            depth + 1
-          );
-          if (result) return result;
-        }
-      }
-    } catch (error) {
-      // Ignore directory access errors
-    }
-
-    return null;
+  public async findYamlConfig(
+    startDir: string,
+    repoRoot?: string
+  ): Promise<string | null> {
+    const boundary = repoRoot || (await this.findRepoRoot(startDir));
+
+    // Search UP to repo root
+    const upwardResult = await findUp(this.YAML_FILENAMES, {
+      cwd: startDir,
+      stopAt: boundary,
+    });
+
+    if (upwardResult) return upwardResult;
+
+    // Search DOWN from repo root
+    return await this.searchDownward(boundary, this.YAML_FILENAMES);
   }
 
   /**
-   * Finds project configuration JSON files (appwrite.json, appwrite.config.json)
-   * Searches up to 5 levels up the directory tree
+   * Finds JSON project configuration files (appwrite.config.json, appwrite.json)
    * @param startDir The directory to start searching from
+   * @param repoRoot The repository root boundary
    * @returns Path to the JSON config file or null if not found
    */
-  public findProjectConfig(startDir: string = process.cwd()): string | null {
-    let currentDir = startDir;
-
-    // Search up to MAX_SEARCH_DEPTH levels up the directory tree
-    for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {
-      for (const configName of this.JSON_FILENAMES) {
-        const configPath = path.join(currentDir, configName);
-        if (fs.existsSync(configPath)) {
-          return configPath;
-        }
-      }
-
-      const parentDir = path.dirname(currentDir);
-      if (parentDir === currentDir) {
-        break; // Reached filesystem root
-      }
-      currentDir = parentDir;
-    }
+  public async findProjectConfig(
+    startDir: string,
+    repoRoot?: string
+  ): Promise<string | null> {
+    const boundary = repoRoot || (await this.findRepoRoot(startDir));
+
+    // Search UP to repo root
+    const upwardResult = await findUp(this.JSON_FILENAMES, {
+      cwd: startDir,
+      stopAt: boundary,
+    });
+
+    if (upwardResult) return upwardResult;
+
+    // Search DOWN from repo root
+    return await this.searchDownward(boundary, this.JSON_FILENAMES);
+  }
 
-    return null;
+  /**
+   * Finds TypeScript configuration files (appwriteConfig.ts)
+   * @param startDir The directory to start searching from
+   * @param repoRoot The repository root boundary
+   * @returns Path to the TypeScript config file or null if not found
+   */
+  public async findTypeScriptConfig(
+    startDir: string,
+    repoRoot?: string
+  ): Promise<string | null> {
+    const boundary = repoRoot || (await this.findRepoRoot(startDir));
+
+    // Search UP to repo root
+    const upwardResult = await findUp(this.TS_FILENAMES, {
+      cwd: startDir,
+      stopAt: boundary,
+    });
+
+    if (upwardResult) return upwardResult;
+
+    // Search DOWN from repo root
+    return await this.searchDownward(boundary, this.TS_FILENAMES);
   }
 
   /**
@@ -367,24 +343,20 @@ export class ConfigDiscoveryService {
    * @param startDir The directory to start searching from
    * @returns Path to .appwrite directory or null if not found
    */
-  public findAppwriteDirectory(startDir: string): string | null {
-    let currentDir = startDir;
-
-    // Search up to MAX_SEARCH_DEPTH levels up the directory tree
-    for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {
-      const appwriteDir = path.join(currentDir, ".appwrite");
-      if (fs.existsSync(appwriteDir) && fs.statSync(appwriteDir).isDirectory()) {
-        return appwriteDir;
-      }
+  public async findAppwriteDirectory(startDir: string): Promise<string | null> {
+    const repoRoot = await this.findRepoRoot(startDir);
 
-      const parentDir = path.dirname(currentDir);
-      if (parentDir === currentDir) {
-        break; // Reached filesystem root
-      }
-      currentDir = parentDir;
-    }
+    // Search UP to repo root
+    const upwardResult = await findUp(".appwrite", {
+      cwd: startDir,
+      type: "directory",
+      stopAt: repoRoot,
+    });
 
-    return null;
+    if (upwardResult) return upwardResult;
+
+    // Search DOWN from repo root
+    return await this.searchDownward(repoRoot, [".appwrite"]);
   }
 
   /**
@@ -392,49 +364,20 @@ export class ConfigDiscoveryService {
    * @param startDir The directory to start searching from
    * @returns Path to functions directory or null if not found
    */
-  public findFunctionsDirectory(startDir: string): string | null {
-    return this.findFunctionsDirectoryRecursive(startDir);
-  }
+  public async findFunctionsDirectory(startDir: string): Promise<string | null> {
+    const repoRoot = await this.findRepoRoot(startDir);
 
-  /**
-   * Recursively searches for the functions directory
-   * @param dir The directory to search
-   * @param depth Current search depth
-   * @returns Path to functions directory or null
-   */
-  private findFunctionsDirectoryRecursive(dir: string, depth: number = 0): string | null {
-    // Limit search depth to prevent infinite recursion
-    if (depth > this.MAX_SEARCH_DEPTH) {
-      return null;
-    }
+    // Search UP to repo root
+    const upwardResult = await findUp("functions", {
+      cwd: startDir,
+      type: "directory",
+      stopAt: repoRoot,
+    });
 
-    if (shouldIgnoreDirectory(path.basename(dir))) {
-      return null;
-    }
+    if (upwardResult) return upwardResult;
 
-    try {
-      const files = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of files) {
-        if (!entry.isDirectory() || shouldIgnoreDirectory(entry.name)) {
-          continue;
-        }
-
-        if (entry.name === "functions") {
-          return path.join(dir, entry.name);
-        }
-
-        const result = this.findFunctionsDirectoryRecursive(
-          path.join(dir, entry.name),
-          depth + 1
-        );
-        if (result) return result;
-      }
-    } catch (error) {
-      // Ignore directory access errors
-    }
-
-    return null;
+    // Search DOWN from repo root
+    return await this.searchDownward(repoRoot, ["functions"]);
   }
 
   /**
@@ -443,21 +386,25 @@ export class ConfigDiscoveryService {
    * @param startDir The directory to start searching from
    * @returns Object containing paths to all discovered config types
    */
-  public getConfigurationSummary(startDir: string): {
+  public async getConfigurationSummary(startDir: string): Promise<{
     yaml: string | null;
     typescript: string | null;
     json: string | null;
     appwriteDirectory: string | null;
     functionsDirectory: string | null;
     selectedConfig: string | null;
-  } {
+    repoRoot: string;
+  }> {
+    const repoRoot = await this.findRepoRoot(startDir);
+
     return {
-      yaml: this.findYamlConfig(startDir),
-      typescript: this.findTypeScriptConfig(startDir),
-      json: this.findProjectConfig(startDir),
-      appwriteDirectory: this.findAppwriteDirectory(startDir),
-      functionsDirectory: this.findFunctionsDirectory(startDir),
-      selectedConfig: this.findConfig(startDir),
+      yaml: await this.findYamlConfig(startDir, repoRoot),
+      typescript: await this.findTypeScriptConfig(startDir, repoRoot),
+      json: await this.findProjectConfig(startDir, repoRoot),
+      appwriteDirectory: await this.findAppwriteDirectory(startDir),
+      functionsDirectory: await this.findFunctionsDirectory(startDir),
+      selectedConfig: await this.findConfig(startDir),
+      repoRoot,
     };
   }
 }

package/src/config/services/ConfigLoaderService.ts

@@ -336,8 +336,8 @@ export class ConfigLoaderService {
         throw new Error(`Failed to load project config from: ${jsonPath}`);
       }
 
-      // Convert project config to AppwriteConfig format
-      const appwriteConfig = projectConfigToAppwriteConfig(projectConfig);
+      // Convert project config to AppwriteConfig format (includes function path normalization)
+      const appwriteConfig = projectConfigToAppwriteConfig(projectConfig, jsonPath);
 
       // Get collections from project config
       const collections = getCollectionsFromProject(projectConfig);
@@ -345,14 +345,6 @@ export class ConfigLoaderService {
         appwriteConfig.collections = collections;
       }
 
-      // Normalize function paths
-      const configDir = path.dirname(jsonPath);
-      if (appwriteConfig.functions) {
-        appwriteConfig.functions = appwriteConfig.functions.map(func =>
-          this.normalizeFunctionPath(func, configDir)
-        );
-      }
-
       MessageFormatter.success(`Loaded project config from: ${jsonPath}`, {
         prefix: "Config",
       });

package/src/functions/methods.ts

@@ -13,6 +13,7 @@ import {
   type FunctionScope,
   type Specification,
   type Runtime as AppwriteUtilsRuntime,
+  EventTypeSchema,
 } from "appwrite-utils";
 import chalk from "chalk";
 import { extract as extractTar } from "tar";
@@ -22,14 +23,26 @@ import { expandTildePath, normalizeFunctionName } from "./pathResolution.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);
 };