appwrite-utils-cli 1.7.9 → 1.8.2

package/dist/collections/attributes.js

@@ -1,33 +1,34 @@
 import { Query } from "node-appwrite";
 import { attributeSchema, parseAttribute, } from "appwrite-utils";
-import { nameToIdMapping, enqueueOperation, markAttributeProcessed, isAttributeProcessed } from "../shared/operationQueue.js";
-import { delay, tryAwaitWithRetry, calculateExponentialBackoff } from "../utils/helperFunctions.js";
+import { nameToIdMapping, enqueueOperation, markAttributeProcessed, isAttributeProcessed, } from "../shared/operationQueue.js";
+import { delay, tryAwaitWithRetry, calculateExponentialBackoff, } from "../utils/helperFunctions.js";
 import chalk from "chalk";
+import { Decimal } from "decimal.js";
 import { logger } from "../shared/logging.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { isDatabaseAdapter } from "../utils/typeGuards.js";
-// Threshold for treating min/max values as undefined (1 trillion)
-const MIN_MAX_THRESHOLD = 1_000_000_000_000;
 // Extreme values that Appwrite may return, which should be treated as undefined
 const EXTREME_MIN_INTEGER = -9223372036854776000;
 const EXTREME_MAX_INTEGER = 9223372036854776000;
-const EXTREME_MIN_FLOAT = -1.7976931348623157e+308;
-const EXTREME_MAX_FLOAT = 1.7976931348623157e+308;
+const EXTREME_MIN_FLOAT = -1.7976931348623157e308;
+const EXTREME_MAX_FLOAT = 1.7976931348623157e308;
 /**
  * Type guard to check if an attribute has min/max properties
  */
 const hasMinMaxProperties = (attribute) => {
-    return attribute.type === 'integer' || attribute.type === 'double' || attribute.type === 'float';
+    return (attribute.type === "integer" ||
+        attribute.type === "double" ||
+        attribute.type === "float");
 };
 /**
- * Normalizes min/max values for integer and float attributes
- * Sets values to undefined if they exceed the threshold or are extreme values from database
+ * Normalizes min/max values for integer and float attributes using Decimal.js for precision
+ * Validates that min < max and handles extreme database values
  */
 const normalizeMinMaxValues = (attribute) => {
     if (!hasMinMaxProperties(attribute)) {
         logger.debug(`Attribute '${attribute.key}' does not have min/max properties`, {
             type: attribute.type,
-            operation: 'normalizeMinMaxValues'
+            operation: "normalizeMinMaxValues",
         });
         return {};
     }
@@ -38,21 +39,20 @@ const normalizeMinMaxValues = (attribute) => {
         type,
         originalMin: min,
         originalMax: max,
-        operation: 'normalizeMinMaxValues'
+        operation: "normalizeMinMaxValues",
     });
