appwrite-utils-cli 1.7.7 → 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.7",
+  "version": "1.7.8",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/cli/commands/databaseCommands.ts

@@ -3,6 +3,9 @@ import chalk from "chalk";
 import { join } from "node:path";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
+import { SelectionDialogs } from "../../shared/selectionDialogs.js";
+import type { DatabaseSelection, BucketSelection } from "../../shared/selectionDialogs.js";
+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";
@@ -12,23 +15,41 @@ export const databaseCommands = {
   async syncDb(cli: InteractiveCLI): Promise<void> {
     MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
 
-    const databases = await (cli as any).selectDatabases(
-      (cli as any).getLocalDatabases(),
-      chalk.blue("Select local databases to push:"),
-      true
-    );
+    try {
+      // Initialize controller
+      await (cli as any).controller!.init();
 
-    if (!databases.length) {
-      MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
-      return;
-    }
+      // Get available and configured databases
+      const availableDatabases = await fetchAllDatabases((cli as any).controller!.database!);
+      const configuredDatabases = (cli as any).controller!.config?.databases || [];
 
-    try {
-      // Loop through each database and prompt for collections specific to that database
-      for (const database of databases) {
-        MessageFormatter.info(`\n📦 Configuring push for database: ${database.name}`, { prefix: "Database" });
+      // Get local collections for selection
+      const localCollections = (cli as any).getLocalCollections();
+
+      // Prompt about existing configuration
+      const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+
+      // Select databases
+      const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+        availableDatabases,
+        configuredDatabases,
+        { showSelectAll: true, allowNewOnly: !syncExisting }
+      );
+
+      if (selectedDatabaseIds.length === 0) {
+        MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
+        return;
+      }
+
+      // Select tables/collections for each database using the existing method
+      const tableSelectionsMap = new Map<string, string[]>();
+      const availableTablesMap = new Map<string, any[]>();
 
-        const collections = await (cli as any).selectCollectionsAndTables(
+      for (const databaseId of selectedDatabaseIds) {
+        const database = availableDatabases.find(db => db.$id === databaseId)!;
+
+        // Use the existing selectCollectionsAndTables method
+        const selectedCollections = await (cli as any).selectCollectionsAndTables(
           database,
           (cli as any).controller!.database!,
           chalk.blue(`Select collections/tables to push to "${database.name}":`),
@@ -36,19 +57,93 @@ export const databaseCommands = {
           true   // prefer local
         );
 
-        if (collections.length === 0) {
+        // Map selected collections to table IDs
+        const selectedTableIds = selectedCollections.map((c: any) => c.$id || c.id);
+
+        // Store selections
+        tableSelectionsMap.set(databaseId, selectedTableIds);
+        availableTablesMap.set(databaseId, selectedCollections);
+
+        if (selectedCollections.length === 0) {
           MessageFormatter.warning(`No collections selected for database "${database.name}". Skipping.`, { prefix: "Database" });
           continue;
         }
+      }
 
-        // Push selected collections to this specific database
-        await (cli as any).controller!.syncDb([database], collections);
-        MessageFormatter.success(
-          `Pushed ${collections.length} collection(s) to database "${database.name}"`,
-          { prefix: "Database" }
-        );
+      // Ask if user wants to select buckets
+      const { selectBuckets } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "selectBuckets",
+          message: "Do you want to select storage buckets to sync as well?",
+          default: false,
+        },
+      ]);
+
+      let bucketSelections: BucketSelection[] = [];
+
+      if (selectBuckets) {
+        // Get available and configured buckets
+        try {
+          const availableBucketsResponse = await listBuckets((cli as any).controller!.storage!);
+          const availableBuckets = availableBucketsResponse.buckets || [];
+          const configuredBuckets = (cli as any).controller!.config?.buckets || [];
+
+          if (availableBuckets.length === 0) {
+            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: true, groupByDatabase: true }
+            );
+
+            if (selectedBucketIds.length > 0) {
+              // Create BucketSelection objects
+              bucketSelections = SelectionDialogs.createBucketSelection(
+                selectedBucketIds,
+                availableBuckets,
+                configuredBuckets,
+                availableDatabases
+              );
+
+              MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Database" });
+            }
+          }
+        } catch (error) {
+          MessageFormatter.warning("Failed to fetch storage buckets. Continuing with databases only.", { prefix: "Database" });
+          logger.warn("Storage bucket fetch failed during syncDb", { error: error instanceof Error ? error.message : String(error) });
+        }
       }
 
+      // Create DatabaseSelection objects
+      const databaseSelections = SelectionDialogs.createDatabaseSelection(
+        selectedDatabaseIds,
+        availableDatabases,
+        tableSelectionsMap,
+        configuredDatabases,
+        availableTablesMap
+      );
+
+      // Show confirmation summary
+      const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+        databaseSelections,
+        bucketSelections
+      );
+
+      const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+
+      if (!confirmed) {
+        MessageFormatter.info("Sync operation cancelled by user", { prefix: "Database" });
+        return;
+      }
+
+      // Perform selective sync using the controller
+      MessageFormatter.progress("Starting selective sync...", { prefix: "Database" });
+      await (cli as any).controller!.selectiveSync(databaseSelections, bucketSelections);
+
       MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
 
       // Then handle functions if requested
@@ -104,23 +199,28 @@ export const databaseCommands = {
         (cli as any).controller!.database!
       );
 
-      // Use the controller's synchronizeConfigurations method which handles collections properly
-      MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
-      await (cli as any).controller!.synchronizeConfigurations(remoteDatabases);
-
-      // Also configure buckets for any new databases
+      // First, prepare the combined database list for bucket configuration
       const localDatabases = (cli as any).controller!.config?.databases || [];
-      const updatedConfig = await (cli as any).configureBuckets({
+      const allDatabases = [
+        ...localDatabases,
+        ...remoteDatabases.filter(
+          (rd: any) => !localDatabases.some((ld: any) => ld.name === rd.name)
+        ),
+      ];
+
+      // Configure buckets FIRST to get user selections before writing config
+      MessageFormatter.progress("Configuring storage buckets...", { prefix: "Buckets" });
+      const configWithBuckets = await (cli as any).configureBuckets({
         ...(cli as any).controller!.config!,
-        databases: [
-          ...localDatabases,
-          ...remoteDatabases.filter(
-            (rd: any) => !localDatabases.some((ld: any) => ld.name === rd.name)
-          ),
-        ],
+        databases: allDatabases,
       });
 
-      (cli as any).controller!.config = updatedConfig;
+      // Update controller config with bucket selections
+      (cli as any).controller!.config = configWithBuckets;
+
+      // Now synchronize configurations with the updated config that includes bucket selections
+      MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
+      await (cli as any).controller!.synchronizeConfigurations(remoteDatabases, configWithBuckets);
     }
 
     // Then sync functions