appwrite-utils-cli 0.0.286 → 0.9.2

package/dist/migrations/transfer.d.ts

@@ -0,0 +1,30 @@
+import { Databases, Storage, type Models } from "node-appwrite";
+export interface TransferOptions {
+    fromDb: Models.Database;
+    targetDb: Models.Database;
+    isRemote: boolean;
+    collections?: string[];
+    transferEndpoint?: string;
+    transferProject?: string;
+    transferKey?: string;
+    sourceBucket?: Models.Bucket;
+    targetBucket?: Models.Bucket;
+}
+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>;
+/**
+ * Transfers all documents from one collection to another in a different database
+ * within the same Appwrite Project
+ */
+export declare const transferDocumentsBetweenDbsLocalToLocal: (db: Databases, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;
+export declare const transferDocumentsBetweenDbsLocalToRemote: (localDb: Databases, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;
+/**
+ * Transfers all collections and documents from one local database to another local database.
+ *
+ * @param {Databases} localDb - The local database instance.
+ * @param {string} fromDbId - The ID of the source database.
+ * @param {string} targetDbId - The ID of the target database.
+ * @return {Promise<void>} A promise that resolves when the transfer is complete.
+ */
+export declare const transferDatabaseLocalToLocal: (localDb: Databases, fromDbId: string, targetDbId: string) => Promise<void>;
+export declare const transferDatabaseLocalToRemote: (localDb: Databases, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string) => Promise<void>;

package/dist/migrations/transfer.js

@@ -0,0 +1,337 @@
+import { tryAwaitWithRetry } from "appwrite-utils";
+import { Client, Databases, IndexType, Query, Storage, } from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { getAppwriteClient } from "../utils/helperFunctions.js";
+import { createOrUpdateAttribute } from "./attributes.js";
+import { parseAttribute } from "appwrite-utils";
+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;
+    const downloadFileWithRetry = async (bucketId, fileId) => {
+        let attempts = 3;
+        while (attempts > 0) {
+            try {
+                return await storage.getFileDownload(bucketId, fileId);
+            }
+            catch (error) {
+                console.error(`Error downloading file ${fileId}: ${error}`);
+                attempts--;
+                if (attempts === 0)
+                    throw error;
+            }
+        }
+    };
+    if (fromFiles.files.length < 100) {
+        for (const file of allFromFiles) {
+            const fileData = await tryAwaitWithRetry(async () => await downloadFileWithRetry(file.bucketId, file.$id));
+            if (!fileData) {
+                console.error(`Error downloading file ${file.$id}`);
+                continue;
+            }
+            const fileToCreate = InputFile.fromBuffer(new Uint8Array(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 tryAwaitWithRetry(async () => 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 tryAwaitWithRetry(async () => await downloadFileWithRetry(file.bucketId, file.$id));
+            if (!fileData) {
+                console.error(`Error downloading file ${file.$id}`);
+                continue;
+            }
+            const fileToCreate = InputFile.fromBuffer(new Uint8Array(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 tryAwaitWithRetry(async () => 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) {
+        const fileData = await tryAwaitWithRetry(async () => await localStorage.getFileDownload(file.bucketId, file.$id));
+        const fileToCreate = InputFile.fromBuffer(new Uint8Array(fileData), file.name);
+        await tryAwaitWithRetry(async () => await remoteStorage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+        numberOfFiles++;
+    }
+    console.log(`Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`);
+};
+/**
+ * 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) {
+        console.log(`No documents found in collection ${fromCollId}`);
+        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;
+        }
+    }
+    console.log(`Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`);
+};
+export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
+    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 = {
+                ...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 = {
+                ...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 = {
+                    ...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}`);
+};
+/**
+ * Transfers all collections and documents from one local database to another local database.
+ *
+ * @param {Databases} localDb - The local database instance.
+ * @param {string} fromDbId - The ID of the source database.
+ * @param {string} targetDbId - The ID of the target database.
+ * @return {Promise<void>} A promise that resolves when the transfer is complete.
+ */
+export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId) => {
+    let lastCollectionId;
+    let fromCollections = await tryAwaitWithRetry(async () => await localDb.listCollections(fromDbId, [Query.limit(50)]));
+    const allFromCollections = fromCollections.collections;
+    if (fromCollections.collections.length < 50) {
+        lastCollectionId = undefined;
+    }
+    else {
+        lastCollectionId =
+            fromCollections.collections[fromCollections.collections.length - 1].$id;
+        while (lastCollectionId) {
+            const collections = await localDb.listCollections(fromDbId, [
+                Query.limit(50),
+                Query.cursorAfter(lastCollectionId),
+            ]);
+            allFromCollections.push(...collections.collections);
+            if (collections.collections.length < 50) {
+                break;
+            }
+            lastCollectionId =
+                collections.collections[collections.collections.length - 1].$id;
+        }
+    }
+    lastCollectionId = undefined;
+    let toCollections = await tryAwaitWithRetry(async () => await localDb.listCollections(targetDbId, [Query.limit(50)]));
+    const allToCollections = toCollections.collections;
+    if (toCollections.collections.length < 50) {
+    }
+    else {
+        lastCollectionId =
+            toCollections.collections[toCollections.collections.length - 1].$id;
+        while (lastCollectionId) {
+            const collections = await localDb.listCollections(targetDbId, [
+                Query.limit(50),
+                Query.cursorAfter(lastCollectionId),
+            ]);
+            allToCollections.push(...collections.collections);
+            if (collections.collections.length < 50) {
+                lastCollectionId = undefined;
+            }
+            else {
+                lastCollectionId =
+                    collections.collections[collections.collections.length - 1].$id;
+            }
+        }
+    }
+    for (const collection of allFromCollections) {
+        const toCollection = allToCollections.find((c) => c.$id === collection.$id);
+        if (toCollection) {
+            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, toCollection.$id);
+        }
+        else {
+            console.log(`Collection ${collection.name} not found in destination database, creating...`);
+            const newCollection = await tryAwaitWithRetry(async () => await localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+            console.log(`Collection ${newCollection.name} created`);
+            for (const attribute of collection.attributes) {
+                await tryAwaitWithRetry(async () => await createOrUpdateAttribute(localDb, targetDbId, newCollection, parseAttribute(attribute)));
+            }
+            for (const index of collection.indexes) {
+                await tryAwaitWithRetry(async () => await localDb.createIndex(targetDbId, newCollection.$id, index.key, index.type, index.attributes, index.orders));
+            }
+            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, newCollection.$id);
+        }
+    }
+};
+export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId) => {
+    const client = getAppwriteClient(endpoint, projectId, apiKey);
+    const remoteDb = new Databases(client);
+    let lastCollectionId;
+    let fromCollections = await tryAwaitWithRetry(async () => await localDb.listCollections(fromDbId, [Query.limit(50)]));
+    const allFromCollections = fromCollections.collections;
+    if (fromCollections.collections.length < 50) {
+    }
+    else {
+        lastCollectionId =
+            fromCollections.collections[fromCollections.collections.length - 1].$id;
+        while (lastCollectionId) {
+            const collections = await tryAwaitWithRetry(async () => await localDb.listCollections(fromDbId, [
+                Query.limit(50),
+                Query.cursorAfter(lastCollectionId),
+            ]));
+            allFromCollections.push(...collections.collections);
+            if (collections.collections.length < 50) {
+                break;
+            }
+            lastCollectionId =
+                collections.collections[collections.collections.length - 1].$id;
+        }
+    }
+    for (const collection of allFromCollections) {
+        const toCollection = await tryAwaitWithRetry(async () => await remoteDb.createCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
+        console.log(`Collection ${toCollection.name} created`);
+        for (const attribute of collection.attributes) {
+            await tryAwaitWithRetry(async () => await createOrUpdateAttribute(remoteDb, toDbId, toCollection, parseAttribute(attribute)));
+        }
+        for (const index of collection.indexes) {
+            await tryAwaitWithRetry(async () => await remoteDb.createIndex(toDbId, toCollection.$id, index.key, index.type, index.attributes, index.orders));
+        }
+        await transferDocumentsBetweenDbsLocalToRemote(localDb, endpoint, projectId, apiKey, fromDbId, toDbId, collection.$id, toCollection.$id);
+    }
+};

package/dist/migrations/users.d.ts

@@ -9,7 +9,8 @@ export declare class UsersController {
     wipeUsers(): Promise<void>;
     getAllUsers(): Promise<Models.User<Models.Preferences>[]>;
     createUsersAndReturn(items: AuthUserCreate[]): Promise<Models.User<Models.Preferences>[]>;
-    createUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences>>;
+    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

@@ -1,8 +1,9 @@
-import { Databases, ID, Query, Users } from "node-appwrite";
+import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
 import { AuthUserSchema, } from "../schemas/authUser.js";
 import _ from "lodash";
 import { logger } from "./logging.js";
 import { splitIntoBatches } from "./migrationHelper.js";
+import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
 export class UsersController {
     config;
     users;
@@ -22,66 +23,45 @@ export class UsersController {
         this.users = new Users(this.config.appwriteClient);
     }
     async wipeUsers() {
-        const users = await this.users.list([Query.limit(200)]);
-        const allUsers = users.users;
-        let lastDocumentId;
-        if (users.users.length >= 200) {
-            lastDocumentId = users.users[users.users.length - 1].$id;
-        }
-        while (lastDocumentId) {
-            const moreUsers = await this.users.list([
-                Query.limit(200),
-                Query.cursorAfter(lastDocumentId),
-            ]);
-            allUsers.push(...moreUsers.users);
-            if (moreUsers.users.length < 200) {
-                break;
-            }
-            lastDocumentId = moreUsers.users[moreUsers.users.length - 1].$id;
-        }
+        const allUsers = await this.getAllUsers();
         console.log("Deleting all users...");
-        const createBatches = (finalData) => {
-            let maxBatchLength = 5;
+        const createBatches = (finalData, batchSize) => {
             const finalBatches = [];
-            for (let i = 0; i < finalData.length; i++) {
-                if (i % maxBatchLength === 0) {
-                    finalBatches.push([]);
-                }
-                finalBatches[finalBatches.length - 1].push(finalData[i]);
+            for (let i = 0; i < finalData.length; i += batchSize) {
+                finalBatches.push(finalData.slice(i, i + batchSize));
             }
             return finalBatches;
         };
-        // const userPromises: Promise<string>[] = [];
         let usersDeleted = 0;
-        for (const user of allUsers) {
-            await this.users.delete(user.$id);
-            usersDeleted++;
+        const batchedUserPromises = createBatches(allUsers, 50); // Batch size of 10
+        for (const batch of batchedUserPromises) {
+            console.log(`Deleting ${batch.length} users...`);
+            await Promise.all(batch.map((user) => tryAwaitWithRetry(async () => await this.users.delete(user.$id))));
+            usersDeleted += batch.length;
             if (usersDeleted % 100 === 0) {
                 console.log(`Deleted ${usersDeleted} users...`);
             }
         }
-        // const batchedUserPromises = createBatches(userPromises);
-        // for (const batch of batchedUserPromises) {
-        //   console.log(`Deleting ${batch.length} users...`);
-        //   await Promise.all(batch);
-        // }
     }
     async getAllUsers() {
         const allUsers = [];
-        const users = await this.users.list([Query.limit(200)]);
+        const users = await tryAwaitWithRetry(async () => await this.users.list([Query.limit(200)]));
+        if (users.users.length === 0) {
+            return [];
+        }
         if (users.users.length === 200) {
             let lastDocumentId = users.users[users.users.length - 1].$id;
             allUsers.push(...users.users);
             while (lastDocumentId) {
-                const moreUsers = await this.users.list([
+                const moreUsers = await tryAwaitWithRetry(async () => await this.users.list([
                     Query.limit(200),
                     Query.cursorAfter(lastDocumentId),
-                ]);
+                ]));
                 allUsers.push(...moreUsers.users);
-                lastDocumentId = moreUsers.users[moreUsers.users.length - 1].$id;
                 if (moreUsers.users.length < 200) {
                     break;
                 }
+                lastDocumentId = moreUsers.users[moreUsers.users.length - 1].$id;
             }
         }
         else {
@@ -93,13 +73,11 @@ export class UsersController {
         const users = await Promise.all(items.map((item) => this.createUserAndReturn(item)));
         return users;
     }
-    async createUserAndReturn(item) {
+    async createUserAndReturn(item, numAttempts) {
         try {
             const user = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
                 ? item.phone
-                : undefined, item.password?.toLowerCase() ||
-                `changeMe${item.email?.toLowerCase()}` ||
-                `changeMePlease`, item.name || undefined);
+                : undefined, `changeMe${item.email?.toLowerCase()}` || `changeMePlease`, item.name || undefined);
             if (item.labels) {
                 await this.users.updateLabels(user.$id, item.labels);
             }
@@ -109,9 +87,21 @@ export class UsersController {
             return user;
         }
         catch (e) {
+            if (e instanceof AppwriteException) {
+                if (e.message.toLowerCase().includes("fetch failed") ||
+                    e.message.toLowerCase().includes("server error")) {
+                    const numberOfAttempts = numAttempts || 0;
+                    if (numberOfAttempts > 5) {
+                        throw e;
+                    }
+                    const user = await this.createUserAndReturn(item, numberOfAttempts + 1);
+                    return user;
+                }
+            }
             if (e instanceof Error) {
-                logger.error("FAILED CREATING USER: ", e.message);
+                logger.error("FAILED CREATING USER: ", e.message, item);
             }
+            console.log("FAILED CREATING USER: ", e, item);
             throw e;
         }
     }
@@ -242,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/schemas/authUser.d.ts

@@ -44,16 +44,16 @@ export declare const AuthUserCreateSchema: z.ZodObject<z.objectUtil.extendShape<
     prefs: Record<string, string>;
     labels: string[];
     email?: string | null | undefined;
-    password?: string | undefined;
     name?: string | null | undefined;
+    password?: string | undefined;
     $createdAt?: string | undefined;
     $updatedAt?: string | undefined;
     phone?: string | null | undefined;
     userId?: string | undefined;
 }, {
     email?: string | null | undefined;
-    password?: string | undefined;
     name?: string | null | undefined;
+    password?: string | undefined;
     $createdAt?: string | undefined;
     $updatedAt?: string | undefined;
     phone?: string | null | undefined;

package/dist/storage/methods.d.ts

@@ -0,0 +1,15 @@
+import { Databases, Storage, type Models } from "node-appwrite";
+import { type AppwriteConfig } from "appwrite-utils";
+export declare const getStorage: (config: AppwriteConfig) => Storage;
+export declare const listBuckets: (storage: Storage, queries?: string[], search?: string) => Promise<Models.BucketList>;
+export declare const getBucket: (storage: Storage, bucketId: string) => Promise<Models.Bucket>;
+export declare const createBucket: (storage: Storage, bucket: Omit<Models.Bucket, "$id" | "$createdAt" | "$updatedAt">, bucketId?: string) => Promise<Models.Bucket>;
+export declare const updateBucket: (storage: Storage, bucket: Models.Bucket, bucketId: string) => Promise<Models.Bucket>;
+export declare const deleteBucket: (storage: Storage, bucketId: string) => Promise<{}>;
+export declare const getFile: (storage: Storage, bucketId: string, fileId: string) => Promise<Models.File>;
+export declare const listFiles: (storage: Storage, bucketId: string, queries?: string[], search?: string) => Promise<Models.FileList>;
+export declare const deleteFile: (storage: Storage, bucketId: string, fileId: string) => Promise<{}>;
+export declare const wipeDocumentStorage: (storage: Storage, bucketId: string) => Promise<void>;
+export declare const initOrGetDocumentStorage: (storage: Storage, config: AppwriteConfig, dbId: string, bucketName?: string) => Promise<Models.Bucket>;
+export declare const initOrGetBackupStorage: (config: AppwriteConfig, storage: Storage) => Promise<Models.Bucket>;
+export declare const backupDatabase: (config: AppwriteConfig, database: Databases, databaseId: string, storage: Storage) => Promise<void>;