appwrite-utils-cli 1.8.6 → 1.8.8

package/CHANGELOG.md

@@ -17,3 +17,11 @@ All notable changes to this project will be documented in this file.
   - Output directory selectable during interactive flow (absolute paths respected)
 - Constants generator now supports selecting which categories to include (databases, collections/tables, buckets, functions).
 - Bucket management: interactive create/delete commands with YAML persistence when active; selective push now diffs and updates bucket settings (name, permissions, security, limits).
+
+## 1.8.8 - 2025-10-29
+
+- Fix: Selective push processed state is tracked per database. Previously, pushing the same table to multiple databases could skip the second database with “already processed”; now each DB is handled independently.
+- Fix: Clear in-memory processing state between databases during multi-DB pushes to prevent cross-database leakage of IDs and processed flags.
+- Enhancement: Interactive selection adds “Use same selection as before” when choosing tables per database, speeding up multi-DB workflows.
+- Behavior: Non-interactive `--push` with both `--dbIds` and `--collectionIds` is fully non-interactive. The provided IDs are applied as-is to every selected database and the confirmation summary is skipped.
+- Improvement: Selective push reloads local config from disk before pushing to ensure the latest YAML/TS changes are used.

package/dist/collections/attributes.js

@@ -1222,7 +1222,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     // Filter to only attributes that need processing (new, changed, or not yet processed)
     const attributesToProcess = attributes.filter((attribute) => {
         // Skip if already processed in this session
-        if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
+        if (isAttributeProcessed(dbId, currentCollection.$id, attribute.key)) {
             return false;
         }
         const existing = existingAttributesMap.get(attribute.key);
@@ -1253,7 +1253,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
             if (success) {
                 // Mark this specific attribute as processed
-                markAttributeProcessed(currentCollection.$id, attribute.key);
+                markAttributeProcessed(dbId, currentCollection.$id, attribute.key);
                 // Get updated collection data for next iteration
                 try {
                     currentCollection = isDatabaseAdapter(db)

package/dist/collections/methods.js

@@ -149,8 +149,8 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
     const relQueue = [];
     for (const collection of collectionsToProcess) {
         const { attributes, indexes, ...collectionData } = collection;
-        // Check if this table has already been processed in this session
-        if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
+        // Check if this table has already been processed in this session (per database)
+        if (collectionData.$id && isCollectionProcessed(collectionData.$id, databaseId)) {
             MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
             continue;
         }
@@ -182,11 +182,34 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 }
             }
         }
-        // Find existing table by name
-        const list = await adapter.listTables({ databaseId, queries: [Query.equal('name', collectionData.name)] });
-        const items = list.tables || [];
-        let table = items[0];
+        // Find existing table — prefer lookup by ID (if provided), then by name
+        let table;
         let tableId;
+        // 1) Try by explicit $id first (handles rename scenarios)
+        if (collectionData.$id) {
+            try {
+                const byId = await adapter.getTable({ databaseId, tableId: collectionData.$id });
+                table = byId.data || byId.tables?.[0];
+                if (table?.$id) {
+                    MessageFormatter.info(`Found existing table by ID: ${table.$id}`, { prefix: 'Tables' });
+                }
+            }
+            catch {
+                // Not found by ID; fall back to name lookup
+            }
+        }
+        // 2) If not found by ID, try by name
+        if (!table) {
+            const list = await adapter.listTables({ databaseId, queries: [Query.equal('name', collectionData.name)] });
+            const items = list.tables || [];
+            table = items[0];
+            if (table?.$id) {
+                // If local has $id that differs from remote, prefer remote (IDs are immutable)
+                if (collectionData.$id && collectionData.$id !== table.$id) {
+                    MessageFormatter.warning(`Config $id '${collectionData.$id}' differs from existing table ID '${table.$id}'. Using existing table.`, { prefix: 'Tables' });
+                }
+            }
+        }
         if (!table) {
             // Determine ID (prefer provided $id or re-use deleted one)
             let foundColl = deletedCollections?.find((coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") === collectionData.name.toLowerCase().trim().replace(" ", ""));
@@ -579,8 +602,8 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         catch (e) {
             MessageFormatter.warning(`Could not evaluate deletions: ${e?.message || e}`, { prefix: 'Attributes' });
         }
-        // Mark this table as fully processed to prevent re-processing
-        markCollectionProcessed(tableId, collectionData.name);
+        // Mark this table as fully processed for this database to prevent re-processing in the same DB only
+        markCollectionProcessed(tableId, collectionData.name, databaseId);
     }
     // Process queued relationships once mapping likely populated
     if (relQueue.length > 0) {

package/dist/interactiveCLI.d.ts

@@ -2,6 +2,7 @@ export declare class InteractiveCLI {
     private currentDir;
     private controller;
     private isUsingTypeScriptConfig;
+    private lastSelectedCollectionIds;
     constructor(currentDir: string);
     run(): Promise<void>;
     private initControllerIfNeeded;

package/dist/interactiveCLI.js

@@ -52,6 +52,7 @@ export class InteractiveCLI {
     currentDir;
     controller;
     isUsingTypeScriptConfig = false;
+    lastSelectedCollectionIds = [];
     constructor(currentDir) {
         this.currentDir = currentDir;
     }
@@ -382,25 +383,41 @@ export class InteractiveCLI {
         }
         // Show current database context clearly before view mode selection
         MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
-        // Ask user if they want to filter by database or show all
+        // Ask user if they want to filter by database, show all, or reuse previous selection
+        const choices = [
+            {
+                name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
+                value: "all"
+            },
+            {
+                name: `Filter by database "${database.name}" - Show only related collections/tables`,
+                value: "filter"
+            }
+        ];
+        if (this.lastSelectedCollectionIds && this.lastSelectedCollectionIds.length > 0) {
+            choices.unshift({
+                name: `Use same selection as before (${this.lastSelectedCollectionIds.length} items)`,
+                value: "same"
+            });
+        }
         const { filterChoice } = await inquirer.prompt([
             {
                 type: "list",
                 name: "filterChoice",
                 message: chalk.blue("How would you like to view collections/tables?"),
-                choices: [
-                    {
-                        name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
-                        value: "all"
-                    },
-                    {
-                        name: `Filter by database "${database.name}" - Show only related collections/tables`,
-                        value: "filter"
-                    }
-                ],
-                default: "all"
+                choices,
+                default: choices[0]?.value || "all"
             }
         ]);
+        // If user wants to reuse the previous selection, map IDs to current config and return
+        if (filterChoice === "same") {
+            const map = new Map(this.getLocalCollections().map((c) => [c.$id || c.id, c]));
+            const selected = this.lastSelectedCollectionIds
+                .map((id) => map.get(id))
+                .filter((c) => !!c);
+            MessageFormatter.info(`Using same selection as previous: ${selected.length} item(s)`, { prefix: "Collections" });
+            return selected;
+        }
         // User's choice overrides the parameter
         const userWantsFiltering = filterChoice === "filter";
         // Show appropriate informational message
@@ -416,7 +433,10 @@ export class InteractiveCLI {
         else {
             MessageFormatter.info(`ℹ️  Showing all available collections/tables - you can push any collection to any database\n`, { prefix: "Collections" });
         }
-        return this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
+        const result = await this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
+        // Remember this selection for subsequent databases
+        this.lastSelectedCollectionIds = (result || []).map((c) => c.$id || c.id);
+        return result;
     }
     getTemplateDefaults(template) {
         const defaults = {

package/dist/main.js

@@ -964,6 +964,7 @@ async function main() {
             // Build DatabaseSelection[] with tableIds per DB
             const databaseSelections = [];
             const allConfigItems = controller.config.collections || controller.config.tables || [];
+            let lastSelectedTableIds = null;
             for (const dbId of selectedDbIds) {
                 const db = availableDatabases.find(d => d.$id === dbId);
                 if (!db)
@@ -983,13 +984,39 @@ async function main() {
                 // Determine selected table IDs
                 let selectedTableIds = [];
                 if (parsedArgv.collectionIds) {
-                    const ids = parsedArgv.collectionIds.split(/[,\s]+/).filter(Boolean);
-                    // Only allow IDs that are in eligible config items
-                    const eligibleIds = new Set(eligibleConfigItems.map((c) => c.$id || c.id));
-                    selectedTableIds = ids.filter(id => eligibleIds.has(id));
+                    // Non-interactive: respect provided table IDs as-is (apply to each selected DB)
+                    selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
                 }
                 else {
-                    selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: [] });
+                    // If we have a previous selection, offer to reuse it
+                    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];
+                        }
+                        else if (reuseMode === "all") {
+                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, allConfigItems, { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds });
+                        }
+                        else {
+                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds });
+                        }
+                    }
+                    else {
+                        selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: [] });
+                    }
                 }
                 databaseSelections.push({
                     databaseId: db.$id,
@@ -998,6 +1025,9 @@ async function main() {
                     tableNames: [],
                     isNew: false,
                 });
+                if (!parsedArgv.collectionIds) {
+                    lastSelectedTableIds = selectedTableIds;
+                }
             }
             if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
                 MessageFormatter.warning("No tables/collections selected for push", { prefix: "Push" });
@@ -1008,10 +1038,13 @@ async function main() {
                 collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
                 details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
             };
-            const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
-            if (!confirmed) {
-                MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
-                return;
+            // Skip confirmation if both dbIds and collectionIds are provided (non-interactive)
+            if (!(parsedArgv.dbIds && parsedArgv.collectionIds)) {
+                const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
+                if (!confirmed) {
+                    MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
+                    return;
+                }
             }
             await controller.selectivePush(databaseSelections, []);
             operationStats.pushedDatabases = databaseSelections.length;

package/dist/shared/operationQueue.d.ts

@@ -20,19 +20,19 @@ export declare const clearProcessingState: () => void;
 /**
  * Check if a collection has already been fully processed
  */
-export declare const isCollectionProcessed: (collectionId: string) => boolean;
+export declare const isCollectionProcessed: (collectionId: string, databaseId: string) => boolean;
 /**
  * Mark a collection as fully processed
  */
-export declare const markCollectionProcessed: (collectionId: string, collectionName?: string) => void;
+export declare const markCollectionProcessed: (collectionId: string, collectionName: string | undefined, databaseId: string) => void;
 /**
  * Check if a specific attribute has been processed
  */
-export declare const isAttributeProcessed: (collectionId: string, attributeKey: string) => boolean;
+export declare const isAttributeProcessed: (databaseId: string, collectionId: string, attributeKey: string) => boolean;
 /**
  * Mark a specific attribute as processed
  */
-export declare const markAttributeProcessed: (collectionId: string, attributeKey: string) => void;
+export declare const markAttributeProcessed: (databaseId: string, collectionId: string, attributeKey: string) => void;
 /**
  * Process only specific attributes in the queue, not entire collections
  * This prevents triggering full collection re-processing cycles

package/dist/shared/operationQueue.js

@@ -7,8 +7,14 @@ import { MessageFormatter } from "../shared/messageFormatter.js";
 // Global state management
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();
+// Keys are scoped per database to avoid cross-database collisions
+// Collections key format: `${databaseId}::${collectionId}`
+// Attributes key format: `${databaseId}::${collectionId}::${attributeKey}`
 export const processedCollections = new Set();
-export const processedAttributes = new Set(); // format: "collectionId:attributeKey"
+export const processedAttributes = new Set();
+// Helpers to build scoped keys
+const collectionKey = (databaseId, collectionId) => `${databaseId}::${collectionId}`;
+const attributeKeyScoped = (databaseId, collectionId, key) => `${databaseId}::${collectionId}::${key}`;
 export const enqueueOperation = (operation) => {
     // Avoid duplicate queue entries for same attribute
     const attributeKey = operation.attribute?.key;
@@ -64,38 +70,40 @@ export const clearProcessingState = () => {
 /**
  * Check if a collection has already been fully processed
  */
-export const isCollectionProcessed = (collectionId) => {
-    return processedCollections.has(collectionId);
+export const isCollectionProcessed = (collectionId, databaseId) => {
+    return processedCollections.has(collectionKey(databaseId, collectionId));
 };
 /**
  * Mark a collection as fully processed
  */
-export const markCollectionProcessed = (collectionId, collectionName) => {
-    processedCollections.add(collectionId);
+export const markCollectionProcessed = (collectionId, collectionName, databaseId) => {
+    processedCollections.add(collectionKey(databaseId, collectionId));
     const logData = {
+        databaseId,
         collectionId,
         collectionName,
         totalProcessedCollections: processedCollections.size,
         operation: 'markCollectionProcessed'
     };
     if (collectionName) {
-        MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`);
+        MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`, { prefix: 'Tables' });
     }
     logger.info('Collection marked as processed', logData);
 };
 /**
  * Check if a specific attribute has been processed
  */
-export const isAttributeProcessed = (collectionId, attributeKey) => {
-    return processedAttributes.has(`${collectionId}:${attributeKey}`);
+export const isAttributeProcessed = (databaseId, collectionId, attributeKey) => {
+    return processedAttributes.has(attributeKeyScoped(databaseId, collectionId, attributeKey));
 };
 /**
  * Mark a specific attribute as processed
  */
-export const markAttributeProcessed = (collectionId, attributeKey) => {
-    const identifier = `${collectionId}:${attributeKey}`;
+export const markAttributeProcessed = (databaseId, collectionId, attributeKey) => {
+    const identifier = attributeKeyScoped(databaseId, collectionId, attributeKey);
     processedAttributes.add(identifier);
     logger.debug('Attribute marked as processed', {
+        databaseId,
         collectionId,
         attributeKey,
         identifier,
@@ -152,8 +160,8 @@ export const processQueue = async (db, dbId) => {
             }
             const attributeKey = operation.attribute.key;
             const collectionId = operation.collectionId;
-            // Skip if this specific attribute was already processed
-            if (isAttributeProcessed(collectionId, attributeKey)) {
+            // Skip if this specific attribute was already processed (per database)
+            if (isAttributeProcessed(dbId, collectionId, attributeKey)) {
                 MessageFormatter.debug(`Attribute '${attributeKey}' already processed, removing from queue`);
                 logger.debug('Removing already processed attribute from queue', {
                     attributeKey,
@@ -268,7 +276,7 @@ export const processQueue = async (db, dbId) => {
                         targetCollectionName: targetCollection.name,
                         operation: 'processQueue'
                     });
-                    markAttributeProcessed(collectionId, attributeKey);
+                    markAttributeProcessed(dbId, collectionId, attributeKey);
                     queuedOperations.splice(i, 1);
                     progress = true;
                 }

package/dist/utilsController.js

@@ -454,6 +454,13 @@ export class UtilsController {
             this.config.apiMode = this.adapter.getApiMode();
             logger.debug(`Updated config.apiMode from adapter: ${this.config.apiMode}`, { prefix: "UtilsController" });
         }
+        // Ensure we don't carry state between databases in a multi-db push
+        // This resets processed sets and name->id mapping per database
+        try {
+            const { clearProcessingState } = await import('./shared/operationQueue.js');
+            clearProcessingState();
+        }
+        catch { }
         // Always prefer adapter path for unified behavior. LegacyAdapter internally translates when needed.
         if (this.adapter) {
             logger.debug("Using adapter for createOrUpdateCollections (unified path)", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.8.6",
+  "version": "1.8.8",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/collections/attributes.ts

@@ -1835,7 +1835,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   // Filter to only attributes that need processing (new, changed, or not yet processed)
   const attributesToProcess = attributes.filter((attribute) => {
     // Skip if already processed in this session
-    if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
+    if (isAttributeProcessed(dbId, currentCollection.$id, attribute.key)) {
       return false;
     }
 
@@ -1879,7 +1879,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
 
       if (success) {
         // Mark this specific attribute as processed
-        markAttributeProcessed(currentCollection.$id, attribute.key);
+        markAttributeProcessed(dbId, currentCollection.$id, attribute.key);
 
         // Get updated collection data for next iteration
         try {

package/src/collections/methods.ts

@@ -215,7 +215,7 @@ export const createOrUpdateCollectionsViaAdapter = async (
 ): Promise<void> => {
   const collectionsToProcess =
     selectedCollections.length > 0 ? selectedCollections : (config.collections || []);
-  if (!collectionsToProcess || collectionsToProcess.length === 0) return;
+  if (!collectionsToProcess || collectionsToProcess.length === 0) return;
 
   const usedIds = new Set<string>();
   MessageFormatter.info(`Processing ${collectionsToProcess.length} tables via adapter with intelligent state management`, { prefix: "Tables" });
@@ -238,11 +238,11 @@ export const createOrUpdateCollectionsViaAdapter = async (
   for (const collection of collectionsToProcess) {
     const { attributes, indexes, ...collectionData } = collection as any;
 
-    // Check if this table has already been processed in this session
-    if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
-      MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
-      continue;
-    }
+    // Check if this table has already been processed in this session (per database)
+    if (collectionData.$id && isCollectionProcessed(collectionData.$id, databaseId)) {
+      MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
+      continue;
+    }
 
     // Prepare permissions as strings (reuse Permission helper)
     const permissions: string[] = [];
@@ -262,45 +262,69 @@ export const createOrUpdateCollectionsViaAdapter = async (
       }
     }
 
-    // Find existing table by name
-    const list = await adapter.listTables({ databaseId, queries: [Query.equal('name', collectionData.name)] });
-    const items: any[] = (list as any).tables || [];
-    let table = items[0];
-    let tableId: string;
-
-    if (!table) {
-      // Determine ID (prefer provided $id or re-use deleted one)
-      let foundColl = deletedCollections?.find(
-        (coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") === collectionData.name.toLowerCase().trim().replace(" ", "")
-      );
-      if (collectionData.$id) tableId = collectionData.$id;
-      else if (foundColl && !usedIds.has(foundColl.collectionId)) tableId = foundColl.collectionId;
-      else tableId = ID.unique();
-      usedIds.add(tableId);
-
-      const res = await adapter.createTable({
-        databaseId,
-        id: tableId,
-        name: collectionData.name,
-        permissions,
-        documentSecurity: !!collectionData.documentSecurity,
-        enabled: collectionData.enabled !== false
-      });
-      table = (res as any).data || res;
-      nameToIdMapping.set(collectionData.name, tableId);
-    } else {
-      tableId = table.$id;
-      await adapter.updateTable({
-        databaseId,
-        id: tableId,
-        name: collectionData.name,
-        permissions,
-        documentSecurity: !!collectionData.documentSecurity,
-        enabled: collectionData.enabled !== false
-      });
-      // Cache the existing table ID
-      nameToIdMapping.set(collectionData.name, tableId);
-    }
+    // Find existing table — prefer lookup by ID (if provided), then by name
+    let table: any | undefined;
+    let tableId: string;
+
+    // 1) Try by explicit $id first (handles rename scenarios)
+    if (collectionData.$id) {
+      try {
+        const byId = await adapter.getTable({ databaseId, tableId: collectionData.$id });
+        table = (byId as any).data || (byId as any).tables?.[0];
+        if (table?.$id) {
+          MessageFormatter.info(`Found existing table by ID: ${table.$id}`, { prefix: 'Tables' });
+        }
+      } catch {
+        // Not found by ID; fall back to name lookup
+      }
+    }
+
+    // 2) If not found by ID, try by name
+    if (!table) {
+      const list = await adapter.listTables({ databaseId, queries: [Query.equal('name', collectionData.name)] });
+      const items: any[] = (list as any).tables || [];
+      table = items[0];
+      if (table?.$id) {
+        // If local has $id that differs from remote, prefer remote (IDs are immutable)
+        if (collectionData.$id && collectionData.$id !== table.$id) {
+          MessageFormatter.warning(`Config $id '${collectionData.$id}' differs from existing table ID '${table.$id}'. Using existing table.`, { prefix: 'Tables' });
+        }
+      }
+    }
+
+    if (!table) {
+      // Determine ID (prefer provided $id or re-use deleted one)
+      let foundColl = deletedCollections?.find(
+        (coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") === collectionData.name.toLowerCase().trim().replace(" ", "")
+      );
+      if (collectionData.$id) tableId = collectionData.$id;
+      else if (foundColl && !usedIds.has(foundColl.collectionId)) tableId = foundColl.collectionId;
+      else tableId = ID.unique();
+      usedIds.add(tableId);
+
+      const res = await adapter.createTable({
+        databaseId,
+        id: tableId,
+        name: collectionData.name,
+        permissions,
+        documentSecurity: !!collectionData.documentSecurity,
+        enabled: collectionData.enabled !== false
+      });
+      table = (res as any).data || res;
+      nameToIdMapping.set(collectionData.name, tableId);
+    } else {
+      tableId = table.$id;
+      await adapter.updateTable({
+        databaseId,
+        id: tableId,
+        name: collectionData.name,
+        permissions,
+        documentSecurity: !!collectionData.documentSecurity,
+        enabled: collectionData.enabled !== false
+      });
+      // Cache the existing table ID
+      nameToIdMapping.set(collectionData.name, tableId);
+    }
 
     // Add small delay after table create/update
     await delay(250);
@@ -625,8 +649,8 @@ export const createOrUpdateCollectionsViaAdapter = async (
       MessageFormatter.warning(`Could not evaluate deletions: ${(e as Error)?.message || e}`, { prefix: 'Attributes' });
     }
 
-    // Mark this table as fully processed to prevent re-processing
-    markCollectionProcessed(tableId, collectionData.name);
+    // Mark this table as fully processed for this database to prevent re-processing in the same DB only
+    markCollectionProcessed(tableId, collectionData.name, databaseId);
   }
 
   // Process queued relationships once mapping likely populated

package/src/interactiveCLI.ts

@@ -74,8 +74,9 @@ enum CHOICES {
 }
 
 export class InteractiveCLI {
-  private controller: UtilsController | undefined;
-  private isUsingTypeScriptConfig: boolean = false;
+  private controller: UtilsController | undefined;
+  private isUsingTypeScriptConfig: boolean = false;
+  private lastSelectedCollectionIds: string[] = [];
 
   constructor(private currentDir: string) {}
 
@@ -454,14 +455,14 @@ export class InteractiveCLI {
   /**
    * Enhanced collection/table selection with better guidance for mixed scenarios
    */
-  private async selectCollectionsAndTables(
-    database: Models.Database,
-    databasesClient: Databases,
-    message: string,
-    multiSelect = true,
-    preferLocal = false,
-    shouldFilterByDatabase = false
-  ): Promise<Models.Collection[]> {
+  private async selectCollectionsAndTables(
+    database: Models.Database,
+    databasesClient: Databases,
+    message: string,
+    multiSelect = true,
+    preferLocal = false,
+    shouldFilterByDatabase = false
+  ): Promise<Models.Collection[]> {
     const configCollections = this.getLocalCollections();
     const collectionsCount = configCollections.filter(c => !c._isFromTablesDir).length;
     const tablesCount = configCollections.filter(c => c._isFromTablesDir).length;
@@ -481,28 +482,48 @@ export class InteractiveCLI {
     // Show current database context clearly before view mode selection
     MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
 
-    // Ask user if they want to filter by database or show all
+    // Ask user if they want to filter by database, show all, or reuse previous selection
+    const choices: { name: string; value: string }[] = [
+      {
+        name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
+        value: "all"
+      },
+      {
+        name: `Filter by database "${database.name}" - Show only related collections/tables`,
+        value: "filter"
+      }
+    ];
+    if (this.lastSelectedCollectionIds && this.lastSelectedCollectionIds.length > 0) {
+      choices.unshift({
+        name: `Use same selection as before (${this.lastSelectedCollectionIds.length} items)`,
+        value: "same"
+      });
+    }
+
     const { filterChoice } = await inquirer.prompt([
       {
         type: "list",
         name: "filterChoice",
         message: chalk.blue("How would you like to view collections/tables?"),
-        choices: [
-          {
-            name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
-            value: "all"
-          },
-          {
-            name: `Filter by database "${database.name}" - Show only related collections/tables`,
-            value: "filter"
-          }
-        ],
-        default: "all"
-      }
-    ]);
-
-    // User's choice overrides the parameter
-    const userWantsFiltering = filterChoice === "filter";
+        choices,
+        default: choices[0]?.value || "all"
+      }
+    ]);
+
+    // If user wants to reuse the previous selection, map IDs to current config and return
+    if (filterChoice === "same") {
+      const map = new Map<string, Models.Collection>(
+        this.getLocalCollections().map((c: any) => [c.$id || c.id, c as Models.Collection])
+      );
+      const selected = this.lastSelectedCollectionIds
+        .map((id) => map.get(id))
+        .filter((c): c is Models.Collection => !!c);
+      MessageFormatter.info(`Using same selection as previous: ${selected.length} item(s)`, { prefix: "Collections" });
+      return selected;
+    }
+
+    // User's choice overrides the parameter
+    const userWantsFiltering = filterChoice === "filter";
 
     // Show appropriate informational message
     if (userWantsFiltering) {
@@ -519,8 +540,18 @@ export class InteractiveCLI {
       MessageFormatter.info(`ℹ️  Showing all available collections/tables - you can push any collection to any database\n`, { prefix: "Collections" });
     }
 
-    return this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
-  }
+    const result = await this.selectCollections(
+      database,
+      databasesClient,
+      message,
+      multiSelect,
+      preferLocal,
+      userWantsFiltering
+    );
+    // Remember this selection for subsequent databases
+    this.lastSelectedCollectionIds = (result || []).map((c: any) => c.$id || c.id);
+    return result;
+  }
 
   private getTemplateDefaults(template: string) {
     const defaults = {

package/src/main.ts

@@ -1398,6 +1398,7 @@ async function main() {
       // Build DatabaseSelection[] with tableIds per DB
       const databaseSelections: DatabaseSelection[] = [];
       const allConfigItems = controller.config.collections || controller.config.tables || [];
+      let lastSelectedTableIds: string[] | null = null;
 
       for (const dbId of selectedDbIds) {
         const db = availableDatabases.find(d => d.$id === dbId);
@@ -1418,18 +1419,54 @@ async function main() {
         // Determine selected table IDs
         let selectedTableIds: string[] = [];
         if (parsedArgv.collectionIds) {
-          const ids = parsedArgv.collectionIds.split(/[,\s]+/).filter(Boolean);
-          // Only allow IDs that are in eligible config items
-          const eligibleIds = new Set(eligibleConfigItems.map((c: any) => c.$id || c.id));
-          selectedTableIds = ids.filter(id => eligibleIds.has(id));
+          // Non-interactive: respect provided table IDs as-is (apply to each selected DB)
+          selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
         } else {
-          selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-            dbId,
-            db.name,
-            availableTables,
-            eligibleConfigItems,
-            { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
-          );
+          // If we have a previous selection, offer to reuse it
+          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];
+            } else if (reuseMode === "all") {
+              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+                dbId,
+                db.name,
+                availableTables,
+                allConfigItems as any[],
+                { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds }
+              );
+            } else {
+              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+                dbId,
+                db.name,
+                availableTables,
+                eligibleConfigItems,
+                { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds }
+              );
+            }
+          } else {
+            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+              dbId,
+              db.name,
+              availableTables,
+              eligibleConfigItems,
+              { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
+            );
+          }
         }
 
         databaseSelections.push({
@@ -1439,6 +1476,9 @@ async function main() {
           tableNames: [],
           isNew: false,
         });
+        if (!parsedArgv.collectionIds) {
+          lastSelectedTableIds = selectedTableIds;
+        }
       }
 
       if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
@@ -1451,10 +1491,13 @@ async function main() {
         collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
         details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
       };
-      const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
-      if (!confirmed) {
-        MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
-        return;
+      // Skip confirmation if both dbIds and collectionIds are provided (non-interactive)
+      if (!(parsedArgv.dbIds && parsedArgv.collectionIds)) {
+        const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
+        if (!confirmed) {
+          MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
+          return;
+        }
       }
 
       await controller.selectivePush(databaseSelections, []);

package/src/shared/operationQueue.ts

@@ -16,10 +16,17 @@ export interface QueuedOperation {
 }
 
 // Global state management
-export const queuedOperations: QueuedOperation[] = [];
-export const nameToIdMapping: Map<string, string> = new Map();
-export const processedCollections: Set<string> = new Set();
-export const processedAttributes: Set<string> = new Set(); // format: "collectionId:attributeKey"
+export const queuedOperations: QueuedOperation[] = [];
+export const nameToIdMapping: Map<string, string> = new Map();
+// Keys are scoped per database to avoid cross-database collisions
+// Collections key format: `${databaseId}::${collectionId}`
+// Attributes key format: `${databaseId}::${collectionId}::${attributeKey}`
+export const processedCollections: Set<string> = new Set();
+export const processedAttributes: Set<string> = new Set();
+
+// Helpers to build scoped keys
+const collectionKey = (databaseId: string, collectionId: string) => `${databaseId}::${collectionId}`;
+const attributeKeyScoped = (databaseId: string, collectionId: string, key: string) => `${databaseId}::${collectionId}::${key}`;
 
 export const enqueueOperation = (operation: QueuedOperation) => {
   // Avoid duplicate queue entries for same attribute
@@ -86,52 +93,54 @@ export const clearProcessingState = () => {
 /**
  * Check if a collection has already been fully processed
  */
-export const isCollectionProcessed = (collectionId: string): boolean => {
-  return processedCollections.has(collectionId);
-};
+export const isCollectionProcessed = (collectionId: string, databaseId: string): boolean => {
+  return processedCollections.has(collectionKey(databaseId, collectionId));
+};
 
 /**
  * Mark a collection as fully processed
  */
-export const markCollectionProcessed = (collectionId: string, collectionName?: string) => {
-  processedCollections.add(collectionId);
-
-  const logData = {
-    collectionId,
-    collectionName,
-    totalProcessedCollections: processedCollections.size,
-    operation: 'markCollectionProcessed'
-  };
-
-  if (collectionName) {
-    MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`);
-  }
-
-  logger.info('Collection marked as processed', logData);
-};
+export const markCollectionProcessed = (collectionId: string, collectionName: string | undefined, databaseId: string) => {
+  processedCollections.add(collectionKey(databaseId, collectionId));
+
+  const logData = {
+    databaseId,
+    collectionId,
+    collectionName,
+    totalProcessedCollections: processedCollections.size,
+    operation: 'markCollectionProcessed'
+  };
+
+  if (collectionName) {
+    MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`, { prefix: 'Tables' });
+  }
+
+  logger.info('Collection marked as processed', logData);
+};
 
 /**
  * Check if a specific attribute has been processed
  */
-export const isAttributeProcessed = (collectionId: string, attributeKey: string): boolean => {
-  return processedAttributes.has(`${collectionId}:${attributeKey}`);
-};
+export const isAttributeProcessed = (databaseId: string, collectionId: string, attributeKey: string): boolean => {
+  return processedAttributes.has(attributeKeyScoped(databaseId, collectionId, attributeKey));
+};
 
 /**
  * Mark a specific attribute as processed
  */
-export const markAttributeProcessed = (collectionId: string, attributeKey: string) => {
-  const identifier = `${collectionId}:${attributeKey}`;
-  processedAttributes.add(identifier);
-
-  logger.debug('Attribute marked as processed', {
-    collectionId,
-    attributeKey,
-    identifier,
-    totalProcessedAttributes: processedAttributes.size,
-    operation: 'markAttributeProcessed'
-  });
-};
+export const markAttributeProcessed = (databaseId: string, collectionId: string, attributeKey: string) => {
+  const identifier = attributeKeyScoped(databaseId, collectionId, attributeKey);
+  processedAttributes.add(identifier);
+
+  logger.debug('Attribute marked as processed', {
+    databaseId,
+    collectionId,
+    attributeKey,
+    identifier,
+    totalProcessedAttributes: processedAttributes.size,
+    operation: 'markAttributeProcessed'
+  });
+};
 
 /**
  * Process only specific attributes in the queue, not entire collections
@@ -193,8 +202,8 @@ export const processQueue = async (db: Databases | DatabaseAdapter, dbId: string
       const attributeKey = operation.attribute.key;
       const collectionId = operation.collectionId;
 
-      // Skip if this specific attribute was already processed
-      if (isAttributeProcessed(collectionId, attributeKey)) {
+      // Skip if this specific attribute was already processed (per database)
+      if (isAttributeProcessed(dbId, collectionId, attributeKey)) {
         MessageFormatter.debug(`Attribute '${attributeKey}' already processed, removing from queue`);
         logger.debug('Removing already processed attribute from queue', {
           attributeKey,
@@ -327,7 +336,7 @@ export const processQueue = async (db: Databases | DatabaseAdapter, dbId: string
             targetCollectionName: targetCollection.name,
             operation: 'processQueue'
           });
-          markAttributeProcessed(collectionId, attributeKey);
+          markAttributeProcessed(dbId, collectionId, attributeKey);
           queuedOperations.splice(i, 1);
           progress = true;
         } else {

package/src/utilsController.ts

@@ -615,9 +615,9 @@ export class UtilsController {
     deletedCollections?: { collectionId: string; collectionName: string }[],
     collections: Models.Collection[] = []
   ) {
-    await this.init();
-    if (!this.database || !this.config)
-      throw new Error("Database or config not initialized");
+    await this.init();
+    if (!this.database || !this.config)
+      throw new Error("Database or config not initialized");
 
     // Ensure apiMode is properly set from adapter
     if (this.adapter && (!this.config.apiMode || this.config.apiMode === 'auto')) {
@@ -625,6 +625,13 @@ export class UtilsController {
       logger.debug(`Updated config.apiMode from adapter: ${this.config.apiMode}`, { prefix: "UtilsController" });
     }
 
+    // Ensure we don't carry state between databases in a multi-db push
+    // This resets processed sets and name->id mapping per database
+    try {
+      const { clearProcessingState } = await import('./shared/operationQueue.js');
+      clearProcessingState();
+    } catch {}
+
     // Always prefer adapter path for unified behavior. LegacyAdapter internally translates when needed.
     if (this.adapter) {
       logger.debug("Using adapter for createOrUpdateCollections (unified path)", {