@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/src/collections/methods.ts

@@ -6,19 +6,19 @@ import {
   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 type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import { getAdapterFromConfig } from "@njdamstra/appwrite-utils-helpers";
 import {
   nameToIdMapping,
   processQueue,
   queuedOperations,
   clearProcessingState,
   isCollectionProcessed,
-  markCollectionProcessed
+  markCollectionProcessed,
+  enqueueOperation
 } from "../shared/operationQueue.js";
-import { logger } from "../shared/logging.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,
@@ -26,11 +26,11 @@ 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 { 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 {
@@ -375,45 +375,105 @@ export const createOrUpdateCollectionsViaAdapter = async (
       );
     }
 
-    // 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) {
+    // 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;
-        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: 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);
         }
-        if (relId && typeof relId === 'string') attr.relatedCollection = relId;
       }
+
+      // 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 { toCreate: relCreate, toUpdate: relUpdate, unchanged: relUnchanged } = diffTableColumns(existingCols2, rels as any);
+      const relPlan = diffColumnsDetailed(relsResolved as any, existingCols2);
 
-      // Relationship plan with icons
+      // Relationship plan with icons (includes recreates)
       {
         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}`);
+        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' });
       }
-      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' }); } }
+
+      // 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) {
@@ -456,144 +516,38 @@ 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' });
-    }
+    // 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));
+      // Also track case-insensitive keys to avoid double-deletion of renames (handled as recreates)
+      const desiredKeysLower = new Set((attributes || []).map((a: any) => a.key?.toLowerCase()));
       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))
+        .filter((col: any) => {
+          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: any) => col.key as string);
 
       if (toDelete.length > 0) {
@@ -607,7 +561,9 @@ export const createOrUpdateCollectionsViaAdapter = async (
               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 : [];
+                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 });
@@ -692,6 +648,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 (

package/src/collections/tableOperations.ts

@@ -1,5 +1,5 @@
 import type { Attribute } from "@njdamstra/appwrite-utils";
-import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "../shared/attributeMapper.js";
+import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "@njdamstra/appwrite-utils-helpers";
 import { Decimal } from "decimal.js";
 const EXTREME_BOUND = new Decimal('1e12');
 
@@ -32,6 +32,10 @@ interface ColumnOperationPlan {
 // Property configuration for different column types
 const MUTABLE_PROPERTIES = {
   string: ["required", "default", "size", "array"],
+  varchar: ["required", "default", "size", "array"],
+  text: ["required", "default", "array"],
+  mediumtext: ["required", "default", "array"],
+  longtext: ["required", "default", "array"],
   integer: ["required", "default", "min", "max", "array"],
   float: ["required", "default", "min", "max", "array"],
   double: ["required", "default", "min", "max", "array"],
@@ -41,11 +45,18 @@ const MUTABLE_PROPERTIES = {
   ip: ["required", "default", "array"],
   url: ["required", "default", "array"],
   enum: ["required", "default", "elements", "array"],
+  point: ["required", "default"],
+  line: ["required", "default"],
+  polygon: ["required", "default"],
   relationship: ["required", "default"],
 } as const;
 
 const IMMUTABLE_PROPERTIES = {
   string: ["encrypt", "key"],
+  varchar: ["encrypt", "key"],
+  text: ["encrypt", "key"],
+  mediumtext: ["encrypt", "key"],
+  longtext: ["encrypt", "key"],
   integer: ["encrypt", "key"],
   float: ["encrypt", "key"],
   double: ["encrypt", "key"],
@@ -55,11 +66,18 @@ const IMMUTABLE_PROPERTIES = {
   ip: ["key"],
   url: ["key"],
   enum: ["key"],
+  point: ["key"],
+  line: ["key"],
+  polygon: ["key"],
   relationship: ["key", "relatedCollection", "relationType", "twoWay", "twoWayKey", "onDelete"],
 } as const;
 
 const TYPE_CHANGE_REQUIRES_RECREATE = [
   "string",
+  "varchar",
+  "text",
+  "mediumtext",
+  "longtext",
   "integer",
   "float",
   "double",
@@ -69,6 +87,9 @@ const TYPE_CHANGE_REQUIRES_RECREATE = [
   "ip",
   "url",
   "enum",
+  "point",
+  "line",
+  "polygon",
   "relationship",
 ];
 
@@ -117,6 +138,13 @@ export function normalizeAttributeToComparable(attr: Attribute): ComparableColum
     base.size = (attr as any).size ?? 255;
     base.encrypt = !!((attr as any).encrypt);
   }
+  if (t === 'varchar') {
+    base.size = (attr as any).size ?? 255;
+    base.encrypt = !!((attr as any).encrypt);
+  }
+  if (t === 'text' || t === 'mediumtext' || t === 'longtext') {
+    base.encrypt = !!((attr as any).encrypt);
+  }
   if (t === 'integer' || t === 'float' || t === 'double') {
     const min = toNumber((attr as any).min);
     const max = toNumber((attr as any).max);
@@ -143,10 +171,13 @@ export function normalizeAttributeToComparable(attr: Attribute): ComparableColum
 }
 
 export function normalizeColumnToComparable(col: any): ComparableColumn {
-  // Detect enum surfaced as string+elements from server and normalize to enum for comparison
+  // Detect enum surfaced as string+elements or string+format:enum from server and normalize to enum for comparison
   let t = String((col?.type ?? col?.columnType ?? '')).toLowerCase();
   const hasElements = Array.isArray(col?.elements) && (col.elements as any[]).length > 0;
-  if (t === 'string' && hasElements) t = 'enum';
+  const hasEnumFormat = (col?.format === 'enum');
+  if (t === 'string' && (hasElements || hasEnumFormat)) {
+    t = 'enum';
+  }
   const base: ComparableColumn = {
     key: col?.key,
     type: t,
@@ -159,6 +190,13 @@ export function normalizeColumnToComparable(col: any): ComparableColumn {
     base.size = typeof col?.size === 'number' ? col.size : undefined;
     base.encrypt = !!col?.encrypt;
   }
+  if (t === 'varchar') {
+    base.size = typeof col?.size === 'number' ? col.size : undefined;
+    base.encrypt = !!col?.encrypt;
+  }
+  if (t === 'text' || t === 'mediumtext' || t === 'longtext') {
+    base.encrypt = !!col?.encrypt;
+  }
   if (t === 'integer' || t === 'float' || t === 'double') {
     // Preserve raw min/max without forcing extremes; compare with Decimal in shallowEqual
     const rawMin = (col as any)?.min;
@@ -227,21 +265,29 @@ export function isIndexEqualToIndex(a: any, b: any): boolean {
   if (String(a.type).toLowerCase() !== String(b.type).toLowerCase()) return false;
 
   // Compare attributes as sets (order-insensitive)
-  const attrsA = Array.isArray(a.attributes) ? [...a.attributes].sort() : [];
-  const attrsB = Array.isArray(b.attributes) ? [...b.attributes].sort() : [];
+  // Support TablesDB which returns 'columns' instead of 'attributes'
+  const attrsAraw = Array.isArray(a.attributes)
+    ? a.attributes
+    : (Array.isArray((a as any).columns) ? (a as any).columns : []);
+  const attrsA = [...attrsAraw].sort();
+  const attrsB = Array.isArray(b.attributes)
+    ? [...b.attributes].sort()
+    : (Array.isArray((b as any).columns) ? [...(b as any).columns].sort() : []);
   if (attrsA.length !== attrsB.length) return false;
   for (let i = 0; i < attrsA.length; i++) if (attrsA[i] !== attrsB[i]) return false;
 
-  // Orders are only considered if BOTH have orders defined
-  const hasOrdersA = Array.isArray(a.orders) && a.orders.length > 0;
-  const hasOrdersB = Array.isArray(b.orders) && b.orders.length > 0;
-  if (hasOrdersA && hasOrdersB) {
-    const ordersA = [...a.orders].sort();
+  // Orders are only considered if CONFIG (b) has orders defined
+  // This prevents false positives when Appwrite returns orders but user didn't specify them
+  const hasConfigOrders = Array.isArray(b.orders) && b.orders.length > 0;
+  if (hasConfigOrders) {
+    // Some APIs may expose 'directions' instead of 'orders'
+    const ordersA = Array.isArray(a.orders)
+      ? [...a.orders].sort()
+      : (Array.isArray((a as any).directions) ? [...(a as any).directions].sort() : []);
     const ordersB = [...b.orders].sort();
     if (ordersA.length !== ordersB.length) return false;
     for (let i = 0; i < ordersA.length; i++) if (ordersA[i] !== ordersB[i]) return false;
   }
-  // If only one side has orders, treat as equal (orders unspecified by user)
   return true;
 }
 
@@ -255,6 +301,8 @@ function compareColumnProperties(
 ): ColumnPropertyChange[] {
   const changes: ColumnPropertyChange[] = [];
   const t = String(columnType || (newAttribute as any).type || '').toLowerCase();
+  const key = newAttribute?.key || 'unknown';
+
   const mutableProps = (MUTABLE_PROPERTIES as any)[t] || [];
   const immutableProps = (IMMUTABLE_PROPERTIES as any)[t] || [];
 
@@ -274,7 +322,9 @@ function compareColumnProperties(
     let newValue = getNewVal(prop);
     // Special-case: enum elements empty/missing should not trigger updates
     if (t === 'enum' && prop === 'elements') {
-      if (!Array.isArray(newValue) || newValue.length === 0) newValue = oldValue;
+      if (!Array.isArray(newValue) || newValue.length === 0) {
+        newValue = oldValue;
+      }
     }
     if (Array.isArray(oldValue) && Array.isArray(newValue)) {
       if (oldValue.length !== newValue.length || oldValue.some((v: any, i: number) => v !== newValue[i])) {
@@ -300,11 +350,11 @@ function compareColumnProperties(
   // Type change requires recreate (normalize string+elements to enum on old side)
   const oldTypeRaw = String(oldColumn?.type || oldColumn?.columnType || '').toLowerCase();
   const oldHasElements = Array.isArray(oldColumn?.elements) && (oldColumn.elements as any[]).length > 0;
-  const oldType = oldTypeRaw === 'string' && oldHasElements ? 'enum' : oldTypeRaw;
+  const oldHasEnumFormat = (oldColumn?.format === 'enum');
+  const oldType = oldTypeRaw === 'string' && (oldHasElements || oldHasEnumFormat) ? 'enum' : oldTypeRaw;
   if (oldType && t && oldType !== t && TYPE_CHANGE_REQUIRES_RECREATE.includes(oldType)) {
     changes.push({ property: 'type', oldValue: oldType, newValue: t, requiresRecreate: true });
   }
-
   return changes;
 }
 
@@ -348,32 +398,53 @@ function analyzeColumnChanges(
 /**
  * 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 function diffColumnsDetailed(
   desiredAttributes: Attribute[],
   existingColumns: any[]
 ): ColumnOperationPlan {
+  // Exact key lookup (case-sensitive)
   const byKey = new Map((existingColumns || []).map((col: any) => [col?.key, col] as const));
+  // Case-insensitive key lookup for detecting renames
+  const byKeyLower = new Map((existingColumns || []).map((col: any) => [col?.key?.toLowerCase(), col] as const));
 
   const toCreate: Attribute[] = [];
   const toUpdate: Array<{ attribute: Attribute; changes: ColumnPropertyChange[] }> = [];
   const toRecreate: Array<{ oldAttribute: any; newAttribute: Attribute }> = [];
   const unchanged: string[] = [];
+  const handledExistingKeys = new Set<string>(); // Track which existing columns we've handled
 
   for (const attr of desiredAttributes || []) {
     const key = (attr as any)?.key;
-    const existing = key ? byKey.get(key) : undefined;
-    if (!existing) {
-      toCreate.push(attr);
+    if (!key) continue;
+
+    // First try exact match
+    const exactMatch = byKey.get(key);
+    if (exactMatch) {
+      handledExistingKeys.add(key);
+      const analysis = analyzeColumnChanges(exactMatch, attr);
+      if (!analysis.hasChanges) unchanged.push(analysis.columnKey);
+      else if (analysis.requiresRecreate) toRecreate.push({ oldAttribute: exactMatch, newAttribute: attr });
+      else toUpdate.push({ attribute: attr, changes: analysis.changes });
       continue;
     }
-    const analysis = analyzeColumnChanges(existing, attr);
-    if (!analysis.hasChanges) unchanged.push(analysis.columnKey);
-    else if (analysis.requiresRecreate) toRecreate.push({ oldAttribute: existing, newAttribute: attr });
-    else toUpdate.push({ attribute: attr, changes: analysis.changes });
+
+    // Check for case-insensitive match (rename scenario like oAuthAccounts -> oauthAccounts)
+    const caseInsensitiveMatch = byKeyLower.get(key.toLowerCase());
+    if (caseInsensitiveMatch && caseInsensitiveMatch.key !== key) {
+      // This is a rename - treat as recreate (delete old, create new)
+      handledExistingKeys.add(caseInsensitiveMatch.key);
+      toRecreate.push({ oldAttribute: caseInsensitiveMatch, newAttribute: attr });
+      continue;
+    }
+
+    // No match - it's a new attribute
+    toCreate.push(attr);
   }
 
   // Note: we keep toDelete empty for now (conservative behavior)
+  // Deletions are handled separately in methods.ts
   return { toCreate, toUpdate, toRecreate, toDelete: [], unchanged };
 }
 

package/src/collections/transferOperations.ts

@@ -4,12 +4,11 @@ import {
   ID,
   Query,
 } from "node-appwrite";
-import { tryAwaitWithRetry, delay, calculateExponentialBackoff } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry, delay, calculateExponentialBackoff, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { chunk } from "es-toolkit";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
-import { getAdapter } from "../utils/getClientFromConfig.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
+import { isLegacyDatabases } from "@njdamstra/appwrite-utils-helpers";
+import { getAdapter } from "@njdamstra/appwrite-utils-helpers";
 
 /**
  * Transfers all documents from one collection to another in a different database