appwrite-utils-cli 1.7.6 → 1.7.8

package/dist/main.js

@@ -13,6 +13,8 @@ import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
+import { SelectionDialogs } from "./shared/selectionDialogs.js";
+import { logger } from "./shared/logging.js";
 import path from "path";
 import fs from "fs";
 import { createRequire } from "node:module";
@@ -23,6 +25,153 @@ const require = createRequire(import.meta.url);
 if (!globalThis.require) {
     globalThis.require = require;
 }
+/**
+ * Enhanced sync function with intelligent configuration detection and selection dialogs
+ */
+async function performEnhancedSync(controller, parsedArgv) {
+    try {
+        MessageFormatter.banner("Enhanced Sync", "Intelligent configuration detection and selection");
+        if (!controller.config) {
+            MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Sync" });
+            return null;
+        }
+        // Get all available databases from remote
+        const availableDatabases = await fetchAllDatabases(controller.database);
+        if (availableDatabases.length === 0) {
+            MessageFormatter.warning("No databases found in remote project", { prefix: "Sync" });
+            return null;
+        }
+        // Get existing configuration
+        const configuredDatabases = controller.config.databases || [];
+        const configuredBuckets = controller.config.buckets || [];
+        // Check if we have existing configuration
+        const hasExistingConfig = configuredDatabases.length > 0 || configuredBuckets.length > 0;
+        let syncExisting = false;
+        let modifyConfiguration = true;
+        if (hasExistingConfig) {
+            // Prompt about existing configuration
+            const response = await SelectionDialogs.promptForExistingConfig([
+                ...configuredDatabases,
+                ...configuredBuckets
+            ]);
+            syncExisting = response.syncExisting;
+            modifyConfiguration = response.modifyConfiguration;
+            if (syncExisting && !modifyConfiguration) {
+                // Just sync existing configuration without changes
+                MessageFormatter.info("Syncing existing configuration without modifications", { prefix: "Sync" });
+                // Convert configured databases to DatabaseSelection format
+                const databaseSelections = configuredDatabases.map(db => ({
+                    databaseId: db.$id,
+                    databaseName: db.name,
+                    tableIds: [], // Tables will be populated from collections config
+                    tableNames: [],
+                    isNew: false
+                }));
+                // Convert configured buckets to BucketSelection format
+                const bucketSelections = configuredBuckets.map(bucket => ({
+                    bucketId: bucket.$id,
+                    bucketName: bucket.name,
+                    databaseId: undefined,
+                    databaseName: undefined,
+                    isNew: false
+                }));
+                const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
+                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+                if (!confirmed) {
+                    MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+                    return null;
+                }
+                // Perform sync with existing configuration
+                await controller.selectiveSync(databaseSelections, bucketSelections);
+                return selectionSummary;
+            }
+        }
+        if (!modifyConfiguration) {
+            MessageFormatter.info("No configuration changes requested", { prefix: "Sync" });
+            return null;
+        }
+        // Allow new items selection based on user choice
+        const allowNewOnly = !syncExisting;
+        // Select databases
+        const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, {
+            showSelectAll: true,
+            allowNewOnly,
+            defaultSelected: syncExisting ? configuredDatabases.map(db => db.$id) : []
+        });
+        if (selectedDatabaseIds.length === 0) {
+            MessageFormatter.warning("No databases selected for sync", { prefix: "Sync" });
+            return null;
+        }
+        // For each selected database, get available tables and select them
+        const tableSelectionsMap = new Map();
+        const availableTablesMap = new Map();
+        for (const databaseId of selectedDatabaseIds) {
+            const database = availableDatabases.find(db => db.$id === databaseId);
+            SelectionDialogs.showProgress(`Fetching tables for database: ${database.name}`);
+            // Get available tables from remote
+            const availableTables = await fetchAllCollections(databaseId, controller.database);
+            availableTablesMap.set(databaseId, availableTables);
+            // Get configured tables for this database
+            // Note: Collections are stored globally in the config, not per database
+            const configuredTables = controller.config.collections || [];
+            // Select tables for this database
+            const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(databaseId, database.name, availableTables, configuredTables, {
+                showSelectAll: true,
+                allowNewOnly,
+                defaultSelected: syncExisting ? configuredTables.map((t) => t.$id) : []
+            });
+            tableSelectionsMap.set(databaseId, selectedTableIds);
+            if (selectedTableIds.length === 0) {
+                MessageFormatter.warning(`No tables selected for database: ${database.name}`, { prefix: "Sync" });
+            }
+        }
+        // Select buckets
+        let selectedBucketIds = [];
+        // Get available buckets from remote
+        if (controller.storage) {
+            try {
+                // Note: We need to implement fetchAllBuckets or use storage.listBuckets
+                // For now, we'll use configured buckets as available
+                SelectionDialogs.showProgress("Fetching storage buckets...");
+                // Create a mock availableBuckets array - in real implementation,
+                // you'd fetch this from the Appwrite API
+                const availableBuckets = configuredBuckets; // Placeholder
+                selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, {
+                    showSelectAll: true,
+                    allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
+                    groupByDatabase: true,
+                    defaultSelected: syncExisting ? configuredBuckets.map(b => b.$id) : []
+                });
+            }
+            catch (error) {
+                MessageFormatter.warning("Could not fetch storage buckets", { prefix: "Sync" });
+                logger.warn("Failed to fetch buckets during sync", { error });
+            }
+        }
+        // Create selection objects
+        const databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
+        const bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, [], // availableBuckets - would be populated from API
+        configuredBuckets, availableDatabases);
+        // Show final confirmation
+        const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
+        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+        if (!confirmed) {
+            MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+            return null;
+        }
+        // Perform the selective sync
+        await controller.selectiveSync(databaseSelections, bucketSelections);
+        MessageFormatter.success("Enhanced sync completed successfully", { prefix: "Sync" });
+        return selectionSummary;
+    }
+    catch (error) {
+        SelectionDialogs.showError("Enhanced sync failed", error instanceof Error ? error : new Error(String(error)));
+        return null;
+    }
+}
+/**
+ * Performs selective sync with the given database and bucket selections
+ */
 /**
  * Checks if the migration from collections to tables should be allowed
  * Returns an object with:
@@ -143,6 +292,15 @@ const argv = yargs(hideBin(process.argv))
     .option("sync", {
     type: "boolean",
     description: "Pull and synchronize your local config with the remote Appwrite project schema",
+})
+    .option("autoSync", {
+    alias: ["auto"],
+    type: "boolean",
+    description: "Skip prompts and sync all databases, tables, and buckets (current behavior)"
+})
+    .option("selectBuckets", {
+    type: "boolean",
+    description: "Force bucket selection dialog even if buckets are already configured"
 })
     .option("endpoint", {
     type: "string",
@@ -711,10 +869,23 @@ async function main() {
             operationStats.pushedCollections = controller.config?.collections?.length || 0;
         }
         else if (parsedArgv.sync) {
-            // SYNC: Pull from remote
-            const databases = options.databases || (await fetchAllDatabases(controller.database));
-            await controller.synchronizeConfigurations(databases);
-            operationStats.syncedDatabases = databases.length;
+            // Enhanced SYNC: Pull from remote with intelligent configuration detection
+            if (parsedArgv.autoSync) {
+                // Legacy behavior: sync everything without prompts
+                MessageFormatter.info("Using auto-sync mode (legacy behavior)", { prefix: "Sync" });
+                const databases = options.databases || (await fetchAllDatabases(controller.database));
+                await controller.synchronizeConfigurations(databases);
+                operationStats.syncedDatabases = databases.length;
+            }
+            else {
+                // Enhanced sync flow with selection dialogs
+                const syncResult = await performEnhancedSync(controller, parsedArgv);
+                if (syncResult) {
+                    operationStats.syncedDatabases = syncResult.databases.length;
+                    operationStats.syncedCollections = syncResult.totalTables;
+                    operationStats.syncedBuckets = syncResult.buckets.length;
+                }
+            }
         }
         if (options.generateSchemas) {
             await controller.generateSchemas();

package/dist/migrations/appwriteToX.d.ts

@@ -1,5 +1,7 @@
 import { Storage, type Models } from "node-appwrite";
 import { type AppwriteConfig } from "appwrite-utils";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseSelection, BucketSelection } from "../shared/selectionDialogs.js";
 export declare class AppwriteToX {
     config: AppwriteConfig;
     storage: Storage;
@@ -102,7 +104,14 @@ export declare class AppwriteToX {
         } | undefined;
     })[]>;
     appwriteFolderPath: string;
+    adapter?: DatabaseAdapter;
+    apiMode?: 'legacy' | 'tablesdb';
+    databaseApiModes: Map<string, "legacy" | "tablesdb">;
     constructor(config: AppwriteConfig, appwriteFolderPath: string, storage: Storage);
+    /**
+     * Initialize adapter for database operations with API mode detection
+     */
+    private initializeAdapter;
     private ensureClientInitialized;
     parsePermissionString: (permissionString: string) => {
         permission: string;
@@ -116,6 +125,22 @@ export declare class AppwriteToX {
         target: string;
     })[];
     updateCollectionConfigAttributes: (collection: Models.Collection) => void;
-    appwriteSync(config: AppwriteConfig, databases?: Models.Database[]): Promise<void>;
-    toSchemas(databases?: Models.Database[]): Promise<void>;
+    /**
+     * Fetch collections/tables using the appropriate adapter or legacy client
+     */
+    private fetchCollectionsOrTables;
+    /**
+     * Get collection/table using the appropriate adapter or legacy client
+     */
+    private getCollectionOrTable;
+    /**
+     * Detect API mode for a specific database by testing adapter capabilities
+     */
+    private detectDatabaseApiMode;
+    /**
+     * Get API mode context for schema generation
+     */
+    private getSchemaGeneratorApiContext;
+    appwriteSync(config: AppwriteConfig, databases?: Models.Database[], databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
+    toSchemas(databases?: Models.Database[], databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
 }