appwrite-utils-cli 1.6.2 → 1.6.4

package/dist/config/services/ConfigDiscoveryService.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Result of discovering configuration files or collections/tables
+ */
+export interface DiscoveryResult {
+    found: boolean;
+    path?: string;
+    type: "yaml" | "typescript" | "json" | "none";
+    files?: string[];
+}
+/**
+ * Service for discovering Appwrite configuration files and collection/table definitions.
+ *
+ * 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
+ */
+export declare class ConfigDiscoveryService {
+    /**
+     * YAML configuration file names to search for
+     */
+    private readonly YAML_FILENAMES;
+    /**
+     * TypeScript configuration file names to search for
+     */
+    private readonly TS_FILENAMES;
+    /**
+     * JSON configuration file names to search for
+     */
+    private readonly JSON_FILENAMES;
+    /**
+     * Maximum levels to search up the directory tree
+     */
+    private readonly MAX_SEARCH_DEPTH;
+    /**
+     * Finds any configuration file with priority: YAML → TypeScript → JSON
+     * @param startDir The directory to start searching from
+     * @returns Path to the configuration file or null if not found
+     */
+    findConfig(startDir: string): string | null;
+    /**
+     * 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
+     */
+    findYamlConfig(startDir: string): string | 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;
+    /**
+     * Finds TypeScript configuration files (appwriteConfig.ts)
+     * @param startDir The directory to start searching from
+     * @returns Path to the TypeScript config file or null if not found
+     */
+    findTypeScriptConfig(startDir: string): string | 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
+     */
+    private findTypeScriptConfigRecursive;
+    /**
+     * Finds project configuration JSON files (appwrite.json, appwrite.config.json)
+     * Searches up to 5 levels up the directory tree
+     * @param startDir The directory to start searching from
+     * @returns Path to the JSON config file or null if not found
+     */
+    findProjectConfig(startDir?: string): string | null;
+    /**
+     * Discovers collection YAML files in a collections/ directory
+     * @param collectionsDir Path to the collections directory
+     * @returns Discovery result with file paths
+     */
+    discoverCollections(collectionsDir: string): Promise<DiscoveryResult>;
+    /**
+     * Discovers table YAML files in a tables/ directory
+     * @param tablesDir Path to the tables directory
+     * @returns Discovery result with file paths
+     */
+    discoverTables(tablesDir: string): Promise<DiscoveryResult>;
+    /**
+     * Finds the .appwrite configuration directory
+     * @param startDir The directory to start searching from
+     * @returns Path to .appwrite directory or null if not found
+     */
+    findAppwriteDirectory(startDir: string): string | null;
+    /**
+     * Finds the functions directory
+     * @param startDir The directory to start searching from
+     * @returns Path to functions directory or null if not found
+     */
+    findFunctionsDirectory(startDir: string): string | null;
+    /**
+     * 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;
+    /**
+     * Gets a summary of all discoverable configuration files
+     * Useful for debugging configuration issues
+     * @param startDir The directory to start searching from
+     * @returns Object containing paths to all discovered config types
+     */
+    getConfigurationSummary(startDir: string): {
+        yaml: string | null;
+        typescript: string | null;
+        json: string | null;
+        appwriteDirectory: string | null;
+        functionsDirectory: string | null;
+        selectedConfig: string | null;
+    };
+}

package/dist/config/services/ConfigDiscoveryService.js

