appwrite-utils-cli 1.9.5 → 1.9.7

package/src/collections/methods.ts

@@ -14,10 +14,11 @@ import {
   queuedOperations,
   clearProcessingState,
   isCollectionProcessed,
-  markCollectionProcessed
+  markCollectionProcessed,
+  enqueueOperation
 } from "../shared/operationQueue.js";
 import { logger } from "../shared/logging.js";
-// Legacy attribute/index helpers removed in favor of unified adapter path
+// Legacy attribute/index helpers removed in favor of unified adapter path
 import { SchemaGenerator } from "../shared/schemaGenerator.js";
 import {
   isNull,
@@ -26,11 +27,12 @@ import {
   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";
+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";
+import { createOrUpdateIndexesViaAdapter, deleteObsoleteIndexesViaAdapter } from "../tables/indexManager.js";
 
 // Re-export wipe operations
 export {
@@ -176,34 +178,34 @@ export const fetchAndCacheCollectionByName = async (
   }
 };
 
-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
-  );
-};
+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 (
@@ -215,22 +217,22 @@ 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" });
-
-  // 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);
-  };
+  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 }[] = [];
@@ -238,11 +240,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 (per database)
-    if (collectionData.$id && isCollectionProcessed(collectionData.$id, databaseId)) {
-      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,176 +264,236 @@ export const createOrUpdateCollectionsViaAdapter = async (
       }
     }
 
-    // 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);
-    }
+    // 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' }); } }
-    }
+    // 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 with recreate support
+    const relsAll = (attributes || []).filter((a: Attribute) => a.type === 'relationship') as any[];
+    if (relsAll.length > 0) {
+      const relsResolved: any[] = [];
+      const relsDeferred: any[] = [];
+
+      // Resolve related collections (names -> IDs) using cache or lookup.
+      // If not resolvable yet (target table created later in the same push), queue for later.
+      for (const attr of relsAll) {
+        const relNameOrId = attr.relatedCollection as string | undefined;
+        if (!relNameOrId) continue;
+        let relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+        let resolved = false;
+        if (nameToIdMapping.has(relNameOrId)) {
+          resolved = true;
+        } else {
+          // Try resolve by name
+          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);
+              resolved = true;
+            }
+          } catch {}
+
+          // If the relNameOrId looks like an ID but isn't resolved yet, attempt a direct get
+          if (!resolved && relNameOrId && relNameOrId.length >= 10) {
+            try {
+              const probe = await adapter.getTable({ databaseId, tableId: relNameOrId });
+              if ((probe as any).data?.$id) {
+                nameToIdMapping.set(relNameOrId, relNameOrId);
+                relId = relNameOrId;
+                resolved = true;
+              }
+            } catch {}
+          }
+        }
+
+        if (resolved && relId && typeof relId === 'string') {
+          attr.relatedCollection = relId;
+          relsResolved.push(attr);
+        } else {
+          // Defer until related table exists; queue a surgical operation
+          enqueueOperation({
+            type: 'attribute',
+            collectionId: tableId,
+            attribute: attr,
+            dependencies: [relNameOrId]
+          });
+          relsDeferred.push(attr);
+        }
+      }
+
+      // Compute a detailed plan for immediately resolvable relationships
+      const tableInfo2 = await adapter.getTable({ databaseId, tableId });
+      const existingCols2: any[] = (tableInfo2 as any).data?.columns || (tableInfo2 as any).data?.attributes || [];
+      const relPlan = diffColumnsDetailed(relsResolved as any, existingCols2);
+
+      // Relationship plan with icons (includes recreates)
+      {
+        const parts: string[] = [];
+        if (relPlan.toCreate.length) parts.push(`➕  ${relPlan.toCreate.length} (${relPlan.toCreate.map((a:any)=>a.key).join(', ')})`);
+        if (relPlan.toUpdate.length) parts.push(`🔧  ${relPlan.toUpdate.length} (${relPlan.toUpdate.map((u:any)=>u.attribute?.key ?? u.key).join(', ')})`);
+        if (relPlan.toRecreate.length) parts.push(`♻️  ${relPlan.toRecreate.length} (${relPlan.toRecreate.map((r:any)=>r.newAttribute?.key ?? r?.key).join(', ')})`);
+        if (relPlan.unchanged.length) parts.push(`⏭️  ${relPlan.unchanged.length}`);
+        MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Relationships' });
+      }
+
+      // Execute plan using the same operation executor to properly handle deletes/recreates
+      const relResults = await executeColumnOperations(adapter, databaseId, tableId, relPlan);
+      if (relResults.success.length > 0) {
+        const totalRelationships = relPlan.toCreate.length + relPlan.toUpdate.length + relPlan.toRecreate.length + relPlan.unchanged.length;
+        const activeRelationships = relPlan.toCreate.length + relPlan.toUpdate.length + relPlan.toRecreate.length;
+
+        if (relResults.success.length !== activeRelationships) {
+          // Show both counts when they differ (usually due to recreations)
+          MessageFormatter.success(`Processed ${relResults.success.length} operations for ${activeRelationships} relationship${activeRelationships === 1 ? '' : 's'}`, { prefix: 'Relationships' });
+        } else {
+          MessageFormatter.success(`Processed ${relResults.success.length} relationship${relResults.success.length === 1 ? '' : 's'}`, { prefix: 'Relationships' });
+        }
+      }
+      if (relResults.errors.length > 0) {
+        MessageFormatter.error(`${relResults.errors.length} relationship operations failed:`, undefined, { prefix: 'Relationships' });
+        for (const err of relResults.errors) {
+          MessageFormatter.error(`  ${err.column}: ${err.error}`, undefined, { prefix: 'Relationships' });
+        }
+      }
+
+      if (relsDeferred.length > 0) {
+        MessageFormatter.info(`Deferred ${relsDeferred.length} relationship(s) until related tables become available`, { prefix: 'Relationships' });
+      }
+    }
 
     // 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)
+      ...relsAll.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 (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'}`);
               }
@@ -456,202 +518,86 @@ export const createOrUpdateCollectionsViaAdapter = async (
       }
     }
 
-    // Prefer local config indexes, but fall back to collection's own indexes if no local config exists (TablesDB path)
+    // Index management: create/update indexes using clean adapter-based system
     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);
-  }
+
+    // Create/update indexes with proper planning and execution
+    await createOrUpdateIndexesViaAdapter(adapter, databaseId, tableId, idxs, indexes);
+
+    // Handle obsolete index deletions
+    const desiredIndexKeys: Set<string> = new Set((indexes || []).map((i: any) => i.key as string));
+    await deleteObsoleteIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexKeys);
+
+    // 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
+                  : (Array.isArray((idx as any).columns) ? (idx as any).columns : []);
+                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) {
@@ -692,6 +638,15 @@ export const createOrUpdateCollectionsViaAdapter = async (
       }
     }
   }
+
+  // Process any remaining queued operations to complete relationship sync
+  try {
+    MessageFormatter.info(`🔄 Processing final operation queue for database ${databaseId}`, { prefix: "Tables" });
+    await processQueue(adapter, databaseId);
+    MessageFormatter.info(`✅ Operation queue processing completed`, { prefix: "Tables" });
+  } catch (error) {
+    MessageFormatter.error(`Failed to process operation queue`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Tables' });
+  }
 };
 
 export const generateMockData = async (