appwrite-utils-cli 1.1.2 → 1.1.4

package/dist/collections/attributes.js

@@ -459,17 +459,53 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             await delay(500); // Longer delay for deletions
         }
     }
-    // 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...`));
+    // First, get fresh collection data and determine which attributes actually need processing
+    console.log(chalk.blue(`Analyzing ${attributes.length} attributes to determine which need processing...`));
     let currentCollection = collection;
-    let attributesToProcess = [...attributes];
+    try {
+        currentCollection = await db.getCollection(dbId, collection.$id);
+    }
+    catch (error) {
+        console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+    }
+    const existingAttributesMap = new Map();
+    try {
+        // @ts-expect-error
+        const parsedAttributes = currentCollection.attributes.map((attr) => parseAttribute(attr));
+        parsedAttributes.forEach(attr => existingAttributesMap.set(attr.key, attr));
+    }
+    catch (error) {
+        console.log(chalk.yellow(`Warning: Could not parse existing attributes: ${error}`));
+    }
+    // Filter to only attributes that need processing (new or changed)
+    const attributesToProcess = attributes.filter(attribute => {
+        const existing = existingAttributesMap.get(attribute.key);
+        if (!existing) {
+            console.log(chalk.blue(`➕ New attribute: ${attribute.key}`));
+            return true;
+        }
+        const needsUpdate = !attributesSame(existing, attribute);
+        if (needsUpdate) {
+            console.log(chalk.blue(`🔄 Changed attribute: ${attribute.key}`));
+        }
+        else {
+            console.log(chalk.gray(`✅ Unchanged attribute: ${attribute.key} (skipping)`));
+        }
+        return needsUpdate;
+    });
+    if (attributesToProcess.length === 0) {
+        console.log(chalk.green(`✅ All ${attributes.length} attributes are already up to date for collection: ${collection.name}`));
+        return true;
+    }
+    console.log(chalk.blue(`Creating ${attributesToProcess.length} attributes sequentially with status monitoring...`));
+    let remainingAttributes = [...attributesToProcess];
     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) {
+    while (remainingAttributes.length > 0 && overallRetryCount < maxOverallRetries) {
+        const attributesToProcessThisRound = [...remainingAttributes];
+        remainingAttributes = []; // Reset for next iteration
+        console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${attributesToProcessThisRound.length} attributes ===`));
+        for (const attribute of attributesToProcessThisRound) {
             console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
             const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
             if (success) {
@@ -486,11 +522,11 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             }
             else {
                 console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
-                attributesToProcess.push(attribute); // Add back to retry list
+                remainingAttributes.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}`));
+        if (remainingAttributes.length === 0) {
+            console.log(chalk.green(`\n✅ Successfully created all ${attributesToProcess.length} attributes for collection: ${collection.name}`));
             return true;
         }
         overallRetryCount++;

package/dist/collections/indexes.js