@@ -0,0 +1,374 @@
+import fs from "fs";
+import path from "path";
+import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { shouldIgnoreDirectory } from "../../utils/directoryUtils.js";
+/**
+ * Service for discovering Appwrite configuration files and collection/table definitions.
+ *
+ * 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
+ */
+export class ConfigDiscoveryService {
+    /**
+     * YAML configuration file names to search for
+     */
+    YAML_FILENAMES = [
+        ".appwrite/config.yaml",
+        ".appwrite/config.yml",
+        ".appwrite/appwriteConfig.yaml",
+        ".appwrite/appwriteConfig.yml",
+        "appwrite.yaml",
+        "appwrite.yml",
+    ];
+    /**
+     * TypeScript configuration file names to search for
+     */
+    TS_FILENAMES = ["appwriteConfig.ts"];
+    /**
+     * JSON configuration file names to search for
+     */
+    JSON_FILENAMES = ["appwrite.json", "appwrite.config.json"];
+    /**
+     * Maximum levels to search up the directory tree
+     */
+    MAX_SEARCH_DEPTH = 5;
+    /**
+     * Finds any configuration file with priority: YAML → TypeScript → JSON
+     * @param startDir The directory to start searching from
+     * @returns Path to the configuration file or null if not found
+     */
+    findConfig(startDir) {
+        // 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;
+        }
+        // Try JSON last (lowest priority)
+        const jsonConfig = this.findProjectConfig(startDir);
+        if (jsonConfig) {
+            return jsonConfig;
+        }
+        return null;
+    }
+    /**
+     * 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
+     */
+    findYamlConfig(startDir) {
+        // 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;
+            }
+        }
+        // Recursively search subdirectories for .appwrite folders
+        const yamlConfigInSubdirs = this.findYamlConfigRecursive(startDir);
+        if (yamlConfigInSubdirs) {
+            return yamlConfigInSubdirs;
+        }
+        // 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;
+                }
+            }
+        }
+        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
+     */
+    findYamlConfigRecursive(dir, depth = 0) {
+        // 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 });
+            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);
+                    if (result)
+                        return result;
+                }
+            }
+        }
+        catch (error) {
+            // Ignore directory access errors
+        }
+        return null;
+    }
+    /**
+     * Finds TypeScript configuration files (appwriteConfig.ts)
+     * @param startDir The directory to start searching from
+     * @returns Path to the TypeScript config file or null if not found
+     */
+    findTypeScriptConfig(startDir) {
+        return this.findTypeScriptConfigRecursive(startDir);
+    }
+    /**
+     * Recursively searches for TypeScript configuration files
+     * @param dir The directory to search
+     * @param depth Current search depth
+     * @returns Path to TypeScript config or null
+     */
+    findTypeScriptConfigRecursive(dir, depth = 0) {
+        // 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;
+    }
+    /**
+     * Finds project configuration JSON files (appwrite.json, appwrite.config.json)
+     * Searches up to 5 levels up the directory tree
+     * @param startDir The directory to start searching from
+     * @returns Path to the JSON config file or null if not found
+     */
+    findProjectConfig(startDir = process.cwd()) {
+        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;
+        }
+        return null;
+    }
+    /**
+     * Discovers collection YAML files in a collections/ directory
+     * @param collectionsDir Path to the collections directory
+     * @returns Discovery result with file paths
+     */
+    async discoverCollections(collectionsDir) {
+        if (!fs.existsSync(collectionsDir)) {
+            return {
+                found: false,
+                type: "none",
+                files: [],
+            };
+        }
+        try {
+            const files = fs.readdirSync(collectionsDir);
+            const collectionFiles = files.filter((file) => (file.endsWith(".yaml") ||
+                file.endsWith(".yml") ||
+                file.endsWith(".ts")) &&
+                file !== "index.ts");
+            if (collectionFiles.length === 0) {
+                return {
+                    found: false,
+                    type: "none",
+                    files: [],
+                };
+            }
+            MessageFormatter.success(`Discovered ${collectionFiles.length} collection file(s) in ${collectionsDir}`, { prefix: "Discovery" });
+            return {
+                found: true,
+                path: collectionsDir,
+                type: "yaml",
+                files: collectionFiles,
+            };
+        }
+        catch (error) {
+            MessageFormatter.error(`Error discovering collections in ${collectionsDir}`, error instanceof Error ? error : undefined, { prefix: "Discovery" });
+            return {
+                found: false,
+                type: "none",
+                files: [],
+            };
+        }
+    }
+    /**
+     * Discovers table YAML files in a tables/ directory
+     * @param tablesDir Path to the tables directory
+     * @returns Discovery result with file paths
+     */
+    async discoverTables(tablesDir) {
+        if (!fs.existsSync(tablesDir)) {
+            return {
+                found: false,
+                type: "none",
+                files: [],
+            };
+        }
+        try {
+            const files = fs.readdirSync(tablesDir);
+            const tableFiles = files.filter((file) => (file.endsWith(".yaml") ||
+                file.endsWith(".yml") ||
+                file.endsWith(".ts")) &&
+                file !== "index.ts");
+            if (tableFiles.length === 0) {
+                return {
+                    found: false,
+                    type: "none",
+                    files: [],
+                };
+            }
+            MessageFormatter.success(`Discovered ${tableFiles.length} table file(s) in ${tablesDir}`, { prefix: "Discovery" });
+            return {
+                found: true,
+                path: tablesDir,
+                type: "yaml",
+                files: tableFiles,
+            };
+        }
+        catch (error) {
+            MessageFormatter.error(`Error discovering tables in ${tablesDir}`, error instanceof Error ? error : undefined, { prefix: "Discovery" });
+            return {
+                found: false,
+                type: "none",
+                files: [],
+            };
+        }
+    }
+    /**
+     * Finds the .appwrite configuration directory
+     * @param startDir The directory to start searching from
+     * @returns Path to .appwrite directory or null if not found
+     */
+    findAppwriteDirectory(startDir) {
+        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;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break; // Reached filesystem root
+            }
+            currentDir = parentDir;
+        }
+        return null;
+    }
+    /**
+     * Finds the functions directory
+     * @param startDir The directory to start searching from
+     * @returns Path to functions directory or null if not found
+     */
+    findFunctionsDirectory(startDir) {
+        return this.findFunctionsDirectoryRecursive(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
+     */
+    findFunctionsDirectoryRecursive(dir, depth = 0) {
+        // Limit search depth to prevent infinite recursion
+        if (depth > this.MAX_SEARCH_DEPTH) {
+            return null;
+        }
+        if (shouldIgnoreDirectory(path.basename(dir))) {
+            return null;
+        }
+        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;
+    }
+    /**
+     * Gets a summary of all discoverable configuration files
+     * Useful for debugging configuration issues
+     * @param startDir The directory to start searching from
+     * @returns Object containing paths to all discovered config types
+     */
+    getConfigurationSummary(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),
+        };
+    }
+}

