appwrite-utils-cli 1.8.9 → 1.9.2

package/dist/utils/projectConfig.d.ts

@@ -103,8 +103,11 @@ export declare function loadAppwriteProjectConfig(configPath?: string): Appwrite
 export declare function detectApiModeFromProject(projectConfig: AppwriteProjectConfig): "legacy" | "tablesdb" | "auto";
 /**
  * Convert project config to AppwriteConfig format
+ * @param projectConfig The project config to convert
+ * @param configPath Optional path to the config file (for resolving relative paths)
+ * @param existingConfig Optional existing config to merge with
  */
-export declare function projectConfigToAppwriteConfig(projectConfig: AppwriteProjectConfig, existingConfig?: Partial<AppwriteConfig>): Partial<AppwriteConfig>;
+export declare function projectConfigToAppwriteConfig(projectConfig: AppwriteProjectConfig, configPath?: string, existingConfig?: Partial<AppwriteConfig>): Partial<AppwriteConfig>;
 /**
  * Get collection/table definitions from project config
  */

package/dist/utils/projectConfig.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve, isAbsolute } from "node:path";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 /**
  * Find appwrite.json or appwrite.config.json in current directory or parents
@@ -70,9 +70,13 @@ export function detectApiModeFromProject(projectConfig) {
 }
 /**
  * Convert project config to AppwriteConfig format
+ * @param projectConfig The project config to convert
+ * @param configPath Optional path to the config file (for resolving relative paths)
+ * @param existingConfig Optional existing config to merge with
  */
