appwrite-utils-cli 1.1.4 → 1.2.1

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)}`);
     }

package/dist/collections/methods.js

@@ -407,9 +407,131 @@ 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');
+};
+/**
+ * Direct HTTP implementation of bulk upsert API
+ */
+const bulkUpsertDocuments = async (client, dbId, collectionId, documents) => {
+    const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
+    const url = new URL(client.config.endpoint + apiPath);
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-Appwrite-Project': client.config.project,
+        'X-Appwrite-Key': client.config.key
+    };
+    const response = await fetch(url.toString(), {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify({ documents })
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ message: 'Unknown error' }));
+        throw new Error(`Bulk upsert failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
+    }
+    return await response.json();
+};
+/**
+ * Direct HTTP implementation of bulk create API
+ */
+const bulkCreateDocuments = async (client, dbId, collectionId, documents) => {
+    const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
+    const url = new URL(client.config.endpoint + apiPath);
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-Appwrite-Project': client.config.project,
+        'X-Appwrite-Key': client.config.key
+    };
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ documents })
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ message: 'Unknown error' }));
+        throw new Error(`Bulk create failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
+    }
+    return await response.json();
+};
+/**
+ * Enhanced bulk document creation using direct HTTP calls
+ */
+const transferDocumentsBulkUpsert = async (client, 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
+        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 direct HTTP call
+            const result = await bulkUpsertDocuments(client, 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 bulkUpsertDocuments(client, 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 db = new Databases(client);
+                        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 db = new Databases(client);
+                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 +571,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, client, dbId, collectionId, documents, batchSize = 10) => {
+    // Check if we can use bulk operations
+    if (supportsBulkOperations(client.config.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(client, 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 +605,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 +618,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, client, 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.4",
+  "version": "1.2.1",
   "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": "^16",
     "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)}`);

package/src/collections/methods.ts

@@ -670,9 +670,172 @@ 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');
+};
+
+/**
+ * Direct HTTP implementation of bulk upsert API
+ */
+const bulkUpsertDocuments = async (
+  client: any,
+  dbId: string,
+  collectionId: string,
+  documents: any[]
+): Promise<any> => {
+  const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
+  const url = new URL(client.config.endpoint + apiPath);
+  
+  const headers = {
+    'Content-Type': 'application/json',
+    'X-Appwrite-Project': client.config.project,
+    'X-Appwrite-Key': client.config.key
+  };
+  
+  const response = await fetch(url.toString(), {
+    method: 'PUT',
+    headers,
+    body: JSON.stringify({ documents })
+  });
+  
+  if (!response.ok) {
+    const errorData: any = await response.json().catch(() => ({ message: 'Unknown error' }));
+    throw new Error(`Bulk upsert failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
+  }
+  
+  return await response.json();
+};
+
+/**
+ * Direct HTTP implementation of bulk create API
+ */
+const bulkCreateDocuments = async (
+  client: any,
+  dbId: string,
+  collectionId: string,
+  documents: any[]
+): Promise<any> => {
+  const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
+  const url = new URL(client.config.endpoint + apiPath);
+  
+  const headers = {
+    'Content-Type': 'application/json',
+    'X-Appwrite-Project': client.config.project,
+    'X-Appwrite-Key': client.config.key
+  };
+  
+  const response = await fetch(url.toString(), {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ documents })
+  });
+  
+  if (!response.ok) {
+    const errorData: any = await response.json().catch(() => ({ message: 'Unknown error' }));
+    throw new Error(`Bulk create failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
+  }
+  
+  return await response.json();
+};
+
+/**
+ * Enhanced bulk document creation using direct HTTP calls
+ */
+const transferDocumentsBulkUpsert = async (
+  client: any,
+  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
+    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 direct HTTP call
+      const result = await bulkUpsertDocuments(client, 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 bulkUpsertDocuments(client, 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 db = new Databases(client);
+            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 db = new Databases(client);
+        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 +896,41 @@ const transferDocumentBatchWithRetry = async (
   return { successful, failed };
 };
 
+/**
+ * Enhanced batch document transfer with fault tolerance and bulk API support
+ */
+const transferDocumentBatchWithRetry = async (
+  db: Databases,
+  client: any,
+  dbId: string,
+  collectionId: string,
+  documents: any[],
+  batchSize: number = 10
+): Promise<{ successful: number; failed: number }> => {
+  // Check if we can use bulk operations
+  if (supportsBulkOperations(client.config.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(client, 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 +953,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 +972,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,
+      client,
       toDbId,
       toCollId,
       fromCollDocs.documents
@@ -788,7 +987,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
       );
     });
   }