appwrite-utils-cli 1.6.2 → 1.6.4

package/dist/collections/attributes.js

@@ -6,8 +6,8 @@ import chalk from "chalk";
 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 (10 billion)
-const MIN_MAX_THRESHOLD = 10_000_000_000;
+// 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;
@@ -121,11 +121,19 @@ const normalizeMinMaxValues = (attribute) => {
  * This is used when comparing database attributes with config attributes
  */
 const normalizeAttributeForComparison = (attribute) => {
-    if (!hasMinMaxProperties(attribute)) {
-        return attribute;
+    const normalized = { ...attribute };
+    // Normalize min/max for numeric types
+    if (hasMinMaxProperties(attribute)) {
+        const { min, max } = normalizeMinMaxValues(attribute);
+        normalized.min = min;
+        normalized.max = max;
+    }
+    // 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)) {
+        delete normalized.xdefault;
     }
-    const { min, max } = normalizeMinMaxValues(attribute);
-    return { ...attribute, min, max };
+    return normalized;
 };
 /**
  * Helper function to create an attribute using either the adapter or legacy API
@@ -296,32 +304,32 @@ const updateLegacyAttribute = async (db, dbId, collectionId, attribute) => {
     const { min: normalizedMin, max: normalizedMax } = normalizeMinMaxValues(attribute);
     switch (attribute.type) {
         case "string":
-            await db.updateStringAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, 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.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, 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.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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);
             break;
         case "boolean":
-            await db.updateBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            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);
@@ -348,12 +356,8 @@ retryCount = 0, maxRetries = 5) => {
     // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
     if (retryCount > 0) {
         const exponentialDelay = calculateExponentialBackoff(retryCount);
-        MessageFormatter.info(chalk.blue(`Waiting for attribute '${attributeKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`));
         await delay(exponentialDelay);
     }
-    else {
-        MessageFormatter.info(chalk.blue(`Waiting for attribute '${attributeKey}' to become available...`));
-    }
     while (Date.now() - startTime < maxWaitTime) {
         try {
             const collection = isDatabaseAdapter(db)
@@ -364,7 +368,6 @@ retryCount = 0, maxRetries = 5) => {
                 MessageFormatter.error(`Attribute '${attributeKey}' not found`);
                 return false;
             }
-            MessageFormatter.info(chalk.gray(`Attribute '${attributeKey}' status: ${attribute.status}`));
             const statusInfo = {
                 attributeKey,
                 status: attribute.status,
@@ -376,15 +379,12 @@ retryCount = 0, maxRetries = 5) => {
             };
             switch (attribute.status) {
                 case "available":
-                    MessageFormatter.info(chalk.green(`✅ Attribute '${attributeKey}' is now available`));
                     logger.info(`Attribute '${attributeKey}' became available`, statusInfo);
                     return true;
                 case "failed":
-                    MessageFormatter.info(chalk.red(`❌ Attribute '${attributeKey}' failed: ${attribute.error}`));
                     logger.error(`Attribute '${attributeKey}' failed`, statusInfo);
                     return false;
                 case "stuck":
-                    MessageFormatter.info(chalk.yellow(`⚠️ Attribute '${attributeKey}' is stuck, will retry...`));
                     logger.warn(`Attribute '${attributeKey}' is stuck`, statusInfo);
                     return false;
                 case "processing":
@@ -475,28 +475,46 @@ const deleteAndRecreateCollection = async (db, dbId, collection, retryCount) =>
         return null;
     }
 };
+/**
+ * Get the fields that should be compared for a specific attribute type
+ * Only returns fields that are valid for the given type to avoid false positives
+ */
+const getComparableFields = (type) => {
+    const baseFields = ["key", "type", "array", "required", "xdefault"];
+    switch (type) {
+        case "string":
+            return [...baseFields, "size", "encrypted"];
+        case "integer":
+        case "double":
+        case "float":
+            return [...baseFields, "min", "max"];
+        case "enum":
+            return [...baseFields, "elements"];
+        case "relationship":
+            return [...baseFields, "relationType", "twoWay", "twoWayKey", "onDelete", "relatedCollection"];
+        case "boolean":
+        case "datetime":
+        case "email":
+        case "ip":
+        case "url":
+            return baseFields;
+        default:
+            // Fallback to all fields for unknown types
+            return [
+                "key", "type", "array", "encrypted", "required", "size",
+                "min", "max", "xdefault", "elements", "relationType",
+                "twoWay", "twoWayKey", "onDelete", "relatedCollection"
+            ];
+    }
+};
 const attributesSame = (databaseAttribute, configAttribute) => {
     // Normalize both attributes for comparison (handle extreme database values)
     const normalizedDbAttr = normalizeAttributeForComparison(databaseAttribute);
     const normalizedConfigAttr = normalizeAttributeForComparison(configAttribute);
-    const attributesToCheck = [
-        "key",
-        "type",
-        "array",
-        "encrypted",
-        "required",
-        "size",
-        "min",
-        "max",
-        "xdefault",
-        "elements",
-        "relationType",
-        "twoWay",
-        "twoWayKey",
-        "onDelete",
-        "relatedCollection",
-    ];
-    return attributesToCheck.every((attr) => {
+    // Use type-specific field list to avoid false positives from irrelevant fields
+    const attributesToCheck = getComparableFields(normalizedConfigAttr.type);
+    const differences = [];
+    const result = attributesToCheck.every((attr) => {
         // Check if both objects have the attribute
         const dbHasAttr = attr in normalizedDbAttr;
         const configHasAttr = attr in normalizedConfigAttr;
@@ -511,14 +529,35 @@ const attributesSame = (databaseAttribute, configAttribute) => {
             }
             // Normalize booleans: treat undefined and false as equivalent
             if (typeof dbValue === "boolean" || typeof configValue === "boolean") {
-                return Boolean(dbValue) === Boolean(configValue);
+                const boolMatch = Boolean(dbValue) === Boolean(configValue);
+                if (!boolMatch) {
+                    differences.push(`${attr}: db=${dbValue} config=${configValue}`);
+                }
+                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))))) {
-                return Number(dbValue) === Number(configValue);
+                const numMatch = Number(dbValue) === Number(configValue);
+                if (!numMatch) {
+                    differences.push(`${attr}: db=${dbValue} config=${configValue}`);
+                }
+                return numMatch;
+            }
+            // For array comparisons (e.g., enum elements), use order-independent equality
+            if (Array.isArray(dbValue) && Array.isArray(configValue)) {
+                const arrayMatch = dbValue.length === configValue.length &&
+                    dbValue.every((val) => configValue.includes(val));
+                if (!arrayMatch) {
+                    differences.push(`${attr}: db=${JSON.stringify(dbValue)} config=${JSON.stringify(configValue)}`);
+                }
+                return arrayMatch;
+            }
+            const match = dbValue === configValue;
+            if (!match) {
+                differences.push(`${attr}: db=${JSON.stringify(dbValue)} config=${JSON.stringify(configValue)}`);
             }
-            return dbValue === configValue;
+            return match;
         }
         // If neither has the attribute, consider it the same
         if (!dbHasAttr && !configHasAttr) {
@@ -529,27 +568,51 @@ const attributesSame = (databaseAttribute, configAttribute) => {
             const dbValue = normalizedDbAttr[attr];
             // Consider default-false booleans as equal to missing in config
             if (typeof dbValue === "boolean") {
-                return dbValue === false; // missing in config equals false in db
+                const match = dbValue === false; // missing in config equals false in db
+                if (!match) {
+                    differences.push(`${attr}: db=${dbValue} config=<missing>`);
+                }
+                return match;
+            }
+            const match = dbValue === undefined || dbValue === null;
+            if (!match) {
+                differences.push(`${attr}: db=${JSON.stringify(dbValue)} config=<missing>`);
             }
-            return dbValue === undefined || dbValue === null;
+            return match;
         }
         if (!dbHasAttr && configHasAttr) {
             const configValue = normalizedConfigAttr[attr];
             // Consider default-false booleans as equal to missing in db
             if (typeof configValue === "boolean") {
-                return configValue === false; // missing in db equals false in config
+                const match = configValue === false; // missing in db equals false in config
+                if (!match) {
+                    differences.push(`${attr}: db=<missing> config=${configValue}`);
+                }
+                return match;
             }
-            return configValue === undefined || configValue === null;
+            const match = configValue === undefined || configValue === null;
+            if (!match) {
+                differences.push(`${attr}: db=<missing> config=${JSON.stringify(configValue)}`);
+            }
+            return match;
         }
         // If we reach here, the attributes are different
+        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'
+        });
+    }
+    return result;
 };
 /**
  * Enhanced attribute creation with proper status monitoring and retry logic
  */
 export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collection, attribute, retryCount = 0, maxRetries = 5) => {
-    MessageFormatter.info(chalk.blue(`Creating/updating attribute '${attribute.key}' (attempt ${retryCount + 1}/${maxRetries + 1})`));
     try {
         // First, try to create/update the attribute using existing logic
         const result = await createOrUpdateAttribute(db, dbId, collection, attribute);
@@ -559,6 +622,11 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
             MessageFormatter.info(chalk.yellow(`⏭️  Deferred relationship attribute '${attribute.key}' — queued for later once dependencies are available`));
             return true;
         }
+        // If collection creation failed, return false to indicate failure
+        if (result === "error") {
+            MessageFormatter.error(`Failed to create collection for attribute '${attribute.key}'`);
+            return false;
+        }
         // Now wait for the attribute to become available
         const success = await waitForAttributeAvailable(db, dbId, collection.$id, attribute.key, 60000, // 1 minute timeout
         retryCount, maxRetries);
@@ -724,6 +792,45 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         }
     }
     finalAttribute = parseAttribute(finalAttribute);
