appwrite-utils-cli 1.1.3 → 1.2.0

package/dist/collections/attributes.js

@@ -218,9 +218,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     const updateEnabled = true;
     let finalAttribute = attribute;
     try {
-        const collectionAttr = collection.attributes.find(
-        // @ts-expect-error
-        (attr) => attr.key === attribute.key);
+        const collectionAttr = collection.attributes.find((attr) => attr.key === attribute.key);
         foundAttribute = parseAttribute(collectionAttr);
         // console.log(`Found attribute: ${JSON.stringify(foundAttribute)}`);
     }
@@ -459,17 +457,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 +520,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/dist/collections/methods.js

@@ -407,9 +407,86 @@ const transferDocumentWithRetry = async (db, dbId, collectionId, documentId, doc
     }
 };
 /**
- * Enhanced batch document transfer with fault tolerance
+ * Check if endpoint supports bulk operations (cloud.appwrite.io)
  */
-const transferDocumentBatchWithRetry = async (db, dbId, collectionId, documents, batchSize = 10) => {
+const supportsBulkOperations = (endpoint) => {
+    return endpoint.includes('cloud.appwrite.io');
+};
+/**
+ * Enhanced bulk document creation using the new bulk upsert API for cloud.appwrite.io
+ */
+const transferDocumentsBulkUpsert = async (db, dbId, collectionId, documents, maxBatchSize = 1000) => {
+    let successful = 0;
+    let failed = 0;
+    // Prepare documents for bulk upsert
+    const preparedDocs = documents.map(doc => {
+        const toCreateObject = { ...doc };
+        delete toCreateObject.$databaseId;
+        delete toCreateObject.$collectionId;
+        delete toCreateObject.$createdAt;
+        delete toCreateObject.$updatedAt;
+        // Keep $id and $permissions for upsert functionality
+        // Appwrite bulk API expects $permissions to be preserved
+        return toCreateObject;
+    });
+    // Process in batches based on plan limits
+    const documentBatches = chunk(preparedDocs, maxBatchSize);
+    for (const batch of documentBatches) {
+        console.log(chalk.blue(`Bulk upserting ${batch.length} documents...`));
+        try {
+            // Try bulk upsert with the highest batch size first
+            const result = await db.upsertDocuments(dbId, collectionId, batch);
+            successful += result.documents?.length || batch.length;
+            console.log(chalk.green(`✅ Bulk upserted ${result.documents?.length || batch.length} documents`));
+        }
+        catch (error) {
+            console.log(chalk.yellow(`Bulk upsert failed, trying smaller batch size...`));
+            // If bulk upsert fails, try with smaller batch size (Pro plan limit)
+            if (maxBatchSize > 100) {
+                const smallerBatches = chunk(batch, 100);
+                for (const smallBatch of smallerBatches) {
+                    try {
+                        const result = await db.upsertDocuments(dbId, collectionId, smallBatch);
+                        successful += result.documents?.length || smallBatch.length;
+                        console.log(chalk.green(`✅ Bulk upserted ${result.documents?.length || smallBatch.length} documents (smaller batch)`));
+                    }
+                    catch (smallBatchError) {
+                        console.log(chalk.yellow(`Smaller batch failed, falling back to individual transfers...`));
+                        // Fall back to individual document transfer for this batch
+                        const { successful: indivSuccessful, failed: indivFailed } = await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, smallBatch.map((doc, index) => ({
+                            ...doc,
+                            $id: documents[documentBatches.indexOf(batch) * maxBatchSize + smallerBatches.indexOf(smallBatch) * 100 + index]?.$id || ID.unique(),
+                            $permissions: documents[documentBatches.indexOf(batch) * maxBatchSize + smallerBatches.indexOf(smallBatch) * 100 + index]?.$permissions || []
+                        })));
+                        successful += indivSuccessful;
+                        failed += indivFailed;
+                    }
+                    // Add delay between batches
+                    await delay(200);
+                }
+            }
+            else {
+                // Fall back to individual document transfer
+                const { successful: indivSuccessful, failed: indivFailed } = await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, batch.map((doc, index) => ({
+                    ...doc,
+                    $id: documents[documentBatches.indexOf(batch) * maxBatchSize + index]?.$id || ID.unique(),
+                    $permissions: documents[documentBatches.indexOf(batch) * maxBatchSize + index]?.$permissions || []
+                })));
+                successful += indivSuccessful;
+                failed += indivFailed;
+            }
+        }
+        // Add delay between major batches
+        if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
+            await delay(500);
+        }
+    }
+    return { successful, failed };
+};
+/**
+ * Fallback batch document transfer with individual retry logic
+ */
+const transferDocumentBatchWithRetryFallback = async (db, dbId, collectionId, documents, batchSize = 10) => {
     let successful = 0;
     let failed = 0;
     // Process documents in smaller batches to avoid overwhelming the server
@@ -449,6 +526,30 @@ const transferDocumentBatchWithRetry = async (db, dbId, collectionId, documents,
     }
     return { successful, failed };
 };