-    // Handle min value
+    // Handle min value - only filter out extreme database values
     if (normalizedMin !== undefined && normalizedMin !== null) {
         const minValue = Number(normalizedMin);
         const originalMin = normalizedMin;
-        // Check if it exceeds threshold or is an extreme database value
+        // Check if it's an extreme database value (but don't filter out large numbers)
         if (type === 'integer') {
-            if (Math.abs(minValue) >= MIN_MAX_THRESHOLD || minValue === EXTREME_MIN_INTEGER) {
+            if (minValue === EXTREME_MIN_INTEGER) {
                 logger.debug(`Min value normalized to undefined for attribute '${attribute.key}'`, {
                     type,
                     originalValue: originalMin,
                     numericValue: minValue,
-                    reason: Math.abs(minValue) >= MIN_MAX_THRESHOLD ? 'exceeds_threshold' : 'extreme_database_value',
-                    threshold: MIN_MAX_THRESHOLD,
+                    reason: 'extreme_database_value',
                     extremeValue: EXTREME_MIN_INTEGER,
                     operation: 'normalizeMinMaxValues'
                 });
@@ -60,13 +60,12 @@ const normalizeMinMaxValues = (attribute) => {
             }
         }
         else { // float/double
-            if (Math.abs(minValue) >= MIN_MAX_THRESHOLD || minValue === EXTREME_MIN_FLOAT) {
+            if (minValue === EXTREME_MIN_FLOAT) {
                 logger.debug(`Min value normalized to undefined for attribute '${attribute.key}'`, {
                     type,
                     originalValue: originalMin,
                     numericValue: minValue,
-                    reason: Math.abs(minValue) >= MIN_MAX_THRESHOLD ? 'exceeds_threshold' : 'extreme_database_value',
-                    threshold: MIN_MAX_THRESHOLD,
+                    reason: 'extreme_database_value',
                     extremeValue: EXTREME_MIN_FLOAT,
                     operation: 'normalizeMinMaxValues'
                 });
@@ -74,19 +73,18 @@ const normalizeMinMaxValues = (attribute) => {
             }
         }
     }
-    // Handle max value
+    // Handle max value - only filter out extreme database values
     if (normalizedMax !== undefined && normalizedMax !== null) {
         const maxValue = Number(normalizedMax);
         const originalMax = normalizedMax;
-        // Check if it exceeds threshold or is an extreme database value
+        // Check if it's an extreme database value (but don't filter out large numbers)
         if (type === 'integer') {
-            if (Math.abs(maxValue) >= MIN_MAX_THRESHOLD || maxValue === EXTREME_MAX_INTEGER) {
+            if (maxValue === EXTREME_MAX_INTEGER) {
                 logger.debug(`Max value normalized to undefined for attribute '${attribute.key}'`, {
                     type,
                     originalValue: originalMax,
                     numericValue: maxValue,
-                    reason: Math.abs(maxValue) >= MIN_MAX_THRESHOLD ? 'exceeds_threshold' : 'extreme_database_value',
-                    threshold: MIN_MAX_THRESHOLD,
+                    reason: 'extreme_database_value',
                     extremeValue: EXTREME_MAX_INTEGER,
                     operation: 'normalizeMinMaxValues'
                 });
@@ -94,13 +92,12 @@ const normalizeMinMaxValues = (attribute) => {
             }
         }
         else { // float/double
-            if (Math.abs(maxValue) >= MIN_MAX_THRESHOLD || maxValue === EXTREME_MAX_FLOAT) {
+            if (maxValue === EXTREME_MAX_FLOAT) {
                 logger.debug(`Max value normalized to undefined for attribute '${attribute.key}'`, {
                     type,
                     originalValue: originalMax,
                     numericValue: maxValue,
-                    reason: Math.abs(maxValue) >= MIN_MAX_THRESHOLD ? 'exceeds_threshold' : 'extreme_database_value',
-                    threshold: MIN_MAX_THRESHOLD,
+                    reason: 'extreme_database_value',
                     extremeValue: EXTREME_MAX_FLOAT,
                     operation: 'normalizeMinMaxValues'
                 });
@@ -108,11 +105,115 @@ const normalizeMinMaxValues = (attribute) => {
             }
         }
     }
+    // Validate that min < max using multiple comparison methods for reliability
+    if (normalizedMin !== undefined && normalizedMax !== undefined &&
+        normalizedMin !== null && normalizedMax !== null) {
+        logger.debug(`Validating min/max values for attribute '${attribute.key}'`, {
+            type,
+            normalizedMin,
+            normalizedMax,
+            normalizedMinType: typeof normalizedMin,
+            normalizedMaxType: typeof normalizedMax,
+            operation: 'normalizeMinMaxValues'
+        });
+        // Use multiple validation approaches to ensure reliability
+        let needsSwap = false;
+        let comparisonMethod = '';
+        try {
+            // Method 1: Direct number comparison (most reliable for normal numbers)
+            const minNum = Number(normalizedMin);
+            const maxNum = Number(normalizedMax);
+            if (!isNaN(minNum) && !isNaN(maxNum)) {
+                needsSwap = minNum >= maxNum;
+                comparisonMethod = 'direct_number_comparison';
+                logger.debug(`Direct number comparison: ${minNum} >= ${maxNum} = ${needsSwap}`, {
+                    operation: 'normalizeMinMaxValues'
+                });
+            }
+            // Method 2: Fallback to string comparison for very large numbers
+            if (!needsSwap && (isNaN(minNum) || isNaN(maxNum) || Math.abs(minNum) > Number.MAX_SAFE_INTEGER || Math.abs(maxNum) > Number.MAX_SAFE_INTEGER)) {
+                const minStr = normalizedMin.toString();
+                const maxStr = normalizedMax.toString();
+                // Simple string length and lexicographical comparison for very large numbers
+                if (minStr.length !== maxStr.length) {
+                    needsSwap = minStr.length > maxStr.length;
+                }
+                else {
+                    needsSwap = minStr >= maxStr;
+                }
+                comparisonMethod = 'string_comparison_fallback';
+                logger.debug(`String comparison fallback: '${minStr}' >= '${maxStr}' = ${needsSwap}`, {
+                    operation: 'normalizeMinMaxValues'
+                });
+            }
+            // Method 3: Final validation using Decimal.js as last resort
+            if (!needsSwap && (typeof normalizedMin === 'string' || typeof normalizedMax === 'string')) {
+                try {
+                    const minDecimal = new Decimal(normalizedMin.toString());
+                    const maxDecimal = new Decimal(normalizedMax.toString());
+                    needsSwap = minDecimal.greaterThanOrEqualTo(maxDecimal);
+                    comparisonMethod = 'decimal_js_fallback';
+                    logger.debug(`Decimal.js fallback: ${normalizedMin} >= ${normalizedMax} = ${needsSwap}`, {
+                        operation: 'normalizeMinMaxValues'
+                    });
+                }
+                catch (decimalError) {
+                    logger.warn(`Decimal.js comparison failed for attribute '${attribute.key}': ${decimalError instanceof Error ? decimalError.message : String(decimalError)}`, {
+                        operation: 'normalizeMinMaxValues'
+                    });
+                }
+            }
+            // Log final validation result
+            if (needsSwap) {
+                logger.error(`Invalid min/max values detected for attribute '${attribute.key}': min (${normalizedMin}) must be less than max (${normalizedMax})`, {
+                    type,
+                    min: normalizedMin,
+                    max: normalizedMax,
+                    comparisonMethod,
+                    operation: 'normalizeMinMaxValues'
+                });
+                // Swap values to ensure min < max (graceful handling)
+                logger.warn(`Swapping min/max values for attribute '${attribute.key}' to fix validation`, {
+                    type,
+                    originalMin: normalizedMin,
+                    originalMax: normalizedMax,
+                    newMin: normalizedMax,
+                    newMax: normalizedMin,
+                    comparisonMethod,
+                    operation: 'normalizeMinMaxValues'
+                });
+                const temp = normalizedMin;
+                normalizedMin = normalizedMax;
+                normalizedMax = temp;
+            }
+            else {
+                logger.debug(`Min/max validation passed for attribute '${attribute.key}'`, {
+                    type,
+                    min: normalizedMin,
+                    max: normalizedMax,
+                    comparisonMethod,
+                    operation: 'normalizeMinMaxValues'
+                });
+            }
+        }
+        catch (error) {
+            logger.error(`Critical error during min/max validation for attribute '${attribute.key}'`, {
+                type,
+                min: normalizedMin,
+                max: normalizedMax,
+                error: error instanceof Error ? error.message : String(error),
+                operation: 'normalizeMinMaxValues'
+            });
+            // If all comparison methods fail, set both to undefined to avoid API errors
+            normalizedMin = undefined;
+            normalizedMax = undefined;
+        }
+    }
     const result = { min: normalizedMin, max: normalizedMax };
     logger.debug(`Min/max normalization complete for attribute '${attribute.key}'`, {
         type,
         result,
-        operation: 'normalizeMinMaxValues'
+        operation: "normalizeMinMaxValues",
     });
     return result;
 };
@@ -122,6 +223,10 @@ const normalizeMinMaxValues = (attribute) => {
  */
 const normalizeAttributeForComparison = (attribute) => {
     const normalized = { ...attribute };
+    // Ignore defaults on required attributes to prevent false positives
+    if (normalized.required === true && "xdefault" in normalized) {
+        delete normalized.xdefault;
+    }
     // Normalize min/max for numeric types
     if (hasMinMaxProperties(attribute)) {
         const { min, max } = normalizeMinMaxValues(attribute);
@@ -130,7 +235,8 @@ const normalizeAttributeForComparison = (attribute) => {
     }
     // Remove xdefault if null/undefined to ensure consistent comparison
     // Appwrite sets xdefault: null for required attributes, but config files omit it
-    if ('xdefault' in normalized && (normalized.xdefault === null || normalized.xdefault === undefined)) {
+    if ("xdefault" in normalized &&
+        (normalized.xdefault === null || normalized.xdefault === undefined)) {
         delete normalized.xdefault;
     }
     return normalized;
@@ -140,13 +246,13 @@ const normalizeAttributeForComparison = (attribute) => {
  */
 const createAttributeViaAdapter = async (db, dbId, collectionId, attribute) => {
     const startTime = Date.now();
-    const adapterType = isDatabaseAdapter(db) ? 'adapter' : 'legacy';
+    const adapterType = isDatabaseAdapter(db) ? "adapter" : "legacy";
     logger.info(`Creating attribute '${attribute.key}' via ${adapterType}`, {
         type: attribute.type,
         dbId,
         collectionId,
         adapterType,
-        operation: 'createAttributeViaAdapter'
+        operation: "createAttributeViaAdapter",
     });
     if (isDatabaseAdapter(db)) {
         // Use the adapter's unified createAttribute method
@@ -158,38 +264,57 @@ const createAttributeViaAdapter = async (db, dbId, collectionId, attribute) => {
             required: attribute.required || false,
             array: attribute.array || false,
             ...(attribute.size && { size: attribute.size }),
-            ...(attribute.xdefault !== undefined && !attribute.required && { default: attribute.xdefault }),
-            ...(attribute.encrypted && { encrypt: attribute.encrypted }),
-            ...(attribute.min !== undefined && { min: attribute.min }),
-            ...(attribute.max !== undefined && { max: attribute.max }),
-            ...(attribute.elements && { elements: attribute.elements }),
-            ...(attribute.relatedCollection && { relatedCollection: attribute.relatedCollection }),
-            ...(attribute.relationType && { relationType: attribute.relationType }),
-            ...(attribute.twoWay !== undefined && { twoWay: attribute.twoWay }),
-            ...(attribute.onDelete && { onDelete: attribute.onDelete }),
-            ...(attribute.twoWayKey && { twoWayKey: attribute.twoWayKey })
+            ...(attribute.xdefault !== undefined &&
+                !attribute.required && { default: attribute.xdefault }),
+            ...(attribute.encrypted && {
+                encrypt: attribute.encrypted,
+            }),
+            ...(attribute.min !== undefined && {
+                min: attribute.min,
+            }),
+            ...(attribute.max !== undefined && {
+                max: attribute.max,
+            }),
+            ...(attribute.elements && {
+                elements: attribute.elements,
+            }),
+            ...(attribute.relatedCollection && {
+                relatedCollection: attribute.relatedCollection,
+            }),
+            ...(attribute.relationType && {
+                relationType: attribute.relationType,
+            }),
+            ...(attribute.twoWay !== undefined && {
+                twoWay: attribute.twoWay,
+            }),
+            ...(attribute.onDelete && {
+                onDelete: attribute.onDelete,
+            }),
+            ...(attribute.twoWayKey && {
+                twoWayKey: attribute.twoWayKey,
+            }),
         };
         logger.debug(`Adapter create parameters for '${attribute.key}'`, {
             params,
-            operation: 'createAttributeViaAdapter'
+            operation: "createAttributeViaAdapter",
         });
         await db.createAttribute(params);
         const duration = Date.now() - startTime;
         logger.info(`Successfully created attribute '${attribute.key}' via adapter`, {
             duration,
-            operation: 'createAttributeViaAdapter'
+            operation: "createAttributeViaAdapter",
         });
     }
     else {
         // Use legacy type-specific methods
         logger.debug(`Using legacy creation for attribute '${attribute.key}'`, {
-            operation: 'createAttributeViaAdapter'
+            operation: "createAttributeViaAdapter",
         });
         await createLegacyAttribute(db, dbId, collectionId, attribute);
         const duration = Date.now() - startTime;
         logger.info(`Successfully created attribute '${attribute.key}' via legacy`, {
             duration,
-            operation: 'createAttributeViaAdapter'
+            operation: "createAttributeViaAdapter",
         });
     }
 };
@@ -203,9 +328,23 @@ const updateAttributeViaAdapter = async (db, dbId, collectionId, attribute) => {
             databaseId: dbId,
             tableId: collectionId,
             key: attribute.key,
+            type: attribute.type,
             required: attribute.required || false,
-            ...(attribute.xdefault !== undefined && !attribute.required && { default: attribute.xdefault })
+            array: attribute.array || false,
+            size: attribute.size,
+            min: attribute.min,
+            max: attribute.max,
+            encrypt: attribute.encrypted ?? attribute.encrypt,
+            elements: attribute.elements,
+            relatedCollection: attribute.relatedCollection,
+            relationType: attribute.relationType,
+            twoWay: attribute.twoWay,
+            twoWayKey: attribute.twoWayKey,
+            onDelete: attribute.onDelete
         };
+        if (!attribute.required && attribute.xdefault !== undefined) {
+            params.default = attribute.xdefault;
+        }
         await db.updateAttribute(params);
     }
     else {
@@ -225,58 +364,80 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
         collectionId,
         normalizedMin,
         normalizedMax,
-        operation: 'createLegacyAttribute'
+        operation: "createLegacyAttribute",
     });
     switch (attribute.type) {
         case "string":
             const stringParams = {
                 size: attribute.size || 255,
                 required: attribute.required || false,
-                defaultValue: attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined,
+                defaultValue: attribute.xdefault !== undefined && !attribute.required
+                    ? attribute.xdefault
+                    : undefined,
                 array: attribute.array || false,
-                encrypted: attribute.encrypted
+                encrypted: attribute.encrypted,
             };
             logger.debug(`Creating string attribute '${attribute.key}'`, {
                 ...stringParams,
-                operation: 'createLegacyAttribute'
+                operation: "createLegacyAttribute",
             });
             await db.createStringAttribute(dbId, collectionId, attribute.key, stringParams.size, stringParams.required, stringParams.defaultValue, stringParams.array, stringParams.encrypted);
             break;
         case "integer":
             const integerParams = {
                 required: attribute.required || false,
-                min: normalizedMin !== undefined ? parseInt(String(normalizedMin)) : undefined,
-                max: normalizedMax !== undefined ? parseInt(String(normalizedMax)) : undefined,
-                defaultValue: attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined,
-                array: attribute.array || false
+                min: normalizedMin !== undefined
+                    ? parseInt(String(normalizedMin))
+                    : undefined,
+                max: normalizedMax !== undefined
+                    ? parseInt(String(normalizedMax))
+                    : undefined,
+                defaultValue: attribute.xdefault !== undefined && !attribute.required
+                    ? attribute.xdefault
+                    : undefined,
+                array: attribute.array || false,
             };
             logger.debug(`Creating integer attribute '${attribute.key}'`, {
                 ...integerParams,
-                operation: 'createLegacyAttribute'
+                operation: "createLegacyAttribute",
             });
             await db.createIntegerAttribute(dbId, collectionId, attribute.key, integerParams.required, integerParams.min, integerParams.max, integerParams.defaultValue, integerParams.array);
             break;
         case "double":
         case "float":
-            await db.createFloatAttribute(dbId, collectionId, attribute.key, attribute.required || false, normalizedMin !== undefined ? Number(normalizedMin) : undefined, normalizedMax !== undefined ? Number(normalizedMax) : undefined, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createFloatAttribute(dbId, collectionId, attribute.key, attribute.required || false, normalizedMin !== undefined ? Number(normalizedMin) : undefined, normalizedMax !== undefined ? Number(normalizedMax) : undefined, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "boolean":
-            await db.createBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "datetime":
-            await db.createDatetimeAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createDatetimeAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "email":
-            await db.createEmailAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createEmailAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "ip":
-            await db.createIpAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createIpAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "url":
-            await db.createUrlAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createUrlAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "enum":
-            await db.createEnumAttribute(dbId, collectionId, attribute.key, attribute.elements || [], attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.array || false);
+            await db.createEnumAttribute(dbId, collectionId, attribute.key, attribute.elements || [], attribute.required || false, attribute.xdefault !== undefined && !attribute.required
+                ? attribute.xdefault
+                : undefined, attribute.array || false);
             break;
         case "relationship":
             await db.createRelationshipAttribute(dbId, collectionId, attribute.relatedCollection, attribute.relationType, attribute.twoWay, attribute.key, attribute.twoWayKey, attribute.onDelete);
@@ -285,8 +446,20 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
             const error = new Error(`Unsupported attribute type: ${attribute.type}`);
             logger.error(`Unsupported attribute type for '${attribute.key}'`, {
                 type: attribute.type,
-                supportedTypes: ['string', 'integer', 'double', 'float', 'boolean', 'datetime', 'email', 'ip', 'url', 'enum', 'relationship'],
-                operation: 'createLegacyAttribute'
+                supportedTypes: [
+                    "string",
+                    "integer",
+                    "double",
+                    "float",
+                    "boolean",
+                    "datetime",
+                    "email",
+                    "ip",
+                    "url",
+                    "enum",
+                    "relationship",
+                ],
+                operation: "createLegacyAttribute",
             });
             throw error;
     }
@@ -294,42 +467,72 @@ const createLegacyAttribute = async (db, dbId, collectionId, attribute) => {
     logger.info(`Successfully created legacy attribute '${attribute.key}'`, {
         type: attribute.type,
         duration,
-        operation: 'createLegacyAttribute'
+        operation: "createLegacyAttribute",
     });
 };
 /**
  * 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":
-            await db.updateStringAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null, attribute.size);
+            await db.updateStringAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null, attribute.size);
             break;
         case "integer":
-            await db.updateIntegerAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null, normalizedMin !== undefined ? parseInt(String(normalizedMin)) : undefined, normalizedMax !== undefined ? parseInt(String(normalizedMax)) : undefined);
+            await db.updateIntegerAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null, normalizedMin !== undefined
+                ? parseInt(String(normalizedMin))
+                : undefined, normalizedMax !== undefined
+                ? parseInt(String(normalizedMax))
+                : undefined);
             break;
         case "double":
         case "float":
-            await db.updateFloatAttribute(dbId, collectionId, attribute.key, attribute.required || false, normalizedMin !== undefined ? Number(normalizedMin) : undefined, normalizedMax !== undefined ? Number(normalizedMax) : undefined, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            const minParam = normalizedMin !== undefined ? Number(normalizedMin) : undefined;
+            const maxParam = normalizedMax !== undefined ? Number(normalizedMax) : undefined;
+            await db.updateFloatAttribute(dbId, collectionId, attribute.key, attribute.required || false, minParam, maxParam, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "boolean":
-            await db.updateBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            await db.updateBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "datetime":
-            await db.updateDatetimeAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            await db.updateDatetimeAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "email":
-            await db.updateEmailAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            await db.updateEmailAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "ip":
-            await db.updateIpAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            await db.updateIpAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "url":
-            await db.updateUrlAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            await db.updateUrlAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "enum":
-            await db.updateEnumAttribute(dbId, collectionId, attribute.key, attribute.elements || [], attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
+            await db.updateEnumAttribute(dbId, collectionId, attribute.key, attribute.elements || [], attribute.required || false, !attribute.required && attribute.xdefault !== undefined
+                ? attribute.xdefault
+                : null);
             break;
         case "relationship":
             await db.updateRelationshipAttribute(dbId, collectionId, attribute.key, attribute.onDelete);
@@ -351,7 +554,7 @@ retryCount = 0, maxRetries = 5) => {
         maxWaitTime,
         retryCount,
         maxRetries,
-        operation: 'waitForAttributeAvailable'
+        operation: "waitForAttributeAvailable",
     });
     // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
     if (retryCount > 0) {
@@ -375,7 +578,7 @@ retryCount = 0, maxRetries = 5) => {
                 dbId,
                 collectionId,
                 waitTime: Date.now() - startTime,
-                operation: 'waitForAttributeAvailable'
+                operation: "waitForAttributeAvailable",
             };
             switch (attribute.status) {
                 case "available":
@@ -405,13 +608,13 @@ retryCount = 0, maxRetries = 5) => {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             MessageFormatter.error(`Error checking attribute status: ${errorMessage}`);
-            logger.error('Error checking attribute status', {
+            logger.error("Error checking attribute status", {
                 attributeKey,
                 dbId,
                 collectionId,
                 error: errorMessage,
                 waitTime: Date.now() - startTime,
-                operation: 'waitForAttributeAvailable'
+                operation: "waitForAttributeAvailable",
             });
             return false;
         }
@@ -464,7 +667,7 @@ const deleteAndRecreateCollection = async (db, dbId, collection, retryCount) =>
                 name: collection.name,
                 permissions: collection.$permissions,
                 documentSecurity: collection.documentSecurity,
-                enabled: collection.enabled
+                enabled: collection.enabled,
             })).data
             : await db.createCollection(dbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled);
         MessageFormatter.success(`✅ Recreated collection '${collection.name}'`);
@@ -491,7 +694,14 @@ const getComparableFields = (type) => {
         case "enum":
             return [...baseFields, "elements"];
         case "relationship":
-            return [...baseFields, "relationType", "twoWay", "twoWayKey", "onDelete", "relatedCollection"];
+            return [
+                ...baseFields,
+                "relationType",
+                "twoWay",
+                "twoWayKey",
+                "onDelete",
+                "relatedCollection",
+            ];
         case "boolean":
         case "datetime":
         case "email":
@@ -501,9 +711,21 @@ const getComparableFields = (type) => {
         default:
             // Fallback to all fields for unknown types
             return [
-                "key", "type", "array", "encrypted", "required", "size",
-                "min", "max", "xdefault", "elements", "relationType",
-                "twoWay", "twoWayKey", "onDelete", "relatedCollection"
+                "key",
+                "type",
+                "array",
+                "encrypted",
+                "required",
+                "size",
+                "min",
+                "max",
+                "xdefault",
+                "elements",
+                "relationType",
+                "twoWay",
+                "twoWayKey",
+                "onDelete",
+                "relatedCollection",
             ];
     }
 };
@@ -513,8 +735,16 @@ const attributesSame = (databaseAttribute, configAttribute) => {
     const normalizedConfigAttr = normalizeAttributeForComparison(configAttribute);
     // Use type-specific field list to avoid false positives from irrelevant fields
     const attributesToCheck = getComparableFields(normalizedConfigAttr.type);
+    const fieldsToCheck = attributesToCheck.filter((attr) => {
+        if (attr !== "xdefault") {
+            return true;
+        }
+        const dbRequired = Boolean(normalizedDbAttr.required);
+        const configRequired = Boolean(normalizedConfigAttr.required);
+        return !(dbRequired || configRequired);
+    });
     const differences = [];
-    const result = attributesToCheck.every((attr) => {
+    const result = fieldsToCheck.every((attr) => {
         // Check if both objects have the attribute
         const dbHasAttr = attr in normalizedDbAttr;
         const configHasAttr = attr in normalizedConfigAttr;
@@ -536,8 +766,14 @@ const attributesSame = (databaseAttribute, configAttribute) => {
                 return boolMatch;
             }
             // For numeric comparisons, compare numbers if both are numeric-like
-            if ((typeof dbValue === "number" || (typeof dbValue === "string" && dbValue !== "" && !isNaN(Number(dbValue)))) &&
-                (typeof configValue === "number" || (typeof configValue === "string" && configValue !== "" && !isNaN(Number(configValue))))) {
+            if ((typeof dbValue === "number" ||
+                (typeof dbValue === "string" &&
+                    dbValue !== "" &&
+                    !isNaN(Number(dbValue)))) &&
+                (typeof configValue === "number" ||
+                    (typeof configValue === "string" &&
+                        configValue !== "" &&
+                        !isNaN(Number(configValue))))) {
                 const numMatch = Number(dbValue) === Number(configValue);
                 if (!numMatch) {
                     differences.push(`${attr}: db=${dbValue} config=${configValue}`);
@@ -600,18 +836,12 @@ const attributesSame = (databaseAttribute, configAttribute) => {
         differences.push(`${attr}: unexpected comparison state`);
         return false;
     });
-    // Log differences if any were found
-    if (differences.length > 0) {
-        logger.debug(`Attribute '${normalizedDbAttr.key}' comparison found differences:`, {
-            differences,
-            operation: 'attributesSame'
-        });
-    }
-    // Log differences if comparison failed (for debugging)
     if (!result && differences.length > 0) {
-        MessageFormatter.debug(`Attribute '${configAttribute.key}' differences detected:`, { prefix: "Attributes" });
-        differences.forEach(diff => {
-            MessageFormatter.debug(`  ${diff}`, { prefix: "Attributes" });
+        logger.debug(`Attribute mismatch detected for '${normalizedConfigAttr.key}'`, {
+            differences,
+            dbAttribute: normalizedDbAttr,
+            configAttribute: normalizedConfigAttr,
+            operation: "attributesSame",
         });
     }
     return result;
@@ -646,7 +876,11 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
             // Try to delete the specific stuck attribute instead of the entire collection
             try {
                 if (isDatabaseAdapter(db)) {
-                    await db.deleteAttribute({ databaseId: dbId, tableId: collection.$id, key: attribute.key });
+                    await db.deleteAttribute({
+                        databaseId: dbId,
+                        tableId: collection.$id,
+                        key: attribute.key,
+                    });
                 }
                 else {
                     await db.deleteAttribute(dbId, collection.$id, attribute.key);
@@ -656,7 +890,8 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
                 await delay(3000);
                 // Get fresh collection data
                 const freshCollection = isDatabaseAdapter(db)
-                    ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data
+                    ? (await db.getTable({ databaseId: dbId, tableId: collection.$id }))
+                        .data
                     : await db.getCollection(dbId, collection.$id);
                 // Retry with the same collection (attribute should be gone now)
                 return await createOrUpdateAttributeWithStatusCheck(db, dbId, freshCollection, attribute, retryCount + 1, maxRetries);
@@ -668,7 +903,8 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
                     MessageFormatter.info(chalk.yellow(`Last resort: Recreating collection for attribute '${attribute.key}'`));
                     // Get fresh collection data
                     const freshCollection = isDatabaseAdapter(db)
-                        ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data
+                        ? (await db.getTable({ databaseId: dbId, tableId: collection.$id }))
+                            .data
                         : await db.getCollection(dbId, collection.$id);
                     // Delete and recreate collection
                     const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
@@ -709,6 +945,30 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     catch (error) {
         foundAttribute = undefined;
     }
+    // If attribute exists but type changed, delete it so we can recreate with new type
+    if (foundAttribute &&
+        foundAttribute.type !== attribute.type) {
+        MessageFormatter.info(chalk.yellow(`Attribute '${attribute.key}' type changed from '${foundAttribute.type}' to '${attribute.type}'. Recreating attribute.`));
+        try {
+            if (isDatabaseAdapter(db)) {
+                await db.deleteAttribute({
+                    databaseId: dbId,
+                    tableId: collection.$id,
+                    key: attribute.key
+                });
+            }
+            else {
+                await db.deleteAttribute(dbId, collection.$id, attribute.key);
+            }
+            // Remove from local collection metadata so downstream logic treats it as new
+            collection.attributes = collection.attributes.filter((attr) => attr.key !== attribute.key);
+            foundAttribute = undefined;
+        }
+        catch (deleteError) {
+            MessageFormatter.error(`Failed to delete attribute '${attribute.key}' before recreation: ${deleteError}`);
+            return "error";
+        }
+    }
     if (foundAttribute &&
         attributesSame(foundAttribute, attribute) &&
         updateEnabled) {
@@ -721,17 +981,46 @@ 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 &&
         foundAttribute &&
         !attributesSame(foundAttribute, attribute)) {
         if (isDatabaseAdapter(db)) {
-            await db.deleteAttribute({ databaseId: dbId, tableId: collection.$id, key: attribute.key });
+            await db.deleteAttribute({
+                databaseId: dbId,
+                tableId: collection.$id,
+                key: attribute.key,
+            });
         }
         else {
             await db.deleteAttribute(dbId, collection.$id, attribute.key);
@@ -747,7 +1036,10 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         // First try treating relatedCollection as an ID directly
         try {
             const byIdCollection = isDatabaseAdapter(db)
-                ? (await db.getTable({ databaseId: dbId, tableId: finalAttribute.relatedCollection })).data
+                ? (await db.getTable({
+                    databaseId: dbId,
+                    tableId: finalAttribute.relatedCollection,
+                })).data
                 : await db.getCollection(dbId, finalAttribute.relatedCollection);
             collectionFoundViaRelatedCollection = byIdCollection;
             relatedCollectionId = byIdCollection.$id;
@@ -757,11 +1049,15 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         catch (_) {
             // Not an ID or not found — fall back to name-based resolution below
         }
-        if (!collectionFoundViaRelatedCollection && nameToIdMapping.has(finalAttribute.relatedCollection)) {
+        if (!collectionFoundViaRelatedCollection &&
+            nameToIdMapping.has(finalAttribute.relatedCollection)) {
             relatedCollectionId = nameToIdMapping.get(finalAttribute.relatedCollection);
             try {
                 collectionFoundViaRelatedCollection = isDatabaseAdapter(db)
-                    ? (await db.getTable({ databaseId: dbId, tableId: relatedCollectionId })).data
+                    ? (await db.getTable({
+                        databaseId: dbId,
+                        tableId: relatedCollectionId,
+                    })).data
                     : await db.getCollection(dbId, relatedCollectionId);
             }
             catch (e) {
@@ -773,8 +1069,13 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         }
         else if (!collectionFoundViaRelatedCollection) {
             const collectionsPulled = isDatabaseAdapter(db)
-                ? await db.listTables({ databaseId: dbId, queries: [Query.equal("name", finalAttribute.relatedCollection)] })
-                : await db.listCollections(dbId, [Query.equal("name", finalAttribute.relatedCollection)]);
+                ? await db.listTables({
+                    databaseId: dbId,
+                    queries: [Query.equal("name", finalAttribute.relatedCollection)],
+                })
+                : await db.listCollections(dbId, [
+                    Query.equal("name", finalAttribute.relatedCollection),
+                ]);
             if (collectionsPulled.total && collectionsPulled.total > 0) {
                 collectionFoundViaRelatedCollection = isDatabaseAdapter(db)
                     ? collectionsPulled.tables?.[0]
@@ -808,8 +1109,9 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     catch (error) {
         // Collection doesn't exist - create it
         if (error.code === 404 ||
-            (error instanceof Error && (error.message.includes('collection_not_found') ||
-                error.message.includes('Collection with the requested ID could not be found')))) {
+            (error instanceof Error &&
+                (error.message.includes("collection_not_found") ||
+                    error.message.includes("Collection with the requested ID could not be found")))) {
             MessageFormatter.info(`Collection '${collection.name}' doesn't exist, creating it first...`);
             try {
                 if (isDatabaseAdapter(db)) {
@@ -819,7 +1121,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                         name: collection.name,
                         permissions: collection.$permissions || [],
                         documentSecurity: collection.documentSecurity ?? false,
-                        enabled: collection.enabled ?? true
+                        enabled: collection.enabled ?? true,
                     });
                 }
                 else {
@@ -829,7 +1131,9 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                 await delay(500); // Wait for collection to be ready
             }
             catch (createError) {
-                MessageFormatter.error(`Failed to create collection '${collection.name}'`, createError instanceof Error ? createError : new Error(String(createError)));
+                MessageFormatter.error(`Failed to create collection '${collection.name}'`, createError instanceof Error
+                    ? createError
+                    : new Error(String(createError)));
                 return "error";
             }
         }
@@ -843,6 +1147,10 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         await tryAwaitWithRetry(async () => await createAttributeViaAdapter(db, dbId, collection.$id, finalAttribute));
     }
     else {
+        console.log(`Updating attribute '${finalAttribute.key}'...`);
+        if (finalAttribute.type === "double" || finalAttribute.type === "integer") {
+            console.log("finalAttribute:", finalAttribute);
+        }
         await tryAwaitWithRetry(async () => await updateAttributeViaAdapter(db, dbId, collection.$id, finalAttribute));
     }
     return "processed";
@@ -851,9 +1159,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
  * Enhanced collection attribute creation with proper status monitoring
  */
 export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId, collection, attributes) => {
-    const existingAttributes = 
-    // @ts-expect-error
-    collection.attributes.map((attr) => parseAttribute(attr)) || [];
+    const existingAttributes = collection.attributes.map((attr) => parseAttribute(attr)) || [];
     const attributesToRemove = existingAttributes.filter((attr) => !attributes.some((a) => a.key === attr.key));
     const indexesToRemove = collection.indexes.filter((index) => attributesToRemove.some((attr) => index.attributes.includes(attr.key)));
     // Handle attribute removal first
@@ -865,7 +1171,11 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             for (const index of indexesToRemove) {
                 await tryAwaitWithRetry(async () => {
                     if (isDatabaseAdapter(db)) {
-                        await db.deleteIndex({ databaseId: dbId, tableId: collection.$id, key: index.key });
+                        await db.deleteIndex({
+                            databaseId: dbId,
+                            tableId: collection.$id,
+                            key: index.key,
+                        });
                     }
                     else {
                         await db.deleteIndex(dbId, collection.$id, index.key);
@@ -878,7 +1188,11 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             MessageFormatter.info(chalk.red(`Removing attribute: ${attr.key} as it is no longer in the collection`));
             await tryAwaitWithRetry(async () => {
                 if (isDatabaseAdapter(db)) {
-                    await db.deleteAttribute({ databaseId: dbId, tableId: collection.$id, key: attr.key });
+                    await db.deleteAttribute({
+                        databaseId: dbId,
+                        tableId: collection.$id,
+                        key: attr.key,
+                    });
                 }
                 else {
                     await db.deleteAttribute(dbId, collection.$id, attr.key);
@@ -899,9 +1213,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     }
     const existingAttributesMap = new Map();
     try {
-        const parsedAttributes = currentCollection.attributes.map((attr) => 
-        // @ts-expect-error
-        parseAttribute(attr));
+        const parsedAttributes = currentCollection.attributes.map((attr) => parseAttribute(attr));
         parsedAttributes.forEach((attr) => existingAttributesMap.set(attr.key, attr));
     }
     catch (error) {
@@ -946,7 +1258,10 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
                 try {
                     currentCollection = isDatabaseAdapter(db)
                         ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data
-                        : await db.getCollection(dbId, collection.$id);
+                        : await db.getCollection({
+                            databaseId: dbId,
+                            collectionId: collection.$id,
+                        });
                 }
                 catch (error) {
                     MessageFormatter.info(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
@@ -969,7 +1284,8 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             // Refresh collection data before retry
             try {
                 currentCollection = isDatabaseAdapter(db)
-                    ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data
+                    ? (await db.getTable({ databaseId: dbId, tableId: collection.$id }))
+                        .data
                     : await db.getCollection(dbId, collection.$id);
             }
             catch (error) {
@@ -990,9 +1306,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
 };
 export const createUpdateCollectionAttributes = async (db, dbId, collection, attributes) => {
     MessageFormatter.info(chalk.green(`Creating/Updating attributes for collection: ${collection.name}`));
-    const existingAttributes = 
-    // @ts-expect-error
-    collection.attributes.map((attr) => parseAttribute(attr)) || [];
+    const existingAttributes = collection.attributes.map((attr) => parseAttribute(attr)) || [];
     const attributesToRemove = existingAttributes.filter((attr) => !attributes.some((a) => a.key === attr.key));
     const indexesToRemove = collection.indexes.filter((index) => attributesToRemove.some((attr) => index.attributes.includes(attr.key)));
     if (attributesToRemove.length > 0) {
@@ -1003,7 +1317,11 @@ export const createUpdateCollectionAttributes = async (db, dbId, collection, att
             for (const index of indexesToRemove) {
                 await tryAwaitWithRetry(async () => {
                     if (isDatabaseAdapter(db)) {
-                        await db.deleteIndex({ databaseId: dbId, tableId: collection.$id, key: index.key });
+                        await db.deleteIndex({
+                            databaseId: dbId,
+                            tableId: collection.$id,
+                            key: index.key,
+                        });
                     }
                     else {
                         await db.deleteIndex(dbId, collection.$id, index.key);
@@ -1016,7 +1334,11 @@ export const createUpdateCollectionAttributes = async (db, dbId, collection, att
             MessageFormatter.info(chalk.red(`Removing attribute: ${attr.key} as it is no longer in the collection`));
             await tryAwaitWithRetry(async () => {
                 if (isDatabaseAdapter(db)) {
-                    await db.deleteAttribute({ databaseId: dbId, tableId: collection.$id, key: attr.key });
+                    await db.deleteAttribute({
+                        databaseId: dbId,
+                        tableId: collection.$id,
+                        key: attr.key,
+                    });
                 }
                 else {
                     await db.deleteAttribute(dbId, collection.$id, attr.key);