+    // Ensure collection/table exists - create it if it doesn't
+    try {
+        await (isDatabaseAdapter(db)
+            ? db.getTable({ databaseId: dbId, tableId: collection.$id })
+            : db.getCollection(dbId, collection.$id));
+    }
+    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')))) {
+            MessageFormatter.info(`Collection '${collection.name}' doesn't exist, creating it first...`);
+            try {
+                if (isDatabaseAdapter(db)) {
+                    await db.createTable({
+                        databaseId: dbId,
+                        id: collection.$id,
+                        name: collection.name,
+                        permissions: collection.$permissions || [],
+                        documentSecurity: collection.documentSecurity ?? false,
+                        enabled: collection.enabled ?? true
+                    });
+                }
+                else {
+                    await db.createCollection(dbId, collection.$id, collection.name, collection.$permissions || [], collection.documentSecurity ?? false, collection.enabled ?? true);
+                }
+                MessageFormatter.success(`Created collection '${collection.name}'`);
+                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)));
+                return "error";
+            }
+        }
+        else {
+            // Other error - re-throw
+            throw error;
+        }
+    }
     // Use adapter-based attribute creation/update
     if (action === "create") {
         await tryAwaitWithRetry(async () => await createAttributeViaAdapter(db, dbId, collection.$id, finalAttribute));
@@ -737,7 +844,6 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
  * Enhanced collection attribute creation with proper status monitoring
  */
 export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId, collection, attributes) => {
-    MessageFormatter.info(chalk.green(`Creating/Updating attributes for collection: ${collection.name} with status monitoring`));
     const existingAttributes = 
     // @ts-expect-error
     collection.attributes.map((attr) => parseAttribute(attr)) || [];
@@ -775,7 +881,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
         }
     }
     // First, get fresh collection data and determine which attributes actually need processing
