appwrite-utils-cli 1.5.1 → 1.6.0

package/dist/utils/configDiscovery.js

@@ -0,0 +1,430 @@
+import path from "path";
+import fs from "fs";
+import {} from "appwrite-utils";
+import { register } from "tsx/esm/api";
+import { pathToFileURL } from "node:url";
+import yaml from "js-yaml";
+import { z } from "zod";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { shouldIgnoreDirectory } from "./directoryUtils.js";
+import { resolveCollectionsDir, resolveTablesDir } from "./pathResolvers.js";
+import { findYamlConfig } from "../config/yamlConfig.js";
+/**
+ * Recursively searches for TypeScript configuration files (appwriteConfig.ts)
+ * @param dir The directory to start the search from
+ * @param depth Current search depth for recursion limiting
+ * @returns Path to the config file or null if not found
+ */
+export const findAppwriteConfigTS = (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() && entry.name === "appwriteConfig.ts") {
+                return path.join(dir, entry.name);
+            }
+        }
+        // Then search subdirectories
+        for (const entry of entries) {
+            if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
+                const result = findAppwriteConfigTS(path.join(dir, entry.name), depth + 1);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    catch (error) {
+        // Ignore directory access errors
+    }
+    return null;
+};
+/**
+ * Recursively searches for configuration files starting from the given directory.
+ * Priority: 1) YAML configs in .appwrite directories, 2) appwriteConfig.ts files in subdirectories
+ * @param dir The directory to start the search from
+ * @returns The directory path where the config was found, suitable for passing to loadConfig()
+ */
+export const findAppwriteConfig = (dir) => {
+    // First try to find YAML config (already searches recursively for .appwrite dirs)
+    const yamlConfig = findYamlConfig(dir);
+    if (yamlConfig) {
+        // Return the directory containing the config file
+        return path.dirname(yamlConfig);
+    }
+    // Fall back to TypeScript config search
+    const tsConfigPath = findAppwriteConfigTS(dir);
+    if (tsConfigPath) {
+        return path.dirname(tsConfigPath);
+    }
+    return null;
+};
+/**
+ * Recursively searches for the functions directory
+ * @param dir The directory to start searching from
+ * @param depth Current search depth for recursion limiting
+ * @returns Path to the functions directory or null if not found
+ */
+export const findFunctionsDir = (dir, depth = 0) => {
+    // Limit search depth to prevent infinite recursion
+    if (depth > 5) {
+        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 = findFunctionsDir(path.join(dir, entry.name), depth + 1);
+            if (result)
+                return result;
+        }
+    }
+    catch (error) {
+        // Ignore directory access errors
+    }
+    return null;
+};
+// YAML Collection Schema
+const YamlCollectionSchema = z.object({
+    name: z.string(),
+    id: z.string().optional(),
+    documentSecurity: z.boolean().default(false),
+    enabled: z.boolean().default(true),
+    permissions: z.array(z.object({
+        permission: z.string(),
+        target: z.string()
+    })).optional().default([]),
+    attributes: z.array(z.object({
+        key: z.string(),
+        type: z.string(),
+        size: z.number().optional(),
+        required: z.boolean().default(false),
+        array: z.boolean().optional(),
+        default: z.any().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+        elements: z.array(z.string()).optional(),
+        relatedCollection: z.string().optional(),
+        relationType: z.string().optional(),
+        twoWay: z.boolean().optional(),
+        twoWayKey: z.string().optional(),
+        onDelete: z.string().optional(),
+        side: z.string().optional()
+    })).optional().default([]),
+    indexes: z.array(z.object({
+        key: z.string(),
+        type: z.string(),
+        attributes: z.array(z.string()),
+        orders: z.array(z.string()).optional()
+    })).optional().default([]),
+    importDefs: z.array(z.any()).optional().default([])
+});
+/**
+ * Loads a YAML collection file and converts it to CollectionCreate format
+ * @param filePath Path to the YAML collection file
+ * @returns CollectionCreate object or null if loading fails
+ */
+export const loadYamlCollection = (filePath) => {
+    try {
+        const fileContent = fs.readFileSync(filePath, "utf8");
+        const yamlData = yaml.load(fileContent);
+        const parsedCollection = YamlCollectionSchema.parse(yamlData);
+        // Convert YAML collection to CollectionCreate format
+        const collection = {
+            name: parsedCollection.name,
+            $id: parsedCollection.id || parsedCollection.name.toLowerCase().replace(/\s+/g, '_'),
+            documentSecurity: parsedCollection.documentSecurity,
+            enabled: parsedCollection.enabled,
+            $permissions: parsedCollection.permissions.map(p => ({
+                permission: p.permission,
+                target: p.target
+            })),
+            attributes: parsedCollection.attributes.map(attr => ({
+                key: attr.key,
+                type: attr.type,
+                size: attr.size,
+                required: attr.required,
+                array: attr.array,
+                xdefault: attr.default,
+                min: attr.min,
+                max: attr.max,
+                elements: attr.elements,
+                relatedCollection: attr.relatedCollection,
+                relationType: attr.relationType,
+                twoWay: attr.twoWay,
+                twoWayKey: attr.twoWayKey,
+                onDelete: attr.onDelete,
+                side: attr.side
+            })),
+            indexes: parsedCollection.indexes.map(idx => ({
+                key: idx.key,
+                type: idx.type,
+                attributes: idx.attributes,
+                orders: idx.orders
+            })),
+            importDefs: parsedCollection.importDefs && Array.isArray(parsedCollection.importDefs) && parsedCollection.importDefs.length > 0 ? parsedCollection.importDefs : []
+        };
+        return collection;
+    }
+    catch (error) {
+        MessageFormatter.error(`Error loading YAML collection from ${filePath}`, error, { prefix: "Config" });
+        return null;
+    }
+};
+/**
+ * Loads a YAML table file and converts it to table format
+ * @param filePath Path to the YAML table file
+ * @returns Table object or null if loading fails
+ */
+export const loadYamlTable = (filePath) => {
+    try {
+        const fileContent = fs.readFileSync(filePath, "utf8");
+        const yamlData = yaml.load(fileContent);
+        // For now, use the collection schema as base and adapt for tables
+        const parsedTable = YamlCollectionSchema.parse(yamlData);
+        // Convert YAML table to TableCreate format
+        const table = {
+            name: parsedTable.name,
+            tableId: yamlData.tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
+            documentSecurity: parsedTable.documentSecurity,
+            enabled: parsedTable.enabled,
+            $permissions: parsedTable.permissions.map(p => ({
+                permission: p.permission,
+                target: p.target
+            })),
+            attributes: parsedTable.attributes.map(attr => ({
+                key: attr.key,
+                type: attr.type,
+                size: attr.size,
+                required: attr.required,
+                array: attr.array,
+                xdefault: attr.default,
+                min: attr.min,
+                max: attr.max,
+                elements: attr.elements,
+                relatedCollection: attr.relatedCollection,
+                relationType: attr.relationType,
+                twoWay: attr.twoWay,
+                twoWayKey: attr.twoWayKey,
+                onDelete: attr.onDelete,
+                side: attr.side
+            })),
+            indexes: parsedTable.indexes.map(idx => ({
+                key: idx.key,
+                type: idx.type,
+                attributes: idx.attributes,
+                orders: idx.orders
+            })),
+            importDefs: parsedTable.importDefs,
+            databaseId: yamlData.databaseId,
+            // Add backward compatibility field
+            $id: yamlData.$id || parsedTable.id
+        };
+        return table;
+    }
+    catch (error) {
+        MessageFormatter.error(`Error loading YAML table from ${filePath}`, error, { prefix: "Config" });
+        return null;
+    }
+};
+/**
+ * Discovers and loads collections from a collections/ directory
+ * @param collectionsDir Path to the collections directory
+ * @returns Discovery result with loaded collections and metadata
+ */
+export const discoverCollections = async (collectionsDir) => {
+    const collections = [];
+    const loadedNames = new Set();
+    const conflicts = [];
+    if (!fs.existsSync(collectionsDir)) {
+        return { collections, loadedNames, conflicts };
+    }
+    const unregister = register(); // Register tsx for collections
+    try {
+        const collectionFiles = fs.readdirSync(collectionsDir);
+        MessageFormatter.success(`Loading from collections/ directory: ${collectionFiles.length} files found`, { prefix: "Config" });
+        for (const file of collectionFiles) {
+            if (file === "index.ts") {
+                continue;
+            }
+            const filePath = path.join(collectionsDir, file);
+            let collection = null;
+            // Handle YAML collections
+            if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                collection = loadYamlCollection(filePath);
+            }
+            // Handle TypeScript collections
+            else if (file.endsWith('.ts')) {
+                const fileUrl = pathToFileURL(filePath).href;
+                const collectionModule = (await import(fileUrl));
+                const importedCollection = collectionModule.default?.default || collectionModule.default || collectionModule;
+                if (importedCollection) {
+                    collection = importedCollection;
+                    // Ensure importDefs are properly loaded
+                    if (collectionModule.importDefs || collection.importDefs) {
+                        collection.importDefs = collectionModule.importDefs || collection.importDefs;
+                    }
+                }
+            }
+            if (collection) {
+                const collectionName = collection.name || collection.$id || file;
+                loadedNames.add(collectionName);
+                collections.push(collection);
+            }
+        }
+    }
+    finally {
+        unregister(); // Unregister tsx when done
+    }
+    return { collections, loadedNames, conflicts };
+};
+/**
+ * Discovers and loads tables from a tables/ directory
+ * @param tablesDir Path to the tables directory
+ * @param existingNames Set of already-loaded collection names to check for conflicts
+ * @returns Discovery result with loaded tables and metadata
+ */
+export const discoverTables = async (tablesDir, existingNames = new Set()) => {
+    const tables = [];
+    const loadedNames = new Set();
+    const conflicts = [];
+    if (!fs.existsSync(tablesDir)) {
+        return { tables, loadedNames, conflicts };
+    }
+    const unregister = register(); // Register tsx for tables
+    try {
+        const tableFiles = fs.readdirSync(tablesDir);
+        MessageFormatter.success(`Loading from tables/ directory: ${tableFiles.length} files found`, { prefix: "Config" });
+        for (const file of tableFiles) {
+            if (file === "index.ts") {
+                continue;
+            }
+            const filePath = path.join(tablesDir, file);
+            let table = null;
+            // Handle YAML tables
+            if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                table = loadYamlTable(filePath);
+            }
+            // Handle TypeScript tables
+            else if (file.endsWith('.ts')) {
+                const fileUrl = pathToFileURL(filePath).href;
+                const tableModule = (await import(fileUrl));
+                const importedTable = tableModule.default?.default || tableModule.default || tableModule;
+                if (importedTable) {
+                    table = importedTable;
+                    // Ensure importDefs are properly loaded
+                    if (tableModule.importDefs || table.importDefs) {
+                        table.importDefs = tableModule.importDefs || table.importDefs;
+                    }
+                }
+            }
+            if (table) {
+                const tableName = table.name || table.tableId || table.$id || file;
+                // Check for naming conflicts with existing collections
+                if (existingNames.has(tableName)) {
+                    conflicts.push({
+                        name: tableName,
+                        source1: "collections/",
+                        source2: "tables/"
+                    });
+                    MessageFormatter.warning(`Skipping duplicate '${tableName}' from tables/ (collections/ takes priority)`, { prefix: "Config" });
+                }
+                else {
+                    loadedNames.add(tableName);
+                    // Mark as coming from tables directory
+                    table._isFromTablesDir = true;
+                    tables.push(table);
+                }
+            }
+        }
+    }
+    finally {
+        unregister(); // Unregister tsx when done
+    }
+    return { tables, loadedNames, conflicts };
+};
+/**
+ * Discovers and loads collections/tables from legacy single directory structure
+ * @param configFileDir Directory containing the config file
+ * @param dirName Directory name to search for ('collections' or 'tables')
+ * @returns Array of discovered collections/tables
+ */
+export const discoverLegacyDirectory = async (configFileDir, dirName) => {
+    const legacyDir = path.join(configFileDir, dirName);
+    const items = [];
+    if (!fs.existsSync(legacyDir)) {
+        return items;
+    }
+    MessageFormatter.info(`Using legacy single directory: ${dirName}/`, { prefix: "Config" });
+    const unregister = register(); // Register tsx for legacy collections
+    try {
+        const collectionFiles = fs.readdirSync(legacyDir);
+        for (const file of collectionFiles) {
+            if (file === "index.ts") {
+                continue;
+            }
+            const filePath = path.join(legacyDir, file);
+            // Handle YAML collections
+            if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                const collection = loadYamlCollection(filePath);
+                if (collection) {
+                    if (dirName === 'tables') {
+                        // Mark as coming from tables directory
+                        const table = {
+                            ...collection,
+                            _isFromTablesDir: true,
+                            tableId: collection.$id || collection.name.toLowerCase().replace(/\s+/g, '_')
+                        };
+                        items.push(table);
+                    }
+                    else {
+                        items.push(collection);
+                    }
+                }
+                continue;
+            }
+            // Handle TypeScript collections
+            if (file.endsWith('.ts')) {
+                const fileUrl = pathToFileURL(filePath).href;
+                const collectionModule = (await import(fileUrl));
+                const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
+                if (collection) {
+                    // Ensure importDefs are properly loaded
+                    if (collectionModule.importDefs || collection.importDefs) {
+                        collection.importDefs = collectionModule.importDefs || collection.importDefs;
+                    }
+                    if (dirName === 'tables') {
+                        // Mark as coming from tables directory
+                        const table = {
+                            ...collection,
+                            _isFromTablesDir: true,
+                            tableId: collection.$id || collection.name.toLowerCase().replace(/\s+/g, '_')
+                        };
+                        items.push(table);
+                    }
+                    else {
+                        items.push(collection);
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        unregister(); // Unregister tsx when done
+    }
+    return items;
+};

package/dist/utils/directoryUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Directory utility functions for filtering and managing directory traversal
+ */
+/**
+ * List of directories that should be ignored during recursive searches
+ * Includes common build outputs, dependencies, caches, and system folders
+ */
+export declare const IGNORED_DIRECTORIES: string[];
+/**
+ * Determines if a directory should be ignored during recursive file operations
+ *
+ * @param dirName - The name of the directory to check
+ * @returns true if the directory should be ignored, false otherwise
+ *
+ * @remarks
+ * A directory is ignored if:
+ * - It matches one of the entries in IGNORED_DIRECTORIES
+ * - It starts with '.git' prefix
+ * - It starts with 'node_modules' prefix
+ * - It starts with '.' (hidden directory) except for '.appwrite'
+ */
+export declare const shouldIgnoreDirectory: (dirName: string) => boolean;

package/dist/utils/directoryUtils.js

@@ -0,0 +1,59 @@
+/**
+ * Directory utility functions for filtering and managing directory traversal
+ */
+/**
+ * List of directories that should be ignored during recursive searches
+ * Includes common build outputs, dependencies, caches, and system folders
+ */
+export const IGNORED_DIRECTORIES = [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.cache',
+    '.git',
+    '.svn',
+    '.hg',
+    '__pycache__',
+    '.pytest_cache',
+    '.mypy_cache',
+    'venv',
+    '.venv',
+    'env',
+    '.env',
+    'target',
+    'out',
+    'bin',
+    'obj',
+    '.vs',
+    '.vscode',
+    '.idea',
+    'temp',
+    'tmp',
+    '.tmp',
+    'logs',
+    'log',
+    '.DS_Store',
+    'Thumbs.db'
+];
+/**
+ * Determines if a directory should be ignored during recursive file operations
+ *
+ * @param dirName - The name of the directory to check
+ * @returns true if the directory should be ignored, false otherwise
+ *
+ * @remarks
+ * A directory is ignored if:
+ * - It matches one of the entries in IGNORED_DIRECTORIES
+ * - It starts with '.git' prefix
+ * - It starts with 'node_modules' prefix
+ * - It starts with '.' (hidden directory) except for '.appwrite'
+ */
+export const shouldIgnoreDirectory = (dirName) => {
+    return IGNORED_DIRECTORIES.includes(dirName) ||
+        dirName.startsWith('.git') ||
+        dirName.startsWith('node_modules') ||
+        (dirName.startsWith('.') && dirName !== '.appwrite');
+};

package/dist/utils/getClientFromConfig.d.ts

@@ -2,29 +2,38 @@ import { type AppwriteConfig } from "appwrite-utils";
 import { Client } from "node-appwrite";
 import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
 /**
- * Legacy function - returns basic Client for backwards compatibility
- * @deprecated Use getAdapterFromConfig for dual API support
+ * Enhanced client creation from config with session authentication support
+ * @deprecated Use getAdapterFromConfig for dual API support with session auth
  */
-export declare const getClientFromConfig: (config: AppwriteConfig) => Client | undefined;
+export declare const getClientFromConfig: (config: AppwriteConfig, sessionCookie?: string) => Client | undefined;
+/**
+ * Enhanced client creation with session authentication support
+ * Priority: explicit session > session from prefs > API key
+ */
+export declare const getClientWithAuth: (endpoint: string, project: string, key?: string, sessionCookie?: string) => Client;
 /**
  * Legacy function - returns basic Client
- * @deprecated Use createDatabaseAdapter for dual API support
+ * @deprecated Use getClientWithAuth for session support or createDatabaseAdapter for dual API support
  */
 export declare const getClient: (endpoint: string, project: string, key: string) => Client;
 /**
- * Modern adapter-based client creation with dual API support
+ * Modern adapter-based client creation with dual API support and session authentication
  * Returns both adapter and legacy client for compatibility
  */
-export declare const getAdapterFromConfig: (config: AppwriteConfig, forceRefresh?: boolean) => Promise<{
+export declare const getAdapterFromConfig: (config: AppwriteConfig, forceRefresh?: boolean, sessionCookie?: string) => Promise<{
     adapter: DatabaseAdapter;
     client: Client;
     apiMode: "legacy" | "tablesdb";
 }>;
 /**
- * Create adapter from individual parameters
+ * Create adapter from individual parameters with session authentication support
  */
-export declare const getAdapter: (endpoint: string, project: string, key: string, apiMode?: "auto" | "legacy" | "tablesdb") => Promise<{
+export declare const getAdapter: (endpoint: string, project: string, key?: string, apiMode?: "auto" | "legacy" | "tablesdb", sessionCookie?: string) => Promise<{
     adapter: DatabaseAdapter;
     client: Client;
     apiMode: "legacy" | "tablesdb";
 }>;
+/**
+ * Check if session authentication is available for a project
+ */
+export declare const checkSessionAuth: (endpoint: string, project: string) => boolean;