appwrite-utils-cli 1.8.9 → 1.9.1

package/dist/adapters/DatabaseAdapter.d.ts

@@ -105,6 +105,15 @@ export interface CreateAttributeParams {
     default?: any;
     array?: boolean;
     encrypt?: boolean;
+    min?: number;
+    max?: number;
+    elements?: string[];
+    relatedCollection?: string;
+    relationType?: 'oneToOne' | 'manyToOne' | 'oneToMany' | 'manyToMany';
+    twoWay?: boolean;
+    twoWayKey?: string;
+    onDelete?: 'setNull' | 'cascade' | 'restrict';
+    side?: 'parent' | 'child';
     [key: string]: any;
 }
 export interface UpdateAttributeParams {

package/dist/adapters/LegacyAdapter.js

@@ -316,7 +316,7 @@ export class LegacyAdapter extends BaseAdapter {
                         relatedCollectionId: params.relatedCollection || '',
                         type: (params.type || 'oneToOne'),
                         twoWay: params.twoWay ?? false,
-                        onDelete: params.onDelete || 'restrict'
+                        onDelete: (params.onDelete || 'restrict')
                     });
                     break;
                 default:

package/dist/adapters/TablesDBAdapter.js

@@ -308,10 +308,10 @@ export class TablesDBAdapter extends BaseAdapter {
                         tableId: params.tableId,
                         key: params.key,
                         relatedTableId: params.relatedCollection || '',
-                        type: (params.type || 'oneToOne'),
+                        type: (params.relationType || 'oneToOne'),
                         twoWay: params.twoWay ?? false,
                         twoWayKey: params.twoWayKey,
-                        onDelete: params.onDelete || 'restrict'
+                        onDelete: (params.onDelete || 'restrict')
                     });
                     break;
                 default:
