appwrite-utils-cli 0.0.1

package/dist/migrations/schemaStrings.js

@@ -0,0 +1,261 @@
+import { toCamelCase, toPascalCase } from "../utils/index.js";
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+export class SchemaGenerator {
+    relationshipMap = new Map();
+    config;
+    appwriteFolderPath;
+    constructor(config, appwriteFolderPath) {
+        this.config = config;
+        this.appwriteFolderPath = appwriteFolderPath;
+        this.extractRelationships();
+    }
+    extractRelationships() {
+        this.config.collections.forEach((collection) => {
+            collection.attributes.forEach((attr) => {
+                if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
+                    const relationshipAttr = attr;
+                    console.log(`Extracting relationship: ${attr.key}`);
+                    let isArrayParent = false;
+                    let isArrayChild = false;
+                    switch (relationshipAttr.relationType) {
+                        case "oneToMany":
+                            isArrayParent = true;
+                            isArrayChild = false;
+                            break;
+                        case "manyToMany":
+                            isArrayParent = true;
+                            isArrayChild = true;
+                            break;
+                        case "oneToOne":
+                            isArrayParent = false;
+                            isArrayChild = false;
+                            break;
+                        case "manyToOne":
+                            isArrayParent = false;
+                            isArrayChild = true;
+                            break;
+                        default:
+                            break;
+                    }
+                    this.addRelationship(collection.name, relationshipAttr.relatedCollection, attr.key, relationshipAttr.twoWayKey, isArrayParent, isArrayChild);
+                }
+            });
+        });
+    }
+    addRelationship(parentCollection, childCollection, parentKey, childKey, isArrayParent, isArrayChild) {
+        const relationshipsChild = this.relationshipMap.get(childCollection) || [];
+        const relationshipsParent = this.relationshipMap.get(parentCollection) || [];
+        relationshipsParent.push({
+            parentCollection,
+            childCollection,
+            parentKey,
+            childKey,
+            isArray: isArrayParent,
+            isChild: false,
+        });
+        relationshipsChild.push({
+            parentCollection,
+            childCollection,
+            parentKey,
+            childKey,
+            isArray: isArrayChild,
+            isChild: true,
+        });
+        this.relationshipMap.set(childCollection, relationshipsChild);
+        this.relationshipMap.set(parentCollection, relationshipsParent);
+    }
+    generateSchemas() {
+        this.config.collections.forEach((collection) => {
+            const schemaString = this.createSchemaString(collection.name, collection.attributes);
+            const camelCaseName = toCamelCase(collection.name);
+            const schemaPath = path.join(this.appwriteFolderPath, "schemas", `${camelCaseName}.ts`);
+            fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
+            console.log(`Schema written to ${schemaPath}`);
+        });
+    }
+    createSchemaString = (name, attributes) => {
+        const pascalName = toPascalCase(name);
+        let imports = `import { z } from "zod";\n`;
+        // Use the relationshipMap to find related collections
+        const relationshipDetails = this.relationshipMap.get(name) || [];
+        const relatedCollections = relationshipDetails.map((detail) => {
+            const relatedCollectionName = detail.isChild
+                ? detail.parentCollection
+                : detail.childCollection;
+            const key = detail.isChild ? detail.childKey : detail.parentKey;
+            const isArray = detail.isArray ? "array" : "";
+            return [relatedCollectionName, key, isArray];
+        });
+        console.log(relatedCollections);
+        let relatedTypes = "";
+        let relatedTypesLazy = "";
+        let curNum = 0;
+        let maxNum = relatedCollections.length;
+        relatedCollections.forEach((relatedCollection) => {
+            const relatedPascalName = toPascalCase(relatedCollection[0]);
+            const relatedCamelName = toCamelCase(relatedCollection[0]);
+            curNum++;
+            let endNameTypes = relatedPascalName;
+            let endNameLazy = `${relatedPascalName}Schema`;
+            if (relatedCollection[2] === "array") {
+                endNameTypes += "[]";
+                endNameLazy += ".array()";
+            }
+            endNameLazy += ".nullish()";
+            imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
+            relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
+            if (relatedTypes.length > 0 && curNum !== maxNum) {
+                relatedTypes += "  ";
+            }
+            relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
+            if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
+                relatedTypesLazy += "  ";
+            }
+        });
+        let schemaString = `${imports}\n\n`;
+        schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
+        schemaString += `  $id: z.string().optional(),\n`;
+        schemaString += `  $createdAt: z.date().or(z.string()).optional(),\n`;
+        schemaString += `  $updatedAt: z.date().or(z.string()).optional(),\n`;
+        for (const attribute of attributes) {
+            if (attribute.type === "relationship") {
+                continue;
+            }
+            schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
+        }
+        schemaString += `});\n\n`;
+        schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
+        if (relatedTypes.length > 0) {
+            schemaString += ` & {\n  ${relatedTypes}};\n\n`;
+        }
+        else {
+            schemaString += `;\n\n`;
+        }
+        schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
+        if (relatedTypes.length > 0) {
+            schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
+        }
+        else {
+            schemaString += `;\n`;
+        }
+        schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+        return schemaString;
+    };
+    typeToZod = (attribute) => {
+        let baseSchemaCode = "";
+        switch (attribute.type) {
+            case "string":
+                baseSchemaCode = "z.string()";
+                if (attribute.size) {
+                    baseSchemaCode += `.max(${attribute.size}, "Maximum length of ${attribute.size} characters exceeded")`;
+                }
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default("${attribute.xdefault}")`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "integer":
+                baseSchemaCode = "z.number().int()";
+                if (attribute.min !== undefined) {
+                    baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+                }
+                if (attribute.max !== undefined) {
+                    baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+                }
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default(${attribute.xdefault})`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "float":
+                baseSchemaCode = "z.number()";
+                if (attribute.min !== undefined) {
+                    baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+                }
+                if (attribute.max !== undefined) {
+                    baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+                }
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default(${attribute.xdefault})`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "boolean":
+                baseSchemaCode = "z.boolean()";
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default(${attribute.xdefault})`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "datetime":
+                baseSchemaCode = "z.date()";
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default(new Date("${attribute.xdefault}"))`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "email":
+                baseSchemaCode = "z.string().email()";
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default("${attribute.xdefault}")`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "ip":
+                baseSchemaCode = "z.string()"; // Add custom validation as needed
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default("${attribute.xdefault}")`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "url":
+                baseSchemaCode = "z.string().url()";
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default("${attribute.xdefault}")`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "enum":
+                baseSchemaCode = `z.enum([${attribute.elements
+                    .map((element) => `"${element}"`)
+                    .join(", ")}])`;
+                if (attribute.xdefault !== undefined) {
+                    baseSchemaCode += `.default("${attribute.xdefault}")`;
+                }
+                if (!attribute.required && !attribute.array) {
+                    baseSchemaCode += ".nullish()";
+                }
+                break;
+            case "relationship":
+                break;
+            default:
+                baseSchemaCode = "z.any()";
+        }
+        // Handle arrays
+        if (attribute.array) {
+            baseSchemaCode = `z.array(${baseSchemaCode})`;
+        }
+        if (attribute.array && !attribute.required) {
+            baseSchemaCode += ".nullish()";
+        }
+        return baseSchemaCode;
+    };
+}

