appwrite-utils-cli 0.0.47 → 0.0.49

package/src/migrations/users.ts

@@ -15,7 +15,10 @@ import {
 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 {
   private config: AppwriteConfig;
@@ -294,4 +297,66 @@ export class UsersController {
       }
     }
   }
+
+  transferUsersBetweenDbsLocalToRemote = async (
+    endpoint: string,
+    projectId: string,
+    apiKey: string
+  ) => {
+    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: Partial<typeof user> = {
+            ...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: Partial<typeof user> = {
+              ...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/src/utils/helperFunctions.ts

@@ -1,4 +1,9 @@
-import { AppwriteException, type Models, type Storage } from "node-appwrite";
+import {
+  AppwriteException,
+  Client,
+  type Models,
+  type Storage,
+} from "node-appwrite";
 import fs from "node:fs";
 import path from "node:path";
 import type { CollectionImportData } from "../migrations/dataLoader.js";
@@ -162,3 +167,14 @@ export const tryAwaitWithRetry = async <T>(
     return Promise.resolve();
   }
 };
+
+export const getAppwriteClient = (
+  endpoint: string,
+  projectId: string,
+  apiKey: string
+) => {
+  return new Client()
+    .setEndpoint(endpoint)
+    .setProject(projectId)
+    .setKey(apiKey);
+};

package/src/utilsController.ts

@@ -20,6 +20,19 @@ 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";
 
 // async function loadConfig(configPath: string) {
 //   if (!fs.existsSync(configPath)) {
@@ -48,6 +61,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 class UtilsController {
@@ -140,6 +164,122 @@ export class UtilsController {
       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);