appwrite-utils-cli 1.0.9 → 1.1.0

package/dist/interactiveCLI.js

@@ -1516,48 +1516,140 @@ export class InteractiveCLI {
     async comprehensiveTransfer() {
         MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
         try {
-            // Get source configuration
-            const sourceConfig = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "sourceEndpoint",
-                    message: "Enter the source Appwrite endpoint:",
-                    validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-                },
-                {
-                    type: "input",
-                    name: "sourceProject",
-                    message: "Enter the source project ID:",
-                    validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-                },
-                {
-                    type: "password",
-                    name: "sourceKey",
-                    message: "Enter the source API key:",
-                    validate: (input) => input.trim() !== "" || "API key cannot be empty",
-                },
-            ]);
-            // Get target configuration
-            const targetConfig = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "targetEndpoint",
-                    message: "Enter the target Appwrite endpoint:",
-                    validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-                },
-                {
-                    type: "input",
-                    name: "targetProject",
-                    message: "Enter the target project ID:",
-                    validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-                },
-                {
-                    type: "password",
-                    name: "targetKey",
-                    message: "Enter the target API key:",
-                    validate: (input) => input.trim() !== "" || "API key cannot be empty",
-                },
-            ]);
+            // Check if user has an appwrite config for easier setup
+            const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint &&
+                this.controller?.config?.appwriteProject &&
+                this.controller?.config?.appwriteKey;
+            let sourceConfig;
+            let targetConfig;
+            if (hasAppwriteConfig) {
+                // Offer to use existing config for source
+                const { useConfigForSource } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "useConfigForSource",
+                        message: "Use your current appwriteConfig as the source?",
+                        default: true,
+                    },
+                ]);
+                if (useConfigForSource) {
+                    sourceConfig = {
+                        sourceEndpoint: this.controller.config.appwriteEndpoint,
+                        sourceProject: this.controller.config.appwriteProject,
+                        sourceKey: this.controller.config.appwriteKey,
+                    };
+                    MessageFormatter.info(`Using config source: ${sourceConfig.sourceEndpoint}`, { prefix: "Transfer" });
+                }
+                else {
+                    // Get source configuration manually
+                    sourceConfig = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "sourceEndpoint",
+                            message: "Enter the source Appwrite endpoint:",
+                            validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                        },
+                        {
+                            type: "input",
+                            name: "sourceProject",
+                            message: "Enter the source project ID:",
+                            validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                        },
+                        {
+                            type: "password",
+                            name: "sourceKey",
+                            message: "Enter the source API key:",
+                            validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                        },
+                    ]);
+                }
+                // Offer to use existing config for target
+                const { useConfigForTarget } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "useConfigForTarget",
+                        message: "Use your current appwriteConfig as the target?",
+                        default: false,
+                    },
+                ]);
+                if (useConfigForTarget) {
+                    targetConfig = {
+                        targetEndpoint: this.controller.config.appwriteEndpoint,
+                        targetProject: this.controller.config.appwriteProject,
+                        targetKey: this.controller.config.appwriteKey,
+                    };
+                    MessageFormatter.info(`Using config target: ${targetConfig.targetEndpoint}`, { prefix: "Transfer" });
+                }
+                else {
+                    // Get target configuration manually
+                    targetConfig = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "targetEndpoint",
+                            message: "Enter the target Appwrite endpoint:",
+                            validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                        },
+                        {
+                            type: "input",
+                            name: "targetProject",
+                            message: "Enter the target project ID:",
+                            validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                        },
+                        {
+                            type: "password",
+                            name: "targetKey",
+                            message: "Enter the target API key:",
+                            validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                        },
+                    ]);
+                }
+            }
+            else {
+                // No appwrite config found, get both configurations manually
+                MessageFormatter.info("No appwriteConfig found, please enter source and target configurations manually", { prefix: "Transfer" });
+                // Get source configuration
+                sourceConfig = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "sourceEndpoint",
+                        message: "Enter the source Appwrite endpoint:",
+                        validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                    },
+                    {
+                        type: "input",
+                        name: "sourceProject",
+                        message: "Enter the source project ID:",
+                        validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                    },
+                    {
+                        type: "password",
+                        name: "sourceKey",
+                        message: "Enter the source API key:",
+                        validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                    },
+                ]);
+                // Get target configuration
+                targetConfig = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "targetEndpoint",
+                        message: "Enter the target Appwrite endpoint:",
+                        validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                    },
+                    {
+                        type: "input",
+                        name: "targetProject",
+                        message: "Enter the target project ID:",
+                        validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                    },
+                    {
+                        type: "password",
+                        name: "targetKey",
+                        message: "Enter the target API key:",
+                        validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                    },
+                ]);
+            }
             // Get transfer options
             const transferOptions = await inquirer.prompt([
                 {

package/dist/migrations/transfer.js

@@ -2,13 +2,13 @@ import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
 import { Client, Databases, IndexType, Query, Storage, Users, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { getAppwriteClient } from "../utils/helperFunctions.js";
-import { createOrUpdateAttribute, createUpdateCollectionAttributes, } from "../collections/attributes.js";
+import { createOrUpdateAttribute, createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck, } from "../collections/attributes.js";
 import { parseAttribute } from "appwrite-utils";
 import chalk from "chalk";
 import { fetchAllCollections } from "../collections/methods.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { createOrUpdateIndex, createOrUpdateIndexes, } from "../collections/indexes.js";
+import { createOrUpdateIndex, createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck, } from "../collections/indexes.js";
 import { getClient } from "../utils/getClientFromConfig.js";
 export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
     MessageFormatter.info(`Transferring files from ${fromBucketId} to ${toBucketId}`, { prefix: "Transfer" });
@@ -161,20 +161,15 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 console.log(chalk.yellow(`Creating collection ${collection.name} in target database...`));
                 targetCollection = await tryAwaitWithRetry(async () => localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-            // Handle attributes
-            const existingAttributes = await tryAwaitWithRetry(async () => await localDb.listAttributes(targetDbId, targetCollection.$id));
-            for (const attribute of collection.attributes) {
-                const parsedAttribute = parseAttribute(attribute);
-                const existingAttribute = existingAttributes.attributes.find((attr) => attr.key === parsedAttribute.key);
-                if (!existingAttribute) {
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(localDb, targetDbId, targetCollection, parsedAttribute));
-                    console.log(chalk.green(`Attribute ${parsedAttribute.key} created`));
-                }
-                else {
-                    console.log(chalk.blue(`Attribute ${parsedAttribute.key} exists, checking for updates...`));
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(localDb, targetDbId, targetCollection, parsedAttribute));
-                }
+            // Handle attributes with enhanced status checking
+            console.log(chalk.blue(`Creating attributes for collection ${collection.name} with enhanced monitoring...`));
+            const allAttributes = collection.attributes.map(attr => parseAttribute(attr));
+            const attributeSuccess = await createUpdateCollectionAttributesWithStatusCheck(localDb, targetDbId, targetCollection, allAttributes);
+            if (!attributeSuccess) {
+                console.log(chalk.red(`❌ Failed to create all attributes for collection ${collection.name}, skipping to next collection`));
+                continue;
             }
+            console.log(chalk.green(`✅ All attributes created successfully for collection ${collection.name}`));
             // Handle indexes
             const existingIndexes = await tryAwaitWithRetry(async () => await localDb.listIndexes(targetDbId, targetCollection.$id));
             for (const index of collection.indexes) {
@@ -226,32 +221,26 @@ export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId
                 console.log(chalk.yellow(`Creating collection ${collection.name} in remote database...`));
                 targetCollection = await tryAwaitWithRetry(async () => remoteDb.createCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-            // Handle attributes
-            const existingAttributes = await tryAwaitWithRetry(async () => await remoteDb.listAttributes(toDbId, targetCollection.$id));
-            for (const attribute of collection.attributes) {
-                const parsedAttribute = parseAttribute(attribute);
-                const existingAttribute = existingAttributes.attributes.find((attr) => attr.key === parsedAttribute.key);
-                if (!existingAttribute) {
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(remoteDb, toDbId, targetCollection, parsedAttribute));
-                    console.log(chalk.green(`Attribute ${parsedAttribute.key} created`));
-                }
-                else {
-                    console.log(chalk.blue(`Attribute ${parsedAttribute.key} exists, checking for updates...`));
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(remoteDb, toDbId, targetCollection, parsedAttribute));
-                }
+            // Handle attributes with enhanced status checking
+            console.log(chalk.blue(`Creating attributes for collection ${collection.name} with enhanced monitoring...`));
+            const attributesToCreate = collection.attributes.map(attr => parseAttribute(attr));
+            const attributesSuccess = await createUpdateCollectionAttributesWithStatusCheck(remoteDb, toDbId, targetCollection, attributesToCreate);
+            if (!attributesSuccess) {
+                console.log(chalk.red(`Failed to create some attributes for collection ${collection.name}`));
+                // Continue with the transfer even if some attributes failed
             }
-            // Handle indexes
-            const existingIndexes = await tryAwaitWithRetry(async () => await remoteDb.listIndexes(toDbId, targetCollection.$id));
-            for (const index of collection.indexes) {
-                const existingIndex = existingIndexes.indexes.find((idx) => idx.key === index.key);
-                if (!existingIndex) {
-                    await createOrUpdateIndex(toDbId, remoteDb, targetCollection.$id, index);
-                    console.log(chalk.green(`Index ${index.key} created`));
-                }
-                else {
-                    console.log(chalk.blue(`Index ${index.key} exists, checking for updates...`));
-                    await createOrUpdateIndex(toDbId, remoteDb, targetCollection.$id, index);
-                }
+            else {
+                console.log(chalk.green(`All attributes created successfully for collection ${collection.name}`));
+            }
+            // Handle indexes with enhanced status checking
+            console.log(chalk.blue(`Creating indexes for collection ${collection.name} with enhanced monitoring...`));
+            const indexesSuccess = await createOrUpdateIndexesWithStatusCheck(toDbId, remoteDb, targetCollection.$id, targetCollection, collection.indexes);
+            if (!indexesSuccess) {
+                console.log(chalk.red(`Failed to create some indexes for collection ${collection.name}`));
+                // Continue with the transfer even if some indexes failed
+            }
+            else {
+                console.log(chalk.green(`All indexes created successfully for collection ${collection.name}`));
             }
             // Transfer documents
             const { transferDocumentsBetweenDbsLocalToRemote } = await import("../collections/methods.js");

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

package/src/collections/attributes.ts

@@ -8,6 +8,165 @@ import { nameToIdMapping, enqueueOperation } from "../shared/operationQueue.js";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import chalk from "chalk";
 
+// Interface for attribute with status (fixing the type issue)
+interface AttributeWithStatus {
+  key: string;
+  type: string;
+  status: 'available' | 'processing' | 'deleting' | 'stuck' | 'failed';
+  error: string;
+  required: boolean;
+  array?: boolean;
+  $createdAt: string;
+  $updatedAt: string;
+  [key: string]: any; // For type-specific fields
+}
+
+/**
+ * Wait for attribute to become available, with retry logic for stuck attributes and exponential backoff
+ */
+const waitForAttributeAvailable = async (
+  db: Databases,
+  dbId: string,
+  collectionId: string,
+  attributeKey: string,
+  maxWaitTime: number = 60000, // 1 minute
+  retryCount: number = 0,
+  maxRetries: number = 5
+): Promise<boolean> => {
+  const startTime = Date.now();
+  let checkInterval = 2000; // Start with 2 seconds
+  
+  // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
+  if (retryCount > 0) {
+    const exponentialDelay = Math.min(2000 * Math.pow(2, retryCount), 30000);
+    console.log(chalk.blue(`Waiting for attribute '${attributeKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`));
+    await delay(exponentialDelay);
+  } else {
+    console.log(chalk.blue(`Waiting for attribute '${attributeKey}' to become available...`));
+  }
+  
+  while (Date.now() - startTime < maxWaitTime) {
+    try {
+      const collection = await db.getCollection(dbId, collectionId);
+      const attribute = (collection.attributes as any[]).find(
+        (attr: AttributeWithStatus) => attr.key === attributeKey
+      ) as AttributeWithStatus | undefined;
+      
+      if (!attribute) {
+        console.log(chalk.red(`Attribute '${attributeKey}' not found`));
+        return false;
+      }
+      
+      console.log(chalk.gray(`Attribute '${attributeKey}' status: ${attribute.status}`));
+      
+      switch (attribute.status) {
+        case 'available':
+          console.log(chalk.green(`✅ Attribute '${attributeKey}' is now available`));
+          return true;
+          
+        case 'failed':
+          console.log(chalk.red(`❌ Attribute '${attributeKey}' failed: ${attribute.error}`));
+          return false;
+          
+        case 'stuck':
+          console.log(chalk.yellow(`⚠️ Attribute '${attributeKey}' is stuck, will retry...`));
+          return false;
+          
+        case 'processing':
+          // Continue waiting
+          break;
+          
+        case 'deleting':
+          console.log(chalk.yellow(`Attribute '${attributeKey}' is being deleted`));
+          break;
+          
+        default:
+          console.log(chalk.yellow(`Unknown status '${attribute.status}' for attribute '${attributeKey}'`));
+          break;
+      }
+      
+      await delay(checkInterval);
+    } catch (error) {
+      console.log(chalk.red(`Error checking attribute status: ${error}`));
+      return false;
+    }
+  }
+  
+  // Timeout reached
+  console.log(chalk.yellow(`⏰ Timeout waiting for attribute '${attributeKey}' (${maxWaitTime}ms)`));
+  
+  // If we have retries left and this isn't the last retry, try recreating
+  if (retryCount < maxRetries) {
+    console.log(chalk.yellow(`🔄 Retrying attribute creation (attempt ${retryCount + 1}/${maxRetries})`));
+    return false; // Signal that we need to retry
+  }
+  
+  return false;
+};
+
+/**
+ * Wait for all attributes in a collection to become available
+ */
+const waitForAllAttributesAvailable = async (
+  db: Databases,
+  dbId: string,
+  collectionId: string,
+  attributeKeys: string[],
+  maxWaitTime: number = 60000
+): Promise<string[]> => {
+  console.log(chalk.blue(`Waiting for ${attributeKeys.length} attributes to become available...`));
+  
+  const failedAttributes: string[] = [];
+  
+  for (const attributeKey of attributeKeys) {
+    const success = await waitForAttributeAvailable(db, dbId, collectionId, attributeKey, maxWaitTime);
+    if (!success) {
+      failedAttributes.push(attributeKey);
+    }
+  }
+  
+  return failedAttributes;
+};
+
+/**
+ * Delete collection and recreate with retry logic
+ */
+const deleteAndRecreateCollection = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  retryCount: number
+): Promise<Models.Collection | null> => {
+  try {
+    console.log(chalk.yellow(`🗑️ Deleting collection '${collection.name}' for 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;
+  }
+};
+
 const attributesSame = (
   databaseAttribute: Attribute,
   configAttribute: Attribute
@@ -72,6 +231,87 @@ const attributesSame = (
   });
 };
 
+/**
+ * Enhanced attribute creation with proper status monitoring and retry logic
+ */
+export const createOrUpdateAttributeWithStatusCheck = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  attribute: Attribute,
+  retryCount: number = 0,
+  maxRetries: number = 5
+): Promise<boolean> => {
+  console.log(chalk.blue(`Creating/updating attribute '${attribute.key}' (attempt ${retryCount + 1}/${maxRetries + 1})`));
+  
+  try {
+    // First, try to create/update the attribute using existing logic
+    await createOrUpdateAttribute(db, dbId, collection, attribute);
+    
+    // Now wait for the attribute to become available
+    const success = await waitForAttributeAvailable(
+      db, 
+      dbId, 
+      collection.$id, 
+      attribute.key, 
+      60000, // 1 minute timeout
+      retryCount, 
+      maxRetries
+    );
+    
+    if (success) {
+      return true;
+    }
+    
+    // If not successful and we have retries left, delete collection 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.red(`❌ Failed to create attribute '${attribute.key}' after ${maxRetries + 1} attempts`));
+    return false;
+    
+  } catch (error) {
+    console.log(chalk.red(`Error creating attribute '${attribute.key}': ${error}`));
+    
+    if (retryCount < maxRetries) {
+      console.log(chalk.yellow(`Retrying attribute '${attribute.key}' due to error...`));
+      
+      // Wait a bit before retry
+      await delay(2000);
+      
+      return await createOrUpdateAttributeWithStatusCheck(
+        db, 
+        dbId, 
+        collection, 
+        attribute, 
+        retryCount + 1, 
+        maxRetries
+      );
+    }
+    
+    return false;
+  }
+};
+
 export const createOrUpdateAttribute = async (
   db: Databases,
   dbId: string,
@@ -514,6 +754,105 @@ export const createOrUpdateAttribute = async (
   }
 };
 
+/**
+ * Enhanced collection attribute creation with proper status monitoring
+ */
+export const createUpdateCollectionAttributesWithStatusCheck = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  attributes: Attribute[]
+): Promise<boolean> => {
+  console.log(
+    chalk.green(
+      `Creating/Updating attributes for collection: ${collection.name} with status monitoring`
+    )
+  );
+
+  const existingAttributes: Attribute[] =
+    // @ts-expect-error
+    collection.attributes.map((attr) => parseAttribute(attr)) || [];
+
+  const attributesToRemove = existingAttributes.filter(
+    (attr) => !attributes.some((a) => a.key === attr.key)
+  );
+  const indexesToRemove = collection.indexes.filter((index) =>
+    attributesToRemove.some((attr) => index.attributes.includes(attr.key))
+  );
+
+  // Handle attribute removal first
+  if (attributesToRemove.length > 0) {
+    if (indexesToRemove.length > 0) {
+      console.log(
+        chalk.red(
+          `Removing indexes as they rely on an attribute that is being removed: ${indexesToRemove
+            .map((index) => index.key)
+            .join(", ")}`
+        )
+      );
+      for (const index of indexesToRemove) {
+        await tryAwaitWithRetry(
+          async () => await db.deleteIndex(dbId, collection.$id, index.key)
+        );
+        await delay(500); // Longer delay for deletions
+      }
+    }
+    for (const attr of attributesToRemove) {
+      console.log(
+        chalk.red(
+          `Removing attribute: ${attr.key} as it is no longer in the collection`
+        )
+      );
+      await tryAwaitWithRetry(
+        async () => await db.deleteAttribute(dbId, collection.$id, attr.key)
+      );
+      await delay(500); // Longer delay for deletions
+    }
+  }
+
+  // Create attributes ONE BY ONE with proper status checking
+  console.log(chalk.blue(`Creating ${attributes.length} attributes sequentially with status monitoring...`));
+  
+  let currentCollection = collection;
+  const failedAttributes: string[] = [];
+  
+  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
+      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}`));
+      failedAttributes.push(attribute.key);
+    }
+  }
+  
+  if (failedAttributes.length > 0) {
+    console.log(chalk.red(`\n❌ Failed to create ${failedAttributes.length} attributes: ${failedAttributes.join(', ')}`));
+    return false;
+  }
+  
+  console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));
+  return true;
+};
+
 export const createUpdateCollectionAttributes = async (
   db: Databases,
   dbId: string,