package/dist/migrations/setupDatabase.d.ts

@@ -0,0 +1,7 @@
+import { Databases, Storage } from "node-appwrite";
+import { type AppwriteConfig } from "./schema.js";
+import type { SetupOptions } from "../utilsController.js";
+export declare const setupMigrationDatabase: (config: AppwriteConfig) => Promise<void>;
+export declare const ensureDatabasesExist: (config: AppwriteConfig) => Promise<void>;
+export declare const wipeOtherDatabases: (database: Databases, config: AppwriteConfig) => Promise<void>;
+export declare const startSetup: (database: Databases, storage: Storage, config: AppwriteConfig, setupOptions: SetupOptions, appwriteFolderPath: string) => Promise<void>;

package/dist/migrations/setupDatabase.js

@@ -0,0 +1,151 @@
+import { Databases, ID, Query, Storage } from "node-appwrite";
+import { createOrUpdateAttribute } from "./attributes.js";
+import { createOrUpdateCollections, generateSchemas, wipeDatabase, } from "./collections.js";
+import { getMigrationCollectionSchemas } from "./backup.js";
+import { areCollectionNamesSame, toCamelCase } from "../utils/index.js";
+import { backupDatabase, initOrGetBackupStorage, initOrGetDocumentStorage, wipeDocumentStorage, } from "./storage.js";
+import {} from "./schema.js";
+import { nameToIdMapping } from "./queue.js";
+import { UsersController } from "./users.js";
+export const setupMigrationDatabase = async (config) => {
+    // Create the migrations database if needed
+    console.log("---------------------------------");
+    console.log("Starting Migrations Setup");
+    console.log("---------------------------------");
+    const database = new Databases(config.appwriteClient);
+    let db = null;
+    const dbCollections = [];
+    const migrationCollectionsSetup = getMigrationCollectionSchemas();
+    try {
+        db = await database.get("migrations");
+        console.log("Migrations database found");
+    }
+    catch (e) {
+        db = await database.create("migrations", "Migrations", true);
+        console.log("Migrations database created");
+    }
+    if (db) {
+        const collectionsPulled = await database.listCollections(db.$id, [
+            Query.limit(25),
+        ]);
+        dbCollections.push(...collectionsPulled.collections);
+    }
+    console.log(`Collections in migrations database: ${dbCollections.length}`);
+    // Iterate over each key in the migrationCollectionsSetup object
+    for (const [collectionName, { collection, attributes }] of Object.entries(migrationCollectionsSetup)) {
+        const collectionId = toCamelCase(collectionName); // Convert name to toCamelCase for the ID
+        let collectionFound = null;
+        try {
+            collectionFound = await database.getCollection(db.$id, collectionId);
+        }
+        catch (e) {
+            console.log(`Collection not found: ${collectionId}`);
+        }
+        if (!collectionFound) {
+            // Create the collection with the provided configuration
+            collectionFound = await database.createCollection(db.$id, collectionId, collectionName, undefined, collection.documentSecurity, collection.enabled);
+        }
+        for (const attribute of attributes) {
+            await createOrUpdateAttribute(database, db.$id, collectionFound, attribute);
+        }
+    }
+    console.log("---------------------------------");
+    console.log("Migrations Setup Complete");
+    console.log("---------------------------------");
+};
+export const ensureDatabasesExist = async (config) => {
+    const database = new Databases(config.appwriteClient);
+    const databasesToEnsure = config.databases;
+    databasesToEnsure.push({
+        $id: "migrations",
+        name: "Migrations",
+    });
+    const dbNames = databasesToEnsure.map((db) => db.name);
+    const existingDatabases = await database.list([Query.equal("name", dbNames)]);
+    for (const db of databasesToEnsure) {
+        if (!existingDatabases.databases.some((d) => d.name === db.name)) {
+            await database.create(db.$id || ID.unique(), db.name, true);
+            console.log(`${db.name} database created`);
+        }
+    }
+};
+export const wipeOtherDatabases = async (database, config) => {
+    const databasesToKeep = config.databases.map((db) => db.name.toLowerCase().trim().replace(" ", ""));
+    databasesToKeep.push("migrations");
+    console.log(`Databases to keep: ${databasesToKeep.join(", ")}`);
+    const allDatabases = await database.list([Query.limit(500)]);
+    for (const db of allDatabases.databases) {
+        if (!databasesToKeep.includes(db.name.toLowerCase().trim().replace(" ", ""))) {
+            await database.delete(db.$id);
+            console.log(`Deleted database: ${db.name}`);
+        }
+    }
+};
+export const startSetup = async (database, storage, config, setupOptions, appwriteFolderPath) => {
+    await setupMigrationDatabase(config);
+    if (config.enableBackups) {
+        await initOrGetBackupStorage(storage);
+        if (setupOptions.wipeDocumentStorage) {
+            if (setupOptions.runProd) {
+                await initOrGetDocumentStorage(storage, config, config.databases[0].name);
+                await wipeDocumentStorage(storage, config, config.databases[0].name);
+            }
+            if (setupOptions.runStaging) {
+                await initOrGetDocumentStorage(storage, config, config.databases[1].name);
+                await wipeDocumentStorage(storage, config, config.databases[1].name);
+            }
+            if (setupOptions.runDev) {
+                await initOrGetDocumentStorage(storage, config, config.databases[2].name);
+                await wipeDocumentStorage(storage, config, config.databases[2].name);
+            }
+        }
+    }
+    if (config.enableWipeOtherDatabases) {
+        await wipeOtherDatabases(database, config);
+    }
+    if (setupOptions.wipeUsers) {
+        const usersController = new UsersController(config, database);
+        console.log("Wiping users");
+        await usersController.wipeUsers();
+        console.log("Users wiped");
+    }
+    await ensureDatabasesExist(config);
+    const databaseNames = config.databases.map((db) => db.name);
+    // Move to here so it always runs if it's set to true
+    if (setupOptions.generateSchemas) {
+        await generateSchemas(config, appwriteFolderPath);
+    }
+    for (const db of config.databases) {
+        // Determine if the current database should be processed based on the setup options
+        const processDatabase = (setupOptions.runProd &&
+            areCollectionNamesSame(db.name, databaseNames[0])) ||
+            (setupOptions.runStaging &&
+                areCollectionNamesSame(db.name, databaseNames[1])) ||
+            (setupOptions.runDev &&
+                areCollectionNamesSame(db.name, databaseNames[2]));
+        if (!processDatabase) {
+            continue;
+        }
+        else {
+            await initOrGetDocumentStorage(storage, config, db.name);
+        }
+        console.log(`---------------------------------`);
+        console.log(`Starting setup for database: ${db.name}`);
+        console.log(`---------------------------------`);
+        let deletedCollections;
+        if (setupOptions.wipeDatabases && processDatabase) {
+            if (config.enableBackups && setupOptions.doBackup) {
+                await backupDatabase(database, db.$id, storage);
+            }
+            deletedCollections = await wipeDatabase(database, db.$id);
+        }
+        if (processDatabase) {
+            await createOrUpdateCollections(database, db.$id, config, deletedCollections);
+        }
+        deletedCollections = undefined;
+        nameToIdMapping.clear();
+        console.log(`---------------------------------`);
+        console.log(`Finished setup for database: ${db.name}`);
+        console.log(`---------------------------------`);
+    }
+};

