appwrite-utils-cli 1.2.6 → 1.2.8

package/dist/config/yamlConfig.d.ts

@@ -492,6 +492,12 @@ export declare const convertYamlToAppwriteConfig: (yamlConfig: YamlConfig) => Ap
 export declare const loadYamlConfig: (configPath: string) => Promise<AppwriteConfig | null>;
 export declare const findYamlConfig: (startDir: string) => string | null;
 export declare const generateYamlConfigTemplate: (outputPath: string) => void;
+/**
+ * Converts AppwriteConfig back to YAML format and writes to file
+ * @param configPath Path to the YAML config file
+ * @param config The AppwriteConfig to convert and save
+ */
+export declare const writeYamlConfig: (configPath: string, config: AppwriteConfig) => Promise<void>;
 /**
  * Adds a new function to the YAML config file
  * @param configPath Path to the YAML config file

package/dist/config/yamlConfig.js

@@ -206,7 +206,7 @@ export const convertYamlToAppwriteConfig = (yamlConfig) => {
             templateBranch: func.templateBranch || "",
             specification: func.specification || "s-0.5vcpu-512mb",
         })),
-        collections: [],
+        collections: [], // Note: Collections are managed separately in YAML configs via individual collection files
     };
     return appwriteConfig;
 };
@@ -397,6 +397,132 @@ export const generateYamlConfigTemplate = (outputPath) => {
     const finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
     fs.writeFileSync(outputPath, finalContent, "utf8");
 };
+/**
+ * Converts AppwriteConfig back to YAML format and writes to file
+ * @param configPath Path to the YAML config file
+ * @param config The AppwriteConfig to convert and save
+ */
+export const writeYamlConfig = async (configPath, config) => {
+    try {
+        // Convert AppwriteConfig back to YAML format
+        const yamlConfig = {
+            appwrite: {
+                endpoint: config.appwriteEndpoint,
+                project: config.appwriteProject,
+                key: config.appwriteKey,
+            },
+            logging: {
+                enabled: config.logging?.enabled || false,
+                level: config.logging?.level || "info",
+                directory: config.logging?.logDirectory,
+                console: config.logging?.console || false,
+            },
+            backups: {
+                enabled: config.enableBackups !== false,
+                interval: config.backupInterval || 3600,
+                retention: config.backupRetention || 30,
+                cleanup: config.enableBackupCleanup !== false,
+            },
+            data: {
+                enableMockData: config.enableMockData || false,
+                documentBucketId: config.documentBucketId || "documents",
+                usersCollectionName: config.usersCollectionName || "Members",
+                importDirectory: config.schemaConfig?.importDirectory || "importData",
+            },
+            schemas: {
+                outputDirectory: config.schemaConfig?.outputDirectory || "schemas",
+                yamlSchemaDirectory: config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas",
+            },
+            migrations: {
+                enabled: config.useMigrations !== false,
+            },
+            databases: config.databases?.map(db => ({
+                id: db.$id,
+                name: db.name,
+                bucket: db.bucket ? {
+                    id: db.bucket.$id,
+                    name: db.bucket.name,
+                    permissions: db.bucket.permissions || [],
+                    fileSecurity: db.bucket.fileSecurity,
+                    enabled: db.bucket.enabled,
+                    maximumFileSize: db.bucket.maximumFileSize,
+                    allowedFileExtensions: db.bucket.allowedFileExtensions,
+                    compression: db.bucket.compression,
+                    encryption: db.bucket.encryption,
+                    antivirus: db.bucket.antivirus,
+                } : undefined,
+            })) || [],
+            buckets: config.buckets?.map(bucket => ({
+                id: bucket.$id,
+                name: bucket.name,
+                permissions: bucket.permissions || [],
+                fileSecurity: bucket.fileSecurity,
+                enabled: bucket.enabled,
+                maximumFileSize: bucket.maximumFileSize,
+                allowedFileExtensions: bucket.allowedFileExtensions,
+                compression: bucket.compression,
+                encryption: bucket.encryption,
+                antivirus: bucket.antivirus,
+            })) || [],
+            functions: config.functions?.map(func => ({
+                id: func.$id,
+                name: func.name,
+                runtime: func.runtime,
+                execute: func.execute,
+                events: func.events,
+                schedule: func.schedule,
+                timeout: func.timeout,
+                enabled: func.enabled,
+                logging: func.logging,
+                entrypoint: func.entrypoint,
+                commands: func.commands,
+                scopes: func.scopes,
+                installationId: func.installationId,
+                providerRepositoryId: func.providerRepositoryId,
+                providerBranch: func.providerBranch,
+                providerSilentMode: func.providerSilentMode,
+                providerRootDirectory: func.providerRootDirectory,
+                templateRepository: func.templateRepository,
+                templateOwner: func.templateOwner,
+                templateRootDirectory: func.templateRootDirectory,
+                // templateBranch: func.templateBranch, // Not available in AppwriteFunction type
+                specification: func.specification,
+            })) || [],
+        };
+        // Write YAML config
+        const yamlContent = yaml.dump(yamlConfig, {
+            indent: 2,
+            lineWidth: 120,
+            sortKeys: false,
+        });
+        // Preserve schema reference if it exists
+        let finalContent = yamlContent;
+        if (fs.existsSync(configPath)) {
+            const existingContent = fs.readFileSync(configPath, "utf8");
+            const lines = existingContent.split('\n');
+            const schemaLine = lines.find(line => line.startsWith('# yaml-language-server:'));
+            const commentLine = lines.find(line => line.startsWith('# Appwrite Project Configuration'));
+            if (schemaLine) {
+                finalContent = schemaLine + '\n';
+                if (commentLine) {
+                    finalContent += commentLine + '\n';
+                }
+                finalContent += yamlContent;
+            }
+        }
+        else {
+            // Add schema reference for new files
+            const schemaReference = "# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json\n";
+            finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
+        }
+        fs.writeFileSync(configPath, finalContent, "utf8");
+        console.log(`✅ Updated YAML configuration at ${configPath}`);
+    }
+    catch (error) {
+        console.error("❌ Error writing YAML config:", error instanceof Error ? error.message : error);
+        throw error;
+    }
+};
 /**
  * Adds a new function to the YAML config file
  * @param configPath Path to the YAML config file

package/dist/migrations/comprehensiveTransfer.d.ts

@@ -102,9 +102,33 @@ export declare class ComprehensiveTransfer {
      */
     private createCollectionIndexesWithStatusCheck;
     /**
-     * Helper method to transfer documents between databases
+     * Helper method to transfer documents between databases using bulk operations with content and permission-based filtering
      */
     private transferDocumentsBetweenDatabases;