+/**
+ * Enhanced batch document transfer with fault tolerance and bulk API support
+ */
+const transferDocumentBatchWithRetry = async (db, endpoint, dbId, collectionId, documents, batchSize = 10) => {
+    // Check if we can use bulk operations
+    if (supportsBulkOperations(endpoint)) {
+        console.log(chalk.green(`🚀 Using bulk upsert API for faster document transfer`));
+        // Try with Scale plan limit first (2500), then Pro (1000), then Free (100)
+        const batchSizes = [1000, 100]; // Start with Pro plan, fallback to Free
+        for (const maxBatchSize of batchSizes) {
+            try {
+                return await transferDocumentsBulkUpsert(db, dbId, collectionId, documents, maxBatchSize);
+            }
+            catch (error) {
+                console.log(chalk.yellow(`Bulk upsert with batch size ${maxBatchSize} failed, trying smaller size...`));
+                continue;
+            }
+        }
+        // If all bulk operations fail, fall back to individual transfers
+        console.log(chalk.yellow(`All bulk operations failed, falling back to individual document transfers`));
+    }
+    // Fall back to individual document transfer
+    return await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, documents, batchSize);
+};
 export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
     console.log(chalk.blue(`Starting enhanced document transfer from ${fromCollId} to ${toCollId}...`));
     const client = new Client()
@@ -459,11 +560,11 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint
     let totalDocumentsProcessed = 0;
     let totalSuccessful = 0;
     let totalFailed = 0;
-    // Fetch documents in batches
+    // Fetch documents in larger batches (1000 at a time)
     let hasMoreDocuments = true;
     let lastDocumentId;
     while (hasMoreDocuments) {
-        const queries = [Query.limit(50)];
+        const queries = [Query.limit(1000)]; // Fetch 1000 documents at a time
         if (lastDocumentId) {
             queries.push(Query.cursorAfter(lastDocumentId));
         }
@@ -472,13 +573,13 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint
             hasMoreDocuments = false;
             break;
         }
-        console.log(chalk.blue(`Processing ${fromCollDocs.documents.length} documents...`));
-        const { successful, failed } = await transferDocumentBatchWithRetry(remoteDb, toDbId, toCollId, fromCollDocs.documents);
+        console.log(chalk.blue(`Fetched ${fromCollDocs.documents.length} documents, processing for transfer...`));
+        const { successful, failed } = await transferDocumentBatchWithRetry(remoteDb, endpoint, toDbId, toCollId, fromCollDocs.documents);
         totalDocumentsProcessed += fromCollDocs.documents.length;
         totalSuccessful += successful;
         totalFailed += failed;
         // Check if we have more documents to process
