appwrite-utils-cli 1.7.6 → 1.7.8

package/dist/utils/yamlConverter.js

@@ -15,9 +15,15 @@ export function collectionToYaml(collection, config = {
     const yamlData = {
         name: collection.name,
         id: collection.$id,
-        documentSecurity: collection.documentSecurity,
         enabled: collection.enabled,
     };
+    // Use appropriate security field based on terminology
+    if (config.useTableTerminology) {
+        yamlData.rowSecurity = collection.documentSecurity;
+    }
+    else {
+        yamlData.documentSecurity = collection.documentSecurity;
+    }
     // Convert permissions
     if (collection.$permissions && collection.$permissions.length > 0) {
         yamlData.permissions = collection.$permissions.map(p => ({
@@ -158,6 +164,11 @@ export function normalizeYamlData(yamlData) {
             columns: undefined
         }));
     }
+    // Normalize security fields - prefer documentSecurity for consistency
+    if (yamlData.rowSecurity !== undefined && yamlData.documentSecurity === undefined) {
+        normalized.documentSecurity = yamlData.rowSecurity;
+        delete normalized.rowSecurity;
+    }
     return normalized;
 }
 /**
@@ -165,7 +176,8 @@ export function normalizeYamlData(yamlData) {
  */
 export function usesTableTerminology(yamlData) {
     return !!(yamlData.columns && yamlData.columns.length > 0) ||
-        !!(yamlData.indexes?.some(idx => !!idx.columns));
+        !!(yamlData.indexes?.some(idx => !!idx.columns)) ||
+        yamlData.rowSecurity !== undefined;
 }
 /**
  * Converts between attribute and column terminology
@@ -190,6 +202,11 @@ export function convertTerminology(yamlData, toTableTerminology) {
                 attributes: idx.attributes // Keep both for compatibility
             }));
         }
+        // Convert security field
+        if (yamlData.documentSecurity !== undefined && yamlData.rowSecurity === undefined) {
+            converted.rowSecurity = yamlData.documentSecurity;
+            delete converted.documentSecurity;
+        }
         return converted;
     }
     else {
@@ -272,7 +289,6 @@ export function generateYamlTemplate(entityName, config) {
     const template = {
         name: entityName,
         id: entityName.toLowerCase().replace(/\s+/g, '_'),
-        documentSecurity: false,
         enabled: true,
         permissions: [
             {
@@ -294,6 +310,13 @@ export function generateYamlTemplate(entityName, config) {
         ],
         importDefs: []
     };
+    // Use appropriate security field based on terminology
+    if (config.useTableTerminology) {
+        template.rowSecurity = false;
+    }
+    else {
+        template.documentSecurity = false;
+    }
     // Assign fields with correct property name
     template[fieldsKey] = fieldsArray;
     template.indexes = indexesArray;

package/dist/utilsController.d.ts

@@ -4,6 +4,7 @@ import { type AfterImportActions, type ConverterFunctions, type ValidationRules
 import { type TransferOptions } from "./migrations/transfer.js";
 import type { DatabaseAdapter } from './adapters/DatabaseAdapter.js';
 import { type ValidationResult } from "./config/configValidation.js";
+import type { DatabaseSelection, BucketSelection } from "./shared/selectionDialogs.js";
 export interface SetupOptions {
     databases?: Models.Database[];
     collections?: string[];
@@ -60,6 +61,9 @@ export declare class UtilsController {
     ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;
     ensureCollectionsExist(database: Models.Database, collections?: Models.Collection[]): Promise<void>;
     getDatabasesByIds(ids: string[]): Promise<Models.Database[] | undefined>;
+    fetchAllBuckets(): Promise<{
+        buckets: Models.Bucket[];
+    }>;
     wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;
     wipeUsers(): Promise<void>;
     backupDatabase(database: Models.Database, format?: 'json' | 'zip'): Promise<void>;
@@ -78,7 +82,8 @@ export declare class UtilsController {
     }[], collections?: Models.Collection[]): Promise<void>;
     generateSchemas(): Promise<void>;
     importData(options?: SetupOptions): Promise<void>;
-    synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig): Promise<void>;
+    synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig, databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
+    selectiveSync(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
     syncDb(databases?: Models.Database[], collections?: Models.Collection[]): Promise<void>;
     getAppwriteFolderPath(): string | undefined;
     transferData(options: TransferOptions): Promise<void>;

package/dist/utilsController.js

@@ -25,6 +25,7 @@ import { configureLogging, updateLogger, logger } from "./shared/logging.js";
 import { MessageFormatter, Messages } from "./shared/messageFormatter.js";
 import { SchemaGenerator } from "./shared/schemaGenerator.js";
 import { findYamlConfig } from "./config/yamlConfig.js";
+import { createImportSchemas } from "./migrations/yaml/generateImportSchemas.js";
 import { validateCollectionsTablesConfig, reportValidationResults, validateWithStrictMode } from "./config/configValidation.js";
 import { ConfigManager } from "./config/ConfigManager.js";
 import { ClientFactory } from "./utils/ClientFactory.js";
@@ -225,6 +226,24 @@ export class UtilsController {
         ]);
         return dbs.databases;
     }
+    async fetchAllBuckets() {
+        await this.init();
+        if (!this.storage) {
+            MessageFormatter.warning("Storage not initialized - buckets will be empty", { prefix: "Controller" });
+            return { buckets: [] };
+        }
+        try {
+            const result = await this.storage.listBuckets([
+                Query.limit(1000) // Increase limit to get all buckets
+            ]);
+            MessageFormatter.success(`Found ${result.buckets.length} buckets`, { prefix: "Controller" });
+            return result;
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to fetch buckets: ${error.message || error}`, error instanceof Error ? error : undefined, { prefix: "Controller" });
+            return { buckets: [] };
+        }
+    }
     async wipeOtherDatabases(databasesToKeep) {
         await this.init();
         if (!this.database) {
@@ -448,7 +467,7 @@ export class UtilsController {
         const importController = new ImportController(this.config, this.database, this.storage, this.appwriteFolderPath, importDataActions, options, options.databases);
         await importController.run(options.collections);
     }
-    async synchronizeConfigurations(databases, config) {
+    async synchronizeConfigurations(databases, config, databaseSelections, bucketSelections) {
         await this.init();
         if (!this.storage) {
             MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
@@ -463,8 +482,25 @@ export class UtilsController {
             MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return;
         }
+        // If selections are provided, filter the databases accordingly
+        let filteredDatabases = databases;
+        if (databaseSelections && databaseSelections.length > 0) {
+            // Convert selections to Models.Database format
+            filteredDatabases = [];
+            const allDatabases = databases ? databases : await fetchAllDatabases(this.database);
+            for (const selection of databaseSelections) {
+                const database = allDatabases.find(db => db.$id === selection.databaseId);
+                if (database) {
+                    filteredDatabases.push(database);
+                }
+                else {
+                    MessageFormatter.warning(`Database with ID ${selection.databaseId} not found`, { prefix: "Controller" });
+                }
+            }
+            MessageFormatter.info(`Syncing ${filteredDatabases.length} selected databases out of ${allDatabases.length} available`, { prefix: "Controller" });
+        }
         const appwriteToX = new AppwriteToX(configToUse, this.appwriteFolderPath, this.storage);
-        await appwriteToX.toSchemas(databases);
+        await appwriteToX.toSchemas(filteredDatabases);
         // Update the controller's config with the synchronized collections
         this.config = appwriteToX.updatedConfig;
         // Write the updated config back to disk
@@ -472,6 +508,59 @@ export class UtilsController {
         const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
         const isYamlProject = !!yamlConfigPath;
         await generator.updateConfig(this.config, isYamlProject);
+        // Regenerate JSON schemas to reflect any table terminology fixes
+        try {
+            MessageFormatter.progress("Regenerating JSON schemas...", { prefix: "Sync" });
+            await createImportSchemas(this.appwriteFolderPath);
+            MessageFormatter.success("JSON schemas regenerated successfully", { prefix: "Sync" });
+        }
+        catch (error) {
+            // Log error but don't fail the sync process
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            MessageFormatter.warning(`Failed to regenerate JSON schemas, but sync completed: ${errorMessage}`, { prefix: "Sync" });
+            logger.warn("Schema regeneration failed during sync:", error);
+        }
+    }
+    async selectiveSync(databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        MessageFormatter.progress("Starting selective sync...", { prefix: "Controller" });
+        // Convert database selections to Models.Database format
+        const selectedDatabases = [];
+        for (const dbSelection of databaseSelections) {
+            // Get the full database object from the controller
+            const databases = await fetchAllDatabases(this.database);
+            const database = databases.find(db => db.$id === dbSelection.databaseId);
+            if (database) {
+                selectedDatabases.push(database);
+                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+                // Log selected tables for this database
+                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+            }
+        }
+        if (selectedDatabases.length === 0) {
+            MessageFormatter.warning("No valid databases selected for sync", { prefix: "Controller" });
+            return;
+        }
+        // Log bucket selections if provided
+        if (bucketSelections && bucketSelections.length > 0) {
+            MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+            for (const bucketSelection of bucketSelections) {
+                const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+                MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+            }
+        }
+        // Perform selective sync using the enhanced synchronizeConfigurations method
+        await this.synchronizeConfigurations(selectedDatabases, this.config, databaseSelections, bucketSelections);
+        MessageFormatter.success("Selective sync completed successfully!", { prefix: "Controller" });
     }
     async syncDb(databases = [], collections = []) {
         await this.init();

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.7.6",
+  "version": "1.7.8",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/adapters/DatabaseAdapter.ts

@@ -86,7 +86,8 @@ export interface BulkUpsertRowsParams {
 export interface BulkDeleteRowsParams {
   databaseId: string;
   tableId: string;
-  rowIds: string[];
+  rowIds: string[]; // Empty array = wipe mode (use Query.limit), otherwise specific IDs to delete
+  batchSize?: number; // Optional batch size for wipe mode (default 250)
 }
 
 // Index operation parameters  

package/src/adapters/LegacyAdapter.ts

@@ -7,32 +7,33 @@
  * older Appwrite instances.
  */
 
-import { Query } from "node-appwrite";
-import {
-  BaseAdapter,
-  type CreateRowParams,
-  type UpdateRowParams,
-  type ListRowsParams,
-  type DeleteRowParams,
-  type CreateTableParams,
-  type UpdateTableParams,
-  type ListTablesParams,
-  type DeleteTableParams,
-  type GetTableParams,
-  type BulkCreateRowsParams,
-  type BulkUpsertRowsParams,
-  type BulkDeleteRowsParams,
-  type CreateIndexParams,
-  type ListIndexesParams,
-  type DeleteIndexParams,
-  type CreateAttributeParams,
-  type UpdateAttributeParams,
-  type DeleteAttributeParams,
-  type ApiResponse,
-  type AdapterMetadata,
-  AdapterError,
-  UnsupportedOperationError
-} from './DatabaseAdapter.js';
+import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
+import {
+  BaseAdapter,
+  type CreateRowParams,
+  type UpdateRowParams,
+  type ListRowsParams,
+  type DeleteRowParams,
+  type CreateTableParams,
+  type UpdateTableParams,
+  type ListTablesParams,
+  type DeleteTableParams,
+  type GetTableParams,
+  type BulkCreateRowsParams,
+  type BulkUpsertRowsParams,
+  type BulkDeleteRowsParams,
+  type CreateIndexParams,
+  type ListIndexesParams,
+  type DeleteIndexParams,
+  type CreateAttributeParams,
+  type UpdateAttributeParams,
+  type DeleteAttributeParams,
+  type ApiResponse,
+  type AdapterMetadata,
+  AdapterError,
+  UnsupportedOperationError
+} from './DatabaseAdapter.js';
 
 /**
  * LegacyAdapter - Translates TablesDB calls to legacy Databases API
@@ -587,62 +588,74 @@ export class LegacyAdapter extends BaseAdapter {
     throw new UnsupportedOperationError('bulkUpsertRows', 'legacy');
   }
   
-async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
-    try {
-      // Try to use deleteDocuments with queries first (more efficient)
-      const queries = params.rowIds.map(id => Query.equal('$id', id));
-      
-      const result = await this.databases.deleteDocuments(
-        params.databaseId,
-        params.tableId, // Maps tableId to collectionId
-        queries
-      );
-      
-      return {
-        data: result,
-        total: params.rowIds.length
-      };
-    } catch (error) {
-      // If deleteDocuments with queries fails, fall back to individual deletes
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      
-      // Check if the error indicates that deleteDocuments with queries is not supported
-      if (errorMessage.includes('not supported') || errorMessage.includes('invalid') || errorMessage.includes('queries')) {
-        // Fall back to individual deletions
-        const results = [];
-        const errors = [];
-        
-        for (const rowId of params.rowIds) {
-          try {
-            await this.deleteRow({
-              databaseId: params.databaseId,
-              tableId: params.tableId,
-              id: rowId
-            });
-            results.push({ id: rowId, deleted: true });
-          } catch (individualError) {
-            errors.push({ 
-              rowId, 
-              error: individualError instanceof Error ? individualError.message : 'Unknown error' 
-            });
-          }
-        }
-        
-        return {
-          data: results,
-          total: results.length,
-          errors: errors.length > 0 ? errors : undefined
-        };
-      } else {
-        // Re-throw the original error if it's not a support issue
-        throw new AdapterError(
-          `Failed to bulk delete rows (legacy): ${errorMessage}`,
-          'BULK_DELETE_ROWS_FAILED',
-          error instanceof Error ? error : undefined
-        );
-      }
-    }
-  }
+async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
+    try {
+      let queries: string[];
+
+      // Wipe mode: use Query.limit for deleting without fetching
+      if (params.rowIds.length === 0) {
+        const batchSize = params.batchSize || 250;
+        queries = [Query.limit(batchSize)];
+      }
+      // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+      // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+      else {
+        const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+        const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+        queries = idBatches.map(batch => Query.equal('$id', batch));
+      }
+
+      const result = await this.databases.deleteDocuments(
+        params.databaseId,
+        params.tableId, // Maps tableId to collectionId
+        queries
+      );
+
+      return {
+        data: result,
+        total: params.rowIds.length || (result as any).total || 0
+      };
+    } catch (error) {
+      // If deleteDocuments with queries fails, fall back to individual deletes
+      const errorMessage = error instanceof Error ? error.message : String(error);
+
+      // Check if the error indicates that deleteDocuments with queries is not supported
+      if (errorMessage.includes('not supported') || errorMessage.includes('invalid') || errorMessage.includes('queries')) {
+        // Fall back to individual deletions
+        const results = [];
+        const errors = [];
+
+        for (const rowId of params.rowIds) {
+          try {
+            await this.deleteRow({
+              databaseId: params.databaseId,
+              tableId: params.tableId,
+              id: rowId
+            });
+            results.push({ id: rowId, deleted: true });
+          } catch (individualError) {
+            errors.push({
+              rowId,
+              error: individualError instanceof Error ? individualError.message : 'Unknown error'
+            });
+          }
+        }
+
+        return {
+          data: results,
+          total: results.length,
+          errors: errors.length > 0 ? errors : undefined
+        };
+      } else {
+        // Re-throw the original error if it's not a support issue
+        throw new AdapterError(
+          `Failed to bulk delete rows (legacy): ${errorMessage}`,
+          'BULK_DELETE_ROWS_FAILED',
+          error instanceof Error ? error : undefined
+        );
+      }
+    }
+  }
   
   // Metadata and Capabilities
   

package/src/adapters/TablesDBAdapter.ts

@@ -6,32 +6,33 @@
  * and returns Models.Row instead of Models.Document.
  */
 
-import { Query } from "node-appwrite";
-import {
-  BaseAdapter,
-  type DatabaseAdapter,
-  type CreateRowParams,
-  type UpdateRowParams,
-  type ListRowsParams,
-  type DeleteRowParams,
-  type CreateTableParams,
-  type UpdateTableParams,
-  type ListTablesParams,
-  type DeleteTableParams,
-  type GetTableParams,
-  type BulkCreateRowsParams,
-  type BulkUpsertRowsParams,
-  type BulkDeleteRowsParams,
-  type CreateIndexParams,
-  type ListIndexesParams,
-  type DeleteIndexParams,
-  type CreateAttributeParams,
-  type UpdateAttributeParams,
-  type DeleteAttributeParams,
-  type ApiResponse,
-  type AdapterMetadata,
-  AdapterError
-} from './DatabaseAdapter.js';
+import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
+import {
+  BaseAdapter,
+  type DatabaseAdapter,
+  type CreateRowParams,
+  type UpdateRowParams,
+  type ListRowsParams,
+  type DeleteRowParams,
+  type CreateTableParams,
+  type UpdateTableParams,
+  type ListTablesParams,
+  type DeleteTableParams,
+  type GetTableParams,
+  type BulkCreateRowsParams,
+  type BulkUpsertRowsParams,
+  type BulkDeleteRowsParams,
+  type CreateIndexParams,
+  type ListIndexesParams,
+  type DeleteIndexParams,
+  type CreateAttributeParams,
+  type UpdateAttributeParams,
+  type DeleteAttributeParams,
+  type ApiResponse,
+  type AdapterMetadata,
+  AdapterError
+} from './DatabaseAdapter.js';
 
 /**
  * TablesDBAdapter implementation for native TablesDB API
@@ -514,27 +515,41 @@ export class TablesDBAdapter extends BaseAdapter {
     }
   }
   
-async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
-    try {
-      // Convert rowIds to queries for the deleteRows API
-      const queries = params.rowIds.map(id => Query.equal('$id', id));
-      const result = await this.tablesDB.deleteRows({
-        databaseId: params.databaseId,
-        tableId: params.tableId,
-        queries: queries
-      });
-      return {
-        data: result,
-        total: params.rowIds.length
-      };
-    } 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
-      );
-    }
-  }
+async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
+    try {
+      let queries: string[];
+
+      // Wipe mode: use Query.limit for deleting without fetching
+      if (params.rowIds.length === 0) {
+        const batchSize = params.batchSize || 250;
+        queries = [Query.limit(batchSize)];
+      }
+      // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+      // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+      else {
+        const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+        const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+        queries = idBatches.map(batch => Query.equal('$id', batch));
+      }
+
+      const result = await this.tablesDB.deleteRows({
+        databaseId: params.databaseId,
+        tableId: params.tableId,
+        queries: queries
+      });
+
+      return {
+        data: result,
+        total: params.rowIds.length || (result as any).total || 0
+      };
+    } 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
+      );
+    }
+  }
   
   // Metadata and Capabilities
   getMetadata(): AdapterMetadata {