appwrite-utils-cli 1.11.0 → 1.12.0

package/dist/migrations/comprehensiveTransfer.js

@@ -0,0 +1,1315 @@
+import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate, } from "appwrite-utils";
+import { Client, Databases, Storage, Users, Functions, Teams, Query, AppwriteException, } from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { MessageFormatter, getClient } from "appwrite-utils-helpers";
+import { processQueue, queuedOperations } from "../shared/operationQueue.js";
+import { ProgressManager } from "../shared/progressManager.js";
+import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./transfer.js";
+import { deployLocalFunction } from "../functions/deployments.js";
+import { listFunctions, downloadLatestFunctionDeployment, } from "../functions/methods.js";
+import pLimit from "p-limit";
+import chalk from "chalk";
+import { join } from "node:path";
+import fs from "node:fs";
+import { getAdapter, mapToCreateAttributeParams } from "appwrite-utils-helpers";
+export class ComprehensiveTransfer {
+    options;
+    sourceClient;
+    targetClient;
+    sourceUsers;
+    targetUsers;
+    sourceTeams;
+    targetTeams;
+    sourceDatabases;
+    targetDatabases;
+    sourceStorage;
+    targetStorage;
+    sourceFunctions;
+    targetFunctions;
+    limit;
+    userLimit;
+    fileLimit;
+    results;
+    startTime;
+    tempDir;
+    cachedMaxFileSize; // Cache successful maximumFileSize for subsequent buckets
+    sourceAdapter;
+    targetAdapter;
+    constructor(options) {
+        this.options = options;
+        this.sourceClient = getClient(options.sourceEndpoint, options.sourceProject, options.sourceKey);
+        this.targetClient = getClient(options.targetEndpoint, options.targetProject, options.targetKey);
+        this.sourceUsers = new Users(this.sourceClient);
+        this.targetUsers = new Users(this.targetClient);
+        this.sourceTeams = new Teams(this.sourceClient);
+        this.targetTeams = new Teams(this.targetClient);
+        this.sourceDatabases = new Databases(this.sourceClient);
+        this.targetDatabases = new Databases(this.targetClient);
+        this.sourceStorage = new Storage(this.sourceClient);
+        this.targetStorage = new Storage(this.targetClient);
+        this.sourceFunctions = new Functions(this.sourceClient);
+        this.targetFunctions = new Functions(this.targetClient);
+        const baseLimit = options.concurrencyLimit || 10;
+        this.limit = pLimit(baseLimit);
+        // Different rate limits for different operations to prevent API throttling
+        // Users: Half speed (more sensitive operations)
+        // Files: Quarter speed (most bandwidth intensive)
+        this.userLimit = pLimit(Math.max(1, Math.floor(baseLimit / 2)));
+        this.fileLimit = pLimit(Math.max(1, Math.floor(baseLimit / 4)));
+        this.results = {
+            users: { transferred: 0, skipped: 0, failed: 0 },
+            teams: { transferred: 0, skipped: 0, failed: 0 },
+            databases: { transferred: 0, skipped: 0, failed: 0 },
+            buckets: { transferred: 0, skipped: 0, failed: 0 },
+            functions: { transferred: 0, skipped: 0, failed: 0 },
+            totalTime: 0,
+        };
+        this.startTime = Date.now();
+        this.tempDir = join(process.cwd(), ".appwrite-transfer-temp");
+    }
+    async execute() {
+        try {
+            MessageFormatter.info("Starting comprehensive transfer", {
+                prefix: "Transfer",
+            });
+            // Initialize adapters for unified API (TablesDB or legacy via adapter)
+            const source = await getAdapter(this.options.sourceEndpoint, this.options.sourceProject, this.options.sourceKey, 'auto');
+            const target = await getAdapter(this.options.targetEndpoint, this.options.targetProject, this.options.targetKey, 'auto');
+            this.sourceAdapter = source.adapter;
+            this.targetAdapter = target.adapter;
+            if (this.options.dryRun) {
+                MessageFormatter.info("DRY RUN MODE - No actual changes will be made", {
+                    prefix: "Transfer",
+                });
+            }
+            // Show rate limiting configuration
+            const baseLimit = this.options.concurrencyLimit || 10;
+            const userLimit = Math.max(1, Math.floor(baseLimit / 2));
+            const fileLimit = Math.max(1, Math.floor(baseLimit / 4));
+            MessageFormatter.info(`Rate limits: General=${baseLimit}, Users=${userLimit}, Files=${fileLimit}`, { prefix: "Transfer" });
+            // Ensure temp directory exists
+            if (!fs.existsSync(this.tempDir)) {
+                fs.mkdirSync(this.tempDir, { recursive: true });
+            }
+            // Execute transfers in the correct order
+            if (this.options.transferUsers !== false) {
+                await this.transferAllUsers();
+            }
+            if (this.options.transferTeams !== false) {
+                await this.transferAllTeams();
+            }
+            if (this.options.transferDatabases !== false) {
+                await this.transferAllDatabases();
+            }
+            if (this.options.transferBuckets !== false) {
+                await this.transferAllBuckets();
+            }
+            if (this.options.transferFunctions !== false) {
+                await this.transferAllFunctions();
+            }
+            this.results.totalTime = Date.now() - this.startTime;
+            this.printSummary();
+            return this.results;
+        }
+        catch (error) {
+            MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            throw error;
+        }
+        finally {
+            // Clean up temp directory
+            if (fs.existsSync(this.tempDir)) {
+                fs.rmSync(this.tempDir, { recursive: true, force: true });
+            }
+        }
+    }
+    async transferAllUsers() {
+        MessageFormatter.info("Starting user transfer phase", {
+            prefix: "Transfer",
+        });
+        if (this.options.dryRun) {
+            const usersList = await this.sourceUsers.list([Query.limit(1)]);
+            MessageFormatter.info(`DRY RUN: Would transfer ${usersList.total} users`, { prefix: "Transfer" });
+            return;
+        }
+        try {
+            // Use the existing user transfer function
+            // Note: The rate limiting is handled at the API level, not per-user
+            // since user operations are already sequential in the existing implementation
+            await transferUsersLocalToRemote(this.sourceUsers, this.options.targetEndpoint, this.options.targetProject, this.options.targetKey);
+            // Get actual count for results
+            const usersList = await this.sourceUsers.list([Query.limit(1)]);
+            this.results.users.transferred = usersList.total;
+            MessageFormatter.success(`User transfer completed`, {
+                prefix: "Transfer",
+            });
+        }
+        catch (error) {
+            MessageFormatter.error("User transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            this.results.users.failed = 1;
+        }
+    }
+    async transferAllTeams() {
+        MessageFormatter.info("Starting team transfer phase", {
+            prefix: "Transfer",
+        });
+        try {
+            // Fetch all teams from source with pagination
+            const allSourceTeams = await this.fetchAllTeams(this.sourceTeams);
+            const allTargetTeams = await this.fetchAllTeams(this.targetTeams);
+            if (this.options.dryRun) {
+                let totalMemberships = 0;
+                for (const team of allSourceTeams) {
+                    const memberships = await this.sourceTeams.listMemberships(team.$id, [
+                        Query.limit(1),
+                    ]);
+                    totalMemberships += memberships.total;
+                }
+                MessageFormatter.info(`DRY RUN: Would transfer ${allSourceTeams.length} teams with ${totalMemberships} memberships`, { prefix: "Transfer" });
+                return;
+            }
+            const transferTasks = allSourceTeams.map((team) => this.limit(async () => {
+                try {
+                    // Check if team exists in target
+                    const existingTeam = allTargetTeams.find((tt) => tt.$id === team.$id);
+                    if (!existingTeam) {
+                        // Fetch all memberships to extract unique roles before creating team
+                        MessageFormatter.info(`Fetching memberships for team ${team.name} to extract roles`, { prefix: "Transfer" });
+                        const memberships = await this.fetchAllMemberships(team.$id);
+                        // Extract unique roles from all memberships
+                        const allRoles = new Set();
+                        memberships.forEach((membership) => {
+                            membership.roles.forEach((role) => allRoles.add(role));
+                        });
+                        const uniqueRoles = Array.from(allRoles);
+                        MessageFormatter.info(`Found ${uniqueRoles.length} unique roles for team ${team.name}: ${uniqueRoles.join(", ")}`, { prefix: "Transfer" });
+                        // Create team in target with the collected roles
+                        await this.targetTeams.create(team.$id, team.name, uniqueRoles);
+                        MessageFormatter.success(`Created team: ${team.name} with roles: ${uniqueRoles.join(", ")}`, { prefix: "Transfer" });
+                    }
+                    else {
+                        MessageFormatter.info(`Team ${team.name} already exists, updating if needed`, { prefix: "Transfer" });
+                        // Update team if needed
+                        if (existingTeam.name !== team.name) {
+                            await this.targetTeams.updateName(team.$id, team.name);
+                            MessageFormatter.success(`Updated team name: ${team.name}`, {
+                                prefix: "Transfer",
+                            });
+                        }
+                    }
+                    // Transfer team memberships
+                    await this.transferTeamMemberships(team.$id);
+                    this.results.teams.transferred++;
+                    MessageFormatter.success(`Team ${team.name} transferred successfully`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Team ${team.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.teams.failed++;
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.success("Team transfer phase completed", {
+                prefix: "Transfer",
+            });
+        }
+        catch (error) {
+            MessageFormatter.error("Team transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    async transferAllDatabases() {
+        MessageFormatter.info("Starting database transfer phase", {
+            prefix: "Transfer",
+        });
+        try {
+            const sourceDatabases = await this.sourceDatabases.list();
+            const targetDatabases = await this.targetDatabases.list();
+            if (this.options.dryRun) {
+                MessageFormatter.info(`DRY RUN: Would transfer ${sourceDatabases.databases.length} databases`, { prefix: "Transfer" });
+                return;
+            }
+            // Phase 1: Create all databases and collections (structure only)
+            MessageFormatter.info("Phase 1: Creating database structures (databases, collections, attributes, indexes)", { prefix: "Transfer" });
+            const structureCreationTasks = sourceDatabases.databases.map((db) => this.limit(async () => {
+                try {
+                    // Check if database exists in target
+                    const existingDb = targetDatabases.databases.find((tdb) => tdb.$id === db.$id);
+                    if (!existingDb) {
+                        // Create database in target
+                        await this.targetDatabases.create(db.$id, db.name, db.enabled);
+                        MessageFormatter.success(`Created database: ${db.name}`, {
+                            prefix: "Transfer",
+                        });
+                    }
+                    // Create collections, attributes, and indexes WITHOUT transferring documents
+                    await this.createDatabaseStructure(db.$id);
+                    MessageFormatter.success(`Database structure created: ${db.name}`, {
+                        prefix: "Transfer",
+                    });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Database structure creation failed for ${db.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.databases.failed++;
+                }
+            }));
+            await Promise.all(structureCreationTasks);
+            // Phase 2: Transfer all documents after all structures are created
+            MessageFormatter.info("Phase 2: Transferring documents to all collections", { prefix: "Transfer" });
+            const documentTransferTasks = sourceDatabases.databases.map((db) => this.limit(async () => {
+                try {
+                    // Transfer documents for this database
+                    await this.transferDatabaseDocuments(db.$id);
+                    this.results.databases.transferred++;
+                    MessageFormatter.success(`Database documents transferred: ${db.name}`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Document transfer failed for ${db.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.databases.failed++;
+                }
+            }));
+            await Promise.all(documentTransferTasks);
+            MessageFormatter.success("Database transfer phase completed", {
+                prefix: "Transfer",
+            });
+        }
+        catch (error) {
+            MessageFormatter.error("Database transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    /**
+     * Phase 1: Create database structure (collections, attributes, indexes) without transferring documents
+     */
+    async createDatabaseStructure(dbId) {
+        MessageFormatter.info(`Creating database structure for ${dbId}`, {
+            prefix: "Transfer",
+        });
+        try {
+            // Get all collections from source database
+            const sourceCollections = await this.fetchAllCollections(dbId, this.sourceDatabases);
+            MessageFormatter.info(`Found ${sourceCollections.length} collections in source database ${dbId}`, { prefix: "Transfer" });
+            // Process each collection
+            for (const collection of sourceCollections) {
+                MessageFormatter.info(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+                try {
+                    // Create or update collection in target
+                    let targetCollection;
+                    const existingCollection = await tryAwaitWithRetry(async () => this.targetDatabases.listCollections(dbId, [
+                        Query.equal("$id", collection.$id),
+                    ]));
+                    if (existingCollection.collections.length > 0) {
+                        targetCollection = existingCollection.collections[0];
+                        MessageFormatter.info(`Collection ${collection.name} exists in target database`, { prefix: "Transfer" });
+                        // Update collection if needed
+                        if (targetCollection.name !== collection.name ||
+                            JSON.stringify(targetCollection.$permissions) !==
+                                JSON.stringify(collection.$permissions) ||
+                            targetCollection.documentSecurity !==
+                                collection.documentSecurity ||
+                            targetCollection.enabled !== collection.enabled) {
+                            targetCollection = await tryAwaitWithRetry(async () => this.targetDatabases.updateCollection(dbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+                            MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
+                        }
+                    }
+                    else {
+                        MessageFormatter.info(`Creating collection ${collection.name} in target database...`, { prefix: "Transfer" });
+                        targetCollection = await tryAwaitWithRetry(async () => this.targetDatabases.createCollection(dbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+                        MessageFormatter.success(`Collection ${collection.name} created`, {
+                            prefix: "Transfer",
+                        });
+                    }
+                    // Handle attributes with enhanced status checking
+                    MessageFormatter.info(`Creating attributes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
+                    const attributesToCreate = collection.attributes.map((attr) => parseAttribute(attr));
+                    const attributesSuccess = await this.createCollectionAttributesWithStatusCheck(this.targetDatabases, dbId, targetCollection, attributesToCreate);
+                    if (!attributesSuccess) {
+                        MessageFormatter.error(`Failed to create some attributes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
+                        MessageFormatter.error(`Skipping index creation and document transfer for collection ${collection.name} due to attribute failures`, undefined, { prefix: "Transfer" });
+                        // Skip indexes and document transfer if attributes failed
+                        continue;
+                    }
+                    else {
+                        MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
+                    }
+                    // Handle indexes with enhanced status checking
+                    MessageFormatter.info(`Creating indexes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
+                    let indexesSuccess = true;
+                    // Check if indexes need to be created ahead of time
+                    if (collection.indexes.some((index) => !targetCollection.indexes.some((ti) => ti.key === index.key ||
+                        ti.attributes.sort().join(",") ===
+                            index.attributes.sort().join(","))) ||
+                        collection.indexes.length !== targetCollection.indexes.length) {
+                        indexesSuccess = await this.createCollectionIndexesWithStatusCheck(dbId, this.targetDatabases, targetCollection.$id, targetCollection, collection.indexes);
+                    }
+                    if (!indexesSuccess) {
+                        MessageFormatter.error(`Failed to create some indexes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
+                        MessageFormatter.warning(`Proceeding with document transfer despite index failures for collection ${collection.name}`, { prefix: "Transfer" });
+                    }
+                    else {
+                        MessageFormatter.success(`All indexes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
+                    }
+                    MessageFormatter.success(`Structure complete for collection ${collection.name}`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Error processing collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                }
+            }
+            // After processing all collections' attributes and indexes, process any queued
+            // relationship attributes so dependencies are resolved within this phase.
+            if (queuedOperations.length > 0) {
+                MessageFormatter.info(`Processing ${queuedOperations.length} queued relationship operations`, { prefix: "Transfer" });
+                await processQueue(this.targetDatabases, dbId);
+            }
+            else {
+                MessageFormatter.info("No queued relationship operations to process", {
+                    prefix: "Transfer",
+                });
+            }
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to create database structure for ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            throw error;
+        }
+    }
+    /**
+     * Phase 2: Transfer documents to all collections in the database
+     */
+    async transferDatabaseDocuments(dbId) {
+        MessageFormatter.info(`Transferring documents for database ${dbId}`, {
+            prefix: "Transfer",
+        });
+        try {
+            // Get all collections from source database
+            const sourceCollections = await this.fetchAllCollections(dbId, this.sourceDatabases);
+            MessageFormatter.info(`Transferring documents for ${sourceCollections.length} collections in database ${dbId}`, { prefix: "Transfer" });
+            // Process each collection
+            for (const collection of sourceCollections) {
+                MessageFormatter.info(`Transferring documents for collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+                try {
+                    // Transfer documents
+                    await this.transferDocumentsBetweenDatabases(this.sourceDatabases, this.targetDatabases, dbId, dbId, collection.$id, collection.$id);
+                    MessageFormatter.success(`Documents transferred for collection ${collection.name}`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Error transferring documents for collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                }
+            }
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to transfer documents for database ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            throw error;
+        }
+    }
+    async transferAllBuckets() {
+        MessageFormatter.info("Starting bucket transfer phase", {
+            prefix: "Transfer",
+        });
+        try {
+            // Get all buckets from source with pagination
+            const allSourceBuckets = await this.fetchAllBuckets(this.sourceStorage);
+            const allTargetBuckets = await this.fetchAllBuckets(this.targetStorage);
+            if (this.options.dryRun) {
+                let totalFiles = 0;
+                for (const bucket of allSourceBuckets) {
+                    const files = await this.sourceStorage.listFiles(bucket.$id, [
+                        Query.limit(1),
+                    ]);
+                    totalFiles += files.total;
+                }
+                MessageFormatter.info(`DRY RUN: Would transfer ${allSourceBuckets.length} buckets with ${totalFiles} files`, { prefix: "Transfer" });
+                return;
+            }
+            const transferTasks = allSourceBuckets.map((bucket) => this.limit(async () => {
+                try {
+                    // Check if bucket exists in target
+                    const existingBucket = allTargetBuckets.find((tb) => tb.$id === bucket.$id);
+                    if (!existingBucket) {
+                        // Create bucket with fallback strategy for maximumFileSize
+                        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++;
+                    MessageFormatter.success(`Bucket ${bucket.name} transferred successfully`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Bucket ${bucket.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.buckets.failed++;
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.success("Bucket transfer phase completed", {
+                prefix: "Transfer",
+            });
+        }
+        catch (error) {
+            MessageFormatter.error("Bucket transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    async createBucketWithFallback(bucket) {
+        // Determine the optimal size to try first
+        let sizeToTry;
+        if (this.cachedMaxFileSize) {
+            // Use cached size if it's smaller than or equal to the bucket's original size
+            if (bucket.maximumFileSize >= this.cachedMaxFileSize) {
+                sizeToTry = this.cachedMaxFileSize;
+                MessageFormatter.info(`Bucket ${bucket.name}: Using cached maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+            }
+            else {
+                // Original size is smaller than cached size, try original first
+                sizeToTry = bucket.maximumFileSize;
+            }
+        }
+        else {
+            // No cached size yet, try original size first
+            sizeToTry = bucket.maximumFileSize;
+        }
+        // Try the optimal size first
+        try {
+            await this.targetStorage.createBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, sizeToTry, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+            // Success - cache this size if it's not already cached or is smaller than cached
+            if (!this.cachedMaxFileSize || sizeToTry < this.cachedMaxFileSize) {
+                this.cachedMaxFileSize = sizeToTry;
+                MessageFormatter.info(`Bucket ${bucket.name}: Cached successful maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+            }
+            // Log if we used a different size than original
+            if (sizeToTry !== bucket.maximumFileSize) {
+                MessageFormatter.warning(`Bucket ${bucket.name}: maximumFileSize used ${sizeToTry} instead of original ${bucket.maximumFileSize} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+            }
+            return; // Success, exit the function
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Check if the error is related to maximumFileSize validation
+            if (err.message.includes("maximumFileSize") ||
+                err.message.includes("valid range")) {
+                MessageFormatter.warning(`Bucket ${bucket.name}: Failed with maximumFileSize ${sizeToTry}, falling back to smaller sizes...`, { prefix: "Transfer" });
+                // Continue to fallback logic below
+            }
+            else {
+                // Different error, don't retry
+                throw err;
+            }
+        }
+        // Fallback to progressively smaller sizes
+        const fallbackSizes = [
+            5_000_000_000, // 5GB
+            2_500_000_000, // 2.5GB
+            2_000_000_000, // 2GB
+            1_000_000_000, // 1GB
+            500_000_000, // 500MB
+            100_000_000, // 100MB
+        ];
+        // Remove sizes that are larger than or equal to the already-tried size
+        const validSizes = fallbackSizes
+            .filter((size) => size < sizeToTry)
+            .sort((a, b) => b - a); // Sort descending
+        let lastError = null;
+        for (const fileSize of validSizes) {
+            try {
+                await this.targetStorage.createBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, fileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+                // Success - cache this size if it's not already cached or is smaller than cached
+                if (!this.cachedMaxFileSize || fileSize < this.cachedMaxFileSize) {
+                    this.cachedMaxFileSize = fileSize;
+                    MessageFormatter.info(`Bucket ${bucket.name}: Cached successful maximumFileSize ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+                }
+                // Log if we had to reduce the file size
+                if (fileSize !== bucket.maximumFileSize) {
+                    MessageFormatter.warning(`Bucket ${bucket.name}: maximumFileSize reduced from ${bucket.maximumFileSize} to ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+                }
+                return; // Success, exit the function
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // Check if the error is related to maximumFileSize validation
+                if (lastError.message.includes("maximumFileSize") ||
+                    lastError.message.includes("valid range")) {
+                    MessageFormatter.warning(`Bucket ${bucket.name}: Failed with maximumFileSize ${fileSize}, trying smaller size...`, { prefix: "Transfer" });
+                    continue; // Try next smaller size
+                }
+                else {
+                    // Different error, don't retry
+                    throw lastError;
+                }
+            }
+        }
+        // If we get here, all fallback sizes failed
+        MessageFormatter.error(`Bucket ${bucket.name}: All fallback file sizes failed. Last error: ${lastError?.message}`, lastError || undefined, { prefix: "Transfer" });
+        throw lastError || new Error("All fallback file sizes failed");
+    }
+    async transferBucketFiles(sourceBucketId, targetBucketId) {
+        let lastFileId;
+        let transferredFiles = 0;
+        while (true) {
+            const queries = [Query.limit(50)]; // Smaller batch size for better rate limiting
+            if (lastFileId) {
+                queries.push(Query.cursorAfter(lastFileId));
+            }
+            const files = await this.sourceStorage.listFiles(sourceBucketId, queries);
+            if (files.files.length === 0)
+                break;
+            // Process files with rate limiting
+            const fileTasks = files.files.map((file) => this.fileLimit(async () => {
+                try {
+                    // Check if file already exists and compare permissions
+                    let existingFile = null;
+                    try {
+                        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) {
+                        // File doesn't exist, proceed with transfer
+                    }
+                    // Download file with validation
+                    const fileData = await this.validateAndDownloadFile(sourceBucketId, file.$id);
+                    if (!fileData) {
+                        MessageFormatter.warning(`File ${file.name} failed validation, skipping`, { prefix: "Transfer" });
+                        return;
+                    }
+                    // Upload file to target
+                    const fileToCreate = InputFile.fromBuffer(new Uint8Array(fileData), file.name);
+                    await this.targetStorage.createFile(targetBucketId, file.$id, fileToCreate, file.$permissions);
+                    transferredFiles++;
+                    MessageFormatter.success(`Transferred file: ${file.name}`, {
+                        prefix: "Transfer",
+                    });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to transfer file ${file.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                }
+            }));
+            await Promise.all(fileTasks);
+            if (files.files.length < 50)
+                break;
+            lastFileId = files.files[files.files.length - 1].$id;
+        }
+        MessageFormatter.info(`Transferred ${transferredFiles} files from bucket ${sourceBucketId}`, { prefix: "Transfer" });
+    }
+    async validateAndDownloadFile(bucketId, fileId) {
+        let attempts = 3;
+        while (attempts > 0) {
+            try {
+                const fileData = await this.sourceStorage.getFileDownload(bucketId, fileId);
+                // Basic validation - ensure file is not empty and not too large
+                if (fileData.byteLength === 0) {
+                    MessageFormatter.warning(`File ${fileId} is empty`, {
+                        prefix: "Transfer",
+                    });
+                    return null;
+                }
+                if (fileData.byteLength > 50 * 1024 * 1024) {
+                    // 50MB limit
+                    MessageFormatter.warning(`File ${fileId} is too large (${fileData.byteLength} bytes)`, { prefix: "Transfer" });
+                    return null;
+                }
+                return fileData;
+            }
+            catch (error) {
+                attempts--;
+                MessageFormatter.warning(`Error downloading file ${fileId}, attempts left: ${attempts}`, { prefix: "Transfer" });
+                if (attempts === 0) {
+                    MessageFormatter.error(`Failed to download file ${fileId} after all attempts`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    return null;
+                }
+                // Wait before retry
+                await new Promise((resolve) => setTimeout(resolve, 1000 * (4 - attempts)));
+            }
+        }
+        return null;
+    }
+    async transferAllFunctions() {
+        MessageFormatter.info("Starting function transfer phase", {
+            prefix: "Transfer",
+        });
+        try {
+            const sourceFunctions = await listFunctions(this.sourceClient, [
+                Query.limit(1000),
+            ]);
+            const targetFunctions = await listFunctions(this.targetClient, [
+                Query.limit(1000),
+            ]);
+            if (this.options.dryRun) {
+                MessageFormatter.info(`DRY RUN: Would transfer ${sourceFunctions.functions.length} functions`, { prefix: "Transfer" });
+                return;
+            }
+            const transferTasks = sourceFunctions.functions.map((func) => this.limit(async () => {
+                try {
+                    // Check if function exists in target
+                    const existingFunc = targetFunctions.functions.find((tf) => tf.$id === func.$id);
+                    if (existingFunc) {
+                        MessageFormatter.info(`Function ${func.name} already exists, skipping creation`, { prefix: "Transfer" });
+                        this.results.functions.skipped++;
+                        return;
+                    }
+                    // Download function from source
+                    const functionPath = await this.downloadFunction(func);
+                    if (!functionPath) {
+                        MessageFormatter.error(`Failed to download function ${func.name}`, undefined, { prefix: "Transfer" });
+                        this.results.functions.failed++;
+                        return;
+                    }
+                    // Deploy function to target
+                    const functionConfig = {
+                        $id: func.$id,
+                        name: func.name,
+                        runtime: func.runtime,
+                        execute: func.execute,
+                        events: func.events,
+                        enabled: func.enabled,
+                        logging: func.logging,
+                        entrypoint: func.entrypoint,
+                        commands: func.commands,
+                        scopes: func.scopes,
+                        timeout: func.timeout,
+                        schedule: func.schedule,
+                        installationId: func.installationId,
+                        providerRepositoryId: func.providerRepositoryId,
+                        providerBranch: func.providerBranch,
+                        providerSilentMode: func.providerSilentMode,
+                        providerRootDirectory: func.providerRootDirectory,
+                        specification: func.specification,
+                        dirPath: functionPath,
+                    };
+                    await deployLocalFunction(this.targetClient, func.name, functionConfig, undefined, this.tempDir);
+                    this.results.functions.transferred++;
+                    MessageFormatter.success(`Function ${func.name} transferred successfully`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Function ${func.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.functions.failed++;
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.success("Function transfer phase completed", {
+                prefix: "Transfer",
+            });
+        }
+        catch (error) {
+            MessageFormatter.error("Function transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    async downloadFunction(func) {
+        try {
+            const { path } = await downloadLatestFunctionDeployment(this.sourceClient, func.$id, this.tempDir);
+            return path;
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to download function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            return null;
+        }
+    }
+    /**
+     * Helper method to fetch all collections from a database
+     */
+    async fetchAllCollections(dbId, databases) {
+        const collections = [];
+        let lastId;
+        while (true) {
+            const queries = [Query.limit(100)];
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            const result = await tryAwaitWithRetry(async () => databases.listCollections(dbId, queries));
+            if (result.collections.length === 0) {
+                break;
+            }
+            collections.push(...result.collections);
+            if (result.collections.length < 100) {
+                break;
+            }
+            lastId = result.collections[result.collections.length - 1].$id;
+        }
+        return collections;
+    }
+    /**
+     * Helper method to fetch all buckets with pagination
+     */
+    async fetchAllBuckets(storage) {
+        const buckets = [];
+        let lastId;
+        while (true) {
+            const queries = [Query.limit(100)];
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            const result = await tryAwaitWithRetry(async () => storage.listBuckets(queries));
+            if (result.buckets.length === 0) {
+                break;
+            }
+            buckets.push(...result.buckets);
+            if (result.buckets.length < 100) {
+                break;
+            }
+            lastId = result.buckets[result.buckets.length - 1].$id;
+        }
+        return buckets;
+    }
+    /**
+     * Helper method to parse attribute objects (simplified version of parseAttribute)
+     */
+    parseAttribute(attr) {
+        // This is a simplified version - in production you'd use the actual parseAttribute from appwrite-utils
+        return {
+            key: attr.key,
+            type: attr.type,
+            size: attr.size,
+            required: attr.required,
+            array: attr.array,
+            default: attr.default,
+            format: attr.format,
+            elements: attr.elements,
+            min: attr.min,
+            max: attr.max,
+            relatedCollection: attr.relatedCollection,
+            relationType: attr.relationType,
+            twoWay: attr.twoWay,
+            twoWayKey: attr.twoWayKey,
+            onDelete: attr.onDelete,
+            side: attr.side,
+        };
+    }
+    /**
+     * Helper method to create collection attributes with status checking
+     */
+    async createCollectionAttributesWithStatusCheck(databases, dbId, collection, attributes) {
+        if (!this.targetAdapter) {
+            throw new Error('Target adapter not initialized');
+        }
+        try {
+            // Create non-relationship attributes first
+            const nonRel = (attributes || []).filter((a) => a.type !== 'relationship');
+            for (const attr of nonRel) {
+                const params = mapToCreateAttributeParams(attr, { databaseId: dbId, tableId: collection.$id });
+                await this.targetAdapter.createAttribute(params);
+                // Small delay between creations
+                await new Promise((r) => setTimeout(r, 150));
+            }
+            // Wait for attributes to become available
+            for (const attr of nonRel) {
+                const maxWait = 60000; // 60s
+                const start = Date.now();
+                let lastStatus = '';
+                while (Date.now() - start < maxWait) {
+                    try {
+                        const tableRes = await this.targetAdapter.getTable({ databaseId: dbId, tableId: collection.$id });
+                        const cols = tableRes.attributes || tableRes.columns || [];
+                        const col = cols.find((c) => c.key === attr.key);
+                        if (col) {
+                            if (col.status === 'available')
+                                break;
+                            if (col.status === 'failed' || col.status === 'stuck') {
+                                throw new Error(col.error || `Attribute ${attr.key} failed`);
+                            }
+                            lastStatus = col.status;
+                        }
+                        await new Promise((r) => setTimeout(r, 2000));
+                    }
+                    catch {
+                        await new Promise((r) => setTimeout(r, 2000));
+                    }
+                }
+                if (Date.now() - start >= maxWait) {
+                    MessageFormatter.warning(`Attribute ${attr.key} did not become available within 60s (last status: ${lastStatus})`, { prefix: 'Attributes' });
+                }
+            }
+            // Create relationship attributes
+            const rels = (attributes || []).filter((a) => a.type === 'relationship');
+            for (const attr of rels) {
+                const params = mapToCreateAttributeParams(attr, { databaseId: dbId, tableId: collection.$id });
+                await this.targetAdapter.createAttribute(params);
+                await new Promise((r) => setTimeout(r, 150));
+            }
+            return true;
+        }
+        catch (e) {
+            MessageFormatter.error('Failed creating attributes via adapter', e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+            return false;
+        }
+    }
+    /**
+     * Helper method to create collection indexes with status checking
+     */
+    async createCollectionIndexesWithStatusCheck(dbId, databases, collectionId, collection, indexes) {
+        if (!this.targetAdapter) {
+            throw new Error('Target adapter not initialized');
+        }
+        try {
+            for (const idx of indexes || []) {
+                await this.targetAdapter.createIndex({
+                    databaseId: dbId,
+                    tableId: collectionId,
+                    key: idx.key,
+                    type: idx.type,
+                    attributes: idx.attributes,
+                    orders: idx.orders || []
+                });
+                await new Promise((r) => setTimeout(r, 150));
+            }
+            return true;
+        }
+        catch (e) {
+            MessageFormatter.error('Failed creating indexes via adapter', e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
+            return false;
+        }
+    }
+    /**
+     * 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} 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 bulkEnabled = false;
+        // Temporarily disable to see if it fixes my permissions issues
+        const supportsBulk = bulkEnabled ? this.options.targetEndpoint.includes("cloud.appwrite.io") : false;
+        if (supportsBulk) {
+            MessageFormatter.info(`Using bulk operations for enhanced performance`, {
+                prefix: "Transfer",
+            });
+        }
+        while (true) {
+            // Fetch source documents in larger batches (1000 instead of 50)
+            const queries = [Query.limit(1000)];
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            const sourceDocuments = await tryAwaitWithRetry(async () => sourceDb.listDocuments(sourceDbId, sourceCollectionId, queries));
+            if (sourceDocuments.documents.length === 0) {
+                break;
+            }
+            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 = Array.from(new Set(sourceDoc.$permissions || [])).sort();
+                    const targetPermissions = Array.from(new Set(existingTargetDoc.$permissions || [])).sort();
+                    const permissionsDiffer = sourcePermissions.join(",") !== targetPermissions.join(",") ||
+                        sourcePermissions.length !== targetPermissions.length;
+                    // 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",
+                        });
+                    }
+                    else if (contentDiffers) {
+                        // Only content differs
+                        documentsToUpdate.push({
+                            doc: sourceDoc,
+                            targetDoc: existingTargetDoc,
+                            reason: "content differs",
+                        });
+                    }
+                    else if (permissionsDiffer) {
+                        // Only permissions differ
+                        documentsToUpdate.push({
+                            doc: sourceDoc,
+                            targetDoc: existingTargetDoc,
+                            reason: "permissions differ",
+                        });
+                    }
+                    else {
+                        // Document exists with identical content AND permissions, skip
+                        totalSkipped++;
+                    }
+                }
+            }
+            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;
+                }
+                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 =
+                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, $sequence, ...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) {
+                    await this.bulkUpsertDocuments(this.targetClient, targetDbId, targetCollectionId, batch);
+                    MessageFormatter.success(`✅ Bulk upserted ${batch.length} documents`, { prefix: "Transfer" });
+                }
+                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, $sequence, ...docData } = doc;
+                await tryAwaitWithRetry(async () => targetDb.createDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
+                successCount++;
+            }
+            catch (error) {
+                if (error instanceof AppwriteException &&
+                    error.message.includes("already exists")) {
+                    try {
+                        // Update it! It's here because it needs an update or a create
+                        const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, $sequence, ...docData } = doc;
+                        await tryAwaitWithRetry(async () => targetDb.updateDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
+                        successCount++;
+                    }
+                    catch (updateError) {
+                        // just send the error to the formatter
+                        MessageFormatter.error(`Failed to transfer document ${doc.$id}`, updateError instanceof Error
+                            ? updateError
+                            : new Error(String(updateError)), { prefix: "Transfer" });
+                    }
+                }
+                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, $sequence, ...docData } = doc;
+                await tryAwaitWithRetry(async () => targetDb.updateDocument(targetDbId, targetCollectionId, doc.$id, docData, $permissions));
+                successCount++;
+            }
+            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));
+        }
+        return chunks;
+    }
+    /**
+     * Helper method to fetch all teams with pagination
+     */
+    async fetchAllTeams(teams) {
+        const teamsList = [];
+        let lastId;
+        while (true) {
+            const queries = [Query.limit(100)];
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            const result = await tryAwaitWithRetry(async () => teams.list(queries));
+            if (result.teams.length === 0) {
+                break;
+            }
+            teamsList.push(...result.teams);
+            if (result.teams.length < 100) {
+                break;
+            }
+            lastId = result.teams[result.teams.length - 1].$id;
+        }
+        return teamsList;
+    }
+    /**
+     * Helper method to fetch all memberships for a team with pagination
+     */
+    async fetchAllMemberships(teamId) {
+        const membershipsList = [];
+        let lastId;
+        while (true) {
+            const queries = [Query.limit(100)];
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            const result = await tryAwaitWithRetry(async () => this.sourceTeams.listMemberships(teamId, queries));
+            if (result.memberships.length === 0) {
+                break;
+            }
+            membershipsList.push(...result.memberships);
+            if (result.memberships.length < 100) {
+                break;
+            }
+            lastId = result.memberships[result.memberships.length - 1].$id;
+        }
+        return membershipsList;
+    }
+    /**
+     * Helper method to transfer team memberships
+     */
+    async transferTeamMemberships(teamId) {
+        MessageFormatter.info(`Transferring memberships for team ${teamId}`, {
+            prefix: "Transfer",
+        });
+        try {
+            // Fetch all memberships for this team
+            const memberships = await this.fetchAllMemberships(teamId);
+            if (memberships.length === 0) {
+                MessageFormatter.info(`No memberships found for team ${teamId}`, {
+                    prefix: "Transfer",
+                });
+                return;
+            }
+            MessageFormatter.info(`Found ${memberships.length} memberships for team ${teamId}`, { prefix: "Transfer" });
+            let totalTransferred = 0;
+            // Transfer memberships with rate limiting
+            const transferTasks = memberships.map((membership) => this.userLimit(async () => {
+                // Use userLimit for team operations (more sensitive)
+                try {
+                    // Check if membership already exists and compare roles
+                    let existingMembership = null;
+                    try {
+                        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) {
+                        // Membership doesn't exist, proceed with creation
+                    }
+                    // Get user data from target (users should already be transferred)
+                    let userData = null;
+                    try {
+                        userData = await this.targetUsers.get(membership.userId);
+                    }
+                    catch (error) {
+                        MessageFormatter.warning(`User ${membership.userId} not found in target, membership ${membership.$id} may fail`, { prefix: "Transfer" });
+                    }
+                    // Create membership using the comprehensive user data
+                    await tryAwaitWithRetry(async () => this.targetTeams.createMembership(teamId, membership.roles, userData?.email || membership.userEmail, // Use target user email if available, fallback to membership email
+                    membership.userId, // User ID
+                    userData?.phone || undefined, // Use target user phone if available
+                    undefined, // Invitation URL placeholder
+                    userData?.name || membership.userName // Use target user name if available, fallback to membership name
+                    ));
+                    totalTransferred++;
+                    MessageFormatter.success(`Transferred membership ${membership.$id} for user ${userData?.name || membership.userName}`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to transfer membership ${membership.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.info(`Transferred ${totalTransferred} memberships for team ${teamId}`, { prefix: "Transfer" });
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to transfer memberships for team ${teamId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    printSummary() {
+        const duration = Math.round((Date.now() - this.startTime) / 1000);
+        MessageFormatter.info("=== COMPREHENSIVE TRANSFER SUMMARY ===", {
+            prefix: "Transfer",
+        });
+        MessageFormatter.info(`Total Time: ${duration}s`, { prefix: "Transfer" });
+        MessageFormatter.info(`Users: ${this.results.users.transferred} transferred, ${this.results.users.skipped} skipped, ${this.results.users.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Teams: ${this.results.teams.transferred} transferred, ${this.results.teams.skipped} skipped, ${this.results.teams.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Databases: ${this.results.databases.transferred} transferred, ${this.results.databases.skipped} skipped, ${this.results.databases.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Buckets: ${this.results.buckets.transferred} transferred, ${this.results.buckets.skipped} skipped, ${this.results.buckets.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Functions: ${this.results.functions.transferred} transferred, ${this.results.functions.skipped} skipped, ${this.results.functions.failed} failed`, { prefix: "Transfer" });
+        const totalTransferred = this.results.users.transferred +
+            this.results.teams.transferred +
+            this.results.databases.transferred +
+            this.results.buckets.transferred +
+            this.results.functions.transferred;
+        const totalFailed = this.results.users.failed +
+            this.results.teams.failed +
+            this.results.databases.failed +
+            this.results.buckets.failed +
+            this.results.functions.failed;
+        if (totalFailed === 0) {
+            MessageFormatter.success(`All ${totalTransferred} items transferred successfully!`, { prefix: "Transfer" });
+        }
+        else {
+            MessageFormatter.warning(`${totalTransferred} items transferred, ${totalFailed} failed`, { prefix: "Transfer" });
+        }
+    }
+}