appwrite-utils-cli 1.1.3 → 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

@@ -69,7 +69,16 @@ retryCount = 0, maxRetries = 5) => {
 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
@@ -89,7 +98,16 @@ export const createOrUpdateIndexWithStatusCheck = async (dbId, db, collectionId,
         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.3",
+  "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

@@ -114,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
@@ -155,7 +167,17 @@ export const createOrUpdateIndexWithStatusCheck = async (
     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...`));