-        if (fromCollDocs.documents.length < 50) {
+        if (fromCollDocs.documents.length < 1000) {
             hasMoreDocuments = false;
         }
         else {

package/dist/functions/methods.js

@@ -58,7 +58,7 @@ export const deleteFunction = async (client, functionId) => {
 };
 export const createFunction = async (client, functionConfig) => {
     const functions = new Functions(client);
-    const functionResponse = await functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes, functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.templateRepository, functionConfig.templateOwner, functionConfig.templateRootDirectory, functionConfig.templateVersion, functionConfig.specification);
+    const functionResponse = await functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes, functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory);
     return functionResponse;
 };
 export const updateFunctionSpecifications = async (client, functionId, specification) => {

package/dist/shared/attributeManager.js

@@ -79,9 +79,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute, o
     let foundAttribute;
     let finalAttribute = attribute;
     try {
-        const collectionAttr = collection.attributes.find(
-        // @ts-expect-error - Appwrite type issues
-        (attr) => attr.key === attribute.key);
+        const collectionAttr = collection.attributes.find((attr) => attr.key === attribute.key);
         foundAttribute = parseAttribute(collectionAttr);
         if (verbose) {
             console.log(`Found attribute: ${JSON.stringify(foundAttribute)}`);
@@ -235,9 +233,7 @@ export const deleteObsoleteAttributes = async (db, dbId, collection, collectionC
     const configAttributes = collectionConfig.attributes || [];
     const configAttributeKeys = new Set(configAttributes.map(attr => attr.key));
     // Find attributes that exist in the database but not in the config
-    const obsoleteAttributes = collection.attributes.filter(
-    // @ts-expect-error - Appwrite type issues
-    (attr) => !configAttributeKeys.has(attr.key));
+    const obsoleteAttributes = collection.attributes.filter((attr) => !configAttributeKeys.has(attr.key));
     if (obsoleteAttributes.length === 0) {
         return;
     }
@@ -248,13 +244,11 @@ export const deleteObsoleteAttributes = async (db, dbId, collection, collectionC
         const queuedOperation = {
             type: "attribute",
             collectionId: collection.$id,
-            // @ts-expect-error - Appwrite type issues
             attribute: { key: attr.key, type: "delete" },
             collection,
         };
         const executeOperation = async () => {
             await attributeLimit(() => tryAwaitWithRetry(async () => {
-                // @ts-expect-error - Appwrite type issues
                 await db.deleteAttribute(dbId, collection.$id, attr.key);
             }));
         };
@@ -266,7 +260,6 @@ export const deleteObsoleteAttributes = async (db, dbId, collection, collectionC
             await delay(250);
         }
         if (verbose) {
-            // @ts-expect-error - Appwrite type issues
             console.log(chalk.gray(`🗑️ Deleted obsolete attribute ${attr.key}`));
         }
     }

package/dist/shared/functionManager.js

@@ -200,7 +200,7 @@ export class FunctionManager {
             console.log(chalk.blue(`Creating function: ${functionConfig.name}`));
         }
         return await tryAwaitWithRetry(async () => {
-            return await this.functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.templateRepository, functionConfig.templateOwner, functionConfig.templateRootDirectory, functionConfig.templateVersion, functionConfig.specification);
+            return await this.functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory);
         });
     }
     async updateFunction(functionConfig, options = {}) {

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.2.0",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -43,7 +43,7 @@
     "js-yaml": "^4.1.0",
     "luxon": "^3.6.1",
     "nanostores": "^0.10.3",
-    "node-appwrite": "^14.2.0",
+    "node-appwrite": "^17",
     "p-limit": "^6.2.0",
     "tar": "^7.4.3",
     "tsx": "^4.20.3",

package/src/collections/attributes.ts

@@ -363,8 +363,7 @@ export const createOrUpdateAttribute = async (
   let finalAttribute: any = attribute;
   try {
     const collectionAttr = collection.attributes.find(
-      // @ts-expect-error
-      (attr) => attr.key === attribute.key
+      (attr: any) => attr.key === attribute.key
     ) as unknown as any;
     foundAttribute = parseAttribute(collectionAttr);
     // console.log(`Found attribute: ${JSON.stringify(foundAttribute)}`);
@@ -849,21 +848,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 +925,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...`));

package/src/collections/methods.ts

@@ -670,9 +670,107 @@ const transferDocumentWithRetry = async (
 };
 
 /**
- * Enhanced batch document transfer with fault tolerance
+ * Check if endpoint supports bulk operations (cloud.appwrite.io)
  */
-const transferDocumentBatchWithRetry = async (
+const supportsBulkOperations = (endpoint: string): boolean => {
+  return endpoint.includes('cloud.appwrite.io');
+};
+
+/**
+ * Enhanced bulk document creation using the new bulk upsert API for cloud.appwrite.io
+ */
+const transferDocumentsBulkUpsert = async (
+  db: Databases,
+  dbId: string,
+  collectionId: string,
+  documents: any[],
+  maxBatchSize: number = 1000
+): Promise<{ successful: number; failed: number }> => {
+  let successful = 0;
+  let failed = 0;
+  
+  // Prepare documents for bulk upsert
+  const preparedDocs = documents.map(doc => {
+    const toCreateObject: any = { ...doc };
+    delete toCreateObject.$databaseId;
+    delete toCreateObject.$collectionId;
+    delete toCreateObject.$createdAt;
+    delete toCreateObject.$updatedAt;
+    
+    // Keep $id and $permissions for upsert functionality
+    // Appwrite bulk API expects $permissions to be preserved
+    return toCreateObject;
+  });
+  
+  // Process in batches based on plan limits
+  const documentBatches = chunk(preparedDocs, maxBatchSize);
+  
+  for (const batch of documentBatches) {
+    console.log(chalk.blue(`Bulk upserting ${batch.length} documents...`));
+    
+    try {
+      // Try bulk upsert with the highest batch size first
+      const result = await (db as any).upsertDocuments(dbId, collectionId, batch);
+      successful += result.documents?.length || batch.length;
+      console.log(chalk.green(`✅ Bulk upserted ${result.documents?.length || batch.length} documents`));
+      
+    } catch (error: any) {
+      console.log(chalk.yellow(`Bulk upsert failed, trying smaller batch size...`));
+      
+      // If bulk upsert fails, try with smaller batch size (Pro plan limit)
+      if (maxBatchSize > 100) {
+        const smallerBatches = chunk(batch, 100);
+        
+        for (const smallBatch of smallerBatches) {
+          try {
+            const result = await (db as any).upsertDocuments(dbId, collectionId, smallBatch);
+            successful += result.documents?.length || smallBatch.length;
+            console.log(chalk.green(`✅ Bulk upserted ${result.documents?.length || smallBatch.length} documents (smaller batch)`));
+          } catch (smallBatchError: any) {
+            console.log(chalk.yellow(`Smaller batch failed, falling back to individual transfers...`));
+            
+            // Fall back to individual document transfer for this batch
+            const { successful: indivSuccessful, failed: indivFailed } = await transferDocumentBatchWithRetryFallback(
+              db, dbId, collectionId, smallBatch.map((doc, index) => ({
+                ...doc,
+                $id: documents[documentBatches.indexOf(batch) * maxBatchSize + smallerBatches.indexOf(smallBatch) * 100 + index]?.$id || ID.unique(),
+                $permissions: documents[documentBatches.indexOf(batch) * maxBatchSize + smallerBatches.indexOf(smallBatch) * 100 + index]?.$permissions || []
+              }))
+            );
+            successful += indivSuccessful;
+            failed += indivFailed;
+          }
+          
+          // Add delay between batches
+          await delay(200);
+        }
+      } else {
+        // Fall back to individual document transfer
+        const { successful: indivSuccessful, failed: indivFailed } = await transferDocumentBatchWithRetryFallback(
+          db, dbId, collectionId, batch.map((doc, index) => ({
+            ...doc,
+            $id: documents[documentBatches.indexOf(batch) * maxBatchSize + index]?.$id || ID.unique(),
+            $permissions: documents[documentBatches.indexOf(batch) * maxBatchSize + index]?.$permissions || []
+          }))
+        );
+        successful += indivSuccessful;
+        failed += indivFailed;
+      }
+    }
+    
+    // Add delay between major batches
+    if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
+      await delay(500);
+    }
+  }
+  
+  return { successful, failed };
+};
+
+/**
+ * Fallback batch document transfer with individual retry logic
+ */
+const transferDocumentBatchWithRetryFallback = async (
   db: Databases,
   dbId: string,
   collectionId: string,
@@ -733,6 +831,41 @@ const transferDocumentBatchWithRetry = async (
   return { successful, failed };
 };
 
+/**
+ * Enhanced batch document transfer with fault tolerance and bulk API support
+ */
+const transferDocumentBatchWithRetry = async (
+  db: Databases,
+  endpoint: string,
+  dbId: string,
+  collectionId: string,
+  documents: any[],
+  batchSize: number = 10
+): Promise<{ successful: number; failed: number }> => {
+  // Check if we can use bulk operations
+  if (supportsBulkOperations(endpoint)) {
+    console.log(chalk.green(`🚀 Using bulk upsert API for faster document transfer`));
+    
+    // Try with Scale plan limit first (2500), then Pro (1000), then Free (100)
+    const batchSizes = [1000, 100]; // Start with Pro plan, fallback to Free
+    
+    for (const maxBatchSize of batchSizes) {
+      try {
+        return await transferDocumentsBulkUpsert(db, dbId, collectionId, documents, maxBatchSize);
+      } catch (error: any) {
+        console.log(chalk.yellow(`Bulk upsert with batch size ${maxBatchSize} failed, trying smaller size...`));
+        continue;
+      }
+    }
+    
+    // If all bulk operations fail, fall back to individual transfers
+    console.log(chalk.yellow(`All bulk operations failed, falling back to individual document transfers`));
+  }
+  
+  // Fall back to individual document transfer
+  return await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, documents, batchSize);
+};
+
 export const transferDocumentsBetweenDbsLocalToRemote = async (
   localDb: Databases,
   endpoint: string,
@@ -755,12 +888,12 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (
   let totalSuccessful = 0;
   let totalFailed = 0;
   
-  // Fetch documents in batches
+  // Fetch documents in larger batches (1000 at a time)
   let hasMoreDocuments = true;
   let lastDocumentId: string | undefined;
   
   while (hasMoreDocuments) {
-    const queries = [Query.limit(50)];
+    const queries = [Query.limit(1000)]; // Fetch 1000 documents at a time
     if (lastDocumentId) {
       queries.push(Query.cursorAfter(lastDocumentId));
     }
@@ -774,10 +907,11 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (
       break;
     }
     
-    console.log(chalk.blue(`Processing ${fromCollDocs.documents.length} documents...`));
+    console.log(chalk.blue(`Fetched ${fromCollDocs.documents.length} documents, processing for transfer...`));
     
     const { successful, failed } = await transferDocumentBatchWithRetry(
       remoteDb,
+      endpoint,
       toDbId,
       toCollId,
       fromCollDocs.documents
@@ -788,7 +922,7 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (
     totalFailed += failed;
     
     // Check if we have more documents to process
-    if (fromCollDocs.documents.length < 50) {
+    if (fromCollDocs.documents.length < 1000) {
       hasMoreDocuments = false;
     } else {
       lastDocumentId = fromCollDocs.documents[fromCollDocs.documents.length - 1].$id;

package/src/functions/methods.ts

@@ -113,12 +113,7 @@ export const createFunction = async (
     functionConfig.providerRepositoryId,
     functionConfig.providerBranch,
     functionConfig.providerSilentMode,
-    functionConfig.providerRootDirectory,
-    functionConfig.templateRepository,
-    functionConfig.templateOwner,
-    functionConfig.templateRootDirectory,
-    functionConfig.templateVersion,
-    functionConfig.specification
+    functionConfig.providerRootDirectory
   );
   return functionResponse;
 };

package/src/shared/attributeManager.ts

@@ -114,8 +114,7 @@ export const createOrUpdateAttribute = async (
   
   try {
     const collectionAttr = collection.attributes.find(
-      // @ts-expect-error - Appwrite type issues
-      (attr) => attr.key === attribute.key
+      (attr: any) => attr.key === attribute.key
     ) as unknown as any;
     foundAttribute = parseAttribute(collectionAttr);
     
@@ -384,8 +383,7 @@ export const deleteObsoleteAttributes = async (
   
   // Find attributes that exist in the database but not in the config
   const obsoleteAttributes = collection.attributes.filter(
-    // @ts-expect-error - Appwrite type issues
-    (attr) => !configAttributeKeys.has(attr.key)
+    (attr: any) => !configAttributeKeys.has(attr.key)
   );
 
   if (obsoleteAttributes.length === 0) {
@@ -400,16 +398,14 @@ export const deleteObsoleteAttributes = async (
     const queuedOperation: QueuedOperation = {
       type: "attribute",
       collectionId: collection.$id,
-      // @ts-expect-error - Appwrite type issues
-      attribute: { key: attr.key, type: "delete" } as Attribute,
+      attribute: { key: (attr as any).key, type: "delete" } as unknown as Attribute,
       collection,
     };
 
     const executeOperation = async () => {
       await attributeLimit(() => 
         tryAwaitWithRetry(async () => {
-          // @ts-expect-error - Appwrite type issues
-          await db.deleteAttribute(dbId, collection.$id, attr.key);
+          await db.deleteAttribute(dbId, collection.$id, (attr as any).key);
         })
       );
     };
@@ -422,8 +418,7 @@ export const deleteObsoleteAttributes = async (
     }
 
     if (verbose) {
-      // @ts-expect-error - Appwrite type issues
-      console.log(chalk.gray(`🗑️ Deleted obsolete attribute ${attr.key}`));
+      console.log(chalk.gray(`🗑️ Deleted obsolete attribute ${(attr as any).key}`));
     }
   }
 };

package/src/shared/functionManager.ts

@@ -310,12 +310,7 @@ export class FunctionManager {
         functionConfig.providerRepositoryId,
         functionConfig.providerBranch,
         functionConfig.providerSilentMode,
-        functionConfig.providerRootDirectory,
-        functionConfig.templateRepository,
-        functionConfig.templateOwner,
-        functionConfig.templateRootDirectory,
-        functionConfig.templateVersion,
-        functionConfig.specification
+        functionConfig.providerRootDirectory
       );
     });
   }