@@ -505,7 +505,21 @@ export class TablesDBAdapter extends BaseAdapter {
             let queries;
             // Wipe mode: use Query.limit for deleting without fetching
             if (params.rowIds.length === 0) {
-                const batchSize = params.batchSize || 250;
+                const batchSize = params.batchSize || 1000;
+                // Validation: Ensure table exists before wiping
+                try {
+                    await this.getTable({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error?.message || String(error);
+                    if (errorMessage.toLowerCase().includes('not found') || error?.code === 404) {
+                        throw new AdapterError(`Table '${params.tableId}' not found in database '${params.databaseId}'`, 'TABLE_NOT_FOUND', error);
+                    }
+                    throw error; // Re-throw other errors
+                }
                 queries = [Query.limit(batchSize)];
             }
             // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
@@ -526,7 +540,18 @@ export class TablesDBAdapter extends BaseAdapter {
             };
         }
         catch (error) {
-            throw new AdapterError(`Failed to bulk delete rows: ${error instanceof Error ? error.message : 'Unknown error'}`, 'BULK_DELETE_ROWS_FAILED', error instanceof Error ? error : undefined);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            // Enhanced error categorization
+            if (errorMessage.toLowerCase().includes('not found') || error?.code === 404) {
+                throw new AdapterError(`Table or rows not found: ${errorMessage}`, 'NOT_FOUND', error instanceof Error ? error : undefined);
+            }
+            else if (errorMessage.toLowerCase().includes('permission') || errorMessage.toLowerCase().includes('unauthorized') || error?.code === 403) {
+                throw new AdapterError(`Permission denied for bulk delete: ${errorMessage}`, 'PERMISSION_DENIED', error instanceof Error ? error : undefined);
+            }
+            else if (errorMessage.toLowerCase().includes('rate limit') || error?.code === 429) {
+                throw new AdapterError(`Rate limit exceeded during bulk delete: ${errorMessage}`, 'RATE_LIMIT', error instanceof Error ? error : undefined);
+            }
+            throw new AdapterError(`Failed to bulk delete rows: ${errorMessage}`, 'BULK_DELETE_ROWS_FAILED', error instanceof Error ? error : undefined);
         }
     }
     // Metadata and Capabilities

package/dist/cli/commands/databaseCommands.d.ts

@@ -10,4 +10,5 @@ export declare const databaseCommands: {
     executeUnifiedBackup(cli: InteractiveCLI, trackingDatabaseId: string, scope: any): Promise<void>;
     wipeDatabase(cli: InteractiveCLI): Promise<void>;
     wipeCollections(cli: InteractiveCLI): Promise<void>;
+    wipeTablesData(cli: InteractiveCLI): Promise<void>;
 };

package/dist/cli/commands/databaseCommands.js

@@ -1,6 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { join } from "node:path";
+import { Query } from "node-appwrite";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
 import { SelectionDialogs } from "../../shared/selectionDialogs.js";
@@ -8,6 +9,7 @@ import { logger } from "../../shared/logging.js";
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
 import { getFunction, downloadLatestFunctionDeployment } from "../../functions/methods.js";
+import { wipeTableRows } from "../../collections/wipeOperations.js";
 export const databaseCommands = {
     async syncDb(cli) {
         MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
@@ -550,5 +552,93 @@ export const databaseCommands = {
             }
         }
         MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
+    },
+    async wipeTablesData(cli) {
+        const controller = cli.controller;
+        if (!controller?.adapter) {
+            throw new Error("Database adapter is not initialized. TablesDB operations require adapter support.");
+        }
+        try {
+            // Step 1: Select database (single selection for clearer UX)
+            const databases = await fetchAllDatabases(controller.database);
+            if (!databases || databases.length === 0) {
+                MessageFormatter.warning("No databases found", { prefix: "Wipe" });
+                return;
+            }
+            const { selectedDatabase } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedDatabase",
+                    message: "Select database containing tables to wipe:",
+                    choices: databases.map((db) => ({
+                        name: `${db.name} (${db.$id})`,
+                        value: db
+                    }))
+                }
+            ]);
+            const database = selectedDatabase;
+            // Step 2: Get available tables
+            const adapter = controller.adapter;
+            const tablesResponse = await adapter.listTables({
+                databaseId: database.$id,
+                queries: [Query.limit(500)]
+            });
+            const availableTables = tablesResponse.tables || [];
+            if (availableTables.length === 0) {
+                MessageFormatter.warning(`No tables found in database: ${database.name}`, { prefix: "Wipe" });
+                return;
+            }
+            // Step 3: Select tables using existing SelectionDialogs
+            const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(database.$id, database.name, availableTables, [], // No configured tables context needed for wipe
+            {
+                showSelectAll: true,
+                allowNewOnly: false,
+                defaultSelected: []
+            });
+            if (selectedTableIds.length === 0) {
+                MessageFormatter.warning("No tables selected. Operation cancelled.", { prefix: "Wipe" });
+                return;
+            }
+            // Step 4: Show confirmation with table details
+            const selectedTables = availableTables.filter((t) => selectedTableIds.includes(t.$id));
+            const tableNames = selectedTables.map((t) => t.name);
+            console.log(chalk.yellow.bold("\n⚠️  WARNING: Table Row Wipe Operation"));
+            console.log(chalk.yellow("This will delete ALL ROWS from the selected tables."));
+            console.log(chalk.yellow("The table structures will remain intact.\n"));
+            console.log(chalk.cyan("Database:"), chalk.white(database.name));
+            console.log(chalk.cyan("Tables to wipe:"));
+            tableNames.forEach((name) => console.log(chalk.white(`  • ${name}`)));
+            console.log();
+            const { confirmed } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirmed",
+                    message: chalk.red.bold("Are you ABSOLUTELY SURE you want to wipe these table rows?"),
+                    default: false
+                }
+            ]);
+            if (!confirmed) {
+                MessageFormatter.info("Wipe operation cancelled by user", { prefix: "Wipe" });
+                return;
+            }
+            // Step 5: Execute wipe using existing wipeTableRows function
+            MessageFormatter.progress("Starting table row wipe operation...", { prefix: "Wipe" });
+            for (const table of selectedTables) {
+                try {
+                    MessageFormatter.info(`Wiping rows from table: ${table.name}`, { prefix: "Wipe" });
+                    // Use existing wipeTableRows from wipeOperations.ts
+                    await wipeTableRows(adapter, database.$id, table.$id);
+                    MessageFormatter.success(`Successfully wiped rows from table: ${table.name}`, { prefix: "Wipe" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to wipe table ${table.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
+                }
+            }
+            MessageFormatter.success(`Wipe operation completed for ${selectedTables.length} table(s)`, { prefix: "Wipe" });
+        }
+        catch (error) {
+            MessageFormatter.error("Table wipe operation failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
+            throw error;
+        }
     }
 };

package/dist/config/ConfigManager.d.ts

@@ -54,6 +54,11 @@ export interface ConfigLoadOptions {
      * Override session authentication (used for preserving session on reload)
      */
     sessionOverride?: SessionAuthInfo;
+    /**
+     * Prefer loading from appwrite.config.json over config.yaml
+     * @default false
+     */
+    preferJson?: boolean;
 }
 /**
  * Filter function for collections (accepts both Collection and CollectionCreate)

package/dist/config/ConfigManager.js

@@ -139,7 +139,7 @@ export class ConfigManager {
         }
         logger.debug("Loading config from file", { prefix: "ConfigManager", options });
         // 2. Discover config file
-        const configPath = this.discoveryService.findConfig(options.configDir || process.cwd());
+        const configPath = await this.discoveryService.findConfig(options.configDir || process.cwd(), options.preferJson || false);
         if (!configPath) {
             const searchDir = options.configDir || process.cwd();
             throw new Error(`No Appwrite configuration found in "${searchDir}".\n` +

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

@@ -10,74 +10,76 @@ 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 declare class ConfigDiscoveryService {
     /**
      * YAML configuration file names to search for
      */
     private readonly YAML_FILENAMES;
+    /**
+     * JSON configuration file names to search for
+     */
+    private readonly JSON_FILENAMES;
     /**
      * TypeScript configuration file names to search for
      */
     private readonly TS_FILENAMES;
     /**
-     * JSON configuration file names to search for
+     * Finds the git repository root directory
+     * @param startDir The directory to start searching from
+     * @returns Path to the repository root, or startDir if no .git found
      */
-    private readonly JSON_FILENAMES;
+    private findRepoRoot;
     /**
-     * Maximum levels to search up the directory tree
+     * 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
      */
-    private readonly MAX_SEARCH_DEPTH;
+    private searchDownward;
     /**
-     * Finds any configuration file with priority: YAML → TypeScript → JSON
+     * Finds any configuration file with configurable priority
      * @param startDir The directory to start searching from
+     * @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
      */
-    findConfig(startDir: string): string | null;
+    findConfig(startDir: string, preferJson?: boolean): Promise<string | null>;
     /**
      * Finds YAML configuration files
-     * Searches current directory, subdirectories, and parent directory
+     * 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
      */
-    findYamlConfig(startDir: string): string | null;
+    findYamlConfig(startDir: string, repoRoot?: string): Promise<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
+     * 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
      */
-    private findYamlConfigRecursive;
+    findProjectConfig(startDir: string, repoRoot?: string): Promise<string | 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
      */
-    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;
+    findTypeScriptConfig(startDir: string, repoRoot?: string): Promise<string | null>;
     /**
      * Discovers collection YAML files in a collections/ directory
      * @param collectionsDir Path to the collections directory
@@ -95,32 +97,26 @@ export declare class ConfigDiscoveryService {
      * @param startDir The directory to start searching from
      * @returns Path to .appwrite directory or null if not found
      */
-    findAppwriteDirectory(startDir: string): string | null;
+    findAppwriteDirectory(startDir: string): Promise<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;
+    findFunctionsDirectory(startDir: string): Promise<string | 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: string): {
+    getConfigurationSummary(startDir: string): Promise<{
         yaml: string | null;
         typescript: string | null;
         json: string | null;
         appwriteDirectory: string | null;
         functionsDirectory: string | null;
         selectedConfig: string | null;
-    };
+        repoRoot: string;
+    }>;
 }