package/dist/migrations/storage.d.ts

@@ -0,0 +1,8 @@
+import { Storage, Databases, type Models } from "node-appwrite";
+import { type OperationCreate } from "./backup.js";
+import type { AppwriteConfig } from "./schema.js";
+export declare const logOperation: (db: Databases, dbId: string, operationDetails: OperationCreate, operationId?: string) => Promise<Models.Document>;
+export declare const initOrGetBackupStorage: (storage: Storage) => Promise<Models.Bucket>;
+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>;

package/dist/migrations/storage.js

@@ -0,0 +1,241 @@
+import { Storage, Databases, Query, InputFile, ID, } from "node-appwrite";
+import {} from "./backup.js";
+import { splitIntoBatches } from "./migrationHelper.js";
+export const logOperation = async (db, dbId, operationDetails, operationId) => {
+    try {
+        let operation;
+        if (operationId) {
+            // Update existing operation log
+            operation = await db.updateDocument("migrations", "currentOperations", operationId, operationDetails);
+        }
+        else {
+            // Create new operation log
+            operation = await db.createDocument("migrations", "currentOperations", ID.unique(), operationDetails);
+        }
+        console.log(`Operation logged: ${operation.$id}`);
+        return operation;
+    }
+    catch (error) {
+        console.error(`Error logging operation: ${error}`);
+        throw error;
+    }
+};
+export const initOrGetBackupStorage = async (storage) => {
+    try {
+        const backupStorage = await storage.getBucket("backupStorage");
+        return backupStorage;
+    }
+    catch (e) {
+        // ID backupStorage
+        // Name Backups Storage
+        const backupStorage = await storage.createBucket("backupStorage", "Backups Storage");
+        return backupStorage;
+    }
+};
+export const initOrGetDocumentStorage = async (storage, config, dbName) => {
+    try {
+        await storage.getBucket(`${config.documentBucketId}_${dbName.toLowerCase().replace(" ", "")}`);
+    }
+    catch (e) {
+        // ID documentStorage
+        // Name Document Storage
+        const documentStorage = await storage.createBucket(`${config.documentBucketId}_${dbName.toLowerCase().replace(" ", "")}`, "Document Storage");
+        return documentStorage;
+    }
+};
+export const wipeDocumentStorage = async (storage, config, dbName) => {
+    const bucketId = `${config.documentBucketId
+        .toLowerCase()
+        .replace(" ", "")}_${dbName.toLowerCase().replace(" ", "")}`;
+    console.log(`Wiping storage for bucket ID: ${bucketId}`);
+    let moreFiles = true;
+    let lastFileId;
+    const allFiles = [];
+    while (moreFiles) {
+        const queries = [Query.limit(100)]; // Adjust the limit as needed
+        if (lastFileId) {
+            queries.push(Query.cursorAfter(lastFileId));
+        }
+        const filesPulled = await storage.listFiles(bucketId, queries);
+        if (filesPulled.files.length === 0) {
+            console.log("No files found, done!");
+            moreFiles = false;
+            break;
+        }
+        else if (filesPulled.files.length > 0) {
+            const fileIds = filesPulled.files.map((file) => file.$id);
+            allFiles.push(...fileIds);
+        }
+        moreFiles = filesPulled.files.length > 100; // Adjust based on the limit
+        if (moreFiles) {
+            lastFileId = filesPulled.files[filesPulled.files.length - 1].$id;
+        }
+    }
+    for (const fileId of allFiles) {
+        console.log(`Deleting file: ${fileId}`);
+        await storage.deleteFile(bucketId, fileId);
+    }
+    console.log(`All files in bucket ${bucketId} have been deleted.`);
+};
+async function retryFailedPromises(batch, maxRetries = 3) {
+    const results = await Promise.allSettled(batch);
+    const toRetry = [];
+    results.forEach((result, index) => {
+        if (result.status === "rejected") {
+            console.error("Promise rejected with reason:", result.reason);
+            if (maxRetries > 0) {
+                toRetry.push(batch[index]);
+            }
+        }
+    });
+    if (toRetry.length > 0) {
+        console.log(`Retrying ${toRetry.length} promises`);
+        return retryFailedPromises(toRetry, maxRetries - 1);
+    }
+    else {
+        return results
+            .filter((result) => result.status === "fulfilled")
+            .map((result) => result);
+    }
+}
+export const backupDatabase = async (database, databaseId, storage) => {
+    console.log("---------------------------------");
+    console.log("Starting Database Backup of " + databaseId);
+    console.log("---------------------------------");
+    let data = {
+        database: "",
+        collections: [],
+        documents: [],
+    };
+    const backupOperation = await logOperation(database, databaseId, {
+        operationType: "backup",
+        collectionId: "",
+        data: "Starting backup...",
+        progress: 0,
+        total: 100, // This will be dynamically updated later
+        error: "",
+        status: "in_progress",
+    });
+    // Fetch and backup the database details
+    let db;
+    try {
+        db = await database.get(databaseId);
+    }
+    catch (e) {
+        console.error(`Error fetching database: ${e}`);
+        await logOperation(database, databaseId, {
+            operationType: "backup",
+            collectionId: "",
+            data: "Error fetching database, skipping...",
+            progress: 0,
+            total: 100, // This will be dynamically updated later
+            error: `Error fetching database: ${e}`,
+            status: "error",
+        }, backupOperation.$id);
+        return;
+    }
+    data.database = JSON.stringify(db);
+    // Initialize pagination for collections
+    let lastCollectionId = "";
+    let moreCollections = true;
+    let progress = 0;
+    let total = 0; // Initialize total to 0, will be updated dynamically
+    while (moreCollections) {
+        const collectionResponse = await database.listCollections(databaseId, [
+            Query.limit(500), // Adjust the limit as needed
+            ...(lastCollectionId ? [Query.cursorAfter(lastCollectionId)] : []),
+        ]);
+        total += collectionResponse.collections.length; // Update total with number of collections
+        for (const { $id: collectionId, name: collectionName, } of collectionResponse.collections) {
+            let collectionDocumentCount = 0; // Initialize document count for the current collection
+            try {
+                const collection = await database.getCollection(databaseId, collectionId);
+                progress++;
+                data.collections.push(JSON.stringify(collection));
+                // Initialize pagination for documents within the current collection
+                let lastDocumentId = "";
+                let moreDocuments = true;
+                while (moreDocuments) {
+                    const documentResponse = await database.listDocuments(databaseId, collectionId, [
+                        Query.limit(500), // Adjust the limit as needed
+                        ...(lastDocumentId ? [Query.cursorAfter(lastDocumentId)] : []),
+                    ]);
+                    total += documentResponse.documents.length; // Update total with number of documents
+                    collectionDocumentCount += documentResponse.documents.length; // Update document count for the current collection
+                    let documentPromises = [];
+                    for (const { $id: documentId } of documentResponse.documents) {
+                        documentPromises.push(database.getDocument(databaseId, collectionId, documentId));
+                    }
+                    const promiseBatches = splitIntoBatches(documentPromises);
+                    const documentsPulled = [];
+                    for (const batch of promiseBatches) {
+                        const successfulDocuments = await retryFailedPromises(batch);
+                        documentsPulled.push(...successfulDocuments);
+                    }
+                    const documents = documentsPulled;
+                    data.documents.push({
+                        collectionId: collectionId,
+                        data: JSON.stringify(documents),
+                    });
+                    progress += documents.length;
+                    console.log(`Collection ${collectionName} backed up ${collectionDocumentCount} documents (so far)`);
+                    // Update the operation log with the current progress
+                    await logOperation(database, databaseId, {
+                        operationType: "backup",
+                        collectionId: collectionId,
+                        data: `Still backing up, ${data.collections.length} collections so far`,
+                        progress: progress,
+                        total: total,
+                        error: "",
+                        status: "in_progress",
+                    }, backupOperation.$id);
+                    // Check if there are more documents to fetch
+                    moreDocuments = documentResponse.documents.length === 500;
+                    if (moreDocuments) {
+                        lastDocumentId =
+                            documentResponse.documents[documentResponse.documents.length - 1]
+                                .$id;
+                    }
+                }
+                console.log(`Collection ${collectionName} backed up with ${collectionDocumentCount} documents.`);
+            }
+            catch (error) {
+                console.log(`Collection ${collectionName} must not exist, continuing...`);
+                continue;
+            }
+        }
+        // Check if there are more collections to fetch
+        moreCollections = collectionResponse.collections.length === 500;
+        if (moreCollections) {
+            lastCollectionId =
+                collectionResponse.collections[collectionResponse.collections.length - 1].$id;
+        }
+    }
+    // Update the backup operation with the current progress and total
+    await logOperation(database, databaseId, {
+        operationType: "backup",
+        collectionId: "",
+        data: `Still backing up, ${data.collections.length} collections so far`,
+        progress: progress,
+        total: total,
+        error: "",
+        status: "in_progress",
+    }, backupOperation.$id);
+    // Create the backup with the accumulated data
+    const bucket = await initOrGetBackupStorage(storage);
+    const inputFile = InputFile.fromPlainText(JSON.stringify(data), `${new Date().toISOString()}-${databaseId}.json`);
+    const fileCreated = await storage.createFile(bucket.$id, ID.unique(), inputFile);
+    // Final update to the backup operation marking it as completed
+    await logOperation(database, databaseId, {
+        operationType: "backup",
+        collectionId: "",
+        data: fileCreated.$id,
+        progress: 100,
+        total: total, // Ensure the total reflects the actual total processed
+        error: "",
+        status: "completed",
+    }, backupOperation.$id);
+    console.log("---------------------------------");
+    console.log("Database Backup Complete");
+    console.log("---------------------------------");
+};

package/dist/migrations/users.d.ts

@@ -0,0 +1,11 @@
+import type { AppwriteConfig } from "./schema.js";
+import { Databases, type Models } from "node-appwrite";
+import { type AuthUserCreate } from "../schemas/authUser.js";
+export declare class UsersController {
+    private config;
+    private users;
+    static userFields: string[];
+    constructor(config: AppwriteConfig, db: Databases);
+    wipeUsers(): Promise<void>;
+    createUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences>>;
+}