appwrite-utils-cli 1.1.1 → 1.1.3

package/dist/collections/attributes.js

@@ -164,16 +164,38 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
         if (success) {
             return true;
         }
-        // If not successful and we have retries left, delete collection and try again
+        // If not successful and we have retries left, delete specific attribute and try again
         if (retryCount < maxRetries) {
-            console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, retrying...`));
-            // Get fresh collection data
-            const freshCollection = await db.getCollection(dbId, collection.$id);
-            // Delete and recreate collection
-            const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
-            if (newCollection) {
-                // Retry with the new collection
-                return await createOrUpdateAttributeWithStatusCheck(db, dbId, newCollection, attribute, retryCount + 1, maxRetries);
+            console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, deleting and retrying...`));
+            // Try to delete the specific stuck attribute instead of the entire collection
+            try {
+                await db.deleteAttribute(dbId, collection.$id, attribute.key);
+                console.log(chalk.yellow(`Deleted stuck attribute '${attribute.key}', will retry creation`));
+                // Wait a bit before retry
+                await delay(3000);
+                // Get fresh collection data
+                const freshCollection = 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);
+            }
+            catch (deleteError) {
+                console.log(chalk.red(`Failed to delete stuck attribute '${attribute.key}': ${deleteError}`));
+                // If attribute deletion fails, only then try collection recreation as last resort
+                if (retryCount >= maxRetries - 1) {
+                    console.log(chalk.yellow(`Last resort: Recreating collection for attribute '${attribute.key}'`));
+                    // Get fresh collection data
+                    const freshCollection = await db.getCollection(dbId, collection.$id);
+                    // Delete and recreate collection
+                    const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
+                    if (newCollection) {
+                        // Retry with the new collection
+                        return await createOrUpdateAttributeWithStatusCheck(db, dbId, newCollection, attribute, retryCount + 1, maxRetries);
+                    }
+                }
+                else {
+                    // Continue to next retry without collection recreation
+                    return await createOrUpdateAttributeWithStatusCheck(db, dbId, collection, attribute, retryCount + 1, maxRetries);
+                }
             }
         }
         console.log(chalk.red(`❌ Failed to create attribute '${attribute.key}' after ${maxRetries + 1} attempts`));
@@ -437,32 +459,58 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             await delay(500); // Longer delay for deletions
         }
     }
-    // Create attributes ONE BY ONE with proper status checking
+    // Create attributes ONE BY ONE with proper status checking and persistent retry logic
     console.log(chalk.blue(`Creating ${attributes.length} attributes sequentially with status monitoring...`));
     let currentCollection = collection;
-    const failedAttributes = [];
-    for (const attribute of attributes) {
-        console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
-        const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
-        if (success) {
-            console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
-            // Get updated collection data for next iteration
+    let attributesToProcess = [...attributes];
+    let overallRetryCount = 0;
+    const maxOverallRetries = 3;
+    while (attributesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+        const remainingAttributes = [...attributesToProcess];
+        attributesToProcess = []; // Reset for next iteration
+        console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingAttributes.length} attributes ===`));
+        for (const attribute of remainingAttributes) {
+            console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
+            const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
+            if (success) {
+                console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
+                // Get updated collection data for next iteration
+                try {
+                    currentCollection = await db.getCollection(dbId, collection.$id);
+                }
+                catch (error) {
+                    console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+                }
+                // Add delay between successful attributes
+                await delay(1000);
+            }
+            else {
+                console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
+                attributesToProcess.push(attribute); // Add back to retry list
+            }
+        }
+        if (attributesToProcess.length === 0) {
+            console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));
+            return true;
+        }
+        overallRetryCount++;
+        if (overallRetryCount < maxOverallRetries) {
+            console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`));
+            await delay(5000);
+            // Refresh collection data before retry
             try {
                 currentCollection = await db.getCollection(dbId, collection.$id);
+                console.log(chalk.blue(`Refreshed collection data for retry`));
             }
             catch (error) {
-                console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+                console.log(chalk.yellow(`Warning: Could not refresh collection data for retry: ${error}`));
             }
