appwrite-utils-cli 1.8.5 → 1.8.7

package/dist/collections/methods.js

@@ -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(" ", ""));
@@ -235,6 +258,11 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
             const plusminus = plan.toUpdate.map((u) => u.attribute.key);
             const minus = plan.toRecreate.map((r) => r.newAttribute.key);
             const skip = plan.unchanged;
+            // Compute deletions (remote extras not present locally)
+            const desiredKeysForDelete = new Set((attributes || []).map((a) => a.key));
+            const extraRemoteKeys = (existingCols || [])
+                .map((c) => c?.key)
+                .filter((k) => !!k && !desiredKeysForDelete.has(k));
             const parts = [];
             if (plus.length)
                 parts.push(`➕  ${plus.length} (${plus.join(', ')})`);
@@ -244,6 +272,7 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 parts.push(`♻️  ${minus.length} (${minus.join(', ')})`);
             if (skip.length)
                 parts.push(`⏭️  ${skip.length}`);
+            parts.push(`🗑️  ${extraRemoteKeys.length}${extraRemoteKeys.length ? ` (${extraRemoteKeys.join(', ')})` : ''}`);
             MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Attributes' });
             // Execute
             const colResults = await executeColumnOperations(adapter, databaseId, tableId, plan);
@@ -458,6 +487,121 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         catch (e) {
             MessageFormatter.error(`Failed to list/create indexes`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
         }
+        // Deletions for indexes: remove remote indexes not declared in YAML/config
+        try {
+            const desiredIndexKeys = new Set((indexes || []).map((i) => i.key));
+            const idxRes = await adapter.listIndexes({ databaseId, tableId });
+            const existingIdx = idxRes.data || idxRes.indexes || [];
+            const extraIdx = existingIdx
+                .filter((i) => i?.key && !desiredIndexKeys.has(i.key))
+                .map((i) => i.key);
+            if (extraIdx.length > 0) {
+                MessageFormatter.info(`Plan → 🗑️  ${extraIdx.length} indexes (${extraIdx.join(', ')})`, { prefix: 'Indexes' });
+                const deleted = [];
+                const errors = [];
+                for (const key of extraIdx) {
+                    try {
+                        await adapter.deleteIndex({ databaseId, tableId, key });
+                        // Optionally wait for index to disappear
+                        const start = Date.now();
+                        const maxWait = 30000;
+                        while (Date.now() - start < maxWait) {
+                            try {
+                                const li = await adapter.listIndexes({ databaseId, tableId });
+                                const list = li.data || li.indexes || [];
+                                if (!list.find((ix) => ix.key === key))
+                                    break;
+                            }
+                            catch { }
+                            await delay(1000);
+                        }
+                        deleted.push(key);
+                    }
+                    catch (e) {
+                        errors.push({ key, error: e?.message || String(e) });
+                    }
+                }
+                if (deleted.length) {
+                    MessageFormatter.success(`Deleted ${deleted.length} indexes: ${deleted.join(', ')}`, { prefix: 'Indexes' });
+                }
+                if (errors.length) {
+                    MessageFormatter.error(`${errors.length} index deletions failed`, undefined, { prefix: 'Indexes' });
+                    errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Indexes' }));
+                }
+            }
+            else {
+                MessageFormatter.info(`Plan → 🗑️  0 indexes`, { prefix: 'Indexes' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.warning(`Could not evaluate index deletions: ${e?.message || e}`, { prefix: 'Indexes' });
+        }
+        // Deletions: remove columns/attributes that are present remotely but not in desired config
+        try {
+            const desiredKeys = new Set((attributes || []).map((a) => a.key));
+            const tableInfo3 = await adapter.getTable({ databaseId, tableId });
+            const existingCols3 = tableInfo3.data?.columns || tableInfo3.data?.attributes || [];
+            const toDelete = existingCols3
+                .filter((col) => col?.key && !desiredKeys.has(col.key))
+                .map((col) => col.key);
+            if (toDelete.length > 0) {
+                MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });
+                const deleted = [];
+                const errors = [];
+                for (const key of toDelete) {
+                    try {
+                        // Drop any indexes that reference this attribute to avoid server errors
+                        try {
+                            const idxRes = await adapter.listIndexes({ databaseId, tableId });
+                            const ilist = idxRes.data || idxRes.indexes || [];
+                            for (const idx of ilist) {
+                                const attrs = Array.isArray(idx.attributes) ? idx.attributes : [];
+                                if (attrs.includes(key)) {
+                                    MessageFormatter.info(`🗑️  Deleting index '${idx.key}' referencing '${key}'`, { prefix: 'Indexes' });
+                                    await adapter.deleteIndex({ databaseId, tableId, key: idx.key });
+                                    await delay(500);
+                                }
+                            }
+                        }
+                        catch { }
+                        await adapter.deleteAttribute({ databaseId, tableId, key });
+                        // Wait briefly for deletion to settle
+                        const start = Date.now();
+                        const maxWaitMs = 60000;
+                        while (Date.now() - start < maxWaitMs) {
+                            try {
+                                const tinfo = await adapter.getTable({ databaseId, tableId });
+                                const cols = tinfo.data?.columns || tinfo.data?.attributes || [];
+                                const found = cols.find((c) => c.key === key);
+                                if (!found)
+                                    break;
+                                if (found.status && found.status !== 'deleting')
+                                    break;
+                            }
+                            catch { }
+                            await delay(1000);
+                        }
+                        deleted.push(key);
+                    }
+                    catch (e) {
+                        errors.push({ key, error: e?.message || String(e) });
+                    }
+                }
+                if (deleted.length) {
+                    MessageFormatter.success(`Deleted ${deleted.length} attributes: ${deleted.join(', ')}`, { prefix: 'Attributes' });
+                }
+                if (errors.length) {
+                    MessageFormatter.error(`${errors.length} deletions failed`, undefined, { prefix: 'Attributes' });
+                    errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Attributes' }));
+                }
+            }
+            else {
+                MessageFormatter.info(`Plan → 🗑️  0`, { prefix: 'Attributes' });
+            }
+        }
+        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);
     }

