appwrite-utils-cli 1.6.2 → 1.6.4

package/src/collections/attributes.ts

@@ -17,8 +17,8 @@ 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;
@@ -142,12 +142,22 @@ const normalizeMinMaxValues = (attribute: Attribute): { min?: number; max?: numb
  * This is used when comparing database attributes with config attributes
  */
 const normalizeAttributeForComparison = (attribute: Attribute): Attribute => {
-  if (!hasMinMaxProperties(attribute)) {
-    return attribute;
+  const normalized: any = { ...attribute };
+
+  // Normalize min/max for numeric types
+  if (hasMinMaxProperties(attribute)) {
+    const { min, max } = normalizeMinMaxValues(attribute);
+    normalized.min = min;
+    normalized.max = max;
   }
 
-  const { min, max } = normalizeMinMaxValues(attribute);
-  return { ...(attribute as any), min, 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;
+  }
+
+  return normalized;
 };
 
 /**
@@ -434,7 +444,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        (attribute as any).xdefault !== undefined && !attribute.required ? (attribute as any).xdefault : undefined,
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null,
         attribute.size
       );
       break;
@@ -444,7 +454,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        (attribute as any).xdefault !== undefined && !attribute.required ? (attribute as any).xdefault : undefined,
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null,
         normalizedMin !== undefined ? parseInt(String(normalizedMin)) : undefined,
         normalizedMax !== undefined ? parseInt(String(normalizedMax)) : undefined
       );
@@ -458,7 +468,7 @@ const updateLegacyAttribute = async (
         attribute.required || false,
         normalizedMin !== undefined ? Number(normalizedMin) : undefined,
         normalizedMax !== undefined ? Number(normalizedMax) : undefined,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "boolean":
@@ -467,7 +477,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "datetime":
@@ -476,7 +486,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "email":
@@ -485,7 +495,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "ip":
@@ -494,7 +504,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "url":
@@ -503,7 +513,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "enum":
@@ -513,7 +523,7 @@ const updateLegacyAttribute = async (
         attribute.key,
         (attribute as any).elements || [],
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "relationship":
@@ -569,18 +579,7 @@ const waitForAttributeAvailable = async (
   // 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) {
@@ -597,10 +596,6 @@ const waitForAttributeAvailable = async (
         return false;
       }
 
-      MessageFormatter.info(
-        chalk.gray(`Attribute '${attributeKey}' status: ${attribute.status}`)
-      );
-
       const statusInfo = {
         attributeKey,
         status: attribute.status,
@@ -613,27 +608,14 @@ const waitForAttributeAvailable = async (
 
       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;
 
@@ -792,6 +774,45 @@ const deleteAndRecreateCollection = async (
   }
 };
 
+/**
+ * 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: string): string[] => {
+  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: Attribute,
   configAttribute: Attribute
@@ -800,25 +821,12 @@ const attributesSame = (
   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: string[] = [];
+
+  const result = attributesToCheck.every((attr) => {
     // Check if both objects have the attribute
     const dbHasAttr = attr in normalizedDbAttr;
     const configHasAttr = attr in normalizedConfigAttr;
@@ -838,16 +846,40 @@ const attributesSame = (
 
       // 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;
       }
-      return dbValue === configValue;
+
+      // 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 match;
     }
 
     // If neither has the attribute, consider it the same
@@ -860,23 +892,50 @@ const attributesSame = (
       const dbValue = normalizedDbAttr[attr as keyof typeof normalizedDbAttr];
       // 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;
       }
-      return dbValue === undefined || dbValue === null;
+      const match = dbValue === undefined || dbValue === null;
+      if (!match) {
+        differences.push(`${attr}: db=${JSON.stringify(dbValue)} config=<missing>`);
+      }
+      return match;
     }
 
     if (!dbHasAttr && configHasAttr) {
       const configValue = normalizedConfigAttr[attr as keyof typeof normalizedConfigAttr];
       // 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;
 };
 
 /**
@@ -890,14 +949,6 @@ export const createOrUpdateAttributeWithStatusCheck = async (
   retryCount: number = 0,
   maxRetries: number = 5
 ): Promise<boolean> => {
-  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);
@@ -913,6 +964,12 @@ export const createOrUpdateAttributeWithStatusCheck = async (
       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,
@@ -1059,7 +1116,7 @@ export const createOrUpdateAttribute = async (
   dbId: string,
   collection: Models.Collection,
   attribute: Attribute
-): Promise<"queued" | "processed"> => {
+): Promise<"queued" | "processed" | "error"> => {
   let action = "create";
   let foundAttribute: Attribute | undefined;
   const updateEnabled = true;
@@ -1069,7 +1126,7 @@ export const createOrUpdateAttribute = async (
       (attr: any) => attr.key === attribute.key
     ) as unknown as any;
     foundAttribute = parseAttribute(collectionAttr);
-
+
   } catch (error) {
     foundAttribute = undefined;
   }
@@ -1110,7 +1167,7 @@ export const createOrUpdateAttribute = async (
     return "processed";
   }
 
-
+
 
   // Relationship attribute logic with adjustments
   let collectionFoundViaRelatedCollection: Models.Collection | undefined;
@@ -1181,7 +1238,57 @@ export const createOrUpdateAttribute = async (
     }
   }
   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 as any).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") {
@@ -1205,12 +1312,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   collection: Models.Collection,
   attributes: Attribute[]
 ): Promise<boolean> => {
-  MessageFormatter.info(
-    chalk.green(
-      `Creating/Updating attributes for collection: ${collection.name} with status monitoring`
-    )
-  );
-
   const existingAttributes: Attribute[] =
     // @ts-expect-error
     collection.attributes.map((attr) => parseAttribute(attr)) || [];
@@ -1265,12 +1366,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   }
 
   // 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)
@@ -1301,44 +1396,28 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   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;
@@ -1350,21 +1429,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
     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,
@@ -1373,10 +1438,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
       );
 
       if (success) {
-        MessageFormatter.info(
-          chalk.green(`✅ Successfully created attribute: ${attribute.key}`)
-        );
-
         // Mark this specific attribute as processed
         markAttributeProcessed(currentCollection.$id, attribute.key);
 
@@ -1394,21 +1455,12 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
         // Add delay between successful attributes
         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;
     }
 
@@ -1416,9 +1468,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
 
     if (overallRetryCount < maxOverallRetries) {
       MessageFormatter.info(
-        chalk.yellow(
-          `\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`
-        )
+        chalk.yellow(`⏳ Retrying ${remainingAttributes.length} failed attributes...`)
       );
       await delay(5000);
 
@@ -1427,13 +1477,8 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
         currentCollection = isDatabaseAdapter(db)
       ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data as Models.Collection
       : 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/src/collections/indexes.ts

@@ -35,12 +35,9 @@ const waitForIndexAvailable = async (
   // 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)
@@ -56,15 +53,8 @@ const waitForIndexAvailable = async (
         return false;
       }
 
-      if (isLegacyDatabases(db)) {
-        MessageFormatter.debug(`Index '${indexKey}' status: ${(index as any).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':
@@ -229,11 +219,7 @@ export const createOrUpdateIndexesWithStatusCheck = async (
     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,
@@ -243,25 +229,24 @@ export const createOrUpdateIndexesWithStatusCheck = async (
       );
 
       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);
     }
   }