-            // Add delay between successful attributes
-            await delay(1000);
-        }
-        else {
-            console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}`));
-            failedAttributes.push(attribute.key);
         }
     }
-    if (failedAttributes.length > 0) {
-        console.log(chalk.red(`\n❌ Failed to create ${failedAttributes.length} attributes: ${failedAttributes.join(', ')}`));
+    // If we get here, some attributes still failed after all retries
+    if (attributesToProcess.length > 0) {
+        console.log(chalk.red(`\n❌ Failed to create ${attributesToProcess.length} attributes after ${maxOverallRetries} attempts: ${attributesToProcess.map(a => a.key).join(', ')}`));
+        console.log(chalk.red(`This may indicate a fundamental issue with the attribute definitions or Appwrite instance`));
         return false;
     }
     console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));

package/dist/collections/indexes.js

@@ -63,28 +63,6 @@ retryCount = 0, maxRetries = 5) => {
     }
     return false;
 };
-/**
- * Delete collection and recreate for index retry (reused from attributes.ts)
- */
-const deleteAndRecreateCollectionForIndex = async (db, dbId, collection, retryCount) => {
-    try {
-        console.log(chalk.yellow(`🗑️ Deleting collection '${collection.name}' for index retry ${retryCount}`));
-        // Delete the collection
-        await db.deleteCollection(dbId, collection.$id);
-        console.log(chalk.yellow(`Deleted collection '${collection.name}'`));
-        // Wait a bit before recreating
-        await delay(2000);
-        // Recreate the collection
-        console.log(chalk.blue(`🔄 Recreating collection '${collection.name}'`));
-        const newCollection = await db.createCollection(dbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled);
-        console.log(chalk.green(`✅ Recreated collection '${collection.name}'`));
-        return newCollection;
-    }
-    catch (error) {
-        console.log(chalk.red(`Failed to delete/recreate collection '${collection.name}': ${error}`));
-        return null;
-    }
-};
 /**
  * Enhanced index creation with proper status monitoring and retry logic
  */
@@ -99,17 +77,13 @@ export const createOrUpdateIndexWithStatusCheck = async (dbId, db, collectionId,
         if (success) {
             return true;
         }
-        // If not successful and we have retries left, delete collection and try again
+        // If not successful and we have retries left, just retry the index creation
         if (retryCount < maxRetries) {
-            console.log(chalk.yellow(`Index '${index.key}' failed/stuck, retrying...`));
-            // Get fresh collection data
-            const freshCollection = await db.getCollection(dbId, collectionId);
-            // Delete and recreate collection
-            const newCollection = await deleteAndRecreateCollectionForIndex(db, dbId, freshCollection, retryCount + 1);
-            if (newCollection) {
-                // Retry with the new collection
-                return await createOrUpdateIndexWithStatusCheck(dbId, db, newCollection.$id, newCollection, index, retryCount + 1, maxRetries);
-            }
+            console.log(chalk.yellow(`Index '${index.key}' failed/stuck, retrying (${retryCount + 1}/${maxRetries})...`));
+            // Wait a bit before retry
+            await new Promise(resolve => setTimeout(resolve, 2000 * (retryCount + 1)));
+            // Retry the index creation
+            return await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index, retryCount + 1, maxRetries);
         }
         console.log(chalk.red(`❌ Failed to create index '${index.key}' after ${maxRetries + 1} attempts`));
         return false;
@@ -130,22 +104,40 @@ export const createOrUpdateIndexWithStatusCheck = async (dbId, db, collectionId,
  */
 export const createOrUpdateIndexesWithStatusCheck = async (dbId, db, collectionId, collection, indexes) => {
     console.log(chalk.blue(`Creating/updating ${indexes.length} indexes with status monitoring...`));
-    const failedIndexes = [];
-    for (const index of indexes) {
-        console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
-        const success = await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index);
-        if (success) {
-            console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
-            // Add delay between successful indexes
-            await delay(1000);
+    let indexesToProcess = [...indexes];
+    let overallRetryCount = 0;
+    const maxOverallRetries = 3;
+    while (indexesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+        const remainingIndexes = [...indexesToProcess];
+        indexesToProcess = []; // Reset for next iteration
+        console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`));
+        for (const index of remainingIndexes) {
+            console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
+            const success = await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index);
+            if (success) {
+                console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
+                // Add delay between successful indexes
+                await delay(1000);
+            }
+            else {
+                console.log(chalk.red(`❌ Failed to create index: ${index.key}, will retry in next round`));
+                indexesToProcess.push(index); // Add back to retry list
+            }
+        }
+        if (indexesToProcess.length === 0) {
+            console.log(chalk.green(`\n✅ Successfully created all ${indexes.length} indexes`));
+            return true;
         }