package/dist/utilsController.js

@@ -619,6 +619,15 @@ export class UtilsController {
             MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
+        // Always reload config from disk so pushes use current local YAML/Ts definitions
+        try {
+            await this.reloadConfig();
+            MessageFormatter.info("Reloaded config from disk for push", { prefix: "Controller" });
+        }
+        catch (e) {
+            // Non-fatal; continue with existing config
+            MessageFormatter.warning("Could not reload config; continuing with current in-memory config", { prefix: "Controller" });
+        }
         MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
         // Convert database selections to Models.Database format
         const selectedDatabases = [];
@@ -665,7 +674,8 @@ export class UtilsController {
                 // Check if this collection was selected for THIS database
                 if (dbSelection.tableIds.includes(collectionId)) {
                     collectionsForDatabase.push(collection);
-                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId}`, { prefix: "Controller" });
+                    const source = collection._isFromTablesDir ? 'tables/' : 'collections/';
+                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId} [source: ${source}]`, { prefix: "Controller" });
                 }
             }
             databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);

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

package/src/collections/methods.ts

@@ -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);
@@ -319,11 +343,18 @@ export const createOrUpdateCollectionsViaAdapter = async (
       const minus = plan.toRecreate.map((r: any) => (r.newAttribute as any).key);
       const skip = plan.unchanged;
 
+      // Compute deletions (remote extras not present locally)
+      const desiredKeysForDelete = new Set((attributes || []).map((a: any) => a.key));
+      const extraRemoteKeys = (existingCols || [])
+        .map((c: any) => c?.key)
+        .filter((k: any): k is string => !!k && !desiredKeysForDelete.has(k));
+
       const parts: string[] = [];
       if (plus.length) parts.push(`➕  ${plus.length} (${plus.join(', ')})`);
       if (plusminus.length) parts.push(`🔧  ${plusminus.length} (${plusminus.join(', ')})`);
       if (minus.length) parts.push(`♻️  ${minus.length} (${minus.join(', ')})`);
       if (skip.length) parts.push(`⏭️  ${skip.length}`);
+      parts.push(`🗑️  ${extraRemoteKeys.length}${extraRemoteKeys.length ? ` (${extraRemoteKeys.join(', ')})` : ''}`);
       MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Attributes' });
 
       // Execute
@@ -510,10 +541,117 @@ export const createOrUpdateCollectionsViaAdapter = async (
     } catch (e) {
       MessageFormatter.error(`Failed to list/create indexes`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
     }
-
-    // Mark this table as fully processed to prevent re-processing
-    markCollectionProcessed(tableId, collectionData.name);
-  }
+
+    // Deletions for indexes: remove remote indexes not declared in YAML/config
+    try {
+      const desiredIndexKeys = new Set((indexes || []).map((i: any) => i.key));
+      const idxRes = await adapter.listIndexes({ databaseId, tableId });
+      const existingIdx: any[] = (idxRes as any).data || (idxRes as any).indexes || [];
+      const extraIdx = existingIdx
+        .filter((i: any) => i?.key && !desiredIndexKeys.has(i.key))
+        .map((i: any) => i.key as string);
+      if (extraIdx.length > 0) {
+        MessageFormatter.info(`Plan → 🗑️  ${extraIdx.length} indexes (${extraIdx.join(', ')})`, { prefix: 'Indexes' });
+        const deleted: string[] = [];
+        const errors: Array<{ key: string; error: string }> = [];
+        for (const key of extraIdx) {
+          try {
+            await adapter.deleteIndex({ databaseId, tableId, key });
+            // Optionally wait for index to disappear
+            const start = Date.now();
+            const maxWait = 30000;
+            while (Date.now() - start < maxWait) {
+              try {
+                const li = await adapter.listIndexes({ databaseId, tableId });
+                const list: any[] = (li as any).data || (li as any).indexes || [];
+                if (!list.find((ix: any) => ix.key === key)) break;
+              } catch {}
+              await delay(1000);
+            }
+            deleted.push(key);
+          } catch (e: any) {
+            errors.push({ key, error: e?.message || String(e) });
+          }
+        }
+        if (deleted.length) {
+          MessageFormatter.success(`Deleted ${deleted.length} indexes: ${deleted.join(', ')}`, { prefix: 'Indexes' });
+        }
+        if (errors.length) {
+          MessageFormatter.error(`${errors.length} index deletions failed`, undefined, { prefix: 'Indexes' });
+          errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Indexes' }));
+        }
+      } else {
+        MessageFormatter.info(`Plan → 🗑️  0 indexes`, { prefix: 'Indexes' });
+      }
+    } catch (e) {
+      MessageFormatter.warning(`Could not evaluate index deletions: ${(e as Error)?.message || e}`, { prefix: 'Indexes' });
+    }
+
+    // Deletions: remove columns/attributes that are present remotely but not in desired config
+    try {
+      const desiredKeys = new Set((attributes || []).map((a: any) => a.key));
+      const tableInfo3 = await adapter.getTable({ databaseId, tableId });
+      const existingCols3: any[] = (tableInfo3 as any).data?.columns || (tableInfo3 as any).data?.attributes || [];
+      const toDelete = existingCols3
+        .filter((col: any) => col?.key && !desiredKeys.has(col.key))
+        .map((col: any) => col.key as string);
+
+      if (toDelete.length > 0) {
+        MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });
+        const deleted: string[] = [];
+        const errors: Array<{ key: string; error: string }> = [];
+        for (const key of toDelete) {
+          try {
+            // Drop any indexes that reference this attribute to avoid server errors
+            try {
+              const idxRes = await adapter.listIndexes({ databaseId, tableId });
+              const ilist: any[] = (idxRes as any).data || (idxRes as any).indexes || [];
+              for (const idx of ilist) {
+                const attrs: string[] = Array.isArray(idx.attributes) ? idx.attributes : [];
+                if (attrs.includes(key)) {
+                  MessageFormatter.info(`🗑️  Deleting index '${idx.key}' referencing '${key}'`, { prefix: 'Indexes' });
+                  await adapter.deleteIndex({ databaseId, tableId, key: idx.key });
+                  await delay(500);
+                }
+              }
+            } catch {}
+
+            await adapter.deleteAttribute({ databaseId, tableId, key });
+            // Wait briefly for deletion to settle
+            const start = Date.now();
+            const maxWaitMs = 60000;
+            while (Date.now() - start < maxWaitMs) {
+              try {
+                const tinfo = await adapter.getTable({ databaseId, tableId });
+                const cols = (tinfo as any).data?.columns || (tinfo as any).data?.attributes || [];
+                const found = cols.find((c: any) => c.key === key);
+                if (!found) break;
+                if (found.status && found.status !== 'deleting') break;
+              } catch {}
+              await delay(1000);
+            }
+            deleted.push(key);
+          } catch (e: any) {
+            errors.push({ key, error: e?.message || String(e) });
+          }
+        }
+        if (deleted.length) {
+          MessageFormatter.success(`Deleted ${deleted.length} attributes: ${deleted.join(', ')}`, { prefix: 'Attributes' });
+        }
+        if (errors.length) {
+          MessageFormatter.error(`${errors.length} deletions failed`, undefined, { prefix: 'Attributes' });
+          errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Attributes' }));
+        }
+      } else {
+        MessageFormatter.info(`Plan → 🗑️  0`, { prefix: 'Attributes' });
+      }
+    } catch (e) {
+      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);
+  }
 
   // Process queued relationships once mapping likely populated
   if (relQueue.length > 0) {

package/src/utilsController.ts

@@ -848,15 +848,24 @@ export class UtilsController {
     MessageFormatter.success("Selective pull completed successfully! Remote config pulled to local.", { prefix: "Controller" });
   }
 
-  async selectivePush(
-    databaseSelections: DatabaseSelection[],
-    bucketSelections: BucketSelection[]
-  ): Promise<void> {
-    await this.init();
-    if (!this.database) {
-      MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
-      return;
-    }
+  async selectivePush(
+    databaseSelections: DatabaseSelection[],
+    bucketSelections: BucketSelection[]
+  ): Promise<void> {
+    await this.init();
+    if (!this.database) {
+      MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+      return;
+    }
+
+    // Always reload config from disk so pushes use current local YAML/Ts definitions
+    try {
+      await this.reloadConfig();
+      MessageFormatter.info("Reloaded config from disk for push", { prefix: "Controller" });
+    } catch (e) {
+      // Non-fatal; continue with existing config
+      MessageFormatter.warning("Could not reload config; continuing with current in-memory config", { prefix: "Controller" });
+    }
 
     MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
 
@@ -900,7 +909,7 @@ export class UtilsController {
     const databaseCollectionsMap = new Map<string, any[]>();
 
     // Get all collections/tables from config (they're at the root level, not nested in databases)
-    const allCollections = this.config?.collections || this.config?.tables || [];
+    const allCollections = this.config?.collections || this.config?.tables || [];
 
     // Create database-specific collection mapping to preserve relationships
     for (const dbSelection of databaseSelections) {
@@ -908,16 +917,17 @@ export class UtilsController {
 
       MessageFormatter.info(`Processing collections for database: ${dbSelection.databaseId}`, { prefix: "Controller" });
 
-      // Filter collections that were selected for THIS specific database
-      for (const collection of allCollections) {
-        const collectionId = collection.$id || (collection as any).id;
-
-        // Check if this collection was selected for THIS database
-        if (dbSelection.tableIds.includes(collectionId)) {
-          collectionsForDatabase.push(collection);
-          MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId}`, { prefix: "Controller" });
-        }
-      }
+      // Filter collections that were selected for THIS specific database
+      for (const collection of allCollections) {
+        const collectionId = collection.$id || (collection as any).id;
+
+        // Check if this collection was selected for THIS database
+        if (dbSelection.tableIds.includes(collectionId)) {
+          collectionsForDatabase.push(collection);
+          const source = (collection as any)._isFromTablesDir ? 'tables/' : 'collections/';
+          MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId} [source: ${source}]`, { prefix: "Controller" });
+        }
+      }
 
       databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
       MessageFormatter.info(`Database ${dbSelection.databaseId}: ${collectionsForDatabase.length} collections selected`, { prefix: "Controller" });