-    MessageFormatter.info(chalk.blue(`Analyzing ${attributes.length} attributes to determine which need processing...`));
     let currentCollection = collection;
     try {
         currentCollection = isDatabaseAdapter(db)
@@ -799,28 +904,25 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     const attributesToProcess = attributes.filter((attribute) => {
         // Skip if already processed in this session
         if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
-            MessageFormatter.info(chalk.gray(`⏭️ Attribute '${attribute.key}' already processed in this session (skipping)`));
             return false;
         }
         const existing = existingAttributesMap.get(attribute.key);
         if (!existing) {
-            MessageFormatter.info(`➕ New attribute: ${attribute.key}`);
+            MessageFormatter.info(`➕ ${attribute.key}`);
             return true;
         }
-        const needsUpdate = !attributesSame(existing, attribute);
+        const needsUpdate = !attributesSame(existing, parseAttribute(attribute));
         if (needsUpdate) {
-            MessageFormatter.info(`🔄 Changed attribute: ${attribute.key}`);
+            MessageFormatter.info(`🔄 ${attribute.key}`);
         }
         else {
-            MessageFormatter.info(chalk.gray(`✅ Unchanged attribute: ${attribute.key} (skipping)`));
+            MessageFormatter.info(chalk.gray(`✅ ${attribute.key}`));
         }
         return needsUpdate;
     });
     if (attributesToProcess.length === 0) {
-        MessageFormatter.info(chalk.green(`✅ All ${attributes.length} attributes are already up to date for collection: ${collection.name}`));
         return true;
     }