@@ -63,35 +63,22 @@ 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
  */
 export const createOrUpdateIndexWithStatusCheck = async (dbId, db, collectionId, collection, index, retryCount = 0, maxRetries = 5) => {
     console.log(chalk.blue(`Creating/updating index '${index.key}' (attempt ${retryCount + 1}/${maxRetries + 1})`));
     try {
-        // First, try to create/update the index using existing logic
+        // First, validate that all required attributes exist
+        const freshCollection = await db.getCollection(dbId, collectionId);
+        const existingAttributeKeys = freshCollection.attributes.map((attr) => attr.key);
+        const missingAttributes = index.attributes.filter(attr => !existingAttributeKeys.includes(attr));
+        if (missingAttributes.length > 0) {
+            console.log(chalk.red(`❌ Index '${index.key}' cannot be created: missing attributes [${missingAttributes.join(', ')}]`));
+            console.log(chalk.red(`Available attributes: [${existingAttributeKeys.join(', ')}]`));
+            return false; // Don't retry if attributes are missing
+        }
+        // Try to create/update the index using existing logic
         await createOrUpdateIndex(dbId, db, collectionId, index);
         // Now wait for the index to become available
         const success = await waitForIndexAvailable(db, dbId, collectionId, index.key, 60000, // 1 minute timeout
@@ -99,23 +86,28 @@ 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;
     }
     catch (error) {
-        console.log(chalk.red(`Error creating index '${index.key}': ${error}`));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.log(chalk.red(`Error creating index '${index.key}': ${errorMessage}`));
+        // Check if this is a permanent error that shouldn't be retried
+        if (errorMessage.includes('not found') ||
+            errorMessage.includes('missing') ||
+            errorMessage.includes('does not exist') ||
+            errorMessage.includes('attribute') && errorMessage.includes('not found')) {
+            console.log(chalk.red(`❌ Index '${index.key}' has permanent error - not retrying`));
+            return false;
+        }
         if (retryCount < maxRetries) {
             console.log(chalk.yellow(`Retrying index '${index.key}' due to error...`));
             // Wait a bit before retry

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.2",
+  "version": "1.1.4",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/collections/attributes.ts

@@ -849,21 +849,60 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
     }
   }
 
-  // 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...`));
+  // First, get fresh collection data and determine which attributes actually need processing
+  console.log(chalk.blue(`Analyzing ${attributes.length} attributes to determine which need processing...`));
   
   let currentCollection = collection;
-  let attributesToProcess = [...attributes];
+  try {
+    currentCollection = await db.getCollection(dbId, collection.$id);
+  } catch (error) {
+    console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+  }
+  
+  const existingAttributesMap = new Map<string, Attribute>();
+  try {
+    // @ts-expect-error
+    const parsedAttributes = currentCollection.attributes.map((attr) => parseAttribute(attr));
+    parsedAttributes.forEach(attr => existingAttributesMap.set(attr.key, attr));
+  } catch (error) {
+    console.log(chalk.yellow(`Warning: Could not parse existing attributes: ${error}`));
+  }
+  
+  // Filter to only attributes that need processing (new or changed)
+  const attributesToProcess = attributes.filter(attribute => {
+    const existing = existingAttributesMap.get(attribute.key);
+    if (!existing) {
+      console.log(chalk.blue(`➕ New attribute: ${attribute.key}`));
+      return true;
+    }
+    
+    const needsUpdate = !attributesSame(existing, attribute);
+    if (needsUpdate) {
+      console.log(chalk.blue(`🔄 Changed attribute: ${attribute.key}`));
+    } else {
+      console.log(chalk.gray(`✅ Unchanged attribute: ${attribute.key} (skipping)`));
+    }
+    return needsUpdate;
+  });
+  
+  if (attributesToProcess.length === 0) {
+    console.log(chalk.green(`✅ All ${attributes.length} attributes are already up to date for collection: ${collection.name}`));
+    return true;
+  }
+  
+  console.log(chalk.blue(`Creating ${attributesToProcess.length} attributes sequentially with status monitoring...`));
+  
+  let remainingAttributes = [...attributesToProcess];
   let overallRetryCount = 0;
   const maxOverallRetries = 3;
   
-  while (attributesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
-    const remainingAttributes = [...attributesToProcess];
-    attributesToProcess = []; // Reset for next iteration
+  while (remainingAttributes.length > 0 && overallRetryCount < maxOverallRetries) {
+    const attributesToProcessThisRound = [...remainingAttributes];
+    remainingAttributes = []; // Reset for next iteration
     
-    console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingAttributes.length} attributes ===`));
+    console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${attributesToProcessThisRound.length} attributes ===`));
     
-    for (const attribute of remainingAttributes) {
+    for (const attribute of attributesToProcessThisRound) {
       console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
       
       const success = await createOrUpdateAttributeWithStatusCheck(
@@ -887,12 +926,12 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
         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
+        remainingAttributes.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}`));
+    if (remainingAttributes.length === 0) {
+      console.log(chalk.green(`\n✅ Successfully created all ${attributesToProcess.length} attributes for collection: ${collection.name}`));
       return true;
     }
     

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
@@ -152,7 +114,19 @@ export const createOrUpdateIndexWithStatusCheck = async (
   console.log(chalk.blue(`Creating/updating index '${index.key}' (attempt ${retryCount + 1}/${maxRetries + 1})`));
   
   try {
-    // First, try to create/update the index using existing logic
+    // First, validate that all required attributes exist
+    const freshCollection = await db.getCollection(dbId, collectionId);
+    const existingAttributeKeys = freshCollection.attributes.map((attr: any) => attr.key);
+    
+    const missingAttributes = index.attributes.filter(attr => !existingAttributeKeys.includes(attr));
+    
+    if (missingAttributes.length > 0) {
+      console.log(chalk.red(`❌ Index '${index.key}' cannot be created: missing attributes [${missingAttributes.join(', ')}]`));
+      console.log(chalk.red(`Available attributes: [${existingAttributeKeys.join(', ')}]`));
+      return false; // Don't retry if attributes are missing
+    }
+    
+    // Try to create/update the index using existing logic
     await createOrUpdateIndex(dbId, db, collectionId, index);
     
     // Now wait for the index to become available
@@ -170,35 +144,40 @@ 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`));
     return false;
     
   } catch (error) {
-    console.log(chalk.red(`Error creating index '${index.key}': ${error}`));
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(chalk.red(`Error creating index '${index.key}': ${errorMessage}`));
+    
+    // Check if this is a permanent error that shouldn't be retried
+    if (errorMessage.includes('not found') || 
+        errorMessage.includes('missing') || 
+        errorMessage.includes('does not exist') ||
+        errorMessage.includes('attribute') && errorMessage.includes('not found')) {
+      console.log(chalk.red(`❌ Index '${index.key}' has permanent error - not retrying`));
+      return false;
+    }
     
     if (retryCount < maxRetries) {
       console.log(chalk.yellow(`Retrying index '${index.key}' due to error...`));