appwrite-utils-cli 1.9.6 → 1.9.7

package/dist/adapters/AdapterFactory.d.ts

@@ -7,7 +7,7 @@
  */
 import type { AppwriteConfig } from "appwrite-utils";
 import { type ApiMode, type VersionDetectionResult } from "../utils/versionDetection.js";
-import type { DatabaseAdapter } from './DatabaseAdapter.js';
+import { type DatabaseAdapter } from './DatabaseAdapter.js';
 export interface AdapterFactoryConfig {
     appwriteEndpoint: string;
     appwriteProject: string;

package/dist/adapters/AdapterFactory.js

@@ -6,6 +6,7 @@
  * and provides a single entry point for all database operations.
  */
 import { detectAppwriteVersionCached, isVersionAtLeast } from "../utils/versionDetection.js";
+import { AdapterError } from './DatabaseAdapter.js';
 import { TablesDBAdapter } from './TablesDBAdapter.js';
 import { LegacyAdapter } from './LegacyAdapter.js';
 import { logger } from '../shared/logging.js';
@@ -161,36 +162,29 @@ export class AdapterFactory {
                 endpoint: config.appwriteEndpoint,
                 operation: 'createTablesDBAdapter'
             });
-            // Use pre-configured client or create session-aware client with TablesDB Client
-            let client;
-            if (config.preConfiguredClient) {
-                client = config.preConfiguredClient;
+            let client = new Client()
+                .setEndpoint(config.appwriteEndpoint)
+                .setProject(config.appwriteProject);
+            // Set authentication method with mode headers
+            // Prefer session with admin mode, fallback to API key with default mode
+            if (config.sessionCookie && isValidSessionCookie(config.sessionCookie)) {
+                client.setSession(config.sessionCookie);
+                client.headers['X-Appwrite-Mode'] = 'admin';
+                logger.debug('Using session authentication for TablesDB adapter', {
+                    project: config.appwriteProject,
+                    operation: 'createTablesDBAdapter'
+                });
+            }
+            else if (config.appwriteKey) {
+                client.setKey(config.appwriteKey);
+                client.headers['X-Appwrite-Mode'] = 'default';
+                logger.debug('Using API key authentication for TablesDB adapter', {
+                    project: config.appwriteProject,
+                    operation: 'createTablesDBAdapter'
+                });
             }
             else {
-                client = new Client()
-                    .setEndpoint(config.appwriteEndpoint)
-                    .setProject(config.appwriteProject);
-                // Set authentication method with mode headers
-                // Prefer session with admin mode, fallback to API key with default mode
-                if (config.sessionCookie && isValidSessionCookie(config.sessionCookie)) {
-                    client.setSession(config.sessionCookie);
-                    client.headers['X-Appwrite-Mode'] = 'admin';
-                    logger.debug('Using session authentication for TablesDB adapter', {
-                        project: config.appwriteProject,
-                        operation: 'createTablesDBAdapter'
-                    });
-                }
-                else if (config.appwriteKey) {
-                    client.setKey(config.appwriteKey);
-                    client.headers['X-Appwrite-Mode'] = 'default';
-                    logger.debug('Using API key authentication for TablesDB adapter', {
-                        project: config.appwriteProject,
-                        operation: 'createTablesDBAdapter'
-                    });
-                }
-                else {
-                    throw new Error("No authentication available for adapter");
-                }
+                throw new Error("No authentication available for adapter");
             }
             const adapter = new TablesDBAdapter(client);
             const totalDuration = Date.now() - startTime;
@@ -204,15 +198,36 @@ export class AdapterFactory {
         catch (error) {
             const errorDuration = Date.now() - startTime;
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            MessageFormatter.warning('Failed to create TablesDB adapter - falling back to legacy', { prefix: "Adapter" });
-            logger.warn('TablesDB adapter creation failed, falling back to legacy', {
-                error: errorMessage,
-                errorDuration,
-                endpoint: config.appwriteEndpoint,
-                operation: 'createTablesDBAdapter'
-            });
-            // Fallback to legacy adapter if TablesDB creation fails
-            return this.createLegacyAdapter(config);
+            // Analyze the error to determine if fallback is appropriate
+            const isAuthError = errorMessage.toLowerCase().includes('unauthorized') ||
+                errorMessage.toLowerCase().includes('forbidden') ||
+                errorMessage.toLowerCase().includes('invalid') ||
+                errorMessage.toLowerCase().includes('authentication');
+            const isVersionError = errorMessage.toLowerCase().includes('not found') ||
+                errorMessage.toLowerCase().includes('unsupported') ||
+                errorMessage.toLowerCase().includes('tablesdb');
+            // Only fallback to legacy if this is genuinely a TablesDB support issue
+            if (isVersionError) {
+                MessageFormatter.warning('TablesDB not supported on this server - using legacy adapter', { prefix: "Adapter" });
+                logger.warn('TablesDB not supported, falling back to legacy', {
+                    error: errorMessage,
+                    errorDuration,
+                    endpoint: config.appwriteEndpoint,
+                    operation: 'createTablesDBAdapter'
+                });
+                return this.createLegacyAdapter(config);
+            }
+            else {
+                // For auth or other errors, re-throw to surface the real problem
+                logger.error('TablesDB adapter creation failed with non-version error', {
+                    error: errorMessage,
+                    errorDuration,
+                    endpoint: config.appwriteEndpoint,
+                    operation: 'createTablesDBAdapter',
+                    isAuthError
+                });
+                throw new AdapterError(`TablesDB adapter creation failed: ${errorMessage}`, 'TABLESDB_ADAPTER_CREATION_FAILED', error instanceof Error ? error : undefined);
+            }
         }
     }
     /**

package/dist/adapters/DatabaseAdapter.d.ts

@@ -84,6 +84,7 @@ export interface CreateIndexParams {
     type: string;
     attributes: string[];
     orders?: string[];
+    lengths?: number[];
 }
 export interface ListIndexesParams {
     databaseId: string;

package/dist/adapters/LegacyAdapter.js

@@ -409,12 +409,15 @@ export class LegacyAdapter extends BaseAdapter {
                     break;
                 case 'enum':
                     const enumAttr = existingAttr;
-                    console.log('Updating enum attribute with params:', params);
+                    // Choose elements to send only when provided, otherwise preserve existing
+                    const provided = params.elements;
+                    const existing = enumAttr?.elements;
+                    const nextElements = (Array.isArray(provided) && provided.length > 0) ? provided : existing;
                     result = await this.databases.updateEnumAttribute({
                         databaseId: params.databaseId,
                         collectionId: params.tableId,
                         key: params.key,
-                        elements: enumAttr.elements || [],
+                        elements: nextElements,
                         required: params.required ?? enumAttr.required,
                         xdefault: params.default !== undefined ? params.default : enumAttr.default
                     });

package/dist/adapters/TablesDBAdapter.js

@@ -8,6 +8,7 @@
 import { IndexType, Query, RelationMutate, RelationshipType } from "node-appwrite";
 import { chunk } from "es-toolkit";
 import { BaseAdapter, AdapterError } from './DatabaseAdapter.js';
+import {} from 'appwrite-utils';
 import { TablesDB, Client } from "node-appwrite";
 /**
  * TablesDBAdapter implementation for native TablesDB API
@@ -156,8 +157,14 @@ export class TablesDBAdapter extends BaseAdapter {
     async listIndexes(params) {
         try {
             const result = await this.tablesDB.listIndexes(params);
+            // Normalize TablesDB response to expose a consistent 'attributes' array
+            const normalized = (result.indexes || []).map((idx) => ({
+                ...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
             };
         }
@@ -167,7 +174,15 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async createIndex(params) {
         try {
-            const result = await this.tablesDB.createIndex(params.databaseId, params.tableId, params.key, params.type, params.attributes, params.orders || []);
+            const result = await this.tablesDB.createIndex({
+                databaseId: params.databaseId,
+                tableId: params.tableId,
+                key: params.key,
+                type: params.type,
+                columns: params.attributes,
+                orders: params.orders || [],
+                lengths: params.lengths || [],
+            });
             return { data: result };
         }
         catch (error) {
@@ -338,7 +353,7 @@ export class TablesDBAdapter extends BaseAdapter {
             let result;
             // Use the appropriate updateXColumn method based on the column type
             // Cast column to proper Models type to access its specific properties
-            const columnType = column.type;
+            const columnType = (column.type === 'string' && !('format' in column)) || column.type !== 'string' ? column.type : 'enum';
             switch (columnType) {
                 case 'string':
                     const stringColumn = column;

package/dist/collections/attributes.js

@@ -474,12 +474,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":
@@ -981,35 +975,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/methods.js

@@ -10,6 +10,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 { wipeDatabase, wipeCollection, wipeAllTables, wipeTableRows, } from "./wipeOperations.js";
 // Re-export transfer operations
@@ -421,164 +422,14 @@ 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));
@@ -598,7 +449,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 });

package/dist/collections/tableOperations.js

@@ -90,11 +90,13 @@ export function normalizeAttributeToComparable(attr) {
     return base;
 }
 export function normalizeColumnToComparable(col) {
-    // 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.length > 0;
-    if (t === 'string' && hasElements)
+    const hasEnumFormat = (col?.format === 'enum');
+    if (t === 'string' && (hasElements || hasEnumFormat)) {
         t = 'enum';
+    }
     const base = {
         key: col?.key,
         type: t,
@@ -185,18 +187,27 @@ export function isIndexEqualToIndex(a, b) {
     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.columns) ? a.columns : []);
+    const attrsA = [...attrsAraw].sort();
+    const attrsB = Array.isArray(b.attributes)
+        ? [...b.attributes].sort()
+        : (Array.isArray(b.columns) ? [...b.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.directions) ? [...a.directions].sort() : []);
         const ordersB = [...b.orders].sort();
         if (ordersA.length !== ordersB.length)
             return false;
@@ -204,7 +215,6 @@ export function isIndexEqualToIndex(a, b) {
             if (ordersA[i] !== ordersB[i])
                 return false;
     }
-    // If only one side has orders, treat as equal (orders unspecified by user)
     return true;
 }
 /**
@@ -213,6 +223,7 @@ export function isIndexEqualToIndex(a, b) {
 function compareColumnProperties(oldColumn, newAttribute, columnType) {
     const changes = [];
     const t = String(columnType || newAttribute.type || '').toLowerCase();
+    const key = newAttribute?.key || 'unknown';
     const mutableProps = MUTABLE_PROPERTIES[t] || [];
     const immutableProps = IMMUTABLE_PROPERTIES[t] || [];
     const getNewVal = (prop) => {
@@ -233,8 +244,9 @@ function compareColumnProperties(oldColumn, newAttribute, columnType) {
         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)
+            if (!Array.isArray(newValue) || newValue.length === 0) {
                 newValue = oldValue;
+            }
         }
         if (Array.isArray(oldValue) && Array.isArray(newValue)) {
             if (oldValue.length !== newValue.length || oldValue.some((v, i) => v !== newValue[i])) {
@@ -260,7 +272,8 @@ function compareColumnProperties(oldColumn, newAttribute, columnType) {
     // 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.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 });
     }

package/dist/config/ConfigManager.js

@@ -3,6 +3,7 @@ import path from "path";
 import { ConfigDiscoveryService, ConfigLoaderService, ConfigMergeService, ConfigValidationService, SessionAuthService, } from "./services/index.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { logger } from "../shared/logging.js";
+import { detectAppwriteVersionCached } from "../utils/versionDetection.js";
 /**
  * Centralized configuration manager with intelligent caching and session management.
  *
@@ -178,6 +179,30 @@ export class ConfigManager {
                     `Run with reportValidation: true to see details.`);
             }
         }
+        // 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/dist/shared/attributeMapper.js

@@ -140,7 +140,7 @@ export function mapToCreateAttributeParams(attr, base) {
  * so we never send an empty elements array (preserve existing on server).
  */
 export function mapToUpdateAttributeParams(attr, base) {
-    const type = String(attr.type || "").toLowerCase();
+    const type = String((attr.type == 'string' && attr.format !== 'enum') || attr.type !== 'string' ? attr.type : 'enum').toLowerCase();
     const params = {
         databaseId: base.databaseId,
         tableId: base.tableId,

package/dist/tables/indexManager.d.ts

@@ -0,0 +1,65 @@
+import type { Index } from "appwrite-utils";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { Models } from "node-appwrite";
+export interface IndexOperation {
+    type: 'create' | 'update' | 'skip' | 'delete';
+    index: Index;
+    existingIndex?: Models.Index;
+    reason?: string;
+}
+export interface IndexOperationPlan {
+    toCreate: IndexOperation[];
+    toUpdate: IndexOperation[];
+    toSkip: IndexOperation[];
+    toDelete: IndexOperation[];
+}
+export interface IndexExecutionResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+    deleted: string[];
+    errors: Array<{
+        key: string;
+        error: string;
+    }>;
+    summary: {
+        total: number;
+        created: number;
+        updated: number;
+        skipped: number;
+        deleted: number;
+        errors: number;
+    };
+}
+/**
+ * Plan index operations by comparing desired indexes with existing ones
+ * Uses the existing isIndexEqualToIndex function for consistent comparison
+ */
+export declare function planIndexOperations(desiredIndexes: Index[], existingIndexes: Models.Index[]): IndexOperationPlan;
+/**
+ * Plan index deletions for indexes that exist but aren't in the desired configuration
+ */
+export declare function planIndexDeletions(desiredIndexKeys: Set<string>, existingIndexes: Models.Index[]): IndexOperation[];
+/**
+ * Execute index operations with proper error handling and status monitoring
+ */
+export declare function executeIndexOperations(adapter: DatabaseAdapter, databaseId: string, tableId: string, plan: IndexOperationPlan): Promise<IndexExecutionResult>;
+/**
+ * Execute index deletions with proper error handling
+ */
+export declare function executeIndexDeletions(adapter: DatabaseAdapter, databaseId: string, tableId: string, deletions: IndexOperation[]): Promise<{
+    deleted: string[];
+    errors: Array<{
+        key: string;
+        error: string;
+    }>;
+}>;
+/**
+ * Main function to create/update indexes via adapter
+ * This replaces the messy inline code in methods.ts
+ */
+export declare function createOrUpdateIndexesViaAdapter(adapter: DatabaseAdapter, databaseId: string, tableId: string, desiredIndexes: Index[], configIndexes?: Index[]): Promise<void>;
+/**
+ * Handle index deletions for obsolete indexes
+ */
+export declare function deleteObsoleteIndexesViaAdapter(adapter: DatabaseAdapter, databaseId: string, tableId: string, desiredIndexKeys: Set<string>): Promise<void>;