-    MessageFormatter.info(chalk.blue(`Creating ${attributesToProcess.length} attributes sequentially with status monitoring...`));
     let remainingAttributes = [...attributesToProcess];
     let overallRetryCount = 0;
     const maxOverallRetries = 3;
@@ -828,12 +930,9 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
         overallRetryCount < maxOverallRetries) {
         const attributesToProcessThisRound = [...remainingAttributes];
         remainingAttributes = []; // Reset for next iteration
-        MessageFormatter.info(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${attributesToProcessThisRound.length} attributes ===`));
         for (const attribute of attributesToProcessThisRound) {
-            MessageFormatter.info(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
             const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
             if (success) {
-                MessageFormatter.info(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
                 // Mark this specific attribute as processed
                 markAttributeProcessed(currentCollection.$id, attribute.key);
                 // Get updated collection data for next iteration
@@ -849,27 +948,25 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
                 await delay(1000);
             }
             else {
-                MessageFormatter.info(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
+                MessageFormatter.info(chalk.red(`❌ ${attribute.key}`));
                 remainingAttributes.push(attribute); // Add back to retry list
             }
         }
         if (remainingAttributes.length === 0) {
-            MessageFormatter.info(chalk.green(`\n✅ Successfully created all ${attributesToProcess.length} attributes for collection: ${collection.name}`));
             return true;
         }
         overallRetryCount++;
         if (overallRetryCount < maxOverallRetries) {
-            MessageFormatter.info(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`));
+            MessageFormatter.info(chalk.yellow(`⏳ Retrying ${remainingAttributes.length} failed attributes...`));
             await delay(5000);
             // Refresh collection data before retry
             try {
                 currentCollection = isDatabaseAdapter(db)
                     ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data
                     : await db.getCollection(dbId, collection.$id);
-                MessageFormatter.info(`Refreshed collection data for retry`);
             }
             catch (error) {
-                MessageFormatter.info(chalk.yellow(`Warning: Could not refresh collection data for retry: ${error}`));
+                // Silently continue if refresh fails
             }
         }
     }

package/dist/collections/indexes.js