package/dist/config/services/ConfigLoaderService.d.ts

@@ -0,0 +1,105 @@
+import type { AppwriteConfig, Collection } from "appwrite-utils";
+import { type YamlSessionOptions } from "../yamlConfig.js";
+/**
+ * Options for loading collections or tables
+ */
+export interface CollectionLoadOptions {
+    /**
+     * Whether to mark loaded items as coming from tables directory
+     */
+    markAsTablesDir?: boolean;
+    /**
+     * Set of existing collection names to check for conflicts
+     */
+    existingNames?: Set<string>;
+}
+/**
+ * Service for loading and parsing Appwrite configuration files.
+ *
+ * Supports:
+ * - YAML configuration files (.appwrite/config.yaml)
+ * - TypeScript configuration files (appwriteConfig.ts)
+ * - JSON project configuration files (appwrite.json)
+ * - Collection and table YAML/TypeScript definitions
+ *
+ * Features:
+ * - Auto-detects configuration file type
+ * - Converts between different configuration formats
+ * - Loads collections and tables from directories
+ * - Handles session preservation
+ * - Validates and normalizes configuration data
+ */
+export declare class ConfigLoaderService {
+    /**
+     * Loads configuration from a discovered path, auto-detecting the type
+     * @param configPath Path to the configuration file
+     * @param sessionOptions Optional session preservation options
+     * @returns Parsed AppwriteConfig
+     */
+    loadFromPath(configPath: string, sessionOptions?: YamlSessionOptions): Promise<AppwriteConfig>;
+    /**
+     * Loads a YAML configuration file
+     * @param yamlPath Path to the YAML config file
+     * @param sessionOptions Optional session preservation options
+     * @returns Parsed AppwriteConfig
+     */
+    loadYaml(yamlPath: string, sessionOptions?: YamlSessionOptions): Promise<AppwriteConfig>;
+    /**
+     * Loads a TypeScript configuration file
+     * @param tsPath Path to the TypeScript config file
+     * @returns Parsed AppwriteConfig
+     */
+    loadTypeScript(tsPath: string): Promise<AppwriteConfig>;
+    /**
+     * Loads an appwrite.json project configuration file
+     * Converts projectId → appwriteProject and detects API mode
+     * @param jsonPath Path to the JSON config file
+     * @returns Partial AppwriteConfig (requires merging with defaults)
+     */
+    loadProjectConfig(jsonPath: string): Promise<Partial<AppwriteConfig>>;
+    /**
+     * Loads all collections from a collections/ directory
+     * Supports both YAML (.yaml, .yml) and TypeScript (.ts) files
+     * @param collectionsDir Path to the collections directory
+     * @param options Loading options
+     * @returns Array of loaded Collection objects
+     */
+    loadCollections(collectionsDir: string, options?: CollectionLoadOptions): Promise<Collection[]>;
+    /**
+     * Loads all tables from a tables/ directory
+     * Supports both YAML (.yaml, .yml) and TypeScript (.ts) files
+     * @param tablesDir Path to the tables directory
+     * @param options Loading options
+     * @returns Array of loaded table objects
+     */
+    loadTables(tablesDir: string, options?: CollectionLoadOptions): Promise<any[]>;
+    /**
+     * Loads collections and tables with conflict detection
+     * Collections take priority over tables when names conflict
+     * @param collectionsDir Path to collections directory
+     * @param tablesDir Path to tables directory
+     * @returns Object containing combined arrays and conflict information
+     */
+    loadCollectionsAndTables(collectionsDir: string, tablesDir: string): Promise<{
+        items: Collection[];
+        fromCollections: number;
+        fromTables: number;
+        conflicts: Array<{
+            name: string;
+            source1: string;
+            source2: string;
+        }>;
+    }>;
+    /**
+     * Validates that a configuration file can be loaded
+     * @param configPath Path to the configuration file
+     * @returns True if the file can be loaded, false otherwise
+     */
+    canLoadConfig(configPath: string): boolean;
+    /**
+     * Gets the type of a configuration file
+     * @param configPath Path to the configuration file
+     * @returns Configuration type or null if unknown
+     */
+    getConfigType(configPath: string): "yaml" | "typescript" | "json" | null;
+}