appwrite-utils-cli 1.9.6 → 1.9.7

package/dist/tables/indexManager.js

@@ -0,0 +1,294 @@
+import { isIndexEqualToIndex } from "../collections/tableOperations.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+/**
+ * Plan index operations by comparing desired indexes with existing ones
+ * Uses the existing isIndexEqualToIndex function for consistent comparison
+ */
+export function planIndexOperations(desiredIndexes, existingIndexes) {
+    const plan = {
+        toCreate: [],
+        toUpdate: [],
+        toSkip: [],
+        toDelete: []
+    };
+    for (const desiredIndex of desiredIndexes) {
+        const existingIndex = existingIndexes.find(idx => idx.key === desiredIndex.key);
+        if (!existingIndex) {
+            // Index doesn't exist - create it
+            plan.toCreate.push({
+                type: 'create',
+                index: desiredIndex,
+                reason: 'New index'
+            });
+        }
+        else if (isIndexEqualToIndex(existingIndex, desiredIndex)) {
+            // Index exists and is identical - skip it
+            plan.toSkip.push({
+                type: 'skip',
+                index: desiredIndex,
+                existingIndex,
+                reason: 'Index unchanged'
+            });
+        }
+        else {
+            // Index exists but is different - update it
+            plan.toUpdate.push({
+                type: 'update',
+                index: desiredIndex,
+                existingIndex,
+                reason: 'Index configuration changed'
+            });
+        }
+    }
+    return plan;
+}
+/**
+ * Plan index deletions for indexes that exist but aren't in the desired configuration
+ */
+export function planIndexDeletions(desiredIndexKeys, existingIndexes) {
+    const deletions = [];
+    for (const existingIndex of existingIndexes) {
+        if (!desiredIndexKeys.has(existingIndex.key)) {
+            deletions.push({
+                type: 'delete',
+                index: existingIndex, // Convert Models.Index to Index for compatibility
+                reason: 'Obsolete index'
+            });
+        }
+    }
+    return deletions;
+}
+/**
+ * Execute index operations with proper error handling and status monitoring
+ */
+export async function executeIndexOperations(adapter, databaseId, tableId, plan) {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+        deleted: [],
+        errors: [],
+        summary: {
+            total: 0,
+            created: 0,
+            updated: 0,
+            skipped: 0,
+            deleted: 0,
+            errors: 0
+        }
+    };
+    // Execute creates
+    for (const operation of plan.toCreate) {
+        try {
+            await adapter.createIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key,
+                type: operation.index.type,
+                attributes: operation.index.attributes,
+                orders: operation.index.orders || []
+            });
+            result.created.push(operation.index.key);
+            MessageFormatter.success(`Created index ${operation.index.key}`, { prefix: 'Indexes' });
+            // Wait for index to become available
+            await waitForIndexAvailable(adapter, databaseId, tableId, operation.index.key);
+            await delay(150); // Brief delay between operations
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push({ key: operation.index.key, error: errorMessage });
+            MessageFormatter.error(`Failed to create index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        }
+    }
+    // Execute updates (delete + recreate)
+    for (const operation of plan.toUpdate) {
+        try {
+            // Delete existing index first
+            await adapter.deleteIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key
+            });
+            await delay(100); // Brief delay for deletion to settle
+            // Create new index
+            await adapter.createIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key,
+                type: operation.index.type,
+                attributes: operation.index.attributes,
+                orders: operation.index.orders || operation.existingIndex?.orders || []
+            });
+            result.updated.push(operation.index.key);
+            MessageFormatter.success(`Updated index ${operation.index.key}`, { prefix: 'Indexes' });
+            // Wait for index to become available
+            await waitForIndexAvailable(adapter, databaseId, tableId, operation.index.key);
+            await delay(150); // Brief delay between operations
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push({ key: operation.index.key, error: errorMessage });
+            MessageFormatter.error(`Failed to update index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        }
+    }
+    // Execute skips
+    for (const operation of plan.toSkip) {
+        result.skipped.push(operation.index.key);
+        MessageFormatter.info(`Index ${operation.index.key} unchanged`, { prefix: 'Indexes' });
+    }
+    // Calculate summary
+    result.summary.total = result.created.length + result.updated.length + result.skipped.length + result.deleted.length;
+    result.summary.created = result.created.length;
+    result.summary.updated = result.updated.length;
+    result.summary.skipped = result.skipped.length;
+    result.summary.deleted = result.deleted.length;
+    result.summary.errors = result.errors.length;
+    return result;
+}
+/**
+ * Execute index deletions with proper error handling
+ */
+export async function executeIndexDeletions(adapter, databaseId, tableId, deletions) {
+    const result = {
+        deleted: [],
+        errors: []
+    };
+    for (const operation of deletions) {
+        try {
+            await adapter.deleteIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key
+            });
+            result.deleted.push(operation.index.key);
+            MessageFormatter.info(`Deleted obsolete index ${operation.index.key}`, { prefix: 'Indexes' });
+            // Wait briefly for deletion to settle
+            await delay(500);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push({ key: operation.index.key, error: errorMessage });
+            MessageFormatter.error(`Failed to delete index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        }
+    }
+    return result;
+}
+/**
+ * Wait for an index to become available with timeout and retry logic
+ * This is an adapter-aware version of the logic from collections/indexes.ts
+ */
+async function waitForIndexAvailable(adapter, databaseId, tableId, indexKey, maxWaitTime = 60000, // 1 minute
+checkInterval = 2000 // 2 seconds
+) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTime) {
+        try {
+            const indexList = await adapter.listIndexes({ databaseId, tableId });
+            const indexes = indexList.data || indexList.indexes || [];
+            const index = indexes.find((idx) => idx.key === indexKey);
+            if (!index) {
+                MessageFormatter.error(`Index '${indexKey}' not found after creation`, undefined, { prefix: 'Indexes' });
+                return false;
+            }
+            switch (index.status) {
+                case 'available':
+                    return true;
+                case 'failed':
+                    MessageFormatter.error(`Index '${indexKey}' failed: ${index.error || 'unknown error'}`, undefined, { prefix: 'Indexes' });
+                    return false;
+                case 'stuck':
+                    MessageFormatter.warning(`Index '${indexKey}' is stuck`, { prefix: 'Indexes' });
+                    return false;
+                case 'processing':
+                case 'deleting':
+                    // Continue waiting
+                    break;
+                default:
+                    MessageFormatter.warning(`Unknown status '${index.status}' for index '${indexKey}'`, { prefix: 'Indexes' });
+                    break;
+            }
+        }
+        catch (error) {
+            MessageFormatter.error(`Error checking index '${indexKey}' status: ${error}`, undefined, { prefix: 'Indexes' });
+        }
+        await delay(checkInterval);
+    }
+    MessageFormatter.warning(`Timeout waiting for index '${indexKey}' to become available (${maxWaitTime}ms)`, { prefix: 'Indexes' });
+    return false;
+}
+/**
+ * Main function to create/update indexes via adapter
+ * This replaces the messy inline code in methods.ts
+ */
+export async function createOrUpdateIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexes, configIndexes) {
+    if (!desiredIndexes || desiredIndexes.length === 0) {
+        MessageFormatter.info('No indexes to process', { prefix: 'Indexes' });
+        return;
+    }
+    MessageFormatter.info(`Processing ${desiredIndexes.length} indexes for table ${tableId}`, { prefix: 'Indexes' });
+    try {
+        // Get existing indexes
+        const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
+        const existingIndexes = existingIdxRes.data || existingIdxRes.indexes || [];
+        // Plan operations
+        const plan = planIndexOperations(desiredIndexes, existingIndexes);
+        // Show plan with icons (consistent with attribute handling)
+        const planParts = [];
+        if (plan.toCreate.length)
+            planParts.push(`➕  ${plan.toCreate.length} (${plan.toCreate.map(op => op.index.key).join(', ')})`);
+        if (plan.toUpdate.length)
+            planParts.push(`🔧  ${plan.toUpdate.length} (${plan.toUpdate.map(op => op.index.key).join(', ')})`);
+        if (plan.toSkip.length)
+            planParts.push(`⏭️  ${plan.toSkip.length}`);
+        MessageFormatter.info(`Plan → ${planParts.join('  |  ') || 'no changes'}`, { prefix: 'Indexes' });
+        // Execute operations
+        const result = await executeIndexOperations(adapter, databaseId, tableId, plan);
+        // Show summary
+        MessageFormatter.info(`Summary → ➕  ${result.summary.created}  |  🔧  ${result.summary.updated}  |  ⏭️  ${result.summary.skipped}`, { prefix: 'Indexes' });
+        // Handle errors if any
+        if (result.errors.length > 0) {
+            MessageFormatter.error(`${result.errors.length} index operations failed:`, undefined, { prefix: 'Indexes' });
+            for (const error of result.errors) {
+                MessageFormatter.error(`  ${error.key}: ${error.error}`, undefined, { prefix: 'Indexes' });
+            }
+        }
+    }
+    catch (error) {
+        MessageFormatter.error('Failed to process indexes', error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        throw error;
+    }
+}
+/**
+ * Handle index deletions for obsolete indexes
+ */
+export async function deleteObsoleteIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexKeys) {
+    try {
+        // Get existing indexes
+        const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
+        const existingIndexes = existingIdxRes.data || existingIdxRes.indexes || [];
+        // Plan deletions
+        const deletions = planIndexDeletions(desiredIndexKeys, existingIndexes);
+        if (deletions.length === 0) {
+            MessageFormatter.info('Plan → 🗑️  0 indexes', { prefix: 'Indexes' });
+            return;
+        }
+        // Show deletion plan
+        MessageFormatter.info(`Plan → 🗑️  ${deletions.length} (${deletions.map(op => op.index.key).join(', ')})`, { prefix: 'Indexes' });
+        // Execute deletions
+        const result = await executeIndexDeletions(adapter, databaseId, tableId, deletions);
+        // Show results
+        if (result.deleted.length > 0) {
+            MessageFormatter.success(`Deleted ${result.deleted.length} indexes: ${result.deleted.join(', ')}`, { prefix: 'Indexes' });
+        }
+        if (result.errors.length > 0) {
+            MessageFormatter.error(`${result.errors.length} index deletions failed:`, undefined, { prefix: 'Indexes' });
+            for (const error of result.errors) {
+                MessageFormatter.error(`  ${error.key}: ${error.error}`, undefined, { prefix: 'Indexes' });
+            }
+        }
+    }
+    catch (error) {
+        MessageFormatter.warning(`Could not evaluate index deletions: ${error?.message || error}`, { prefix: 'Indexes' });
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

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
           });