@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/dist/cli/commands/storageCommands.js

@@ -1,10 +1,9 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { Storage, Permission, Role, Compression } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 import { listBuckets, createBucket as createBucketApi, deleteBucket as deleteBucketApi } from "../../storage/methods.js";
-import { writeYamlConfig } from "../../config/yamlConfig.js";
-import { ConfigManager } from "../../config/ConfigManager.js";
+import { writeYamlConfig, ConfigManager } from "@njdamstra/appwrite-utils-helpers";
 export const storageCommands = {
     async createBucket(cli) {
         const storage = cli.controller.storage;

package/dist/cli/commands/transferCommands.js

@@ -1,9 +1,9 @@
 import inquirer from "inquirer";
 import { Databases, Storage } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
-import { getClient } from "../../utils/getClientFromConfig.js";
+import { getClient } from "@njdamstra/appwrite-utils-helpers";
 import { ComprehensiveTransfer } from "../../migrations/comprehensiveTransfer.js";
 export const transferCommands = {
     async transferData(cli) {
@@ -91,9 +91,7 @@ export const transferCommands = {
             fromDb,
             targetDb,
             isRemote,
-            collections: selectedCollections.length > 0
-                ? selectedCollections.map((c) => c.$id)
-                : undefined,
+            collections: selectedCollections.map((c) => c.$id),
             sourceBucket,
             targetBucket,
         };

package/dist/collections/attributes.d.ts

@@ -1,6 +1,6 @@
 import { type Databases, type Models } from "node-appwrite";
 import { type Attribute } from "@njdamstra/appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Enhanced attribute creation with proper status monitoring and retry logic
  */

package/dist/collections/attributes.js

@@ -1,12 +1,10 @@
 import { Query } from "node-appwrite";
 import { attributeSchema, parseAttribute, } from "@njdamstra/appwrite-utils";
 import { nameToIdMapping, enqueueOperation, markAttributeProcessed, isAttributeProcessed, } from "../shared/operationQueue.js";
-import { delay, tryAwaitWithRetry, calculateExponentialBackoff, } from "../utils/helperFunctions.js";
+import { delay, tryAwaitWithRetry, calculateExponentialBackoff, } from "@njdamstra/appwrite-utils-helpers";
 import chalk from "chalk";
 import { Decimal } from "decimal.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { isDatabaseAdapter } from "../utils/typeGuards.js";
+import { logger, MessageFormatter, isDatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 // Extreme values that Appwrite may return, which should be treated as undefined
 const EXTREME_MIN_INTEGER = -9223372036854776000;
 const EXTREME_MAX_INTEGER = 9223372036854776000;
@@ -439,6 +437,39 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
                 ? attribute.xdefault
                 : undefined, attribute.array || false);
             break;
+        case "varchar":
+            await db.createVarcharAttribute(dbId, collectionId, attribute.key, attribute.size || 255, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false, attribute.encrypt);
+            break;
+        case "text":
+        case "mediumtext":
+        case "longtext": {
+            const createFn = attribute.type === "text"
+                ? db.createTextAttribute.bind(db)
+                : attribute.type === "mediumtext"
+                    ? db.createMediumtextAttribute.bind(db)
+                    : db.createLongtextAttribute.bind(db);
+            await createFn(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false, attribute.encrypt);
+            break;
+        }
+        case "point":
+            await db.createPointAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined);
+            break;
+        case "line":
+            await db.createLineAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined);
+            break;
+        case "polygon":
+            await db.createPolygonAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined);
+            break;
         case "relationship":
             await db.createRelationshipAttribute(dbId, collectionId, attribute.relatedCollection, attribute.relationType, attribute.twoWay, attribute.key, attribute.twoWayKey, attribute.onDelete);
             break;
@@ -448,6 +479,10 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
                 type: attribute.type,
                 supportedTypes: [
                     "string",
+                    "varchar",
+                    "text",
+                    "mediumtext",
+                    "longtext",
                     "integer",
                     "double",
                     "float",
@@ -457,6 +492,9 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
                     "ip",
                     "url",
                     "enum",
+                    "point",
+                    "line",
+                    "polygon",
                     "relationship",
                 ],
                 operation: "createLegacyAttribute",
@@ -474,12 +512,6 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
  * Legacy attribute update using type-specific methods
  */
 const updateLegacyAttribute = async (db, dbId, collectionId, attribute) => {
-    console.log(`DEBUG updateLegacyAttribute before normalizeMinMaxValues:`, {
-        key: attribute.key,
-        type: attribute.type,
-        min: attribute.min,
-        max: attribute.max
-    });
     const { min: normalizedMin, max: normalizedMax } = normalizeMinMaxValues(attribute);
     switch (attribute.type) {
         case "string":
@@ -534,6 +566,39 @@ const updateLegacyAttribute = async (db, dbId, collectionId, attribute) => {
                 ? attribute.xdefault
                 : null);
             break;
+        case "varchar":
+            await db.updateVarcharAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null, attribute.size);
+            break;
+        case "text":
+        case "mediumtext":
+        case "longtext": {
+            const updateFn = attribute.type === "text"
+                ? db.updateTextAttribute.bind(db)
+                : attribute.type === "mediumtext"
+                    ? db.updateMediumtextAttribute.bind(db)
+                    : db.updateLongtextAttribute.bind(db);
+            await updateFn(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
+            break;
+        }
+        case "point":
+            await db.updatePointAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
+            break;
+        case "line":
+            await db.updateLineAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
+            break;
+        case "polygon":
+            await db.updatePolygonAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
+            break;
         case "relationship":
             await db.updateRelationshipAttribute(dbId, collectionId, attribute.key, attribute.onDelete);
             break;
@@ -687,12 +752,22 @@ const getComparableFields = (type) => {
     switch (type) {
         case "string":
             return [...baseFields, "size", "encrypt"];
+        case "varchar":
+            return [...baseFields, "size", "encrypt"];
+        case "text":
+        case "mediumtext":
+        case "longtext":
+            return [...baseFields, "encrypt"];
         case "integer":
         case "double":
         case "float":
             return [...baseFields, "min", "max"];
         case "enum":
             return [...baseFields, "elements"];
+        case "point":
+        case "line":
+        case "polygon":
+            return baseFields;
         case "relationship":
             return [
                 ...baseFields,
@@ -981,35 +1056,10 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         // MessageFormatter.info(
         //   `Updating attribute with same key ${attribute.key} but different values`
         // );
-        // DEBUG: Log before object merge to detect corruption
-        if ((attribute.key === 'conversationType' || attribute.key === 'messageStreakCount')) {
-            console.log(`[DEBUG] MERGE - key="${attribute.key}"`, {
-                found: {
-                    elements: foundAttribute?.elements,
-                    min: foundAttribute?.min,
-                    max: foundAttribute?.max
-                },
-                desired: {
-                    elements: attribute?.elements,
-                    min: attribute?.min,
-                    max: attribute?.max
-                }
-            });
-        }
         finalAttribute = {
             ...foundAttribute,
             ...attribute,
         };
-        // DEBUG: Log after object merge to detect corruption
-        if ((finalAttribute.key === 'conversationType' || finalAttribute.key === 'messageStreakCount')) {
-            console.log(`[DEBUG] AFTER_MERGE - key="${finalAttribute.key}"`, {
-                merged: {
-                    elements: finalAttribute?.elements,
-                    min: finalAttribute?.min,
-                    max: finalAttribute?.max
-                }
-            });
-        }
         action = "update";
     }
     else if (!updateEnabled &&

package/dist/collections/indexes.js

@@ -1,8 +1,6 @@
 import { indexSchema } from "@njdamstra/appwrite-utils";
-import { Databases, IndexType, Query } from "node-appwrite";
-import { delay, tryAwaitWithRetry, calculateExponentialBackoff } from "../utils/helperFunctions.js";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { Databases, IndexType, OrderBy, Query } from "node-appwrite";
+import { delay, tryAwaitWithRetry, calculateExponentialBackoff, isLegacyDatabases, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 // System attributes that are always available for indexing in Appwrite
 const SYSTEM_ATTRIBUTES = ['$id', '$createdAt', '$updatedAt', '$permissions'];
 /**

package/dist/collections/methods.d.ts

@@ -1,6 +1,6 @@
 import { Databases, type Models } from "node-appwrite";
 import type { AppwriteConfig, CollectionCreate } from "@njdamstra/appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 export { wipeDatabase, wipeCollection, wipeAllTables, wipeTableRows, } from "./wipeOperations.js";
 export { transferDocumentsBetweenDbsLocalToLocal, transferDocumentsBetweenDbsLocalToRemote, } from "./transferOperations.js";
 export declare const documentExists: (db: Databases | DatabaseAdapter, dbId: string, targetCollectionId: string, toCreateObject: any) => Promise<Models.Document | null>;

package/dist/collections/methods.js

@@ -1,15 +1,14 @@
 import { Databases, ID, Permission, Query, } from "node-appwrite";
-import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
-import { nameToIdMapping, processQueue, queuedOperations, clearProcessingState, isCollectionProcessed, markCollectionProcessed } from "../shared/operationQueue.js";
-import { logger } from "../shared/logging.js";
+import { getAdapterFromConfig } from "@njdamstra/appwrite-utils-helpers";
+import { nameToIdMapping, processQueue, queuedOperations, clearProcessingState, isCollectionProcessed, markCollectionProcessed, enqueueOperation } from "../shared/operationQueue.js";
+import { logger, SchemaGenerator } from "@njdamstra/appwrite-utils-helpers";
 // 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 { delay, tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
+import { MessageFormatter, mapToCreateAttributeParams, mapToUpdateAttributeParams } from "@njdamstra/appwrite-utils-helpers";
+import { isLegacyDatabases } from "@njdamstra/appwrite-utils-helpers";
 import { diffTableColumns, isIndexEqualToIndex, diffColumnsDetailed, executeColumnOperations } from "./tableOperations.js";
+import { createOrUpdateIndexesViaAdapter, deleteObsoleteIndexesViaAdapter } from "../tables/indexManager.js";
 // Re-export wipe operations
 export { wipeDatabase, wipeCollection, wipeAllTables, wipeTableRows, } from "./wipeOperations.js";
 // Re-export transfer operations
@@ -287,63 +286,106 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
             }
             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) => a.type === 'relationship');
-        if (rels.length > 0) {
-            for (const attr of rels) {
+        // Relationship attributes — resolve relatedCollection to ID, then diff and create/update with recreate support
+        const relsAll = (attributes || []).filter((a) => a.type === 'relationship');
+        if (relsAll.length > 0) {
+            const relsResolved = [];
+            const relsDeferred = [];
+            // 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;
                 if (!relNameOrId)
                     continue;
                 let relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
-                if (!nameToIdMapping.has(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 = relList.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.data?.$id) {
+                                nameToIdMapping.set(relNameOrId, relNameOrId);
+                                relId = relNameOrId;
+                                resolved = true;
+                            }
+                        }
+                        catch { }
+                    }
                 }
-                if (relId && typeof relId === 'string')
+                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 = tableInfo2.data?.columns || tableInfo2.data?.attributes || [];
-            const { toCreate: relCreate, toUpdate: relUpdate, unchanged: relUnchanged } = diffTableColumns(existingCols2, rels);
-            // Relationship plan with icons
+            const relPlan = diffColumnsDetailed(relsResolved, existingCols2);
+            // Relationship plan with icons (includes recreates)
             {
                 const parts = [];
-                if (relCreate.length)
-                    parts.push(`➕  ${relCreate.length} (${relCreate.map((a) => a.key).join(', ')})`);
-                if (relUpdate.length)
-                    parts.push(`🔧  ${relUpdate.length} (${relUpdate.map((a) => a.key).join(', ')})`);
-                if (relUnchanged.length)
-                    parts.push(`⏭️  ${relUnchanged.length}`);
+                if (relPlan.toCreate.length)
+                    parts.push(`➕  ${relPlan.toCreate.length} (${relPlan.toCreate.map((a) => a.key).join(', ')})`);
+                if (relPlan.toUpdate.length)
+                    parts.push(`🔧  ${relPlan.toUpdate.length} (${relPlan.toUpdate.map((u) => u.attribute?.key ?? u.key).join(', ')})`);
+                if (relPlan.toRecreate.length)
+                    parts.push(`♻️  ${relPlan.toRecreate.length} (${relPlan.toRecreate.map((r) => r.newAttribute?.key ?? r?.key).join(', ')})`);
+                if (relPlan.unchanged.length)
+                    parts.push(`⏭️  ${relPlan.unchanged.length}`);
                 MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Relationships' });
             }
-            for (const attr of relUpdate) {
-                try {
-                    await updateAttr(tableId, attr);
+            // 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' });
                 }
-                catch (e) {
-                    MessageFormatter.error(`Failed to update relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+                else {
+                    MessageFormatter.success(`Processed ${relResults.success.length} relationship${relResults.success.length === 1 ? '' : 's'}`, { prefix: 'Relationships' });
                 }
             }
-            for (const attr of relCreate) {
-                try {
-                    await createAttr(tableId, attr);
-                }
-                catch (e) {
-                    MessageFormatter.error(`Failed to create relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+            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) => a.key),
-            ...rels.filter((a) => a.relatedCollection).map((a) => a.key)
+            ...relsAll.filter((a) => a.relatedCollection).map((a) => a.key)
         ];
         if (allAttrKeys.length > 0) {
             for (const attrKey of allAttrKeys) {
@@ -378,171 +420,37 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 }
             }
         }
-        // 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 ?? []);
-        // Compare with existing indexes and create/update accordingly with status checks
-        try {
-            const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
-            const existingIdx = existingIdxRes.data || existingIdxRes.indexes || [];
-            MessageFormatter.debug(`Existing index keys: ${existingIdx.map((i) => i.key).join(', ')}`, undefined, { prefix: 'Indexes' });
-            // Show a concise plan with icons before executing
-            const idxPlanPlus = [];
-            const idxPlanPlusMinus = [];
-            const idxPlanSkip = [];
-            for (const idx of idxs) {
-                const found = existingIdx.find((i) => 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 = [];
-            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 = [];
-            const updated = [];
-            const skipped = [];
-            for (const idx of idxs) {
-                const found = existingIdx.find((i) => 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) {
-                            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) {
-                        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 = li.data || li.indexes || [];
-                        const cur = list.find((i) => 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) => 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' });
-        }
+        // Create/update indexes with proper planning and execution
+        await createOrUpdateIndexesViaAdapter(adapter, databaseId, tableId, idxs, indexes);
+        // Handle obsolete index deletions
+        const desiredIndexKeys = new Set((indexes || []).map((i) => i.key));
+        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) => a.key));
+            // Also track case-insensitive keys to avoid double-deletion of renames (handled as recreates)
+            const desiredKeysLower = new Set((attributes || []).map((a) => a.key?.toLowerCase()));
             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))
+                .filter((col) => {
+                if (!col?.key)
+                    return false;
+                // Exact match - keep it
+                if (desiredKeys.has(col.key))
+                    return false;
+                // Case-insensitive match (rename scenario) - already handled as recreate, don't delete again
+                if (desiredKeysLower.has(col.key?.toLowerCase()))
+                    return false;
+                // Don't delete child-side relationship attributes - they're auto-managed by Appwrite
+                // for two-way relationships and deleting them would break the parent relationship
+                if (col.type === 'relationship' && col.side === 'child')
+                    return false;
+                return true;
+            })
                 .map((col) => col.key);
             if (toDelete.length > 0) {
                 MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });
@@ -555,7 +463,9 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                             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 : [];
+                                const attrs = Array.isArray(idx.attributes)
+                                    ? idx.attributes
+                                    : (Array.isArray(idx.columns) ? idx.columns : []);
                                 if (attrs.includes(key)) {
                                     MessageFormatter.info(`🗑️  Deleting index '${idx.key}' referencing '${key}'`, { prefix: 'Indexes' });
                                     await adapter.deleteIndex({ databaseId, tableId, key: idx.key });
@@ -647,6 +557,15 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
             }
         }
     }
+    // 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 (database, databaseId, configCollections) => {
     for (const { collection, mockFunction } of configCollections) {

package/dist/collections/tableOperations.d.ts

@@ -45,6 +45,7 @@ export declare function isIndexEqualToIndex(a: any, b: any): boolean;
 /**
  * Enhanced version of columns diff with detailed change analysis
  * Order: desired first, then existing (matches internal usage here)
+ * Handles case-insensitive key matches as renames (recreates)
  */
 export declare function diffColumnsDetailed(desiredAttributes: Attribute[], existingColumns: any[]): ColumnOperationPlan;
 /**