appwrite-utils-cli 0.0.46 → 0.0.48

package/dist/migrations/importController.js

@@ -7,6 +7,9 @@ import { logger } from "./logging.js";
 import { updateOperation } from "./migrationHelper.js";
 import { BatchSchema, OperationCreateSchema, OperationSchema, } from "./backup.js";
 import { DataLoader } from "./dataLoader.js";
+import { transferDocumentsBetweenDbsLocalToLocal } from "./collections.js";
+import { transferDatabaseLocalToLocal } from "./databases.js";
+import { transferStorageLocalToLocal } from "./storage.js";
 export class ImportController {
     config;
     database;
@@ -37,6 +40,7 @@ export class ImportController {
                 this.setupOptions.runDev))
             .map((db) => db.name);
         let dataLoader;
+        let databaseRan;
         for (let db of this.config.databases) {
             if (db.name.toLowerCase().trim().replace(" ", "") === "migrations" ||
                 !databasesToRun.includes(db.name)) {
@@ -54,21 +58,30 @@ export class ImportController {
             console.log(`Starting import data for database: ${db.name}`);
             console.log(`---------------------------------`);
             // await this.importCollections(db);
-            if (!dataLoader) {
+            if (!databaseRan) {
+                databaseRan = db;
                 dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
                 await dataLoader.start(db.$id);
+                await this.importCollections(db, dataLoader);
+                await resolveAndUpdateRelationships(db.$id, this.database, this.config);
+                await this.executePostImportActions(db.$id, dataLoader);
             }
-            else {
-                console.log(`Using data from previous import run`);
+            else if (databaseRan.$id !== db.$id) {
+                await this.updateOthersToFinalData(databaseRan, db);
             }
-            await this.importCollections(db, dataLoader);
-            await resolveAndUpdateRelationships(db.$id, this.database, this.config);
-            await this.executePostImportActions(db.$id, dataLoader);
             console.log(`---------------------------------`);
             console.log(`Finished import data for database: ${db.name}`);
             console.log(`---------------------------------`);
         }
     }
+    async updateOthersToFinalData(updatedDb, targetDb) {
+        await transferDatabaseLocalToLocal(this.database, updatedDb.$id, targetDb.$id);
+        await transferStorageLocalToLocal(this.storage, `${this.config.documentBucketId}_${updatedDb.name
+            .toLowerCase()
+            .replace(" ", "")}`, `${this.config.documentBucketId}_${targetDb.name
+            .toLowerCase()
+            .replace(" ", "")}`);
+    }
     async importCollections(db, dataLoader) {
         if (!this.config.collections) {
             return;

package/dist/migrations/storage.d.ts

@@ -6,3 +6,5 @@ export declare const initOrGetBackupStorage: (storage: Storage) => Promise<Model
 export declare const initOrGetDocumentStorage: (storage: Storage, config: AppwriteConfig, dbName: string) => Promise<Models.Bucket | undefined>;
 export declare const wipeDocumentStorage: (storage: Storage, config: AppwriteConfig, dbName: string) => Promise<void>;
 export declare const backupDatabase: (database: Databases, databaseId: string, storage: Storage) => Promise<void>;
+export declare const transferStorageLocalToLocal: (storage: Storage, fromBucketId: string, toBucketId: string) => Promise<void>;
+export declare const transferStorageLocalToRemote: (localStorage: Storage, endpoint: string, projectId: string, apiKey: string, fromBucketId: string, toBucketId: string) => Promise<void>;

package/dist/migrations/storage.js

@@ -1,7 +1,7 @@
 import { Storage, Databases, Query, InputFile, ID, Permission, } from "node-appwrite";
 import {} from "./backup.js";
 import { splitIntoBatches } from "./migrationHelper.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
 export const logOperation = async (db, dbId, operationDetails, operationId) => {
     try {
         let operation;
@@ -245,3 +245,70 @@ export const backupDatabase = async (database, databaseId, storage) => {
     console.log("Database Backup Complete");
     console.log("---------------------------------");
 };
+export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
+    console.log(`Transferring files from ${fromBucketId} to ${toBucketId}`);
+    let lastFileId;
+    let fromFiles = await tryAwaitWithRetry(async () => await storage.listFiles(fromBucketId, [Query.limit(100)]));
+    const allFromFiles = fromFiles.files;
+    let numberOfFiles = 0;
+    if (fromFiles.files.length < 100) {
+        for (const file of allFromFiles) {
+            const fileData = await storage.getFileDownload(file.bucketId, file.$id);
+            const fileToCreate = InputFile.fromBuffer(Buffer.from(fileData), file.name);
+            console.log(`Creating file: ${file.name}`);
+            tryAwaitWithRetry(async () => await storage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+            numberOfFiles++;
+        }
+    }
+    else {
+        lastFileId = fromFiles.files[fromFiles.files.length - 1].$id;
+        while (lastFileId) {
+            const files = await storage.listFiles(fromBucketId, [
+                Query.limit(100),
+                Query.cursorAfter(lastFileId),
+            ]);
+            allFromFiles.push(...files.files);
+            if (files.files.length < 100) {
+                lastFileId = undefined;
+            }
+            else {
+                lastFileId = files.files[files.files.length - 1].$id;
+            }
+        }
+        for (const file of allFromFiles) {
+            const fileData = await storage.getFileDownload(file.bucketId, file.$id);
+            const fileToCreate = InputFile.fromBuffer(Buffer.from(fileData), file.name);
+            await tryAwaitWithRetry(async () => await storage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+            numberOfFiles++;
+        }
+    }
+    console.log(`Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`);
+};
+export const transferStorageLocalToRemote = async (localStorage, endpoint, projectId, apiKey, fromBucketId, toBucketId) => {
+    console.log(`Transferring files from current storage ${fromBucketId} to ${endpoint} bucket ${toBucketId}`);
+    const client = getAppwriteClient(endpoint, apiKey, projectId);
+    const remoteStorage = new Storage(client);
+    let numberOfFiles = 0;
+    let lastFileId;
+    let fromFiles = await tryAwaitWithRetry(async () => await localStorage.listFiles(fromBucketId, [Query.limit(100)]));
+    const allFromFiles = fromFiles.files;
+    if (fromFiles.files.length === 100) {
+        lastFileId = fromFiles.files[fromFiles.files.length - 1].$id;
+        while (lastFileId) {
+            const files = await localStorage.listFiles(fromBucketId, [
+                Query.limit(100),
+                Query.cursorAfter(lastFileId),
+            ]);
+            allFromFiles.push(...files.files);
+            if (files.files.length < 100) {
+                break;
+            }
+            lastFileId = files.files[files.files.length - 1].$id;
+        }
+    }
+    for (const file of allFromFiles) {
+        await tryAwaitWithRetry(async () => await remoteStorage.createFile(toBucketId, file.$id, file, file.$permissions));
+        numberOfFiles++;
+    }
+    console.log(`Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`);
+};

package/dist/migrations/users.d.ts

@@ -12,4 +12,5 @@ export declare class UsersController {
     createUserAndReturn(item: AuthUserCreate, numAttempts?: number): Promise<Models.User<Models.Preferences>>;
     createAndCheckForUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
     getUserIdByEmailOrPhone(email?: string, phone?: string): Promise<string | undefined>;
+    transferUsersBetweenDbsLocalToRemote: (endpoint: string, projectId: string, apiKey: string) => Promise<void>;
 }

package/dist/migrations/users.js

@@ -3,7 +3,7 @@ import { AuthUserSchema, } from "../schemas/authUser.js";
 import _ from "lodash";
 import { logger } from "./logging.js";
 import { splitIntoBatches } from "./migrationHelper.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
 export class UsersController {
     config;
     users;
@@ -232,4 +232,49 @@ export class UsersController {
             }
         }
     }
+    transferUsersBetweenDbsLocalToRemote = async (endpoint, projectId, apiKey) => {
+        const localUsers = this.users;
+        const client = getAppwriteClient(endpoint, projectId, apiKey);
+        const remoteUsers = new Users(client);
+        let fromUsers = await localUsers.list([Query.limit(50)]);
+        if (fromUsers.users.length === 0) {
+            console.log(`No users found`);
+            return;
+        }
+        else if (fromUsers.users.length < 50) {
+            console.log(`Transferring ${fromUsers.users.length} users to remote`);
+            const batchedPromises = fromUsers.users.map((user) => {
+                return tryAwaitWithRetry(async () => {
+                    const toCreateObject = {
+                        ...user,
+                    };
+                    delete toCreateObject.$id;
+                    delete toCreateObject.$createdAt;
+                    delete toCreateObject.$updatedAt;
+                    await remoteUsers.create(user.$id, user.email, user.phone, user.password, user.name);
+                });
+            });
+            await Promise.all(batchedPromises);
+        }
+        else {
+            while (fromUsers.users.length === 50) {
+                fromUsers = await localUsers.list([
+                    Query.limit(50),
+                    Query.cursorAfter(fromUsers.users[fromUsers.users.length - 1].$id),
+                ]);
+                const batchedPromises = fromUsers.users.map((user) => {
+                    return tryAwaitWithRetry(async () => {
+                        const toCreateObject = {
+                            ...user,
+                        };
+                        delete toCreateObject.$id;
+                        delete toCreateObject.$createdAt;
+                        delete toCreateObject.$updatedAt;
+                        await remoteUsers.create(user.$id, user.email, user.phone, user.password, user.name);
+                    });
+                });
+                await Promise.all(batchedPromises);
+            }
+        }
+    };
 }

package/dist/utils/helperFunctions.d.ts

@@ -1,4 +1,4 @@
-import { type Models } from "node-appwrite";
+import { Client, type Models } from "node-appwrite";
 import type { CollectionImportData } from "../migrations/dataLoader.js";
 import type { ConfigCollection } from "appwrite-utils";
 export declare const toPascalCase: (str: string) => string;
@@ -44,3 +44,4 @@ export declare let numTimesFailedTotal: number;
  * @return {Promise<any>} - A promise that resolves to the result of the createFunction or rejects with an error if it fails after 5 attempts.
  */
 export declare const tryAwaitWithRetry: <T>(createFunction: () => Promise<T>, attemptNum?: number, throwError?: boolean) => Promise<T>;
+export declare const getAppwriteClient: (endpoint: string, projectId: string, apiKey: string) => Client;

package/dist/utils/helperFunctions.js

@@ -1,4 +1,4 @@
-import { AppwriteException } from "node-appwrite";
+import { AppwriteException, Client, } from "node-appwrite";
 import fs from "node:fs";
 import path from "node:path";
 export const toPascalCase = (str) => {
@@ -109,3 +109,9 @@ export const tryAwaitWithRetry = async (createFunction, attemptNum = 0, throwErr
         return Promise.resolve();
     }
 };
+export const getAppwriteClient = (endpoint, projectId, apiKey) => {
+    return new Client()
+        .setEndpoint(endpoint)
+        .setProject(projectId)
+        .setKey(apiKey);
+};

package/dist/utilsController.d.ts

@@ -16,6 +16,17 @@ export interface SetupOptions {
     endpoint?: string;
     project?: string;
     key?: string;
+    transfer?: boolean;
+    transferEndpoint?: string;
+    transferProject?: string;
+    transferKey?: string;
+    fromDbId?: string;
+    targetDbId?: string;
+    fromCollection?: string;
+    collection?: string;
+    transferUsers?: boolean;
+    fromBucket?: string;
+    targetBucket?: string;
 }
 export declare class UtilsController {
     private appwriteFolderPath;

package/dist/utilsController.js

@@ -12,6 +12,10 @@ import _ from "lodash";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { loadConfig as loadTsConfig } from "./utils/loadConfigs.js";
 import { findAppwriteConfig } from "./utils/loadConfigs.js";
+import { transferDocumentsBetweenDbsLocalToLocal, transferDocumentsBetweenDbsLocalToRemote, } from "./migrations/collections.js";
+import { UsersController } from "./migrations/users.js";
+import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, } from "./migrations/databases.js";
+import { transferStorageLocalToLocal, transferStorageLocalToRemote, } from "./migrations/storage.js";
 export class UtilsController {
     appwriteFolderPath;
     appwriteConfigPath;
@@ -96,6 +100,56 @@ export class UtilsController {
         if (!this.database || !this.storage || !this.config) {
             throw new Error("Database or storage not initialized");
         }
+        if (options.transfer) {
+            if (options.fromCollection) {
+                if (options.transferEndpoint &&
+                    options.transferProject &&
+                    options.transferKey) {
+                    if (options.transferUsers) {
+                        console.log(`Transferring users from local database ${options.fromDbId} to remote database ${options.targetDbId} on endpoint ${options.transferEndpoint}...`);
+                        const usersController = new UsersController(this.config, this.database);
+                        await usersController.transferUsersBetweenDbsLocalToRemote(options.transferEndpoint, options.transferProject, options.transferKey);
+                    }
+                    console.log("Transferring documents to remote database...");
+                    await transferDocumentsBetweenDbsLocalToRemote(this.database, options.transferEndpoint, options.transferProject, options.transferKey, options.fromDbId, options.targetDbId, options.fromCollection, options.collection);
+                }
+                else {
+                    console.log("Transferring documents between local databases...");
+                    await transferDocumentsBetweenDbsLocalToLocal(this.database, options.fromDbId, options.targetDbId, options.fromCollection, options.collection);
+                }
+            }
+            else if (options.fromDbId && options.targetDbId) {
+                if (options.transferEndpoint &&
+                    options.transferProject &&
+                    options.transferKey) {
+                    if (options.transferUsers) {
+                        console.log(`Transferring users from local database ${options.fromDbId} to remote database ${options.targetDbId} on endpoint ${options.transferEndpoint}...`);
+                        const usersController = new UsersController(this.config, this.database);
+                        await usersController.transferUsersBetweenDbsLocalToRemote(options.transferEndpoint, options.transferProject, options.transferKey);
+                    }
+                    console.log(`Transferring databases from local database ${options.fromDbId} to remote database ${options.targetDbId} on endpoint ${options.transferEndpoint}...`);
+                    await transferDatabaseLocalToRemote(this.database, options.transferEndpoint, options.transferProject, options.transferKey, options.fromDbId, options.targetDbId);
+                }
+                else {
+                    console.log(`Transferring databases from local database ${options.fromDbId} to local database ${options.targetDbId}`);
+                    await transferDatabaseLocalToLocal(this.database, options.fromDbId, options.targetDbId);
+                }
+            }
+            if (options.fromBucket && options.targetBucket) {
+                if (options.transferEndpoint &&
+                    options.transferProject &&
+                    options.transferKey) {
+                    console.log(`Transferring files from bucket ${options.fromBucket} to bucket ${options.targetBucket} on endpoint ${options.transferEndpoint}...`);
+                    await transferStorageLocalToRemote(this.storage, options.transferEndpoint, options.transferProject, options.transferKey, options.fromBucket, options.targetBucket);
+                }
+                else {
+                    console.log(`Transferring files from bucket ${options.fromBucket} to bucket ${options.targetBucket}...`);
+                    await transferStorageLocalToLocal(this.storage, options.fromBucket, options.targetBucket);
+                }
+            }
+            console.log("Transfer complete.");
+            return;
+        }
         if (options.sync) {
             console.log("Starting synchronization with server...");
             const appwriteToX = new AppwriteToX(this.config, this.appwriteFolderPath);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "@types/inquirer": "^9.0.7",
-    "appwrite-utils": "^0.2.6",
+    "appwrite-utils": "^0.2.7",
     "commander": "^12.0.0",
     "inquirer": "^9.2.20",
     "js-yaml": "^4.1.0",

package/src/main.ts

@@ -9,6 +9,45 @@ program
   .option("--endpoint <endpoint>", "Set the Appwrite endpoint", undefined)
   .option("--project <project>", "Set the Appwrite project ID", undefined)
   .option("--key <key>", "Set the Appwrite API key", undefined)
+  .option("--transfer", "Transfer documents between databases", false)
+  .option("--transfer-users", "Transfer users between local and remote", false)
+  .option(
+    "--transferendpoint <transferEndpoint>",
+    "Set the transfer endpoint for remote transfers",
+    undefined
+  )
+  .option(
+    "--transferproject <transferProject>",
+    "Set the transfer project ID for remote transfers",
+    undefined
+  )
+  .option(
+    "--transferkey <transferKey>",
+    "Set the transfer key for remote transfers",
+    undefined
+  )
+  .option("--fromdb <fromDbId>", "Set the source database ID", undefined)
+  .option(
+    "--targetdb <targetDbId>",
+    "Set the destination database ID",
+    undefined
+  )
+  .option(
+    "--fromcoll <collectionId>",
+    "Set the source collection ID for transfer, only used for transfer",
+    undefined
+  )
+  .option(
+    "--targetcoll <collectionId>",
+    "Set the collection ID to import data into",
+    undefined
+  )
+  .option("--frombucket <bucketId>", "Set the source bucket ID", undefined)
+  .option(
+    "--targetbucket <bucketId>",
+    "Set the destination bucket ID",
+    undefined
+  )
   .option("--backup", "Perform a backup before executing the command", false)
   .option("--dev", "Run in development environment", false)
   .option("--prod", "Run in production environment", false)
@@ -28,6 +67,9 @@ program.on("--help", () => {
   console.log(
     "  $ npx appwrite-utils-cli appwrite-migrate --sync --endpoint https://appwrite.example.com --project 123456 --key 7890"
   );
+  console.log(
+    "  $ npx appwrite-utils-cli appwrite-migrate --transfer --fromdb fromDbId --targetdb toDbId --transferendpoint https://appwrite.otherserver.com --transferproject yourProjectId --transferkey yourApiKey"
+  );
   console.log(
     "  $ npx appwrite-utils-cli appwrite-migrate --sync --dev --backup"
   );
@@ -70,6 +112,17 @@ program.action(async (options) => {
       endpoint: options.endpoint,
       project: options.project,
       key: options.key,
+      transfer: options.transfer,
+      transferEndpoint: options.transferEndpoint,
+      transferProject: options.transferProject,
+      transferKey: options.transferKey,
+      fromDbId: options.fromdb,
+      targetDbId: options.targetdb,
+      fromCollection: options.fromcoll,
+      collection: options.targetcoll, // Add this line
+      transferUsers: options.transferUsers,
+      fromBucket: options.frombucket,
+      targetBucket: options.targetbucket,
     };
     console.log("Running operation...", setupOptions);
 

package/src/migrations/collections.ts

@@ -1,4 +1,11 @@
-import { Databases, ID, Permission, Query, type Models } from "node-appwrite";
+import {
+  Client,
+  Databases,
+  ID,
+  Permission,
+  Query,
+  type Models,
+} from "node-appwrite";
 import type { AppwriteConfig, CollectionCreate } from "appwrite-utils";
 import { nameToIdMapping, processQueue } from "./queue.js";
 import { createUpdateCollectionAttributes } from "./attributes.js";
@@ -133,7 +140,9 @@ export const wipeDatabase = async (
       collectionId: collectionId,
       collectionName: name,
     });
-    await database.deleteCollection(databaseId, collectionId);
+    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
   }
   return collectionsDeleted;
 };
@@ -201,16 +210,16 @@ export const createOrUpdateCollections = async (
     let collectionId: string;
     if (!collectionToUse) {
       console.log(`Creating collection: ${collection.name}`);
-      const foundColl = deletedCollections?.find(
+      let foundColl = deletedCollections?.find(
         (coll) =>
           coll.collectionName.toLowerCase().trim().replace(" ", "") ===
           collection.name.toLowerCase().trim().replace(" ", "")
       );
 
-      if (foundColl && !usedIds.has(foundColl.collectionId)) {
+      if (collection.$id) {
+        collectionId = collection.$id; // Always use the provided $id if present
+      } else if (foundColl && !usedIds.has(foundColl.collectionId)) {
         collectionId = foundColl.collectionId; // Use ID from deleted collection if not already used
-      } else if (collection.$id && !usedIds.has(collection.$id)) {
-        collectionId = collection.$id; // Use the provided $id if not already used
       } else {
         collectionId = ID.unique(); // Generate a new unique ID
       }
@@ -322,3 +331,214 @@ export const fetchAllCollections = async (
   console.log(`Fetched a total of ${collections.length} 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: Databases,
+  fromDbId: string,
+  toDbId: string,
+  fromCollId: string,
+  toCollId: string
+) => {
+  let fromCollDocs = await tryAwaitWithRetry(async () =>
+    db.listDocuments(fromDbId, fromCollId, [Query.limit(50)])
+  );
+  let totalDocumentsTransferred = 0;
+
+  if (fromCollDocs.documents.length === 0) {
+    console.log(`No documents found in collection ${fromCollId}`);
+    return;
+  } else if (fromCollDocs.documents.length < 50) {
+    const batchedPromises = fromCollDocs.documents.map((doc) => {
+      const toCreateObject: Partial<typeof doc> = {
+        ...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: Partial<typeof doc> = {
+        ...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 db.listDocuments(fromDbId, fromCollId, [
+        Query.limit(50),
+        Query.cursorAfter(
+          fromCollDocs.documents[fromCollDocs.documents.length - 1].$id
+        ),
+      ]);
+      const batchedPromises = fromCollDocs.documents.map((doc) => {
+        const toCreateObject: Partial<typeof doc> = {
+          ...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;
+    }
+  }
+
+  console.log(
+    `Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`
+  );
+};
+
+export const transferDocumentsBetweenDbsLocalToRemote = async (
+  localDb: Databases,
+  endpoint: string,
+  projectId: string,
+  apiKey: string,
+  fromDbId: string,
+  toDbId: string,
+  fromCollId: string,
+  toCollId: string
+) => {
+  const client = new Client()
+    .setEndpoint(endpoint)
+    .setProject(projectId)
+    .setKey(apiKey);
+  let totalDocumentsTransferred = 0;
+  const remoteDb = new Databases(client);
+  let fromCollDocs = await tryAwaitWithRetry(async () =>
+    localDb.listDocuments(fromDbId, fromCollId, [Query.limit(50)])
+  );
+
+  if (fromCollDocs.documents.length === 0) {
+    console.log(`No documents found in collection ${fromCollId}`);
+    return;
+  } else if (fromCollDocs.documents.length < 50) {
+    const batchedPromises = fromCollDocs.documents.map((doc) => {
+      const toCreateObject: Partial<typeof doc> = {
+        ...doc,
+      };
+      delete toCreateObject.$databaseId;
+      delete toCreateObject.$collectionId;
+      delete toCreateObject.$createdAt;
+      delete toCreateObject.$updatedAt;
+      delete toCreateObject.$id;
+      delete toCreateObject.$permissions;
+      return tryAwaitWithRetry(async () =>
+        remoteDb.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: Partial<typeof doc> = {
+        ...doc,
+      };
+      delete toCreateObject.$databaseId;
+      delete toCreateObject.$collectionId;
+      delete toCreateObject.$createdAt;
+      delete toCreateObject.$updatedAt;
+      delete toCreateObject.$id;
+      delete toCreateObject.$permissions;
+      return tryAwaitWithRetry(async () =>
+        remoteDb.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 () =>
+        localDb.listDocuments(fromDbId, fromCollId, [
+          Query.limit(50),
+          Query.cursorAfter(
+            fromCollDocs.documents[fromCollDocs.documents.length - 1].$id
+          ),
+        ])
+      );
+      const batchedPromises = fromCollDocs.documents.map((doc) => {
+        const toCreateObject: Partial<typeof doc> = {
+          ...doc,
+        };
+        delete toCreateObject.$databaseId;
+        delete toCreateObject.$collectionId;
+        delete toCreateObject.$createdAt;
+        delete toCreateObject.$updatedAt;
+        delete toCreateObject.$id;
+        delete toCreateObject.$permissions;
+        return tryAwaitWithRetry(async () =>
+          remoteDb.createDocument(
+            toDbId,
+            toCollId,
+            doc.$id,
+            toCreateObject,
+            doc.$permissions
+          )
+        );
+      });
+      await Promise.all(batchedPromises);
+      totalDocumentsTransferred += fromCollDocs.documents.length;
+    }
+  }
+  console.log(
+    `Total documents transferred from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}: ${totalDocumentsTransferred}`
+  );
+};