-export function projectConfigToAppwriteConfig(projectConfig, existingConfig) {
+export function projectConfigToAppwriteConfig(projectConfig, configPath, existingConfig) {
     const apiMode = detectApiModeFromProject(projectConfig);
+    const configDir = configPath ? dirname(configPath) : process.cwd();
     const baseConfig = {
         ...existingConfig,
         appwriteProject: projectConfig.projectId,
@@ -82,10 +86,20 @@ export function projectConfigToAppwriteConfig(projectConfig, existingConfig) {
     if (projectConfig.endpoint) {
         baseConfig.appwriteEndpoint = projectConfig.endpoint;
     }
-    // Convert databases (works for both legacy and TablesDB)
-    if (projectConfig.databases || projectConfig.tablesDB) {
-        const databases = projectConfig.databases || projectConfig.tablesDB || [];
-        baseConfig.databases = databases.map(db => ({
+    // Merge databases and tablesDB arrays (modern Appwrite may have both)
+    const allDatabases = [
+        ...(projectConfig.databases || []),
+        ...(projectConfig.tablesDB || [])
+    ];
+    // Remove duplicates by $id
+    const uniqueDatabasesMap = new Map();
+    for (const db of allDatabases) {
+        if (!uniqueDatabasesMap.has(db.$id)) {
+            uniqueDatabasesMap.set(db.$id, db);
+        }
+    }
+    if (uniqueDatabasesMap.size > 0) {
+        baseConfig.databases = Array.from(uniqueDatabasesMap.values()).map(db => ({
             $id: db.$id,
             name: db.name,
             // Add basic bucket configuration if not exists
@@ -112,6 +126,27 @@ export function projectConfigToAppwriteConfig(projectConfig, existingConfig) {
             antivirus: bucket.antiVirus ?? false,
         }));
     }
+    // Convert functions with path normalization
+    if (projectConfig.functions) {
+        baseConfig.functions = projectConfig.functions.map(func => {
+            const normalizedFunc = {
+                $id: func.$id,
+                name: func.name,
+                runtime: func.runtime,
+                entrypoint: func.entrypoint,
+                commands: func.commands,
+                events: func.events,
+            };
+            // Convert path to dirPath and make absolute
+            if (func.path) {
+                const expandedPath = func.path;
+                normalizedFunc.dirPath = isAbsolute(expandedPath)
+                    ? expandedPath
+                    : resolve(configDir, expandedPath);
+            }
+            return normalizedFunc;
+        });
+    }
     return baseConfig;
 }
 /**

package/dist/utilsController.d.ts

@@ -55,6 +55,7 @@ export declare class UtilsController {
         strictMode?: boolean;
         useSession?: boolean;
         sessionCookie?: string;
+        preferJson?: boolean;
     }): Promise<void>;
     reloadConfig(): Promise<void>;
     ensureDatabaseConfigBucketsExist(databases?: Models.Database[]): Promise<void>;

package/dist/utilsController.js

@@ -151,7 +151,7 @@ export class UtilsController {
         }
     }
     async init(options = {}) {
-        const { validate = false, strictMode = false } = options;
+        const { validate = false, strictMode = false, preferJson = false } = options;
         const configManager = ConfigManager.getInstance();
         // Load config if not already loaded
         if (!configManager.hasConfig()) {
@@ -159,6 +159,7 @@ export class UtilsController {
                 configDir: this.currentUserDir,
                 validate,
                 strictMode,
+                preferJson,
             });
         }
         const config = configManager.getConfig();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.8.9",
+  "version": "1.9.2",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -45,6 +45,7 @@
     "commander": "^12.1.0",
     "decimal.js": "^10.6.0",
     "es-toolkit": "^1.39.4",
+    "find-up": "^8.0.0",
     "ignore": "^6.0.2",
     "inquirer": "^9.3.7",
     "js-yaml": "^4.1.0",

package/src/adapters/DatabaseAdapter.ts

@@ -126,6 +126,18 @@ export interface CreateAttributeParams {
   default?: any;
   array?: boolean;
   encrypt?: boolean;
+  // Numeric type parameters
+  min?: number;
+  max?: number;
+  // Enum type parameters
+  elements?: string[];
+  // Relationship type parameters
+  relatedCollection?: string;
+  relationType?: 'oneToOne' | 'manyToOne' | 'oneToMany' | 'manyToMany';
+  twoWay?: boolean;
+  twoWayKey?: string;
+  onDelete?: 'setNull' | 'cascade' | 'restrict';
+  side?: 'parent' | 'child';
   // Additional type-specific parameters
   [key: string]: any;
 }

package/src/adapters/LegacyAdapter.ts

@@ -483,7 +483,7 @@ export class LegacyAdapter extends BaseAdapter {
             relatedCollectionId: params.relatedCollection || '',
             type: (params.type || 'oneToOne') as RelationshipType,
             twoWay: params.twoWay ?? false,
-            onDelete: params.onDelete || 'restrict'
+            onDelete: (params.onDelete || 'restrict') as RelationMutate
           });
           break;
           
@@ -534,33 +534,33 @@ export class LegacyAdapter extends BaseAdapter {
           });
           break;
 
-        case 'integer':
-          const integerAttr = existingAttr as Models.AttributeInteger;
-          result = await this.databases.updateIntegerAttribute({
-            databaseId: params.databaseId,
-            collectionId: params.tableId,
-            key: params.key,
-            required: params.required ?? integerAttr.required,
-            xdefault: params.default !== undefined ? params.default : integerAttr.default,
-            // Only include when explicitly provided to avoid resubmitting extreme values
-            ...(params.min !== undefined ? { min: params.min } : {}),
-            ...(params.max !== undefined ? { max: params.max } : {}),
-          });
-          break;
+        case 'integer':
+          const integerAttr = existingAttr as Models.AttributeInteger;
+          result = await this.databases.updateIntegerAttribute({
+            databaseId: params.databaseId,
+            collectionId: params.tableId,
+            key: params.key,
+            required: params.required ?? integerAttr.required,
+            xdefault: params.default !== undefined ? params.default : integerAttr.default,
+            // Only include when explicitly provided to avoid resubmitting extreme values
+            ...(params.min !== undefined ? { min: params.min } : {}),
+            ...(params.max !== undefined ? { max: params.max } : {}),
+          });
+          break;
 
-        case 'float':
-        case 'double':
-          const floatAttr = existingAttr as Models.AttributeFloat;
-          result = await this.databases.updateFloatAttribute({
-            databaseId: params.databaseId,
-            collectionId: params.tableId,
-            key: params.key,
-            required: params.required ?? floatAttr.required,
-            xdefault: params.default !== undefined ? params.default : floatAttr.default,
-            ...(params.min !== undefined ? { min: params.min } : {}),
-            ...(params.max !== undefined ? { max: params.max } : {}),
-          });
-          break;
+        case 'float':
+        case 'double':
+          const floatAttr = existingAttr as Models.AttributeFloat;
+          result = await this.databases.updateFloatAttribute({
+            databaseId: params.databaseId,
+            collectionId: params.tableId,
+            key: params.key,
+            required: params.required ?? floatAttr.required,
+            xdefault: params.default !== undefined ? params.default : floatAttr.default,
+            ...(params.min !== undefined ? { min: params.min } : {}),
+            ...(params.max !== undefined ? { max: params.max } : {}),
+          });
+          break;
 
         case 'boolean':
           const booleanAttr = existingAttr as Models.AttributeBoolean;
@@ -838,4 +838,4 @@ async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
       };
     }
   }
-}
+}

package/src/adapters/TablesDBAdapter.ts

@@ -448,10 +448,10 @@ export class TablesDBAdapter extends BaseAdapter {
             tableId: params.tableId,
             key: params.key,
             relatedTableId: params.relatedCollection || '',
-            type: (params.type || 'oneToOne') as RelationshipType,
+            type: (params.relationType || 'oneToOne') as RelationshipType,
             twoWay: params.twoWay ?? false,
             twoWayKey: params.twoWayKey,
-            onDelete: params.onDelete || 'restrict'
+            onDelete: (params.onDelete || 'restrict') as RelationMutate
           });
           break;
 
@@ -693,7 +693,26 @@ async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
 
       // 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: any) {
+          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
@@ -715,8 +734,31 @@ async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
         total: params.rowIds.length || (result as any).total || 0
       };
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // Enhanced error categorization
+      if (errorMessage.toLowerCase().includes('not found') || (error as any)?.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 as any)?.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 as any)?.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: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        `Failed to bulk delete rows: ${errorMessage}`,
         'BULK_DELETE_ROWS_FAILED',
         error instanceof Error ? error : undefined
       );

package/src/cli/commands/databaseCommands.ts

@@ -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";
@@ -9,6 +10,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";
 import type { InteractiveCLI } from "../../interactiveCLI.js";
 
 export const databaseCommands = {
@@ -29,11 +31,11 @@ export const databaseCommands = {
       // Push operations always use local configuration as source of truth
 
       // Select databases
-      const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
-        availableDatabases,
-        configuredDatabases,
-        { showSelectAll: false, allowNewOnly: false, defaultSelected: [] }
-      );
+      const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+        availableDatabases,
+        configuredDatabases,
+        { showSelectAll: false, allowNewOnly: false, defaultSelected: [] }
+      );
 
       if (selectedDatabaseIds.length === 0) {
         MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
@@ -93,12 +95,12 @@ export const databaseCommands = {
             MessageFormatter.warning("No storage buckets available in remote instance.", { prefix: "Database" });
           } else {
             // Select buckets using SelectionDialogs
-            const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
-              selectedDatabaseIds,
-              availableBuckets,
-              configuredBuckets,
-              { showSelectAll: false, groupByDatabase: true, defaultSelected: [] }
-            );
+            const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+              selectedDatabaseIds,
+              availableBuckets,
+              configuredBuckets,
+              { showSelectAll: false, groupByDatabase: true, defaultSelected: [] }
+            );
 
             if (selectedBucketIds.length > 0) {
               // Create BucketSelection objects
@@ -745,5 +747,133 @@ export const databaseCommands = {
       }
     }
     MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
+  },
+
+  async wipeTablesData(cli: InteractiveCLI): Promise<void> {
+    const controller = (cli as any).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: any) => ({
+            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 as any).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: any) =>
+        selectedTableIds.includes(t.$id)
+      );
+      const tableNames = selectedTables.map((t: any) => 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: string) => 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/src/config/ConfigManager.ts

@@ -77,6 +77,12 @@ 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;
 }
 
 /**
@@ -233,7 +239,10 @@ 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();