@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/dist/interactiveCLI.js

@@ -12,9 +12,8 @@ import { join } from "node:path";
 import path from "path";
 import fs from "node:fs";
 import os from "node:os";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter, findYamlConfig } from "@njdamstra/appwrite-utils-helpers";
 import { findAppwriteConfig } from "./utils/loadConfigs.js";
-import { findYamlConfig } from "./config/yamlConfig.js";
 // Import command modules
 import { configCommands } from "./cli/commands/configCommands.js";
 import { databaseCommands } from "./cli/commands/databaseCommands.js";
@@ -22,6 +21,7 @@ import { functionCommands } from "./cli/commands/functionCommands.js";
 import { storageCommands } from "./cli/commands/storageCommands.js";
 import { transferCommands } from "./cli/commands/transferCommands.js";
 import { schemaCommands } from "./cli/commands/schemaCommands.js";
+import { importFileCommands } from "./cli/commands/importFileCommands.js";
 var CHOICES;
 (function (CHOICES) {
     CHOICES["MIGRATE_CONFIG"] = "\uD83D\uDD04 Migrate TypeScript config to YAML (.appwrite structure)";
@@ -43,6 +43,7 @@ var CHOICES;
     CHOICES["GENERATE_SCHEMAS"] = "\uD83C\uDFD7\uFE0F Generate schemas";
     CHOICES["GENERATE_CONSTANTS"] = "\uD83D\uDCCB Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)";
     CHOICES["IMPORT_DATA"] = "\uD83D\uDCE5 Import data";
+    CHOICES["IMPORT_FILE"] = "\uD83D\uDCC4 Import file (CSV/JSON) directly into a table";
     CHOICES["RELOAD_CONFIG"] = "\uD83D\uDD04 Reload configuration files";
     CHOICES["UPDATE_FUNCTION_SPEC"] = "\u2699\uFE0F Update function specifications";
     CHOICES["MANAGE_BUCKETS"] = "\uD83E\uDEA3 Manage storage buckets";
@@ -53,12 +54,14 @@ export class InteractiveCLI {
     controller;
     isUsingTypeScriptConfig = false;
     lastSelectedCollectionIds = [];
-    constructor(currentDir) {
+    options;
+    constructor(currentDir, options = {}) {
         this.currentDir = currentDir;
+        this.options = options;
     }
     async run() {
         MessageFormatter.banner("Appwrite Utils CLI", "Welcome to Appwrite Utils CLI Tool by Zach Handley");
-        MessageFormatter.info("For more information, visit https://github.com/zachhandley/AppwriteUtils");
+        MessageFormatter.info("For more information, visit https://github.com/njdamstra/AppwriteUtils");
         // Detect configuration type
         try {
             await this.detectConfigurationType();
@@ -148,6 +151,10 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await schemaCommands.importData(this);
                     break;
+                case CHOICES.IMPORT_FILE:
+                    await this.initControllerIfNeeded();
+                    await importFileCommands.importFile(this);
+                    break;
                 case CHOICES.RELOAD_CONFIG:
                     await configCommands.reloadConfigWithSessionPreservation(this);
                     break;
@@ -167,7 +174,10 @@ export class InteractiveCLI {
     async initControllerIfNeeded(directConfig) {
         if (!this.controller) {
             this.controller = UtilsController.getInstance(this.currentDir, directConfig);
-            await this.controller.init();
+            await this.controller.init({
+                useSession: this.options.useSession,
+                sessionCookie: this.options.sessionCookie
+            });
         }
         else {
             // Extract session info from existing controller before reinitializing
@@ -182,13 +192,19 @@ export class InteractiveCLI {
                 // Reinitialize with session preservation
                 UtilsController.clearInstance();
                 this.controller = UtilsController.getInstance(this.currentDir, enhancedDirectConfig);
-                await this.controller.init();
+                await this.controller.init({
+                    useSession: this.options.useSession,
+                    sessionCookie: this.options.sessionCookie
+                });
             }
             else if (directConfig) {
                 // Standard reinitialize without session
                 UtilsController.clearInstance();
                 this.controller = UtilsController.getInstance(this.currentDir, directConfig);
-                await this.controller.init();
+                await this.controller.init({
+                    useSession: this.options.useSession,
+                    sessionCookie: this.options.sessionCookie
+                });
             }
             // If no directConfig provided, keep existing controller
         }
@@ -258,7 +274,8 @@ export class InteractiveCLI {
                 pageSize: 10,
             },
         ]);
-        return selectedDatabases;
+        // "list" type returns a single value, "checkbox" returns an array — normalize to array
+        return Array.isArray(selectedDatabases) ? selectedDatabases : [selectedDatabases];
     }
     async selectCollections(database, databasesClient, message, multiSelect = true, preferLocal = false, shouldFilterByDatabase = false) {
         await this.initControllerIfNeeded();
@@ -299,6 +316,9 @@ export class InteractiveCLI {
         allCollections = allCollections.filter((collection) => !collection.$id.startsWith('_'));
         const hasLocalAndRemote = allCollections.some((coll) => configCollections.some((c) => c.name === coll.name || c.$id === coll.$id)) &&
             allCollections.some((coll) => !configCollections.some((c) => c.name === coll.name || c.$id === coll.$id));
+        const getCollectionId = (collection) => collection.$id || collection.name;
+        const localCollectionIds = new Set(configCollections.map((c) => c.$id || c.name));
+        const localCollections = allCollections.filter((collection) => localCollectionIds.has(getCollectionId(collection)));
         // Enhanced choice display with type indicators
         const choices = allCollections
             .sort((a, b) => {
@@ -349,6 +369,18 @@ export class InteractiveCLI {
                 value: collection,
             };
         });
+        if (multiSelect && localCollections.length > 1) {
+            choices.unshift({
+                name: chalk.green.bold(`📋 Select All Local Items (${localCollections.length})`),
+                value: "__SELECT_ALL_LOCAL__"
+            });
+        }
+        if (multiSelect && allCollections.length > 1) {
+            choices.unshift({
+                name: chalk.green.bold(`📋 Select All Shown (${allCollections.length})`),
+                value: "__SELECT_ALL__"
+            });
+        }
         const { selectedCollections } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -357,8 +389,27 @@ export class InteractiveCLI {
                 choices,
                 loop: true,
                 pageSize: 15, // Increased page size to accommodate additional info
+                validate: (input) => {
+                    if (!multiSelect)
+                        return true;
+                    if (input.includes("__SELECT_ALL__") && input.length > 1) {
+                        return "Cannot select 'Select All' with individual items.";
+                    }
+                    if (input.includes("__SELECT_ALL_LOCAL__") && input.length > 1) {
+                        return "Cannot select 'Select All Local' with individual items.";
+                    }
+                    return true;
+                }
             },
         ]);
+        if (multiSelect && Array.isArray(selectedCollections)) {
+            if (selectedCollections.includes("__SELECT_ALL__")) {
+                return allCollections;
+            }
+            if (selectedCollections.includes("__SELECT_ALL_LOCAL__")) {
+                return localCollections;
+            }
+        }
         return selectedCollections;
     }
     /**
@@ -800,7 +851,10 @@ export class InteractiveCLI {
         }, bucketId.length > 0 ? bucketId : ulid());
     }
     getLocalCollections() {
-        const configCollections = this.controller.config?.collections || [];
+        const configCollections = [
+            ...(this.controller.config?.collections || []),
+            ...(this.controller.config?.tables || [])
+        ];
         // @ts-expect-error - appwrite invalid types
         return configCollections.map((c) => ({
             $id: c.$id || ulid(),

package/dist/main.js

@@ -5,22 +5,18 @@ import { hideBin } from "yargs/helpers";
 import { InteractiveCLI } from "./interactiveCLI.js";
 import { UtilsController } from "./utilsController.js";
 import { Databases, Storage } from "node-appwrite";
-import { getClient } from "./utils/getClientFromConfig.js";
+import { getClient } from "@njdamstra/appwrite-utils-helpers";
 import { fetchAllDatabases } from "./databases/methods.js";
 import { setupDirsFiles } from "./utils/setupFiles.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter, logger, AuthenticationError } from "@njdamstra/appwrite-utils-helpers";
 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";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, projectConfigToAppwriteConfig, } from "./utils/projectConfig.js";
-import { hasSessionAuth, getAvailableSessions, getAuthenticationStatus, } from "./utils/sessionAuth.js";
-import { findYamlConfig, loadYamlConfigWithSession, } from "./config/yamlConfig.js";
 const require = createRequire(import.meta.url);
 if (!globalThis.require) {
     globalThis.require = require;
@@ -217,6 +213,11 @@ const argv = yargs(hideBin(process.argv))
     .option("config", {
     type: "string",
     description: "Path to Appwrite configuration file (appwriteConfig.ts)",
+})
+    .option("appwriteConfig", {
+    alias: ["appwrite-config", "use-appwrite-config"],
+    type: "boolean",
+    description: "Prefer loading from appwrite.config.json instead of config.yaml",
 })
     .option("it", {
     alias: ["interactive", "i"],
@@ -438,134 +439,85 @@ const argv = yargs(hideBin(process.argv))
     .option("sessionCookie", {
     type: "string",
     description: "Explicit session cookie to use for authentication",
+})
+    .option("importFile", {
+    alias: ["import-file"],
+    type: "string",
+    description: "Import a CSV or JSON file directly into a table (no config needed)",
+})
+    .option("targetDb", {
+    alias: ["target-db"],
+    type: "string",
+    description: "Target database ID for --importFile (prompted if omitted)",
+})
+    .option("targetTable", {
+    alias: ["target-table"],
+    type: "string",
+    description: "Target table ID for --importFile (prompted if omitted)",
 })
     .parse();
 async function main() {
     const startTime = Date.now();
     const operationStats = {};
-    // Early session detection for better user guidance
-    const availableSessions = getAvailableSessions();
-    let hasAnyValidSessions = availableSessions.length > 0;
     if (argv.it) {
-        const cli = new InteractiveCLI(process.cwd());
+        const cli = new InteractiveCLI(process.cwd(), {
+            useSession: argv.useSession,
+            sessionCookie: argv.sessionCookie
+        });
         await cli.run();
     }
     else {
-        // Enhanced config creation with session and project file support
-        let directConfig = undefined;
-        // Show authentication status on startup if no config provided
-        if (!argv.config &&
-            !argv.endpoint &&
-            !argv.projectId &&
-            !argv.apiKey &&
-            !argv.useSession &&
-            !argv.sessionCookie) {
-            if (hasAnyValidSessions) {
-                MessageFormatter.info(`Found ${availableSessions.length} available session(s)`, { prefix: "Auth" });
-                availableSessions.forEach((session) => {
-                    MessageFormatter.info(`  \u2022 ${session.projectId} (${session.email || "unknown"}) at ${session.endpoint}`, { prefix: "Auth" });
-                });
-                MessageFormatter.info("Use --session to enable session authentication", { prefix: "Auth" });
-            }
-            else {
-                MessageFormatter.info("No active Appwrite sessions found", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("\u2022 Run 'appwrite login' to authenticate with session", { prefix: "Auth" });
-                MessageFormatter.info("\u2022 Or provide --apiKey for API key authentication", { prefix: "Auth" });
-            }
-        }
-        // Priority 1: Check for appwrite.json project configuration
-        const projectConfigPath = findAppwriteProjectConfig(process.cwd());
-        if (projectConfigPath) {
-            const projectConfig = loadAppwriteProjectConfig(projectConfigPath);
-            if (projectConfig) {
-                directConfig = projectConfigToAppwriteConfig(projectConfig);
-                MessageFormatter.info(`Loaded project configuration from ${projectConfigPath}`, { prefix: "CLI" });
-            }
-        }
-        // Priority 2: CLI arguments override project config
-        if (argv.endpoint ||
-            argv.projectId ||
-            argv.apiKey ||
-            argv.useSession ||
-            argv.sessionCookie) {
-            directConfig = {
-                ...directConfig,
-                appwriteEndpoint: argv.endpoint || directConfig?.appwriteEndpoint,
-                appwriteProject: argv.projectId || directConfig?.appwriteProject,
-                appwriteKey: argv.apiKey || directConfig?.appwriteKey,
+        // Non-interactive mode - pass auth flags through to controller
+        // ConfigManager will handle config discovery and auth decisions
+        // Users can provide credentials via CLI flags even without a config file
+        const controller = UtilsController.getInstance(process.cwd());
+        // Build init options from CLI flags
+        const initOptions = {
+            useSession: argv.useSession,
+            sessionCookie: argv.sessionCookie,
+            preferJson: argv.appwriteConfig,
+        };
+        // Add CLI overrides if provided - these can work even without a config file
+        if (argv.endpoint || argv.projectId || argv.apiKey) {
+            initOptions.overrides = {
+                appwriteEndpoint: argv.endpoint,
+                appwriteProject: argv.projectId,
+                appwriteKey: argv.apiKey,
             };
         }
-        // Priority 3: Session authentication support with improved detection
-        let sessionAuthAvailable = false;
-        if (directConfig?.appwriteEndpoint && directConfig?.appwriteProject) {
-            sessionAuthAvailable = hasSessionAuth(directConfig.appwriteEndpoint, directConfig.appwriteProject);
+        try {
+            await controller.init(initOptions);
         }
-        if (argv.useSession || argv.sessionCookie) {
-            if (argv.sessionCookie) {
-                // Explicit session cookie provided
-                MessageFormatter.info("Using explicit session cookie for authentication", { prefix: "Auth" });
-            }
-            else if (sessionAuthAvailable) {
-                MessageFormatter.info("Session authentication detected and will be used", { prefix: "Auth" });
-            }
-            else {
-                MessageFormatter.warning("Session authentication requested but no valid session found", { prefix: "Auth" });
-                const availableSessions = getAvailableSessions();
-                if (availableSessions.length > 0) {
-                    MessageFormatter.info(`Available sessions: ${availableSessions
-                        .map((s) => `${s.projectId} (${s.email || "unknown"})`)
-                        .join(", ")}`, { prefix: "Auth" });
-                    MessageFormatter.info("Use --session flag to enable session authentication", { prefix: "Auth" });
-                }
-                else {
-                    MessageFormatter.warning("No Appwrite CLI sessions found. Please run 'appwrite login' first.", { prefix: "Auth" });
-                }
-                MessageFormatter.error("Session authentication requested but not available", undefined, { prefix: "Auth" });
-                return; // Exit early if session auth was requested but not available
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                MessageFormatter.error(error.getFormattedMessage(), undefined, { prefix: "Auth" });
+                process.exit(1);
             }
+            // Re-throw other errors
+            throw error;
         }
-        else if (sessionAuthAvailable && !argv.apiKey) {
-            // Auto-detect session authentication when no API key is provided
-            MessageFormatter.info("Session authentication detected - no API key required", { prefix: "Auth" });
-            MessageFormatter.info("Use --session flag to explicitly enable session authentication", { prefix: "Auth" });
-        }
-        // Enhanced session authentication support:
-        // 1. If session auth is explicitly requested via flags, use it
-        // 2. If no API key is provided but sessions are available, offer to use session auth
-        // 3. Auto-detect session authentication when possible
-        let finalDirectConfig = directConfig;
-        if ((argv.useSession || argv.sessionCookie) &&
-            (!directConfig ||
-                !directConfig.appwriteEndpoint ||
-                !directConfig.appwriteProject)) {
-            // Don't pass incomplete directConfig - let UtilsController load YAML config normally
-            finalDirectConfig = null;
+        // After init, check if we have a valid config (from file OR CLI overrides)
+        if (!controller.config) {
+            MessageFormatter.error("No Appwrite configuration available", undefined, { prefix: "CLI" });
+            MessageFormatter.info("Provide credentials via CLI flags (--endpoint, --projectId, --apiKey or --session)", { prefix: "CLI" });
+            MessageFormatter.info("Or create a config file using --setup", { prefix: "CLI" });
+            return;
         }
-        else if (finalDirectConfig &&
-            !finalDirectConfig.appwriteKey &&
-            !argv.useSession &&
-            !argv.sessionCookie) {
-            // Auto-detect session authentication when no API key provided
-            if (sessionAuthAvailable) {
-                MessageFormatter.info("No API key provided, but session authentication is available", { prefix: "Auth" });
-                MessageFormatter.info("Automatically using session authentication (add --session to suppress this message)", { prefix: "Auth" });
-                // Implicitly enable session authentication
-                argv.useSession = true;
+        const parsedArgv = argv;
+        if (argv.importFile) {
+            const { importFileFromPath, importFilePromptMissing } = await import("./cli/commands/importFileCommands.js");
+            if (!controller.adapter) {
+                MessageFormatter.error("No adapter available — check your credentials", undefined, { prefix: "Import" });
+                return;
             }
-        }
-        // Create controller with session authentication support using singleton
-        const controller = UtilsController.getInstance(process.cwd(), finalDirectConfig);
-        // Pass session authentication options to the controller
-        const initOptions = {};
-        if (argv.useSession || argv.sessionCookie) {
-            initOptions.useSession = true;
-            if (argv.sessionCookie) {
-                initOptions.sessionCookie = argv.sessionCookie;
+            if (parsedArgv.targetDb && parsedArgv.targetTable) {
+                await importFileFromPath(controller.adapter, argv.importFile, parsedArgv.targetDb, parsedArgv.targetTable);
+            }
+            else {
+                await importFilePromptMissing(controller.adapter, controller.database, argv.importFile, parsedArgv.targetDb, parsedArgv.targetTable);
             }
+            return;
         }
-        await controller.init(initOptions);
         if (argv.setup) {
             await setupDirsFiles(false, process.cwd());
             return;
@@ -576,7 +528,7 @@ async function main() {
             return;
         }
         if (argv.generateConstants) {
-            const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+            const { ConstantsGenerator } = await import("@njdamstra/appwrite-utils-helpers");
             if (!controller.config) {
                 MessageFormatter.error("No Appwrite configuration found", undefined, {
                     prefix: "Constants",
@@ -642,7 +594,7 @@ async function main() {
                     MessageFormatter.info("  • tables/ folder must not exist or be empty", { prefix: "Migration" });
                     return;
                 }
-                const { migrateCollectionsToTables } = await import("./config/configMigration.js");
+                const { migrateCollectionsToTables } = await import("@njdamstra/appwrite-utils-helpers");
                 MessageFormatter.info("Starting collections to tables migration...", {
                     prefix: "Migration",
                 });
@@ -666,41 +618,9 @@ async function main() {
             }
             return;
         }
-        if (!controller.config) {
-            // Provide better guidance based on available authentication methods
-            const availableSessions = getAvailableSessions();
-            if (availableSessions.length > 0) {
-                MessageFormatter.error("No Appwrite configuration found", undefined, {
-                    prefix: "CLI",
-                });
-                MessageFormatter.info("Available authentication options:", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("• Session authentication: Add --session flag", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("• API key authentication: Add --apiKey YOUR_API_KEY", { prefix: "Auth" });
-                MessageFormatter.info(`• Available sessions: ${availableSessions
-                    .map((s) => `${s.projectId} (${s.email || "unknown"})`)
-                    .join(", ")}`, { prefix: "Auth" });
-            }
-            else {
-                MessageFormatter.error("No Appwrite configuration found", undefined, {
-                    prefix: "CLI",
-                });
-                MessageFormatter.info("Authentication options:", { prefix: "Auth" });
-                MessageFormatter.info("• Login with Appwrite CLI: Run 'appwrite login' then use --session flag", { prefix: "Auth" });
-                MessageFormatter.info("• Use API key: Add --apiKey YOUR_API_KEY", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("• Create config file: Run with --setup to initialize project configuration", { prefix: "Auth" });
-            }
-            return;
-        }
-        const parsedArgv = argv;
         // List backups if requested
         if (parsedArgv.listBackups) {
-            const { AdapterFactory } = await import("./adapters/AdapterFactory.js");
+            const { AdapterFactory } = await import("@njdamstra/appwrite-utils-helpers");
             const { listBackups } = await import("./shared/backupTracking.js");
             if (!controller.config) {
                 MessageFormatter.error("No Appwrite configuration found", undefined, {
@@ -789,7 +709,7 @@ async function main() {
         // Comprehensive backup (all databases + all buckets)
         if (parsedArgv.comprehensiveBackup) {
             const { comprehensiveBackup } = await import("./backups/operations/comprehensiveBackup.js");
-            const { AdapterFactory } = await import("./adapters/AdapterFactory.js");
+            const { AdapterFactory } = await import("@njdamstra/appwrite-utils-helpers");
             // Get tracking database ID (interactive prompt if not specified)
             let trackingDatabaseId = parsedArgv.trackingDatabaseId;
             if (!trackingDatabaseId) {
@@ -963,7 +883,10 @@ async function main() {
             }
             // Build DatabaseSelection[] with tableIds per DB
             const databaseSelections = [];
-            const allConfigItems = controller.config.collections || controller.config.tables || [];
+            const allConfigItems = [
+                ...(controller.config.collections || []),
+                ...(controller.config.tables || [])
+            ];
             let lastSelectedTableIds = null;
             for (const dbId of selectedDbIds) {
                 const db = availableDatabases.find(d => d.$id === dbId);
@@ -979,8 +902,16 @@ async function main() {
                         return one === dbId;
                     return true; // eligible everywhere if unspecified
                 });
-                // Fetch available tables from remote for selection context
+                // Fetch available tables from remote for status/context
                 const availableTables = await fetchAllCollections(dbId, controller.database);
+                const remoteTableIds = new Set(availableTables.map(table => table.$id));
+                const localItems = eligibleConfigItems;
+                const localItemIds = localItems.map(item => item.$id || item.id || item.tableId || item.name);
+                const localNewItems = localItems.filter(item => {
+                    const itemId = item.$id || item.id || item.tableId || item.name;
+                    return !remoteTableIds.has(itemId);
+                });
+                const localNewIds = localNewItems.map(item => item.$id || item.id || item.tableId || item.name);
                 // Determine selected table IDs
                 let selectedTableIds = [];
                 if (parsedArgv.collectionIds) {
@@ -988,35 +919,57 @@ async function main() {
                     selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
                 }
                 else {
-                    // If we have a previous selection, offer to reuse it
+                    const inquirer = (await import("inquirer")).default;
+                    const choices = [];
                     if (lastSelectedTableIds && lastSelectedTableIds.length > 0) {
-                        const inquirer = (await import("inquirer")).default;
-                        const { reuseMode } = await inquirer.prompt([
-                            {
-                                type: "list",
-                                name: "reuseMode",
-                                message: `How do you want to select tables for ${db.name}?`,
-                                choices: [
-                                    { name: `Use same selection as previous (${lastSelectedTableIds.length} items)`, value: "same" },
-                                    { name: `Filter by this database (manual select)`, value: "filter" },
-                                    { name: `Show all available in this database (manual select)`, value: "all" }
-                                ],
-                                default: "same"
-                            }
-                        ]);
-                        if (reuseMode === "same") {
-                            selectedTableIds = [...lastSelectedTableIds];
+                        choices.push({
+                            name: `Use same selection as previous (${lastSelectedTableIds.length} items)`,
+                            value: "same"
+                        });
+                    }
+                    if (localItemIds.length > 0) {
+                        choices.push({
+                            name: `Select all local items for ${db.name} (${localItemIds.length} items)`,
+                            value: "all_local"
+                        });
+                    }
+                    if (localNewIds.length > 0) {
+                        choices.push({
+                            name: `Select only new local items (not on remote) (${localNewIds.length} items)`,
+                            value: "new_only"
+                        });
+                    }
+                    choices.push({
+                        name: "Manual selection",
+                        value: "manual"
+                    });
+                    const { selectionMode } = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "selectionMode",
+                            message: `How do you want to select tables for ${db.name}?`,
+                            choices,
+                            default: choices[0]?.value || "manual"
                         }
-                        else if (reuseMode === "all") {
-                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, allConfigItems, { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds });
+                    ]);
+                    if (selectionMode === "same") {
+                        selectedTableIds = [...(lastSelectedTableIds || [])];
+                    }
+                    else if (selectionMode === "all_local") {
+                        selectedTableIds = [...localItemIds];
+                    }
+                    else if (selectionMode === "new_only") {
+                        selectedTableIds = [...localNewIds];
+                    }
+                    else {
+                        if (localItems.length === 0) {
+                            MessageFormatter.warning(`No local tables/collections available for ${db.name}`, { prefix: "Push" });
+                            selectedTableIds = [];
                         }
                         else {
-                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds });
+                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, localItems, availableTables, { showSelectAll: localItems.length > 1, allowNewOnly: false, defaultSelected: lastSelectedTableIds || [] });
                         }
                     }
-                    else {
-                        selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: [] });
-                    }
                 }
                 databaseSelections.push({
                     databaseId: db.$id,

package/dist/migrations/afterImportActions.js

@@ -3,10 +3,9 @@ import { InputFile } from "node-appwrite/file";
 import path from "path";
 import fs from "fs";
 import os from "os";
-import { logger } from "../shared/logging.js";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { tryAwaitWithRetry, } from "@njdamstra/appwrite-utils";
-import { getClientFromConfig } from "../utils/getClientFromConfig.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { getClientFromConfig } from "@njdamstra/appwrite-utils-helpers";
 export const getDatabaseFromConfig = (config) => {
     getClientFromConfig(config); // Sets config.appwriteClient if missing
     return new Databases(config.appwriteClient);

package/dist/migrations/appwriteToX.d.ts

@@ -1,6 +1,6 @@
 import { Storage, type Models } from "node-appwrite";
 import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 import type { DatabaseSelection, BucketSelection } from "../shared/selectionDialogs.js";
 export declare class AppwriteToX {
     config: AppwriteConfig;

package/dist/migrations/appwriteToX.js

@@ -1,15 +1,14 @@
-import { SchemaGenerator } from "../shared/schemaGenerator.js";
-import { findYamlConfig } from "../config/yamlConfig.js";
+import { SchemaGenerator, findYamlConfig } from "@njdamstra/appwrite-utils-helpers";
 import { Client, Compression, Databases, Query, Storage, } from "node-appwrite";
 import { fetchAllCollections } from "../collections/methods.js";
 import { fetchAllDatabases } from "../databases/methods.js";
 import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, parseAttribute, } from "@njdamstra/appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
-import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import { getAdapterFromConfig } from "@njdamstra/appwrite-utils-helpers";
 import { listBuckets } from "../storage/methods.js";
 import { listFunctions, listFunctionDeployments, getFunction } from "../functions/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { isLegacyDatabases } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Convert between collection and table terminology based on data structure
  */
@@ -80,8 +79,11 @@ export class AppwriteToX {
             const client = new Client();
             client
                 .setEndpoint(this.config.appwriteEndpoint)
-                .setProject(this.config.appwriteProject)
-                .setKey(this.config.appwriteKey);
+                .setProject(this.config.appwriteProject);
+            // Only set API key if provided (session auth is alternative)
+            if (this.config.appwriteKey) {
+                client.setKey(this.config.appwriteKey);
+            }
             this.config.appwriteClient = client;
         }
     }