@njdamstra/appwrite-utils-cli 1.8.9

package/src/collections/methods.ts

@@ -0,0 +1,745 @@
+import {
+  Databases,
+  ID,
+  Permission,
+  Query,
+  type Models,
+} from "node-appwrite";
+import type { AppwriteConfig, CollectionCreate, Indexes, Attribute } from "@njdamstra/appwrite-utils";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import {
+  nameToIdMapping,
+  processQueue,
+  queuedOperations,
+  clearProcessingState,
+  isCollectionProcessed,
+  markCollectionProcessed
+} from "../shared/operationQueue.js";
+import { logger } from "../shared/logging.js";
+// Legacy attribute/index helpers removed in favor of unified adapter path
+import { SchemaGenerator } from "../shared/schemaGenerator.js";
+import {
+  isNull,
+  isUndefined,
+  isNil,
+  isPlainObject,
+  isString,
+} from "es-toolkit";
+import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { isLegacyDatabases } from "../utils/typeGuards.js";
+import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "../shared/attributeMapper.js";
+import { diffTableColumns, isIndexEqualToIndex, diffColumnsDetailed, executeColumnOperations } from "./tableOperations.js";
+
+// Re-export wipe operations
+export {
+  wipeDatabase,
+  wipeCollection,
+  wipeAllTables,
+  wipeTableRows,
+} from "./wipeOperations.js";
+
+// Re-export transfer operations
+export {
+  transferDocumentsBetweenDbsLocalToLocal,
+  transferDocumentsBetweenDbsLocalToRemote,
+} from "./transferOperations.js";
+
+export const documentExists = async (
+  db: Databases | DatabaseAdapter,
+  dbId: string,
+  targetCollectionId: string,
+  toCreateObject: any
+): Promise<Models.Document | null> => {
+  const collection = await (isLegacyDatabases(db) ?
+    db.getCollection(dbId, targetCollectionId) :
+    db.getTable({ databaseId: dbId, tableId: targetCollectionId }));
+  const attributes = (collection as any).attributes as any[];
+  let arrayTypeAttributes = attributes
+    .filter((attribute: any) => attribute.array === true)
+    .map((attribute: any) => attribute.key);
+
+  const isJsonString = (str: string) => {
+    try {
+      const json = JSON.parse(str);
+      return typeof json === "object" && json !== null;
+    } catch (e) {
+      return false;
+    }
+  };
+
+  // Convert object to entries and filter
+  const validEntries = Object.entries(toCreateObject).filter(
+    ([key, value]) =>
+      !arrayTypeAttributes.includes(key) &&
+      !key.startsWith("$") &&
+      !isNull(value) &&
+      !isUndefined(value) &&
+      !isNil(value) &&
+      !isPlainObject(value) &&
+      !Array.isArray(value) &&
+      !(isString(value) && isJsonString(value)) &&
+      (isString(value) ? value.length < 4096 && value.length > 0 : true)
+  );
+
+  // Map and filter valid entries
+  const validMappedEntries = validEntries
+    .map(([key, value]) => [
+      key,
+      isString(value) || typeof value === "number" || typeof value === "boolean"
+        ? value
+        : null,
+    ])
+    .filter(([key, value]) => !isNull(value) && isString(key))
+    .slice(0, 25);
+
+  // Convert to Query parameters
+  const validQueryParams = validMappedEntries.map(([key, value]) =>
+    Query.equal(key as string, value as any)
+  );
+
+  // Execute the query with the validated and prepared parameters
+  const result = await (isLegacyDatabases(db) ?
+    db.listDocuments(dbId, targetCollectionId, validQueryParams) :
+    db.listRows({ databaseId: dbId, tableId: targetCollectionId, queries: validQueryParams }));
+
+  const items = isLegacyDatabases(db) ? result.documents : ((result as any).rows || result.documents);
+  return items?.[0] || null;
+};
+
+export const checkForCollection = async (
+  db: Databases | DatabaseAdapter,
+  dbId: string,
+  collection: Partial<CollectionCreate>
+): Promise<Models.Collection | null> => {
+  try {
+    MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
+    const response = await tryAwaitWithRetry(
+      async () => isLegacyDatabases(db) ?
+        await db.listCollections(dbId, [Query.equal("name", collection.name!)]) :
+        await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collection.name!)] })
+    );
+    const items = isLegacyDatabases(db) ? response.collections : ((response as any).tables || response.collections);
+    if (items && items.length > 0) {
+      MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
+      // Return remote collection for update operations (don't merge local config over it)
+      return items[0] as Models.Collection;
+    } else {
+      MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
+      return null;
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    MessageFormatter.error(`Error checking for collection: ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Collections" });
+    logger.error('Collection check failed', {
+      collectionName: collection.name,
+      dbId,
+      error: errorMessage,
+      operation: 'checkForCollection'
+    });
+    return null;
+  }
+};
+
+// Helper function to fetch and cache collection by name
+export const fetchAndCacheCollectionByName = async (
+  db: Databases | DatabaseAdapter,
+  dbId: string,
+  collectionName: string
+): Promise<Models.Collection | undefined> => {
+  if (nameToIdMapping.has(collectionName)) {
+    const collectionId = nameToIdMapping.get(collectionName);
+    MessageFormatter.debug(`Collection found in cache: ${collectionId}`, undefined, { prefix: "Collections" });
+    return await tryAwaitWithRetry(
+      async () => isLegacyDatabases(db) ?
+        await db.getCollection(dbId, collectionId!) :
+        await db.getTable({ databaseId: dbId, tableId: collectionId! })
+    ) as Models.Collection;
+  } else {
+    MessageFormatter.progress(`Fetching collection by name: ${collectionName}`, { prefix: "Collections" });
+    const collectionsPulled = await tryAwaitWithRetry(
+      async () => isLegacyDatabases(db) ?
+        await db.listCollections(dbId, [Query.equal("name", collectionName)]) :
+        await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collectionName)] })
+    );
+    const items = isLegacyDatabases(db) ? collectionsPulled.collections : ((collectionsPulled as any).tables || collectionsPulled.collections);
+    if ((collectionsPulled.total || items?.length) > 0) {
+      const collection = items[0];
+      MessageFormatter.info(`Collection found: ${collection.$id}`, { prefix: "Collections" });
+      nameToIdMapping.set(collectionName, collection.$id);
+      return collection;
+    } else {
+      MessageFormatter.warning(`Collection not found by name: ${collectionName}`, { prefix: "Collections" });
+      return undefined;
+    }
+  }
+};
+
+export const generateSchemas = async (
+  config: AppwriteConfig,
+  appwriteFolderPath: string
+): Promise<void> => {
+  const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
+  await schemaGenerator.generateSchemas();
+};
+
+export const createOrUpdateCollections = async (
+  database: Databases,
+  databaseId: string,
+  config: AppwriteConfig,
+  deletedCollections?: { collectionId: string; collectionName: string }[],
+  selectedCollections: Models.Collection[] = []
+): Promise<void> => {
+  // Clear processing state at the start of a new operation
+  clearProcessingState();
+
+  // Always use adapter path (LegacyAdapter translates when pre-1.8)
+  const { adapter } = await getAdapterFromConfig(config);
+  await createOrUpdateCollectionsViaAdapter(
+    adapter,
+    databaseId,
+    config,
+    deletedCollections,
+    selectedCollections
+  );
+};
+
+// New: Adapter-based implementation for TablesDB with state management
+export const createOrUpdateCollectionsViaAdapter = async (
+  adapter: DatabaseAdapter,
+  databaseId: string,
+  config: AppwriteConfig,
+  deletedCollections?: { collectionId: string; collectionName: string }[],
+  selectedCollections: Models.Collection[] = []
+): Promise<void> => {
+  const collectionsToProcess =
+    selectedCollections.length > 0 ? selectedCollections : (config.collections || []);
+  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" });
+
+  // Helpers for attribute operations through adapter
+  const createAttr = async (tableId: string, attr: Attribute) => {
+    const params = mapToCreateAttributeParams(attr as any, { databaseId, tableId });
+    await adapter.createAttribute(params);
+    await delay(150);
+  };
+  const updateAttr = async (tableId: string, attr: Attribute) => {
+    const params = mapToUpdateAttributeParams(attr as any, { databaseId, tableId }) as any;
+    await adapter.updateAttribute(params);
+    await delay(150);
+  };
+
+  // Local queue for unresolved relationships
+  const relQueue: { tableId: string; attr: Attribute }[] = [];
+
+  for (const collection of collectionsToProcess) {
+    const { attributes, indexes, ...collectionData } = collection as any;
+
+    // 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[] = [];
+    if (collection.$permissions && collection.$permissions.length > 0) {
+      for (const p of collection.$permissions as any[]) {
+        if (typeof p === 'string') permissions.push(p);
+        else {
+          switch (p.permission) {
+            case 'read': permissions.push(Permission.read(p.target)); break;
+            case 'create': permissions.push(Permission.create(p.target)); break;
+            case 'update': permissions.push(Permission.update(p.target)); break;
+            case 'delete': permissions.push(Permission.delete(p.target)); break;
+            case 'write': permissions.push(Permission.write(p.target)); break;
+            default: break;
+          }
+        }
+      }
+    }
+
+    // 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);
+
+    // Create/Update attributes: non-relationship first using enhanced planning
+    const nonRel = (attributes || []).filter((a: Attribute) => a.type !== 'relationship');
+    if (nonRel.length > 0) {
+      // Fetch existing columns once
+      const tableInfo = await adapter.getTable({ databaseId, tableId });
+      const existingCols: any[] = (tableInfo as any).data?.columns || (tableInfo as any).data?.attributes || [];
+
+      // Plan with icons
+      const plan = diffColumnsDetailed(nonRel as any, existingCols);
+      const plus = plan.toCreate.map((a: any) => a.key);
+      const plusminus = plan.toUpdate.map((u: any) => (u.attribute as any).key);
+      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
+      const colResults = await executeColumnOperations(adapter, databaseId, tableId, plan);
+
+      if (colResults.success.length > 0) {
+        MessageFormatter.success(`Processed ${colResults.success.length} ops`, { prefix: 'Attributes' });
+      }
+      if (colResults.errors.length > 0) {
+        MessageFormatter.error(`${colResults.errors.length} attribute operations failed:`, undefined, { prefix: 'Attributes' });
+        for (const err of colResults.errors) {
+          MessageFormatter.error(`  ${err.column}: ${err.error}`, undefined, { prefix: 'Attributes' });
+        }
+      }
+      MessageFormatter.info(
+        `Summary → ➕  ${plan.toCreate.length}  |  🔧  ${plan.toUpdate.length}  |  ♻️  ${plan.toRecreate.length}  |  ⏭️  ${plan.unchanged.length}`,
+        { prefix: 'Attributes' }
+      );
+    }
+
+    // Relationship attributes — resolve relatedCollection to ID, then diff and create/update
+    const rels = (attributes || []).filter((a: Attribute) => a.type === 'relationship') as any[];
+    if (rels.length > 0) {
+      for (const attr of rels) {
+        const relNameOrId = attr.relatedCollection as string | undefined;
+        if (!relNameOrId) continue;
+        let relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+        if (!nameToIdMapping.has(relNameOrId)) {
+          try {
+            const relList = await adapter.listTables({ databaseId, queries: [Query.equal('name', relNameOrId)] });
+            const relItems: any[] = (relList as any).tables || [];
+            if (relItems[0]?.$id) {
+              relId = relItems[0].$id;
+              nameToIdMapping.set(relNameOrId, relId);
+            }
+          } catch {}
+        }
+        if (relId && typeof relId === 'string') attr.relatedCollection = relId;
+      }
+      const tableInfo2 = await adapter.getTable({ databaseId, tableId });
+      const existingCols2: any[] = (tableInfo2 as any).data?.columns || (tableInfo2 as any).data?.attributes || [];
+      const { toCreate: relCreate, toUpdate: relUpdate, unchanged: relUnchanged } = diffTableColumns(existingCols2, rels as any);
+
+      // Relationship plan with icons
+      {
+        const parts: string[] = [];
+        if (relCreate.length) parts.push(`➕  ${relCreate.length} (${relCreate.map((a:any)=>a.key).join(', ')})`);
+        if (relUpdate.length) parts.push(`🔧  ${relUpdate.length} (${relUpdate.map((a:any)=>a.key).join(', ')})`);
+        if (relUnchanged.length) parts.push(`⏭️  ${relUnchanged.length}`);
+        MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Relationships' });
+      }
+      for (const attr of relUpdate) { try { await updateAttr(tableId, attr as Attribute); } catch (e) { MessageFormatter.error(`Failed to update relationship ${(attr as any).key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' }); } }
+      for (const attr of relCreate) { try { await createAttr(tableId, attr as Attribute); } catch (e) { MessageFormatter.error(`Failed to create relationship ${(attr as any).key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' }); } }
+    }
+
+    // Wait for all attributes to become available before creating indexes
+    const allAttrKeys = [
+      ...nonRel.map((a: any) => a.key),
+      ...rels.filter((a: any) => a.relatedCollection).map((a: any) => a.key)
+    ];
+
+    if (allAttrKeys.length > 0) {
+      for (const attrKey of allAttrKeys) {
+        const maxWait = 60000; // 60 seconds
+        const startTime = Date.now();
+        let lastStatus = '';
+
+        while (Date.now() - startTime < maxWait) {
+          try {
+            const tableData = await adapter.getTable({ databaseId, tableId });
+            const attrs = (tableData as any).data?.columns || (tableData as any).data?.attributes || [];
+            const attr = attrs.find((a: any) => a.key === attrKey);
+
+            if (attr) {
+              if (attr.status === 'available') {
+                break; // Attribute is ready
+              }
+              if (attr.status === 'failed' || attr.status === 'stuck') {
+                throw new Error(`Attribute ${attrKey} failed to create: ${attr.error || 'unknown error'}`);
+              }
+              // Still processing, continue waiting
+              lastStatus = attr.status;
+            }
+
+            await delay(2000); // Check every 2 seconds
+          } catch (e) {
+            // If we can't check status, assume it's processing and continue
+            await delay(2000);
+          }
+        }
+
+        // Timeout check
+        if (Date.now() - startTime >= maxWait) {
+          MessageFormatter.warning(
+            `Attribute ${attrKey} did not become available within ${maxWait / 1000}s (last status: ${lastStatus}). Proceeding anyway.`,
+            { prefix: 'Attributes' }
+          );
+        }
+      }
+    }
+
+    // Prefer local config indexes, but fall back to collection's own indexes if no local config exists (TablesDB path)
+    const localTableConfig = config.collections?.find(
+      c => c.name === collectionData.name || c.$id === collectionData.$id
+    );
+    const idxs = (localTableConfig?.indexes ?? indexes ?? []) as any[];
+    // Compare with existing indexes and create/update accordingly with status checks
+    try {
+      const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
+      const existingIdx: any[] = (existingIdxRes as any).data || (existingIdxRes as any).indexes || [];
+      MessageFormatter.debug(`Existing index keys: ${existingIdx.map((i:any)=>i.key).join(', ')}`, undefined, { prefix: 'Indexes' });
+      // Show a concise plan with icons before executing
+      const idxPlanPlus: string[] = [];
+      const idxPlanPlusMinus: string[] = [];
+      const idxPlanSkip: string[] = [];
+      for (const idx of idxs) {
+        const found = existingIdx.find((i: any) => i.key === idx.key);
+        if (found) {
+          if (isIndexEqualToIndex(found, idx)) idxPlanSkip.push(idx.key);
+          else idxPlanPlusMinus.push(idx.key);
+        } else idxPlanPlus.push(idx.key);
+      }
+      const planParts: string[] = [];
+      if (idxPlanPlus.length) planParts.push(`➕  ${idxPlanPlus.length} (${idxPlanPlus.join(', ')})`);
+      if (idxPlanPlusMinus.length) planParts.push(`🔧  ${idxPlanPlusMinus.length} (${idxPlanPlusMinus.join(', ')})`);
+      if (idxPlanSkip.length) planParts.push(`⏭️  ${idxPlanSkip.length}`);
+      MessageFormatter.info(`Plan → ${planParts.join('  |  ') || 'no changes'}`, { prefix: 'Indexes' });
+      const created: string[] = [];
+      const updated: string[] = [];
+      const skipped: string[] = [];
+      for (const idx of idxs) {
+        const found = existingIdx.find((i: any) => i.key === idx.key);
+        if (found) {
+          if (isIndexEqualToIndex(found, idx)) {
+            MessageFormatter.info(`Index ${idx.key} unchanged`, { prefix: 'Indexes' });
+            skipped.push(idx.key);
+          } else {
+            try { await adapter.deleteIndex({ databaseId, tableId, key: idx.key }); await delay(100); } catch {}
+            try {
+              await adapter.createIndex({ databaseId, tableId, key: idx.key, type: idx.type, attributes: idx.attributes, orders: idx.orders || [] });
+              updated.push(idx.key);
+            } catch (e: any) {
+              const msg = (e?.message || '').toString().toLowerCase();
+              if (msg.includes('already exists')) {
+                MessageFormatter.info(`Index ${idx.key} already exists after delete attempt, skipping`, { prefix: 'Indexes' });
+                skipped.push(idx.key);
+              } else {
+                throw e;
+              }
+            }
+          }
+        } else {
+          try {
+            await adapter.createIndex({ databaseId, tableId, key: idx.key, type: idx.type, attributes: idx.attributes, orders: idx.orders || [] });
+            created.push(idx.key);
+          } catch (e: any) {
+            const msg = (e?.message || '').toString().toLowerCase();
+            if (msg.includes('already exists')) {
+              MessageFormatter.info(`Index ${idx.key} already exists (create), skipping`, { prefix: 'Indexes' });
+              skipped.push(idx.key);
+            } else {
+              throw e;
+            }
+          }
+        }
+        // Wait for index availability
+        const maxWait = 60000; const start = Date.now(); let lastStatus = '';
+        while (Date.now() - start < maxWait) {
+          try {
+            const li = await adapter.listIndexes({ databaseId, tableId });
+            const list: any[] = (li as any).data || (li as any).indexes || [];
+            const cur = list.find((i: any) => i.key === idx.key);
+            if (cur) {
+              if (cur.status === 'available') break;
+              if (cur.status === 'failed' || cur.status === 'stuck') { throw new Error(cur.error || `Index ${idx.key} failed`); }
+              lastStatus = cur.status;
+            }
+            await delay(2000);
+          } catch { await delay(2000); }
+        }
+        await delay(150);
+      }
+      MessageFormatter.info(`Summary → ➕  ${created.length}  |  🔧  ${updated.length}  |  ⏭️  ${skipped.length}` , { prefix: 'Indexes' });
+    } 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: 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 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) {
+    MessageFormatter.info(`🔧 Processing ${relQueue.length} queued relationship attributes for tables`, { prefix: "Tables" });
+    for (const { tableId, attr } of relQueue) {
+      const relNameOrId = (attr as any).relatedCollection as string | undefined;
+      if (!relNameOrId) continue;
+      const relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+      if (relId) {
+        (attr as any).relatedCollection = relId;
+        try {
+          await adapter.createAttribute({
+            databaseId,
+            tableId,
+            key: (attr as any).key,
+            type: (attr as any).type,
+            size: (attr as any).size,
+            required: !!(attr as any).required,
+            default: (attr as any).xdefault,
+            array: !!(attr as any).array,
+            min: (attr as any).min,
+            max: (attr as any).max,
+            elements: (attr as any).elements,
+            relatedCollection: relId,
+            relationType: (attr as any).relationType,
+            twoWay: (attr as any).twoWay,
+            twoWayKey: (attr as any).twoWayKey,
+            onDelete: (attr as any).onDelete,
+            side: (attr as any).side
+          });
+          await delay(150);
+          MessageFormatter.info(`✅ Successfully processed queued relationship: ${attr.key}`, { prefix: "Tables" });
+        } catch (e) {
+          MessageFormatter.error(`Failed queued relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+        }
+      } else {
+        MessageFormatter.warning(`Could not resolve relationship ${attr.key} -> ${relNameOrId}`, { prefix: "Tables" });
+      }
+    }
+  }
+};
+
+export const generateMockData = async (
+  database: Databases,
+  databaseId: string,
+  configCollections: any[]
+): Promise<void> => {
+  for (const { collection, mockFunction } of configCollections) {
+    if (mockFunction) {
+      MessageFormatter.progress(`Generating mock data for collection: ${collection.name}`, { prefix: "Mock Data" });
+      const mockData = mockFunction();
+      for (const data of mockData) {
+        await database.createDocument(
+          databaseId,
+          collection.$id,
+          ID.unique(),
+          data
+        );
+      }
+    }
+  }
+};
+
+export const fetchAllCollections = async (
+  dbId: string,
+  database: Databases
+): Promise<Models.Collection[]> => {
+  MessageFormatter.progress(`Fetching all collections for database ID: ${dbId}`, { prefix: "Collections" });
+  let collections: Models.Collection[] = [];
+  let moreCollections = true;
+  let lastCollectionId: string | undefined;
+
+  while (moreCollections) {
+    const queries = [Query.limit(500)];
+    if (lastCollectionId) {
+      queries.push(Query.cursorAfter(lastCollectionId));
+    }
+    const response = await tryAwaitWithRetry(
+      async () => await database.listCollections(dbId, queries)
+    );
+    collections = collections.concat(response.collections);
+    moreCollections = response.collections.length === 500;
+    if (moreCollections) {
+      lastCollectionId =
+        response.collections[response.collections.length - 1].$id;
+    }
+  }
+
+  MessageFormatter.success(`Fetched a total of ${collections.length} collections`, { prefix: "Collections" });
+  return collections;
+};