appwrite-utils-cli 1.5.1 → 1.6.0

package/dist/collections/methods.js

@@ -1,16 +1,20 @@
-import { Client, Databases, ID, Permission, Query, } from "node-appwrite";
+import { Databases, ID, Permission, Query, } from "node-appwrite";
 import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
-import { nameToIdMapping, processQueue, queuedOperations } from "../shared/operationQueue.js";
-import { createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
-import { createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck } from "./indexes.js";
+import { nameToIdMapping, processQueue, queuedOperations, clearProcessingState, isCollectionProcessed, markCollectionProcessed } from "../shared/operationQueue.js";
+import { logger } from "../shared/logging.js";
+import { createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
+import { createOrUpdateIndexesWithStatusCheck } from "./indexes.js";
 import { SchemaGenerator } from "../shared/schemaGenerator.js";
-import { isNull, isUndefined, isNil, isPlainObject, isString, isJSONValue, chunk, } from "es-toolkit";
+import { isNull, isUndefined, isNil, isPlainObject, isString, } from "es-toolkit";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
-import { ProgressManager } from "../shared/progressManager.js";
-import chalk from "chalk";
+import { isLegacyDatabases } from "../utils/typeGuards.js";
+// Re-export wipe operations
+export { wipeDatabase, wipeCollection, wipeAllTables, wipeTableRows, } from "./wipeOperations.js";
+// Re-export transfer operations
+export { transferDocumentsBetweenDbsLocalToLocal, transferDocumentsBetweenDbsLocalToRemote, } from "./transferOperations.js";
 export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
-    const collection = await (db instanceof Databases ?
+    const collection = await (isLegacyDatabases(db) ?
         db.getCollection(dbId, targetCollectionId) :
         db.getTable({ databaseId: dbId, tableId: targetCollectionId }));
     const attributes = collection.attributes;
@@ -49,19 +53,19 @@ export const documentExists = async (db, dbId, targetCollectionId, toCreateObjec
     // Convert to Query parameters
     const validQueryParams = validMappedEntries.map(([key, value]) => Query.equal(key, value));
     // Execute the query with the validated and prepared parameters
-    const result = await (db instanceof Databases ?
+    const result = await (isLegacyDatabases(db) ?
         db.listDocuments(dbId, targetCollectionId, validQueryParams) :
         db.listRows({ databaseId: dbId, tableId: targetCollectionId, queries: validQueryParams }));
-    const items = db instanceof Databases ? result.documents : (result.rows || result.documents);
+    const items = isLegacyDatabases(db) ? result.documents : (result.rows || result.documents);
     return items?.[0] || null;
 };
 export const checkForCollection = async (db, dbId, collection) => {
     try {
         MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
-        const response = await tryAwaitWithRetry(async () => db instanceof Databases ?
+        const response = await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
             await db.listCollections(dbId, [Query.equal("name", collection.name)]) :
             await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collection.name)] }));
-        const items = db instanceof Databases ? response.collections : (response.tables || response.collections);
+        const items = isLegacyDatabases(db) ? response.collections : (response.tables || response.collections);
         if (items && items.length > 0) {
             MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
             return { ...collection, ...items[0] };
@@ -72,7 +76,14 @@ export const checkForCollection = async (db, dbId, collection) => {
         }
     }
     catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
         MessageFormatter.error(`Error checking for collection: ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Collections" });
+        logger.error('Collection check failed', {
+            collectionName: collection.name,
+            dbId,
+            error: errorMessage,
+            operation: 'checkForCollection'
+        });
         return null;
     }
 };
@@ -81,16 +92,16 @@ export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) =>
     if (nameToIdMapping.has(collectionName)) {
         const collectionId = nameToIdMapping.get(collectionName);
         MessageFormatter.debug(`Collection found in cache: ${collectionId}`, undefined, { prefix: "Collections" });
-        return await tryAwaitWithRetry(async () => db instanceof Databases ?
+        return await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
             await db.getCollection(dbId, collectionId) :
             await db.getTable({ databaseId: dbId, tableId: collectionId }));
     }
     else {
         MessageFormatter.progress(`Fetching collection by name: ${collectionName}`, { prefix: "Collections" });
-        const collectionsPulled = await tryAwaitWithRetry(async () => db instanceof Databases ?
+        const collectionsPulled = await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
             await db.listCollections(dbId, [Query.equal("name", collectionName)]) :
             await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collectionName)] }));
-        const items = db instanceof Databases ? collectionsPulled.collections : (collectionsPulled.tables || collectionsPulled.collections);
+        const items = isLegacyDatabases(db) ? collectionsPulled.collections : (collectionsPulled.tables || collectionsPulled.collections);
         if ((collectionsPulled.total || items?.length) > 0) {
             const collection = items[0];
             MessageFormatter.info(`Collection found: ${collection.$id}`, { prefix: "Collections" });
@@ -103,173 +114,13 @@ export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) =>
         }
     }
 };
-async function wipeDocumentsFromCollection(database, databaseId, collectionId) {
-    try {
-        const initialDocuments = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
-        let documents = initialDocuments.documents;
-        let totalDocuments = documents.length;
-        let cursor = initialDocuments.documents.length >= 1000
-            ? initialDocuments.documents[initialDocuments.documents.length - 1].$id
-            : undefined;
-        while (cursor) {
-            const docsResponse = await database.listDocuments(databaseId, collectionId, [Query.limit(1000), ...(cursor ? [Query.cursorAfter(cursor)] : [])]);
-            documents.push(...docsResponse.documents);
-            totalDocuments = documents.length;
-            cursor =
-                docsResponse.documents.length >= 1000
-                    ? docsResponse.documents[docsResponse.documents.length - 1].$id
-                    : undefined;
-            if (totalDocuments % 10000 === 0) {
-                MessageFormatter.progress(`Found ${totalDocuments} documents...`, { prefix: "Wipe" });
-            }
-        }
-        MessageFormatter.info(`Found ${totalDocuments} documents to delete`, { prefix: "Wipe" });
-        if (totalDocuments === 0) {
-            MessageFormatter.info("No documents to delete", { prefix: "Wipe" });
-            return;
-        }
-        // Create progress tracker for deletion
-        const progress = ProgressManager.create(`delete-${collectionId}`, totalDocuments, { title: "Deleting documents" });
-        const maxStackSize = 50; // Reduced batch size
-        const docBatches = chunk(documents, maxStackSize);
-        let documentsProcessed = 0;
-        for (let i = 0; i < docBatches.length; i++) {
-            const batch = docBatches[i];
-            const deletePromises = batch.map(async (doc) => {
-                try {
-                    await tryAwaitWithRetry(async () => database.deleteDocument(databaseId, collectionId, doc.$id));
-                    documentsProcessed++;
-                    progress.update(documentsProcessed);
-                }
-                catch (error) {
-                    // Skip if document doesn't exist or other non-critical errors
-                    if (!error.message?.includes("Document with the requested ID could not be found")) {
-                        MessageFormatter.error(`Failed to delete document ${doc.$id}`, error.message, { prefix: "Wipe" });
-                    }
-                    documentsProcessed++;
-                    progress.update(documentsProcessed);
-                }
-            });
-            await Promise.all(deletePromises);
-            await delay(50); // Increased delay between batches
-            // Progress is now handled by ProgressManager automatically
-        }
-        progress.stop();
-        MessageFormatter.success(`Completed deletion of ${totalDocuments} documents from collection ${collectionId}`, { prefix: "Wipe" });
-    }
-    catch (error) {
-        MessageFormatter.error(`Error wiping documents from collection ${collectionId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
-        throw error;
-    }
-}
-export const wipeDatabase = async (database, databaseId) => {
-    MessageFormatter.info(`Wiping database: ${databaseId}`, { prefix: "Wipe" });
-    const existingCollections = await fetchAllCollections(databaseId, database);
-    let collectionsDeleted = [];
-    if (existingCollections.length === 0) {
-        MessageFormatter.info("No collections to delete", { prefix: "Wipe" });
-        return collectionsDeleted;
-    }
-    const progress = ProgressManager.create(`wipe-db-${databaseId}`, existingCollections.length, { title: "Deleting collections" });
-    let processed = 0;
-    for (const { $id: collectionId, name: name } of existingCollections) {
-        MessageFormatter.progress(`Deleting collection: ${collectionId}`, { prefix: "Wipe" });
-        collectionsDeleted.push({
-            collectionId: collectionId,
-            collectionName: name,
-        });
-        tryAwaitWithRetry(async () => await database.deleteCollection(databaseId, collectionId)); // Try to delete the collection and ignore errors if it doesn't exist or if it's already being deleted
-        processed++;
-        progress.update(processed);
-        await delay(100);
-    }
-    progress.stop();
-    MessageFormatter.success(`Deleted ${collectionsDeleted.length} collections from database`, { prefix: "Wipe" });
-    return collectionsDeleted;
-};
-export const wipeCollection = async (database, databaseId, collectionId) => {
-    const collections = await database.listCollections(databaseId, [
-        Query.equal("$id", collectionId),
-    ]);
-    if (collections.total === 0) {
-        MessageFormatter.warning(`Collection ${collectionId} not found`, { prefix: "Wipe" });
-        return;
-    }
-    const collection = collections.collections[0];
-    await wipeDocumentsFromCollection(database, databaseId, collection.$id);
-};
-// TablesDB helpers for wiping
-export const wipeAllTables = async (adapter, databaseId) => {
-    MessageFormatter.info(`Wiping tables in database: ${databaseId}`, { prefix: 'Wipe' });
-    const res = await adapter.listTables({ databaseId, queries: [Query.limit(500)] });
-    const tables = res.tables || [];
-    const deleted = [];
-    const progress = ProgressManager.create(`wipe-db-${databaseId}`, tables.length, { title: 'Deleting tables' });
-    let processed = 0;
-    for (const t of tables) {
-        try {
-            await adapter.deleteTable({ databaseId, tableId: t.$id });
-            deleted.push({ tableId: t.$id, tableName: t.name });
-        }
-        catch (e) {
-            MessageFormatter.error(`Failed deleting table ${t.$id}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Wipe' });
-        }
-        processed++;
-        progress.update(processed);
-        await delay(100);
-    }
-    progress.stop();
-    return deleted;
-};
-export const wipeTableRows = async (adapter, databaseId, tableId) => {
-    try {
-        const initial = await adapter.listRows({ databaseId, tableId, queries: [Query.limit(1000)] });
-        let rows = initial.rows || [];
-        let total = rows.length;
-        let cursor = rows.length >= 1000 ? rows[rows.length - 1].$id : undefined;
-        while (cursor) {
-            const resp = await adapter.listRows({ databaseId, tableId, queries: [Query.limit(1000), ...(cursor ? [Query.cursorAfter(cursor)] : [])] });
-            const more = resp.rows || [];
-            rows.push(...more);
-            total = rows.length;
-            cursor = more.length >= 1000 ? more[more.length - 1].$id : undefined;
-            if (total % 10000 === 0) {
-                MessageFormatter.progress(`Found ${total} rows...`, { prefix: 'Wipe' });
-            }
-        }
-        MessageFormatter.info(`Found ${total} rows to delete`, { prefix: 'Wipe' });
-        if (total === 0)
-            return;
-        const progress = ProgressManager.create(`delete-${tableId}`, total, { title: 'Deleting rows' });
-        let processed = 0;
-        const maxStackSize = 50;
-        const batches = chunk(rows, maxStackSize);
-        for (const batch of batches) {
-            await Promise.all(batch.map(async (row) => {
-                try {
-                    await adapter.deleteRow({ databaseId, tableId, id: row.$id });
-                }
-                catch (e) {
-                    // ignore missing rows
-                }
-                processed++;
-                progress.update(processed);
-            }));
-            await delay(50);
-        }
-        progress.stop();
-        MessageFormatter.success(`Completed deletion of ${total} rows from table ${tableId}`, { prefix: 'Wipe' });
-    }
-    catch (error) {
-        MessageFormatter.error(`Error wiping rows from table ${tableId}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Wipe' });
-        throw error;
-    }
-};
 export const generateSchemas = async (config, appwriteFolderPath) => {
     const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
     schemaGenerator.generateSchemas();
 };
 export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections, selectedCollections = []) => {
+    // Clear processing state at the start of a new operation
+    clearProcessingState();
     // If API mode is tablesdb, route to adapter-based implementation
     try {
         const { adapter, apiMode } = await getAdapterFromConfig(config);
@@ -286,8 +137,14 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         return;
     }
     const usedIds = new Set();
+    MessageFormatter.info(`Processing ${collectionsToProcess.length} collections with intelligent state management`, { prefix: "Collections" });
     for (const collection of collectionsToProcess) {
         const { attributes, indexes, ...collectionData } = collection;
+        // Check if this collection has already been processed in this session
+        if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
+            MessageFormatter.info(`Collection '${collectionData.name}' already processed, skipping`, { prefix: "Collections" });
+            continue;
+        }
         // Prepare permissions for the collection
         const permissions = [];
         if (collection.$permissions && collection.$permissions.length > 0) {
@@ -354,6 +211,8 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         else {
             MessageFormatter.info(`Collection ${collectionData.name} exists, updating it`, { prefix: "Collections" });
             await tryAwaitWithRetry(async () => await database.updateCollection(databaseId, collectionToUse.$id, collectionData.name, permissions, collectionData.documentSecurity ?? false, collectionData.enabled ?? true));
+            // Cache the existing collection ID
+            nameToIdMapping.set(collectionData.name, collectionToUse.$id);
         }
         // Add delay after creating/updating collection
         await delay(250);
@@ -370,24 +229,28 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
                 ?.indexes ?? [];
         MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
         await createOrUpdateIndexesWithStatusCheck(databaseId, database, collectionToUse.$id, collectionToUse, indexesToUse);
+        // Mark this collection as fully processed to prevent re-processing
+        markCollectionProcessed(collectionToUse.$id, collectionData.name);
         // Add delay after creating indexes
         await delay(250);
     }
-    // Process any remaining tasks in the queue (only if there are operations to process)
+    // Process any remaining relationship attributes in the queue
+    // This surgical approach only processes specific attributes, not entire collections
     if (queuedOperations.length > 0) {
-        MessageFormatter.info(`Processing ${queuedOperations.length} queued operations (relationship dependencies)`, { prefix: "Collections" });
+        MessageFormatter.info(`🔧 Processing ${queuedOperations.length} queued relationship attributes (surgical approach)`, { prefix: "Collections" });
         await processQueue(database, databaseId);
     }
     else {
-        MessageFormatter.info("No queued operations to process", { prefix: "Collections" });
+        MessageFormatter.info("✅ No queued relationship attributes to process", { prefix: "Collections" });
     }
 };
-// New: Adapter-based implementation for TablesDB
+// New: Adapter-based implementation for TablesDB with state management
 export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, config, deletedCollections, selectedCollections = []) => {
     const collectionsToProcess = selectedCollections.length > 0 ? selectedCollections : (config.collections || []);
     if (!collectionsToProcess || collectionsToProcess.length === 0)
         return;
     const usedIds = new Set();
+    MessageFormatter.info(`Processing ${collectionsToProcess.length} tables via adapter with intelligent state management`, { prefix: "Tables" });
     // Helper: create attributes through adapter
     const createAttr = async (tableId, attr) => {
         const base = {
@@ -417,6 +280,11 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
     const relQueue = [];
     for (const collection of collectionsToProcess) {
         const { attributes, indexes, ...collectionData } = collection;
+        // Check if this table has already been processed in this session
+        if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
+            MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
+            continue;
+        }
         // Prepare permissions as strings (reuse Permission helper)
         const permissions = [];
         if (collection.$permissions && collection.$permissions.length > 0) {
@@ -481,6 +349,8 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 documentSecurity: !!collectionData.documentSecurity,
                 enabled: collectionData.enabled !== false
             });
+            // Cache the existing table ID
+            nameToIdMapping.set(collectionData.name, tableId);
         }
         // Add small delay after table create/update
         await delay(250);
@@ -535,39 +405,48 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 MessageFormatter.error(`Failed to create index ${idx.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
             }
         }
+        // Mark this table as fully processed to prevent re-processing
+        markCollectionProcessed(tableId, collectionData.name);
     }
     // Process queued relationships once mapping likely populated
-    for (const { tableId, attr } of relQueue) {
-        const relNameOrId = attr.relatedCollection;
-        if (!relNameOrId)
-            continue;
-        const relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
-        if (relId) {
-            attr.relatedCollection = relId;
-            try {
-                await adapter.createAttribute({
-                    databaseId,
-                    tableId,
-                    key: attr.key,
-                    type: attr.type,
-                    size: attr.size,
-                    required: !!attr.required,
-                    default: attr.xdefault,
-                    array: !!attr.array,
-                    min: attr.min,
-                    max: attr.max,
-                    elements: attr.elements,
-                    relatedCollection: relId,
-                    relationType: attr.relationType,
-                    twoWay: attr.twoWay,
-                    twoWayKey: attr.twoWayKey,
-                    onDelete: attr.onDelete,
-                    side: attr.side
-                });
-                await delay(150);
+    if (relQueue.length > 0) {
+        MessageFormatter.info(`🔧 Processing ${relQueue.length} queued relationship attributes for tables`, { prefix: "Tables" });
+        for (const { tableId, attr } of relQueue) {
+            const relNameOrId = attr.relatedCollection;
+            if (!relNameOrId)
+                continue;
+            const relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+            if (relId) {
+                attr.relatedCollection = relId;
+                try {
+                    await adapter.createAttribute({
+                        databaseId,
+                        tableId,
+                        key: attr.key,
+                        type: attr.type,
+                        size: attr.size,
+                        required: !!attr.required,
+                        default: attr.xdefault,
+                        array: !!attr.array,
+                        min: attr.min,
+                        max: attr.max,
+                        elements: attr.elements,
+                        relatedCollection: relId,
+                        relationType: attr.relationType,
+                        twoWay: attr.twoWay,
+                        twoWayKey: attr.twoWayKey,
+                        onDelete: attr.onDelete,
+                        side: attr.side
+                    });
+                    await delay(150);
+                    MessageFormatter.info(`✅ Successfully processed queued relationship: ${attr.key}`, { prefix: "Tables" });
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed queued relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+                }
             }
-            catch (e) {
-                MessageFormatter.error(`Failed queued relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+            else {
+                MessageFormatter.warning(`Could not resolve relationship ${attr.key} -> ${relNameOrId}`, { prefix: "Tables" });
             }
         }
     }
@@ -604,330 +483,3 @@ export const fetchAllCollections = async (dbId, database) => {
     MessageFormatter.success(`Fetched a total of ${collections.length} collections`, { prefix: "Collections" });
     return collections;
 };
-/**
- * Transfers all documents from one collection to another in a different database
- * within the same Appwrite Project
- */
-export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDbId, fromCollId, toCollId) => {
-    let fromCollDocs = await tryAwaitWithRetry(async () => db.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
-    let totalDocumentsTransferred = 0;
-    if (fromCollDocs.documents.length === 0) {
-        MessageFormatter.info(`No documents found in collection ${fromCollId}`, { prefix: "Transfer" });
-        return;
-    }
-    else if (fromCollDocs.documents.length < 50) {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => await db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-    }
-    else {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-        while (fromCollDocs.documents.length === 50) {
-            fromCollDocs = await tryAwaitWithRetry(async () => await db.listDocuments(fromDbId, fromCollId, [
-                Query.limit(50),
-                Query.cursorAfter(fromCollDocs.documents[fromCollDocs.documents.length - 1].$id),
-            ]));
-            const batchedPromises = fromCollDocs.documents.map((doc) => {
-                const toCreateObject = {
-                    ...doc,
-                };
-                delete toCreateObject.$databaseId;
-                delete toCreateObject.$collectionId;
-                delete toCreateObject.$createdAt;
-                delete toCreateObject.$updatedAt;
-                delete toCreateObject.$id;
-                delete toCreateObject.$permissions;
-                return tryAwaitWithRetry(async () => await db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-            });
-            await Promise.all(batchedPromises);
-            totalDocumentsTransferred += fromCollDocs.documents.length;
-        }
-    }
-    MessageFormatter.success(`Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`, { prefix: "Transfer" });
-};
-/**
- * Enhanced document transfer with fault tolerance and exponential backoff
- */
-const transferDocumentWithRetry = async (db, dbId, collectionId, documentId, documentData, permissions, maxRetries = 3, retryCount = 0) => {
-    try {
-        await db.createDocument(dbId, collectionId, documentId, documentData, permissions);
-        return true;
-    }
-    catch (error) {
-        // Check if document already exists
-        if (error.code === 409 || error.message?.toLowerCase().includes('already exists')) {
-            await db.updateDocument(dbId, collectionId, documentId, documentData, permissions);
-        }
-        if (retryCount < maxRetries) {
-            // Calculate exponential backoff: 1s, 2s, 4s
-            const exponentialDelay = Math.min(1000 * Math.pow(2, retryCount), 8000);
-            console.log(chalk.yellow(`Retrying document ${documentId} (attempt ${retryCount + 1}/${maxRetries}, backoff: ${exponentialDelay}ms)`));
-            await delay(exponentialDelay);
-            return await transferDocumentWithRetry(db, dbId, collectionId, documentId, documentData, permissions, maxRetries, retryCount + 1);
-        }
-        console.log(chalk.red(`Failed to transfer document ${documentId} after ${maxRetries} retries: ${error.message}`));
-        return false;
-    }
-};
-/**
- * Check if endpoint supports bulk operations (cloud.appwrite.io)
- */
-const supportsBulkOperations = (endpoint) => {
-    return endpoint.includes('cloud.appwrite.io');
-};
-/**
- * Direct HTTP implementation of bulk upsert API
- */
-const bulkUpsertDocuments = async (client, dbId, collectionId, documents) => {
-    const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
-    const url = new URL(client.config.endpoint + apiPath);
-    const headers = {
-        'Content-Type': 'application/json',
-        'X-Appwrite-Project': client.config.project,
-        'X-Appwrite-Key': client.config.key
-    };
-    const response = await fetch(url.toString(), {
-        method: 'PUT',
-        headers,
-        body: JSON.stringify({ documents })
-    });
-    if (!response.ok) {
-        const errorData = await response.json().catch(() => ({ message: 'Unknown error' }));
-        throw new Error(`Bulk upsert failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
-    }
-    return await response.json();
-};
-/**
- * Direct HTTP implementation of bulk create API
- */
-const bulkCreateDocuments = async (client, dbId, collectionId, documents) => {
-    const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
-    const url = new URL(client.config.endpoint + apiPath);
-    const headers = {
-        'Content-Type': 'application/json',
-        'X-Appwrite-Project': client.config.project,
-        'X-Appwrite-Key': client.config.key
-    };
-    const response = await fetch(url.toString(), {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({ documents })
-    });
-    if (!response.ok) {
-        const errorData = await response.json().catch(() => ({ message: 'Unknown error' }));
-        throw new Error(`Bulk create failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
-    }
-    return await response.json();
-};
-/**
- * Enhanced bulk document creation using direct HTTP calls
- */
-const transferDocumentsBulkUpsert = async (client, dbId, collectionId, documents, maxBatchSize = 1000) => {
-    let successful = 0;
-    let failed = 0;
-    // Prepare documents for bulk upsert
-    const preparedDocs = documents.map(doc => {
-        const toCreateObject = { ...doc };
-        delete toCreateObject.$databaseId;
-        delete toCreateObject.$collectionId;
-        delete toCreateObject.$createdAt;
-        delete toCreateObject.$updatedAt;
-        // Keep $id and $permissions for upsert functionality
-        return toCreateObject;
-    });
-    // Process in batches based on plan limits
-    const documentBatches = chunk(preparedDocs, maxBatchSize);
-    for (const batch of documentBatches) {
-        console.log(chalk.blue(`Bulk upserting ${batch.length} documents...`));
-        try {
-            // Try bulk upsert with direct HTTP call
-            const result = await bulkUpsertDocuments(client, dbId, collectionId, batch);
-            successful += result.documents?.length || batch.length;
-            console.log(chalk.green(`✅ Bulk upserted ${result.documents?.length || batch.length} documents`));
-        }
-        catch (error) {
-            console.log(chalk.yellow(`Bulk upsert failed, trying smaller batch size...`));
-            // If bulk upsert fails, try with smaller batch size (Pro plan limit)
-            if (maxBatchSize > 100) {
-                const smallerBatches = chunk(batch, 100);
-                for (const smallBatch of smallerBatches) {
-                    try {
-                        const result = await bulkUpsertDocuments(client, dbId, collectionId, smallBatch);
-                        successful += result.documents?.length || smallBatch.length;
-                        console.log(chalk.green(`✅ Bulk upserted ${result.documents?.length || smallBatch.length} documents (smaller batch)`));
-                    }
-                    catch (smallBatchError) {
-                        console.log(chalk.yellow(`Smaller batch failed, falling back to individual transfers...`));
-                        // Fall back to individual document transfer for this batch
-                        const db = new Databases(client);
-                        const { successful: indivSuccessful, failed: indivFailed } = await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, smallBatch.map((doc, index) => ({
-                            ...doc,
-                            $id: documents[documentBatches.indexOf(batch) * maxBatchSize + smallerBatches.indexOf(smallBatch) * 100 + index]?.$id || ID.unique(),
-                            $permissions: documents[documentBatches.indexOf(batch) * maxBatchSize + smallerBatches.indexOf(smallBatch) * 100 + index]?.$permissions || []
-                        })));
-                        successful += indivSuccessful;
-                        failed += indivFailed;
-                    }
-                    // Add delay between batches
-                    await delay(200);
-                }
-            }
-            else {
-                // Fall back to individual document transfer
-                const db = new Databases(client);
-                const { successful: indivSuccessful, failed: indivFailed } = await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, batch.map((doc, index) => ({
-                    ...doc,
-                    $id: documents[documentBatches.indexOf(batch) * maxBatchSize + index]?.$id || ID.unique(),
-                    $permissions: documents[documentBatches.indexOf(batch) * maxBatchSize + index]?.$permissions || []
-                })));
-                successful += indivSuccessful;
-                failed += indivFailed;
-            }
-        }
-        // Add delay between major batches
-        if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
-            await delay(500);
-        }
-    }
-    return { successful, failed };
-};
-/**
- * Fallback batch document transfer with individual retry logic
- */
-const transferDocumentBatchWithRetryFallback = async (db, dbId, collectionId, documents, batchSize = 10) => {
-    let successful = 0;
-    let failed = 0;
-    // Process documents in smaller batches to avoid overwhelming the server
-    const documentBatches = chunk(documents, batchSize);
-    for (const batch of documentBatches) {
-        console.log(chalk.blue(`Processing batch of ${batch.length} documents...`));
-        const batchPromises = batch.map(async (doc) => {
-            const toCreateObject = { ...doc };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            const result = await transferDocumentWithRetry(db, dbId, collectionId, doc.$id, toCreateObject, doc.$permissions || []);
-            return { docId: doc.$id, success: result };
-        });
-        const results = await Promise.allSettled(batchPromises);
-        results.forEach((result, index) => {
-            if (result.status === 'fulfilled') {
-                if (result.value.success) {
-                    successful++;
-                }
-                else {
-                    failed++;
-                }
-            }
-            else {
-                console.log(chalk.red(`Batch promise rejected for document ${batch[index].$id}: ${result.reason}`));
-                failed++;
-            }
-        });
-        // Add delay between batches to avoid rate limiting
-        if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
-            await delay(500);
-        }
-    }
-    return { successful, failed };
-};
-/**
- * Enhanced batch document transfer with fault tolerance and bulk API support
- */
-const transferDocumentBatchWithRetry = async (db, client, dbId, collectionId, documents, batchSize = 10) => {
-    // Check if we can use bulk operations
-    if (supportsBulkOperations(client.config.endpoint)) {
-        console.log(chalk.green(`🚀 Using bulk upsert API for faster document transfer`));
-        // Try with Scale plan limit first (2500), then Pro (1000), then Free (100)
-        const batchSizes = [1000, 100]; // Start with Pro plan, fallback to Free
-        for (const maxBatchSize of batchSizes) {
-            try {
-                return await transferDocumentsBulkUpsert(client, dbId, collectionId, documents, maxBatchSize);
-            }
-            catch (error) {
-                console.log(chalk.yellow(`Bulk upsert with batch size ${maxBatchSize} failed, trying smaller size...`));
-                continue;
-            }
-        }
-        // If all bulk operations fail, fall back to individual transfers
-        console.log(chalk.yellow(`All bulk operations failed, falling back to individual document transfers`));
-    }
-    // Fall back to individual document transfer
-    return await transferDocumentBatchWithRetryFallback(db, dbId, collectionId, documents, batchSize);
-};
-export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
-    console.log(chalk.blue(`Starting enhanced document transfer from ${fromCollId} to ${toCollId}...`));
-    const client = new Client()
-        .setEndpoint(endpoint)
-        .setProject(projectId)
-        .setKey(apiKey);
-    const remoteDb = new Databases(client);
-    let totalDocumentsProcessed = 0;
-    let totalSuccessful = 0;
-    let totalFailed = 0;
-    // Fetch documents in larger batches (1000 at a time)
-    let hasMoreDocuments = true;
-    let lastDocumentId;
-    while (hasMoreDocuments) {
-        const queries = [Query.limit(1000)]; // Fetch 1000 documents at a time
-        if (lastDocumentId) {
-            queries.push(Query.cursorAfter(lastDocumentId));
-        }
-        const fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, queries));
-        if (fromCollDocs.documents.length === 0) {
-            hasMoreDocuments = false;
-            break;
-        }
-        console.log(chalk.blue(`Fetched ${fromCollDocs.documents.length} documents, processing for transfer...`));
-        const { successful, failed } = await transferDocumentBatchWithRetry(remoteDb, client, toDbId, toCollId, fromCollDocs.documents);
-        totalDocumentsProcessed += fromCollDocs.documents.length;
-        totalSuccessful += successful;
-        totalFailed += failed;
-        // Check if we have more documents to process
-        if (fromCollDocs.documents.length < 1000) {
-            hasMoreDocuments = false;
-        }
-        else {
-            lastDocumentId = fromCollDocs.documents[fromCollDocs.documents.length - 1].$id;
-        }
-        console.log(chalk.gray(`Batch complete: ${successful} successful, ${failed} failed`));
-    }
-    if (totalDocumentsProcessed === 0) {
-        MessageFormatter.info(`No documents found in collection ${fromCollId}`, { prefix: "Transfer" });
-        return;
-    }
-    const message = `Total documents processed: ${totalDocumentsProcessed}, successful: ${totalSuccessful}, failed: ${totalFailed}`;
-    if (totalFailed > 0) {
-        MessageFormatter.warning(message, { prefix: "Transfer" });
-    }
-    else {
-        MessageFormatter.success(message, { prefix: "Transfer" });
-    }
-};