@@ -13,12 +13,8 @@ retryCount = 0, maxRetries = 5) => {
     // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
     if (retryCount > 0) {
         const exponentialDelay = calculateExponentialBackoff(retryCount);
-        MessageFormatter.info(`Waiting for index '${indexKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`);
         await delay(exponentialDelay);
     }
-    else {
-        MessageFormatter.info(`Waiting for index '${indexKey}' to become available...`);
-    }
     while (Date.now() - startTime < maxWaitTime) {
         try {
             const indexList = await (isLegacyDatabases(db)
@@ -32,15 +28,8 @@ retryCount = 0, maxRetries = 5) => {
                 MessageFormatter.error(`Index '${indexKey}' not found in database '${dbId}' collection '${collectionId}'`);
                 return false;
             }
-            if (isLegacyDatabases(db)) {
-                MessageFormatter.debug(`Index '${indexKey}' status: ${index.status}`);
-            }
-            else {
-                MessageFormatter.debug(`Index '${indexKey}' detected (TablesDB)`);
-            }
             switch (index.status) {
                 case 'available':
-                    MessageFormatter.success(`Index '${indexKey}' is now available (type: ${index.type}, attributes: [${index.attributes.join(', ')}])`);
                     return true;
                 case 'failed':
                     MessageFormatter.error(`Index '${indexKey}' failed: ${index.error} (type: ${index.type}, attributes: [${index.attributes.join(', ')}])`);
@@ -139,27 +128,24 @@ export const createOrUpdateIndexesWithStatusCheck = async (dbId, db, collectionI
     while (indexesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
         const remainingIndexes = [...indexesToProcess];
         indexesToProcess = []; // Reset for next iteration
-        MessageFormatter.info(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`);
         for (const index of remainingIndexes) {
-            MessageFormatter.info(`\n--- Processing index: ${index.key} (type: ${index.type}, attributes: [${index.attributes.join(', ')}]) ---`);
             const success = await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index);
             if (success) {
-                MessageFormatter.success(`Successfully created index: ${index.key} (type: ${index.type})`);
+                MessageFormatter.info(`✅ ${index.key} (${index.type})`);
                 // Add delay between successful indexes
                 await delay(1000);
             }
             else {
-                MessageFormatter.error(`Failed to create index: ${index.key} (type: ${index.type}), will retry in next round`);
+                MessageFormatter.info(`❌ ${index.key} (${index.type})`);
                 indexesToProcess.push(index); // Add back to retry list
             }
         }
         if (indexesToProcess.length === 0) {
-            MessageFormatter.success(`\nSuccessfully created all ${indexes.length} indexes for collection '${collectionId}'`);
             return true;
         }
         overallRetryCount++;
         if (overallRetryCount < maxOverallRetries) {
-            MessageFormatter.warning(`\nWaiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`);
+            MessageFormatter.warning(`⏳ Retrying ${indexesToProcess.length} failed indexes...`);
             await delay(5000);
         }
     }

package/dist/collections/methods.js

@@ -387,6 +387,44 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 relQueue.push({ tableId, attr: attr });
             }
         }
+        // Wait for all attributes to become available before creating indexes
+        const allAttrKeys = [
+            ...nonRel.map((a) => a.key),
+            ...rels.filter((a) => a.relatedCollection).map((a) => a.key)
+        ];
+        if (allAttrKeys.length > 0) {
+            for (const attrKey of allAttrKeys) {
+                const maxWait = 60000; // 60 seconds
+                const startTime = Date.now();
+                let lastStatus = '';
+                while (Date.now() - startTime < maxWait) {
+                    try {
+                        const tableData = await adapter.getTable({ databaseId, tableId });
+                        const attrs = tableData.attributes || [];
+                        const attr = attrs.find((a) => a.key === attrKey);
+                        if (attr) {
+                            if (attr.status === 'available') {
+                                break; // Attribute is ready
+                            }
+                            if (attr.status === 'failed' || attr.status === 'stuck') {
+                                throw new Error(`Attribute ${attrKey} failed to create: ${attr.error || 'unknown error'}`);
+                            }
+                            // Still processing, continue waiting
+                            lastStatus = attr.status;
+                        }
+                        await delay(2000); // Check every 2 seconds
+                    }
+                    catch (e) {
+                        // If we can't check status, assume it's processing and continue
+                        await delay(2000);
+                    }
+                }
+                // Timeout check
+                if (Date.now() - startTime >= maxWait) {
+                    MessageFormatter.warning(`Attribute ${attrKey} did not become available within ${maxWait / 1000}s (last status: ${lastStatus}). Proceeding anyway.`, { prefix: 'Attributes' });
+                }
+            }
+        }
         // Indexes
         const idxs = (indexes || []);
         for (const idx of idxs) {