appwrite-utils-cli 1.9.6 → 1.9.7

package/src/adapters/TablesDBAdapter.ts

@@ -33,6 +33,7 @@ import {
   type AdapterMetadata,
   AdapterError
 } from './DatabaseAdapter.js';
+import { type Column } from 'appwrite-utils';
 import { TablesDB, Client } from "node-appwrite";
 
 /**
@@ -256,8 +257,14 @@ export class TablesDBAdapter extends BaseAdapter {
   async listIndexes(params: ListIndexesParams): Promise<ApiResponse> {
     try {
       const result = await this.tablesDB.listIndexes(params);
+      // Normalize TablesDB response to expose a consistent 'attributes' array
+      const normalized = (result.indexes || []).map((idx: any) => ({
+        ...idx,
+        attributes: Array.isArray(idx?.attributes) ? idx.attributes : (Array.isArray(idx?.columns) ? idx.columns : []),
+        orders: Array.isArray(idx?.orders) ? idx.orders : (Array.isArray(idx?.directions) ? idx.directions : []),
+      }));
       return {
-        data: result.indexes,
+        data: normalized,
         total: result.total
       };
     } catch (error) {
@@ -271,14 +278,15 @@ export class TablesDBAdapter extends BaseAdapter {
   
   async createIndex(params: CreateIndexParams): Promise<ApiResponse> {
     try {
-      const result = await this.tablesDB.createIndex(
-        params.databaseId,
-        params.tableId,
-        params.key,
-        params.type as IndexType,
-        params.attributes,
-        params.orders || []
-      );
+      const result = await this.tablesDB.createIndex({
+        databaseId: params.databaseId,
+        tableId: params.tableId,
+        key: params.key,
+        type: params.type as IndexType,
+        columns: params.attributes,
+        orders: params.orders || [],
+        lengths: params.lengths || [],
+      });
       return { data: result };
     } catch (error) {
       throw new AdapterError(
@@ -494,7 +502,7 @@ export class TablesDBAdapter extends BaseAdapter {
 
       // Use the appropriate updateXColumn method based on the column type
       // Cast column to proper Models type to access its specific properties
-      const columnType = (column as any).type;
+      const columnType = (column.type === 'string' && !('format' in column)) || column.type !== 'string' ? column.type : 'enum';
 
       switch (columnType) {
         case 'string':

package/src/collections/attributes.ts

@@ -651,13 +651,6 @@ const updateLegacyAttribute = async (
   collectionId: string,
   attribute: Attribute
 ): Promise<void> => {
-  console.log(`DEBUG updateLegacyAttribute before normalizeMinMaxValues:`, {
-    key: attribute.key,
-    type: attribute.type,
-    min: (attribute as any).min,
-    max: (attribute as any).max
-  });
-
   const { min: normalizedMin, max: normalizedMax } =
     normalizeMinMaxValues(attribute);
 
@@ -1515,37 +1508,10 @@ export const createOrUpdateAttribute = async (
     //   `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 as any)?.elements,
-          min: (foundAttribute as any)?.min,
-          max: (foundAttribute as any)?.max
-        },
-        desired: {
-          elements: (attribute as any)?.elements,
-          min: (attribute as any)?.min,
-          max: (attribute as any)?.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 as any)?.min,
-          max: (finalAttribute as any)?.max
-        }
-      });
-    }
     action = "update";
   } else if (
     !updateEnabled &&

package/src/collections/methods.ts

@@ -32,6 +32,7 @@ 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 {
@@ -517,136 +518,18 @@ 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 {
@@ -668,7 +551,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 });

package/src/collections/tableOperations.ts

@@ -143,10 +143,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,
@@ -227,21 +230,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 +266,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 +287,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 +315,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;
 }
 

package/src/config/ConfigManager.ts

@@ -14,6 +14,7 @@ import {
 } from "./services/index.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { logger } from "../shared/logging.js";
+import { detectAppwriteVersionCached, type ApiMode } from "../utils/versionDetection.js";
 
 /**
  * Database type from AppwriteConfig
@@ -297,6 +298,37 @@ export class ConfigManager {
       }
     }
 
+    // 8. Run version detection and set apiMode if not explicitly configured
+    if (!config.apiMode || config.apiMode === 'auto') {
+      try {
+        logger.debug('Running version detection for API mode detection', {
+          prefix: "ConfigManager",
+          endpoint: config.appwriteEndpoint
+        });
+
+        const versionResult = await detectAppwriteVersionCached(
+          config.appwriteEndpoint,
+          config.appwriteProject,
+          config.appwriteKey
+        );
+
+        config.apiMode = versionResult.apiMode;
+        logger.info(`API mode detected: ${config.apiMode}`, {
+          prefix: "ConfigManager",
+          method: versionResult.detectionMethod,
+          confidence: versionResult.confidence,
+          serverVersion: versionResult.serverVersion,
+        });
+
+      } catch (error) {
+        logger.warn('Version detection failed, defaulting to legacy mode', {
+          prefix: "ConfigManager",
+          error: error instanceof Error ? error.message : 'Unknown error',
+        });
+        config.apiMode = 'legacy';
+      }
+    }
+
     // 8. Cache the config
     this.cachedConfig = config;
     this.cachedConfigPath = configPath;

package/src/shared/attributeMapper.ts

@@ -161,7 +161,7 @@ export function mapToUpdateAttributeParams(
   attr: Attribute,
   base: { databaseId: string; tableId: string }
 ): UpdateAttributeParams {
-  const type = String((attr as any).type || "").toLowerCase();
+  const type = String((attr.type == 'string' && attr.format !== 'enum') || attr.type !== 'string' ? (attr as any).type : 'enum').toLowerCase();
   const params: UpdateAttributeParams = {
     databaseId: base.databaseId,
     tableId: base.tableId,