-        else {
-            console.log(chalk.red(`❌ Failed to create index: ${index.key}`));
-            failedIndexes.push(index.key);
+        overallRetryCount++;
+        if (overallRetryCount < maxOverallRetries) {
+            console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`));
+            await delay(5000);
         }
     }
-    if (failedIndexes.length > 0) {
-        console.log(chalk.red(`\n❌ Failed to create ${failedIndexes.length} indexes: ${failedIndexes.join(', ')}`));
+    // If we get here, some indexes still failed after all retries
+    if (indexesToProcess.length > 0) {
+        console.log(chalk.red(`\n❌ Failed to create ${indexesToProcess.length} indexes after ${maxOverallRetries} attempts: ${indexesToProcess.map(i => i.key).join(', ')}`));
+        console.log(chalk.red(`This may indicate a fundamental issue with the index definitions or Appwrite instance`));
         return false;
     }
     console.log(chalk.green(`\n✅ Successfully created all ${indexes.length} indexes`));

package/dist/interactiveCLI.js

@@ -1516,7 +1516,9 @@ export class InteractiveCLI {
     async comprehensiveTransfer() {
         MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
         try {
-            // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)\n      await this.initControllerIfNeeded();\n      \n      // Check if user has an appwrite config for easier setup
+            // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)
+            await this.initControllerIfNeeded();
+            // Check if user has an appwrite config for easier setup
             const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint &&
                 this.controller?.config?.appwriteProject &&
                 this.controller?.config?.appwriteKey;

package/dist/migrations/comprehensiveTransfer.js

@@ -213,7 +213,9 @@ export class ComprehensiveTransfer {
                     const attributesSuccess = await this.createCollectionAttributesWithStatusCheck(this.targetDatabases, dbId, targetCollection, attributesToCreate);
                     if (!attributesSuccess) {
                         MessageFormatter.error(`Failed to create some attributes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
-                        // Continue with the transfer even if some attributes failed
+                        MessageFormatter.error(`Skipping index creation and document transfer for collection ${collection.name} due to attribute failures`, undefined, { prefix: "Transfer" });
+                        // Skip indexes and document transfer if attributes failed
+                        continue;
                     }
                     else {
                         MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
@@ -223,7 +225,7 @@ export class ComprehensiveTransfer {
                     const indexesSuccess = await this.createCollectionIndexesWithStatusCheck(dbId, this.targetDatabases, targetCollection.$id, targetCollection, collection.indexes);
                     if (!indexesSuccess) {
                         MessageFormatter.error(`Failed to create some indexes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
-                        // Continue with the transfer even if some indexes failed
+                        MessageFormatter.warning(`Proceeding with document transfer despite index failures for collection ${collection.name}`, { prefix: "Transfer" });
                     }
                     else {
                         MessageFormatter.success(`All indexes created successfully for collection ${collection.name}`, { prefix: "Transfer" });

package/package.json

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

package/src/collections/attributes.ts

@@ -263,26 +263,65 @@ export const createOrUpdateAttributeWithStatusCheck = async (
       return true;
     }
     
-    // If not successful and we have retries left, delete collection and try again
+    // If not successful and we have retries left, delete specific attribute and try again
     if (retryCount < maxRetries) {
-      console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, retrying...`));
+      console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, deleting and retrying...`));
       
-      // Get fresh collection data
-      const freshCollection = await db.getCollection(dbId, collection.$id);
-      
-      // Delete and recreate collection
-      const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
-      
-      if (newCollection) {
-        // Retry with the new collection
+      // Try to delete the specific stuck attribute instead of the entire collection
+      try {
+        await db.deleteAttribute(dbId, collection.$id, attribute.key);
+        console.log(chalk.yellow(`Deleted stuck attribute '${attribute.key}', will retry creation`));
+        
+        // Wait a bit before retry
+        await delay(3000);
+        
+        // Get fresh collection data
+        const freshCollection = await db.getCollection(dbId, collection.$id);
+        
+        // Retry with the same collection (attribute should be gone now)
         return await createOrUpdateAttributeWithStatusCheck(
           db, 
           dbId, 
-          newCollection, 
+          freshCollection, 
           attribute, 
           retryCount + 1, 
           maxRetries
         );
+      } catch (deleteError) {
+        console.log(chalk.red(`Failed to delete stuck attribute '${attribute.key}': ${deleteError}`));
+        
+        // If attribute deletion fails, only then try collection recreation as last resort
+        if (retryCount >= maxRetries - 1) {
+          console.log(chalk.yellow(`Last resort: Recreating collection for attribute '${attribute.key}'`));
+          
+          // Get fresh collection data
+          const freshCollection = await db.getCollection(dbId, collection.$id);
+          
+          // Delete and recreate collection
+          const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
+          
+          if (newCollection) {
+            // Retry with the new collection
+            return await createOrUpdateAttributeWithStatusCheck(
+              db, 
+              dbId, 
+              newCollection, 
+              attribute, 
+              retryCount + 1, 
+              maxRetries
+            );
+          }
+        } else {
+          // Continue to next retry without collection recreation
+          return await createOrUpdateAttributeWithStatusCheck(
+            db, 
+            dbId, 
+            collection, 
+            attribute, 
+            retryCount + 1, 
+            maxRetries
+          );
+        }
       }
     }
     
@@ -810,42 +849,73 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
     }
   }
 
-  // Create attributes ONE BY ONE with proper status checking
+  // Create attributes ONE BY ONE with proper status checking and persistent retry logic
   console.log(chalk.blue(`Creating ${attributes.length} attributes sequentially with status monitoring...`));
   
   let currentCollection = collection;
-  const failedAttributes: string[] = [];
+  let attributesToProcess = [...attributes];
+  let overallRetryCount = 0;
+  const maxOverallRetries = 3;
   
-  for (const attribute of attributes) {
-    console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
+  while (attributesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+    const remainingAttributes = [...attributesToProcess];
+    attributesToProcess = []; // Reset for next iteration
     
-    const success = await createOrUpdateAttributeWithStatusCheck(
-      db, 
-      dbId, 
-      currentCollection, 
-      attribute
-    );
+    console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingAttributes.length} attributes ===`));
     
-    if (success) {
-      console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
+    for (const attribute of remainingAttributes) {
+      console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
+      
+      const success = await createOrUpdateAttributeWithStatusCheck(
+        db, 
+        dbId, 
+        currentCollection, 
+        attribute
+      );
+      
+      if (success) {
+        console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
+        
+        // Get updated collection data for next iteration
+        try {
+          currentCollection = await db.getCollection(dbId, collection.$id);
+        } catch (error) {
+          console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+        }
+        
+        // Add delay between successful attributes
+        await delay(1000);
+      } else {
+        console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
+        attributesToProcess.push(attribute); // Add back to retry list
+      }
+    }
+    
+    if (attributesToProcess.length === 0) {
+      console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));
+      return true;
+    }
+    
+    overallRetryCount++;
+    
+    if (overallRetryCount < maxOverallRetries) {
+      console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`));
+      await delay(5000);
       
-      // Get updated collection data for next iteration
+      // Refresh collection data before retry
       try {
         currentCollection = await db.getCollection(dbId, collection.$id);
+        console.log(chalk.blue(`Refreshed collection data for retry`));
       } catch (error) {
-        console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+        console.log(chalk.yellow(`Warning: Could not refresh collection data for retry: ${error}`));
       }
-      
-      // Add delay between successful attributes
-      await delay(1000);
-    } else {
-      console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}`));
-      failedAttributes.push(attribute.key);
     }
   }
   
