appwrite-utils-cli 1.9.5 → 1.9.7

package/src/adapters/AdapterFactory.ts

@@ -7,14 +7,14 @@
  */
 
 import type { AppwriteConfig } from "appwrite-utils";
-import { detectAppwriteVersionCached, isVersionAtLeast, type ApiMode, type VersionDetectionResult } from "../utils/versionDetection.js";
-import type { DatabaseAdapter } from './DatabaseAdapter.js';
-import { TablesDBAdapter } from './TablesDBAdapter.js';
-import { LegacyAdapter } from './LegacyAdapter.js';
-import { logger } from '../shared/logging.js';
-import { isValidSessionCookie } from '../utils/sessionAuth.js';
-import { MessageFormatter } from '../shared/messageFormatter.js';
-import { Client } from 'node-appwrite';
+import { detectAppwriteVersionCached, isVersionAtLeast, type ApiMode, type VersionDetectionResult } from "../utils/versionDetection.js";
+import { AdapterError, type DatabaseAdapter } from './DatabaseAdapter.js';
+import { TablesDBAdapter } from './TablesDBAdapter.js';
+import { LegacyAdapter } from './LegacyAdapter.js';
+import { logger } from '../shared/logging.js';
+import { isValidSessionCookie } from '../utils/sessionAuth.js';
+import { MessageFormatter } from '../shared/messageFormatter.js';
+import { Client } from 'node-appwrite';
 
 export interface AdapterFactoryConfig {
   appwriteEndpoint: string;
@@ -201,134 +201,153 @@ export class AdapterFactory {
   /**
    * Create TablesDB adapter with dynamic import
    */
-  private static async createTablesDBAdapter(
-    config: AdapterFactoryConfig
-  ): Promise<{ adapter: DatabaseAdapter; client: any }> {
-    const startTime = Date.now();
-
-    try {
-      logger.info('Creating TablesDB adapter (static SDK imports)', {
-        endpoint: config.appwriteEndpoint,
-        operation: 'createTablesDBAdapter'
-      });
-
-      // Use pre-configured client or create session-aware client with TablesDB Client
-      let client: any;
-      if (config.preConfiguredClient) {
-        client = config.preConfiguredClient;
-      } 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");
-        }
-      }
-
-      const adapter = new TablesDBAdapter(client);
-
-      const totalDuration = Date.now() - startTime;
-      logger.info('TablesDB adapter created successfully', {
-        totalDuration,
-        endpoint: config.appwriteEndpoint,
-        operation: 'createTablesDBAdapter'
-      });
-
-      return { adapter, client };
-
-    } 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,
+  private static async createTablesDBAdapter(
+    config: AdapterFactoryConfig
+  ): Promise<{ adapter: DatabaseAdapter; client: any }> {
+    const startTime = Date.now();
+
+    try {
+      logger.info('Creating TablesDB adapter (static SDK imports)', {
         endpoint: config.appwriteEndpoint,
         operation: 'createTablesDBAdapter'
       });
 
-      // Fallback to legacy adapter if TablesDB creation fails
-      return this.createLegacyAdapter(config);
+      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 {
+        throw new Error("No authentication available for adapter");
+      }
+
+      const adapter = new TablesDBAdapter(client);
+
+      const totalDuration = Date.now() - startTime;
+      logger.info('TablesDB adapter created successfully', {
+        totalDuration,
+        endpoint: config.appwriteEndpoint,
+        operation: 'createTablesDBAdapter'
+      });
+
+      return { adapter, client };
+
+    } catch (error) {
+      const errorDuration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      // 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
+        );
+      }
     }
   }
   
   /**
    * Create Legacy adapter with dynamic import
    */
-  private static async createLegacyAdapter(
-    config: AdapterFactoryConfig
-  ): Promise<{ adapter: DatabaseAdapter; client: any }> {
-    const startTime = Date.now();
-
-    try {
-      logger.info('Creating legacy adapter (static SDK imports)', {
-        endpoint: config.appwriteEndpoint,
-        operation: 'createLegacyAdapter'
-      });
-
-      // Use pre-configured client or create session-aware client with Legacy Client
-      let client: any;
-      if (config.preConfiguredClient) {
-        client = config.preConfiguredClient;
-      } 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 as any).setSession(config.sessionCookie);
-          client.headers['X-Appwrite-Mode'] = 'admin';
-          logger.debug('Using session authentication for Legacy adapter', {
-            project: config.appwriteProject,
-            operation: 'createLegacyAdapter'
-          });
-        } else if (config.appwriteKey) {
-          client.setKey(config.appwriteKey);
-          client.headers['X-Appwrite-Mode'] = 'default';
-          logger.debug('Using API key authentication for Legacy adapter', {
-            project: config.appwriteProject,
-            operation: 'createLegacyAdapter'
-          });
-        } else {
-          throw new Error("No authentication available for adapter");
-        }
-      }
-
-      const adapter = new LegacyAdapter(client);
-
-      const totalDuration = Date.now() - startTime;
-      logger.info('Legacy adapter created successfully', {
-        totalDuration,
-        endpoint: config.appwriteEndpoint,
-        operation: 'createLegacyAdapter'
-      });
-
-      return { adapter, client };
-
-    } catch (error) {
-      const errorDuration = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+  private static async createLegacyAdapter(
+    config: AdapterFactoryConfig
+  ): Promise<{ adapter: DatabaseAdapter; client: any }> {
+    const startTime = Date.now();
+
+    try {
+      logger.info('Creating legacy adapter (static SDK imports)', {
+        endpoint: config.appwriteEndpoint,
+        operation: 'createLegacyAdapter'
+      });
+
+      // Use pre-configured client or create session-aware client with Legacy Client
+      let client: any;
+      if (config.preConfiguredClient) {
+        client = config.preConfiguredClient;
+      } 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 as any).setSession(config.sessionCookie);
+          client.headers['X-Appwrite-Mode'] = 'admin';
+          logger.debug('Using session authentication for Legacy adapter', {
+            project: config.appwriteProject,
+            operation: 'createLegacyAdapter'
+          });
+        } else if (config.appwriteKey) {
+          client.setKey(config.appwriteKey);
+          client.headers['X-Appwrite-Mode'] = 'default';
+          logger.debug('Using API key authentication for Legacy adapter', {
+            project: config.appwriteProject,
+            operation: 'createLegacyAdapter'
+          });
+        } else {
+          throw new Error("No authentication available for adapter");
+        }
+      }
+
+      const adapter = new LegacyAdapter(client);
+
+      const totalDuration = Date.now() - startTime;
+      logger.info('Legacy adapter created successfully', {
+        totalDuration,
+        endpoint: config.appwriteEndpoint,
+        operation: 'createLegacyAdapter'
+      });
+
+      return { adapter, client };
+
+    } catch (error) {
+      const errorDuration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
 
       logger.error('Failed to load legacy Appwrite SDK', {
         error: errorMessage,
@@ -507,4 +526,4 @@ export async function getApiCapabilities(
     terminology: metadata.terminology,
     capabilities
   };
-}
+}

package/src/adapters/DatabaseAdapter.ts

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

package/src/adapters/LegacyAdapter.ts

@@ -597,12 +597,15 @@ export class LegacyAdapter extends BaseAdapter {
 
         case 'enum':
           const enumAttr = existingAttr as Models.AttributeEnum;
-          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 as any)?.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/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 &&