@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/dist/config/services/ConfigDiscoveryService.js

@@ -1,374 +0,0 @@
-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

@@ -1,129 +0,0 @@
-import type { AppwriteConfig, Collection } from "@njdamstra/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 {
-    /**
-     * Normalizes function dirPath to absolute path
-     * @param func Function configuration object
-     * @param configDir Directory containing the config file
-     * @returns Function with normalized dirPath
-     */
-    private normalizeFunctionPath;
-    /**
-     * 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;
-        }>;
-    }>;
-    /**
-     * Loads tables first (higher priority), then collections (backward compatibility)
-     * Used for TablesDB projects (>= 1.8.0)
-     * @param tablesDir Path to the tables directory
-     * @param collectionsDir Path to the collections directory
-     * @returns Loading result with items, counts, and conflicts
-     */
-    loadTablesFirst(tablesDir: string, collectionsDir: 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;
-}