-  if (failedAttributes.length > 0) {
-    console.log(chalk.red(`\n❌ Failed to create ${failedAttributes.length} attributes: ${failedAttributes.join(', ')}`));
+  // If we get here, some attributes still failed after all retries
+  if (attributesToProcess.length > 0) {
+    console.log(chalk.red(`\n❌ Failed to create ${attributesToProcess.length} attributes after ${maxOverallRetries} attempts: ${attributesToProcess.map(a => a.key).join(', ')}`));
+    console.log(chalk.red(`This may indicate a fundamental issue with the attribute definitions or Appwrite instance`));
     return false;
   }
   

package/src/collections/indexes.ts

@@ -98,44 +98,6 @@ const waitForIndexAvailable = async (
   return false;
 };
 
-/**
- * Delete collection and recreate for index retry (reused from attributes.ts)
- */
-const deleteAndRecreateCollectionForIndex = async (
-  db: Databases,
-  dbId: string,
-  collection: Models.Collection,
-  retryCount: number
-): Promise<Models.Collection | null> => {
-  try {
-    console.log(chalk.yellow(`🗑️ Deleting collection '${collection.name}' for index retry ${retryCount}`));
-    
-    // Delete the collection
-    await db.deleteCollection(dbId, collection.$id);
-    console.log(chalk.yellow(`Deleted collection '${collection.name}'`));
-    
-    // Wait a bit before recreating
-    await delay(2000);
-    
-    // Recreate the collection
-    console.log(chalk.blue(`🔄 Recreating collection '${collection.name}'`));
-    const newCollection = await db.createCollection(
-      dbId,
-      collection.$id,
-      collection.name,
-      collection.$permissions,
-      collection.documentSecurity,
-      collection.enabled
-    );
-    
-    console.log(chalk.green(`✅ Recreated collection '${collection.name}'`));
-    return newCollection;
-    
-  } catch (error) {
-    console.log(chalk.red(`Failed to delete/recreate collection '${collection.name}': ${error}`));
-    return null;
-  }
-};
 
 /**
  * Enhanced index creation with proper status monitoring and retry logic
@@ -170,28 +132,23 @@ export const createOrUpdateIndexWithStatusCheck = async (
       return true;
     }
     
-    // If not successful and we have retries left, delete collection and try again
+    // If not successful and we have retries left, just retry the index creation
     if (retryCount < maxRetries) {
-      console.log(chalk.yellow(`Index '${index.key}' failed/stuck, retrying...`));
-      
-      // Get fresh collection data
-      const freshCollection = await db.getCollection(dbId, collectionId);
+      console.log(chalk.yellow(`Index '${index.key}' failed/stuck, retrying (${retryCount + 1}/${maxRetries})...`));
       
-      // Delete and recreate collection
-      const newCollection = await deleteAndRecreateCollectionForIndex(db, dbId, freshCollection, retryCount + 1);
+      // Wait a bit before retry
+      await new Promise(resolve => setTimeout(resolve, 2000 * (retryCount + 1)));
       
-      if (newCollection) {
-        // Retry with the new collection
-        return await createOrUpdateIndexWithStatusCheck(
-          dbId, 
-          db, 
-          newCollection.$id, 
-          newCollection, 
-          index, 
-          retryCount + 1, 
-          maxRetries
-        );
-      }
+      // Retry the index creation
+      return await createOrUpdateIndexWithStatusCheck(
+        dbId, 
+        db, 
+        collectionId, 
+        collection, 
+        index, 
+        retryCount + 1, 
+        maxRetries
+      );
     }
     
     console.log(chalk.red(`❌ Failed to create index '${index.key}' after ${maxRetries + 1} attempts`));
@@ -233,32 +190,55 @@ export const createOrUpdateIndexesWithStatusCheck = async (
 ): Promise<boolean> => {
   console.log(chalk.blue(`Creating/updating ${indexes.length} indexes with status monitoring...`));
   
-  const failedIndexes: string[] = [];
+  let indexesToProcess = [...indexes];
+  let overallRetryCount = 0;
+  const maxOverallRetries = 3;
   
-  for (const index of indexes) {
-    console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
+  while (indexesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+    const remainingIndexes = [...indexesToProcess];
+    indexesToProcess = []; // Reset for next iteration
     
-    const success = await createOrUpdateIndexWithStatusCheck(
-      dbId, 
-      db, 
-      collectionId, 
-      collection, 
-      index
-    );
+    console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`));
     
-    if (success) {
-      console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
+    for (const index of remainingIndexes) {
+      console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
       
-      // Add delay between successful indexes
-      await delay(1000);
-    } else {
-      console.log(chalk.red(`❌ Failed to create index: ${index.key}`));
-      failedIndexes.push(index.key);
+      const success = await createOrUpdateIndexWithStatusCheck(
+        dbId, 
+        db, 
+        collectionId, 
+        collection, 
+        index
+      );
+      
+      if (success) {
+        console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
+        
+        // Add delay between successful indexes
+        await delay(1000);
+      } else {
+        console.log(chalk.red(`❌ Failed to create index: ${index.key}, will retry in next round`));
+        indexesToProcess.push(index); // Add back to retry list
+      }
+    }
+    
+    if (indexesToProcess.length === 0) {
+      console.log(chalk.green(`\n✅ Successfully created all ${indexes.length} indexes`));
+      return true;
+    }
+    
+    overallRetryCount++;
+    
+    if (overallRetryCount < maxOverallRetries) {
+      console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`));
+      await delay(5000);
     }
   }
   
-  if (failedIndexes.length > 0) {
-    console.log(chalk.red(`\n❌ Failed to create ${failedIndexes.length} indexes: ${failedIndexes.join(', ')}`));
+  // If we get here, some indexes still failed after all retries
+  if (indexesToProcess.length > 0) {
+    console.log(chalk.red(`\n❌ Failed to create ${indexesToProcess.length} indexes after ${maxOverallRetries} attempts: ${indexesToProcess.map(i => i.key).join(', ')}`));
+    console.log(chalk.red(`This may indicate a fundamental issue with the index definitions or Appwrite instance`));
     return false;
   }
   

package/src/interactiveCLI.ts

@@ -2052,7 +2052,10 @@ export class InteractiveCLI {
     MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
 
     try {
-      // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)\n      await this.initControllerIfNeeded();\n      \n      // Check if user has an appwrite config for easier setup
+      // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)
+      await this.initControllerIfNeeded();
+      
+      // Check if user has an appwrite config for easier setup
       const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint && 
                                this.controller?.config?.appwriteProject && 
                                this.controller?.config?.appwriteKey;

package/src/migrations/comprehensiveTransfer.ts

@@ -331,7 +331,9 @@ export class ComprehensiveTransfer {
           
           if (!attributesSuccess) {
             MessageFormatter.error(`Failed to create some attributes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
-            // Continue with the transfer even if some attributes failed
+            MessageFormatter.error(`Skipping index creation and document transfer for collection ${collection.name} due to attribute failures`, undefined, { prefix: "Transfer" });
+            // Skip indexes and document transfer if attributes failed
+            continue;
           } else {
             MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
           }
@@ -349,7 +351,7 @@ export class ComprehensiveTransfer {
           
           if (!indexesSuccess) {
             MessageFormatter.error(`Failed to create some indexes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
-            // Continue with the transfer even if some indexes failed
+            MessageFormatter.warning(`Proceeding with document transfer despite index failures for collection ${collection.name}`, { prefix: "Transfer" });
           } else {
             MessageFormatter.success(`All indexes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
           }