+    /**
+     * Fetch target documents by IDs in batches to check existence and permissions
+     */
+    private fetchTargetDocumentsBatch;
+    /**
+     * Transfer documents using bulk operations with proper batch size handling
+     */
+    private transferDocumentsBulk;
+    /**
+     * Direct HTTP implementation of bulk upsert API
+     */
+    private bulkUpsertDocuments;
+    /**
+     * Transfer documents individually with rate limiting
+     */
+    private transferDocumentsIndividual;
+    /**
+     * Update documents individually with content and/or permission changes
+     */
+    private updateDocumentsIndividual;
+    /**
+     * Utility method to chunk arrays
+     */
+    private chunkArray;
     /**
      * Helper method to fetch all teams with pagination
      */

package/dist/migrations/comprehensiveTransfer.js

@@ -1,4 +1,4 @@
-import { converterFunctions, tryAwaitWithRetry, parseAttribute } from "appwrite-utils";
+import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate } from "appwrite-utils";
 import { Client, Databases, Storage, Users, Functions, Teams, Query, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { MessageFormatter } from "../shared/messageFormatter.js";
@@ -361,6 +361,27 @@ export class ComprehensiveTransfer {
                         await this.createBucketWithFallback(bucket);
                         MessageFormatter.success(`Created bucket: ${bucket.name}`, { prefix: "Transfer" });
                     }
+                    else {
+                        // Compare bucket permissions and update if needed
+                        const sourcePermissions = JSON.stringify(bucket.$permissions?.sort() || []);
+                        const targetPermissions = JSON.stringify(existingBucket.$permissions?.sort() || []);
+                        if (sourcePermissions !== targetPermissions ||
+                            existingBucket.name !== bucket.name ||
+                            existingBucket.fileSecurity !== bucket.fileSecurity ||
+                            existingBucket.enabled !== bucket.enabled) {
+                            MessageFormatter.warning(`Bucket ${bucket.name} exists but has different settings. Updating to match source.`, { prefix: "Transfer" });
+                            try {
+                                await this.targetStorage.updateBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+                                MessageFormatter.success(`Updated bucket ${bucket.name} to match source`, { prefix: "Transfer" });
+                            }
+                            catch (updateError) {
+                                MessageFormatter.error(`Failed to update bucket ${bucket.name}`, updateError instanceof Error ? updateError : new Error(String(updateError)), { prefix: "Transfer" });
+                            }
+                        }
+                        else {
+                            MessageFormatter.info(`Bucket ${bucket.name} already exists with matching settings`, { prefix: "Transfer" });
+                        }
+                    }
                     // Transfer bucket files with enhanced validation
                     await this.transferBucketFiles(bucket.$id, bucket.$id);
                     this.results.buckets.transferred++;
@@ -481,10 +502,27 @@ export class ComprehensiveTransfer {
             // Process files with rate limiting
             const fileTasks = files.files.map(file => this.fileLimit(async () => {
                 try {
-                    // Check if file already exists
+                    // Check if file already exists and compare permissions
+                    let existingFile = null;
                     try {
-                        await this.targetStorage.getFile(targetBucketId, file.$id);
-                        MessageFormatter.info(`File ${file.name} already exists, skipping`, { prefix: "Transfer" });
+                        existingFile = await this.targetStorage.getFile(targetBucketId, file.$id);
+                        // Compare permissions between source and target file
+                        const sourcePermissions = JSON.stringify(file.$permissions?.sort() || []);
+                        const targetPermissions = JSON.stringify(existingFile.$permissions?.sort() || []);
+                        if (sourcePermissions !== targetPermissions) {
+                            MessageFormatter.warning(`File ${file.name} (${file.$id}) exists but has different permissions. Source: ${sourcePermissions}, Target: ${targetPermissions}`, { prefix: "Transfer" });
+                            // Update file permissions to match source
+                            try {
+                                await this.targetStorage.updateFile(targetBucketId, file.$id, file.name, file.$permissions);
+                                MessageFormatter.success(`Updated file ${file.name} permissions to match source`, { prefix: "Transfer" });
+                            }
+                            catch (updateError) {
+                                MessageFormatter.error(`Failed to update permissions for file ${file.name}`, updateError instanceof Error ? updateError : new Error(String(updateError)), { prefix: "Transfer" });
+                            }
+                        }
+                        else {
+                            MessageFormatter.info(`File ${file.name} already exists with matching permissions, skipping`, { prefix: "Transfer" });
+                        }
                         return;
                     }
                     catch (error) {
@@ -702,50 +740,259 @@ export class ComprehensiveTransfer {
         return await createOrUpdateIndexesWithStatusCheck(dbId, databases, collectionId, collection, indexes);
     }
     /**
-     * Helper method to transfer documents between databases
+     * Helper method to transfer documents between databases using bulk operations with content and permission-based filtering
      */
     async transferDocumentsBetweenDatabases(sourceDb, targetDb, sourceDbId, targetDbId, sourceCollectionId, targetCollectionId) {
-        MessageFormatter.info(`Transferring documents from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+        MessageFormatter.info(`Transferring documents from ${sourceCollectionId} to ${targetCollectionId} with bulk operations, content comparison, and permission filtering`, { prefix: "Transfer" });
         let lastId;
         let totalTransferred = 0;
+        let totalSkipped = 0;
+        let totalUpdated = 0;
+        // Check if bulk operations are supported
+        const supportsBulk = this.options.sourceEndpoint.includes('cloud.appwrite.io') ||
+            this.options.targetEndpoint.includes('cloud.appwrite.io');
+        if (supportsBulk) {
+            MessageFormatter.info(`Using bulk operations for enhanced performance`, { prefix: "Transfer" });
+        }
         while (true) {
-            const queries = [Query.limit(50)]; // Smaller batch size for better performance
+            // Fetch source documents in larger batches (1000 instead of 50)
+            const queries = [Query.limit(1000)];
             if (lastId) {
                 queries.push(Query.cursorAfter(lastId));
             }
-            const documents = await tryAwaitWithRetry(async () => sourceDb.listDocuments(sourceDbId, sourceCollectionId, queries));
-            if (documents.documents.length === 0) {
+            const sourceDocuments = await tryAwaitWithRetry(async () => sourceDb.listDocuments(sourceDbId, sourceCollectionId, queries));
+            if (sourceDocuments.documents.length === 0) {
                 break;
             }
-            // Transfer documents with rate limiting
-            const transferTasks = documents.documents.map(doc => this.limit(async () => {
-                try {
-                    // Check if document already exists
-                    try {
-                        await targetDb.getDocument(targetDbId, targetCollectionId, doc.$id);
-                        MessageFormatter.info(`Document ${doc.$id} already exists, skipping`, { prefix: "Transfer" });
-                        return;
+            MessageFormatter.info(`Processing batch of ${sourceDocuments.documents.length} source documents`, { prefix: "Transfer" });
+            // Extract document IDs from the current batch
+            const sourceDocIds = sourceDocuments.documents.map(doc => doc.$id);
+            // Fetch existing documents from target in a single query
+            const existingTargetDocs = await this.fetchTargetDocumentsBatch(targetDb, targetDbId, targetCollectionId, sourceDocIds);
+            // Create a map for quick lookup of existing documents
+            const existingDocsMap = new Map();
+            existingTargetDocs.forEach(doc => {
+                existingDocsMap.set(doc.$id, doc);
+            });
+            // Filter documents based on existence, content comparison, and permission comparison
+            const documentsToTransfer = [];
+            const documentsToUpdate = [];
+            for (const sourceDoc of sourceDocuments.documents) {
+                const existingTargetDoc = existingDocsMap.get(sourceDoc.$id);
+                if (!existingTargetDoc) {
+                    // Document doesn't exist in target, needs to be transferred
+                    documentsToTransfer.push(sourceDoc);
+                }
+                else {
+                    // Document exists, compare both content and permissions
+                    const sourcePermissions = JSON.stringify((sourceDoc.$permissions || []).sort());
+                    const targetPermissions = JSON.stringify((existingTargetDoc.$permissions || []).sort());
+                    const permissionsDiffer = sourcePermissions !== targetPermissions;
+                    // Use objectNeedsUpdate to compare document content (excluding system fields)
+                    const contentDiffers = objectNeedsUpdate(existingTargetDoc, sourceDoc);
+                    if (contentDiffers && permissionsDiffer) {
+                        // Both content and permissions differ
+                        documentsToUpdate.push({
+                            doc: sourceDoc,
+                            targetDoc: existingTargetDoc,
+                            reason: "content and permissions differ"
+                        });
+                        MessageFormatter.info(`Document ${sourceDoc.$id} exists but content and permissions differ - will update`, { prefix: "Transfer" });
                     }
-                    catch (error) {
-                        // Document doesn't exist, proceed with creation
+                    else if (contentDiffers) {
+                        // Only content differs
+                        documentsToUpdate.push({
+                            doc: sourceDoc,
+                            targetDoc: existingTargetDoc,
+                            reason: "content differs"
+                        });
+                        MessageFormatter.info(`Document ${sourceDoc.$id} exists but content differs - will update`, { prefix: "Transfer" });
+                    }
+                    else if (permissionsDiffer) {
+                        // Only permissions differ
+                        documentsToUpdate.push({
+                            doc: sourceDoc,
+                            targetDoc: existingTargetDoc,
+                            reason: "permissions differ"
+                        });
+                        MessageFormatter.info(`Document ${sourceDoc.$id} exists but permissions differ - will update`, { prefix: "Transfer" });
+                    }
+                    else {
+                        // Document exists with identical content AND permissions, skip
+                        totalSkipped++;
+                        MessageFormatter.info(`Document ${sourceDoc.$id} exists with matching content and permissions - skipping`, { prefix: "Transfer" });
                     }
-                    // Create document in target
-                    const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
-                    await tryAwaitWithRetry(async () => targetDb.createDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
-                    totalTransferred++;
-                    MessageFormatter.success(`Transferred document ${doc.$id}`, { prefix: "Transfer" });
                 }
-                catch (error) {
-                    MessageFormatter.error(`Failed to transfer document ${doc.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            }
+            MessageFormatter.info(`Batch analysis: ${documentsToTransfer.length} to create, ${documentsToUpdate.length} to update, ${totalSkipped} skipped so far`, { prefix: "Transfer" });
+            // Process new documents with bulk operations if supported and available
+            if (documentsToTransfer.length > 0) {
+                if (supportsBulk && documentsToTransfer.length >= 10) {
+                    // Use bulk operations for large batches
+                    await this.transferDocumentsBulk(targetDb, targetDbId, targetCollectionId, documentsToTransfer);
+                    totalTransferred += documentsToTransfer.length;
+                    MessageFormatter.success(`Bulk transferred ${documentsToTransfer.length} new documents`, { prefix: "Transfer" });
                 }
-            }));
-            await Promise.all(transferTasks);
-            if (documents.documents.length < 50) {
+                else {
+                    // Use individual transfers for smaller batches or non-bulk endpoints
+                    const transferCount = await this.transferDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documentsToTransfer);
+                    totalTransferred += transferCount;
+                }
+            }
+            // Process document updates (always individual since bulk update with permissions needs special handling)
+            if (documentsToUpdate.length > 0) {
+                const updateCount = await this.updateDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documentsToUpdate);
+                totalUpdated += updateCount;
+            }
+            if (sourceDocuments.documents.length < 1000) {
                 break;
             }
-            lastId = documents.documents[documents.documents.length - 1].$id;
+            lastId = sourceDocuments.documents[sourceDocuments.documents.length - 1].$id;
+        }
+        MessageFormatter.info(`Transfer complete: ${totalTransferred} new, ${totalUpdated} updated, ${totalSkipped} skipped from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+    }
+    /**
+     * Fetch target documents by IDs in batches to check existence and permissions
+     */
+    async fetchTargetDocumentsBatch(targetDb, targetDbId, targetCollectionId, docIds) {
+        const documents = [];
+        // Split IDs into chunks of 100 for Query.equal limitations
+        const idChunks = this.chunkArray(docIds, 100);
+        for (const chunk of idChunks) {
+            try {
+                const result = await tryAwaitWithRetry(async () => targetDb.listDocuments(targetDbId, targetCollectionId, [
+                    Query.equal('$id', chunk),
+                    Query.limit(100)
+                ]));
+                documents.push(...result.documents);
+            }
+            catch (error) {
+                // If query fails, fall back to individual gets (less efficient but more reliable)
+                MessageFormatter.warning(`Batch query failed for ${chunk.length} documents, falling back to individual checks`, { prefix: "Transfer" });
+                for (const docId of chunk) {
+                    try {
+                        const doc = await targetDb.getDocument(targetDbId, targetCollectionId, docId);
+                        documents.push(doc);
+                    }
+                    catch (getError) {
+                        // Document doesn't exist, which is fine
+                    }
+                }
+            }
+        }
+        return documents;
+    }
+    /**
+     * Transfer documents using bulk operations with proper batch size handling
+     */
+    async transferDocumentsBulk(targetDb, targetDbId, targetCollectionId, documents) {
+        // Prepare documents for bulk upsert
+        const preparedDocs = documents.map(doc => {
+            const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
+            return {
+                $id,
+                $permissions,
+                ...docData
+            };
+        });
+        // Process in smaller chunks for bulk operations (1000 for Pro, 100 for Free tier)
+        const batchSizes = [1000, 100]; // Start with Pro plan, fallback to Free
+        let processed = false;
+        for (const maxBatchSize of batchSizes) {
+            const documentBatches = this.chunkArray(preparedDocs, maxBatchSize);
+            try {
+                for (const batch of documentBatches) {
+                    MessageFormatter.info(`Bulk upserting ${batch.length} documents...`, { prefix: "Transfer" });
+                    await this.bulkUpsertDocuments(this.targetClient, targetDbId, targetCollectionId, batch);
+                    MessageFormatter.success(`✅ Bulk upserted ${batch.length} documents`, { prefix: "Transfer" });
+                    // Add delay between batches to respect rate limits
+                    if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
+                        await new Promise(resolve => setTimeout(resolve, 200));
+                    }
+                }
+                processed = true;
+                break; // Success, exit batch size loop
+            }
+            catch (error) {
+                MessageFormatter.warning(`Bulk upsert with batch size ${maxBatchSize} failed, trying smaller size...`, { prefix: "Transfer" });
+                continue; // Try next smaller batch size
+            }
+        }
+        if (!processed) {
+            MessageFormatter.warning(`All bulk operations failed, falling back to individual transfers`, { prefix: "Transfer" });
+            // Fall back to individual transfers
+            await this.transferDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documents);
+        }
+    }
+    /**
+     * Direct HTTP implementation of bulk upsert API
+     */
+    async bulkUpsertDocuments(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();
+    }
+    /**
+     * Transfer documents individually with rate limiting
+     */
+    async transferDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documents) {
+        let successCount = 0;
+        const transferTasks = documents.map(doc => this.limit(async () => {
+            try {
+                const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
+                await tryAwaitWithRetry(async () => targetDb.createDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
+                successCount++;
+                MessageFormatter.success(`Transferred document ${doc.$id}`, { prefix: "Transfer" });
+            }
+            catch (error) {
+                MessageFormatter.error(`Failed to transfer document ${doc.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            }
+        }));
+        await Promise.all(transferTasks);
+        return successCount;
+    }
+    /**
+     * Update documents individually with content and/or permission changes
+     */
+    async updateDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documentPairs) {
+        let successCount = 0;
+        const updateTasks = documentPairs.map(({ doc, targetDoc, reason }) => this.limit(async () => {
+            try {
+                const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
+                await tryAwaitWithRetry(async () => targetDb.updateDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
+                successCount++;
+                MessageFormatter.success(`Updated document ${doc.$id} (${reason}) - permissions: [${targetDoc.$permissions?.join(', ')}] → [${doc.$permissions?.join(', ')}]`, { prefix: "Transfer" });
+            }
+            catch (error) {
+                MessageFormatter.error(`Failed to update document ${doc.$id} (${reason})`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            }
+        }));
+        await Promise.all(updateTasks);
+        return successCount;
+    }
+    /**
+     * Utility method to chunk arrays
+     */
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
         }
-        MessageFormatter.info(`Transferred ${totalTransferred} documents from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+        return chunks;
     }
     /**
      * Helper method to fetch all teams with pagination
@@ -810,10 +1057,27 @@ export class ComprehensiveTransfer {
             // Transfer memberships with rate limiting
             const transferTasks = memberships.map(membership => this.userLimit(async () => {
                 try {
-                    // Check if membership already exists
+                    // Check if membership already exists and compare roles
+                    let existingMembership = null;
                     try {
-                        await this.targetTeams.getMembership(teamId, membership.$id);
-                        MessageFormatter.info(`Membership ${membership.$id} already exists, skipping`, { prefix: "Transfer" });
+                        existingMembership = await this.targetTeams.getMembership(teamId, membership.$id);
+                        // Compare roles between source and target membership
+                        const sourceRoles = JSON.stringify(membership.roles?.sort() || []);
+                        const targetRoles = JSON.stringify(existingMembership.roles?.sort() || []);
+                        if (sourceRoles !== targetRoles) {
+                            MessageFormatter.warning(`Membership ${membership.$id} exists but has different roles. Source: ${sourceRoles}, Target: ${targetRoles}`, { prefix: "Transfer" });
+                            // Update membership roles to match source
+                            try {
+                                await this.targetTeams.updateMembership(teamId, membership.$id, membership.roles);
+                                MessageFormatter.success(`Updated membership ${membership.$id} roles to match source`, { prefix: "Transfer" });
+                            }
+                            catch (updateError) {
+                                MessageFormatter.error(`Failed to update roles for membership ${membership.$id}`, updateError instanceof Error ? updateError : new Error(String(updateError)), { prefix: "Transfer" });
+                            }
+                        }
+                        else {
+                            MessageFormatter.info(`Membership ${membership.$id} already exists with matching roles, skipping`, { prefix: "Transfer" });
+                        }
                         return;
                     }
                     catch (error) {

package/dist/shared/schemaGenerator.d.ts

@@ -7,6 +7,8 @@ export declare class SchemaGenerator {
     updateYamlCollections(): void;
     updateTsSchemas(): void;
     updateConfig(config: AppwriteConfig): void;
+    private updateYamlConfig;
+    private updateTypeScriptConfig;
     private extractRelationships;
     private addRelationship;
     generateSchemas(options?: {

package/dist/shared/schemaGenerator.js

@@ -155,6 +155,33 @@ export class SchemaGenerator {
         });
     }
     updateConfig(config) {
+        // Check if user is using YAML config
+        const { findYamlConfig, writeYamlConfig } = require("../config/yamlConfig.js");
+        const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
+        if (yamlConfigPath) {
+            // User has YAML config - update it and generate individual collection files
+            this.updateYamlConfig(config, yamlConfigPath);
+        }
+        else {
+            // User has TypeScript config - update the TS file
+            this.updateTypeScriptConfig(config);
+        }
+    }
+    async updateYamlConfig(config, yamlConfigPath) {
+        try {
+            const { writeYamlConfig } = await import("../config/yamlConfig.js");
+            // Write the main YAML config (without collections)
+            await writeYamlConfig(yamlConfigPath, config);
+            // Generate individual collection YAML files
+            this.updateYamlCollections();
+            console.log("✅ Updated YAML configuration and collection files");
+        }
+        catch (error) {
+            console.error("❌ Error updating YAML config:", error instanceof Error ? error.message : error);
+            throw error;
+        }
+    }
+    updateTypeScriptConfig(config) {
         const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
         const configContent = `import { type AppwriteConfig } from "appwrite-utils";
 
@@ -175,7 +202,7 @@ const appwriteConfig: AppwriteConfig = {
             $id: func.$id || ulid(),
             name: func.name,
             runtime: func.runtime,
-            dirPath: func.dirPath || `functions/${func.name}`,
+            dirPath: func.dirPath || "functions/" + func.name,
             entrypoint: func.entrypoint || "src/index.ts",
             execute: func.execute || [],
             events: func.events || [],
@@ -191,12 +218,14 @@ const appwriteConfig: AppwriteConfig = {
             providerSilentMode: func.providerSilentMode,
             providerRootDirectory: func.providerRootDirectory,
             specification: func.specification,
-        })), null, 4)}
+        })), null, 4)},
+  collections: ${JSON.stringify(config.collections, null, 4)}
 };
 
 export default appwriteConfig;
 `;
         fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
+        console.log("✅ Updated TypeScript configuration file");
     }
     extractRelationships() {
         if (!this.config.collections) {

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