appwrite-utils-cli 0.0.1

package/dist/migrations/importController.js

@@ -0,0 +1,312 @@
+import { ID, Query, } from "node-appwrite";
+import { checkForCollection } from "./collections.js";
+import path from "path";
+import fs from "fs";
+import { convertObjectByAttributeMappings } from "./converters.js";
+import _ from "lodash";
+import { documentExists } from "./collections.js";
+import { areCollectionNamesSame } from "../utils/index.js";
+import { resolveAndUpdateRelationships } from "./relationships.js";
+import { AuthUserCreateSchema } from "../types.js";
+import { UsersController } from "./users.js";
+export class ImportController {
+    config;
+    database;
+    storage;
+    appwriteFolderPath;
+    importDataActions;
+    setupOptions;
+    documentCache;
+    batchLimit = 25; // Define batch size limit
+    postImportActionsQueue = [];
+    constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions) {
+        this.config = config;
+        this.database = database;
+        this.storage = storage;
+        this.appwriteFolderPath = appwriteFolderPath;
+        this.importDataActions = importDataActions;
+        this.setupOptions = setupOptions;
+        this.documentCache = new Map();
+    }
+    async run() {
+        const databasesToRun = this.config.databases
+            .filter((db) => (areCollectionNamesSame(db.name, this.config.databases[0].name) &&
+            this.setupOptions.runProd) ||
+            (areCollectionNamesSame(db.name, this.config.databases[1].name) &&
+                this.setupOptions.runStaging) ||
+            (areCollectionNamesSame(db.name, this.config.databases[2].name) &&
+                this.setupOptions.runDev))
+            .map((db) => db.name);
+        for (let db of this.config.databases) {
+            if (db.name.toLowerCase().trim().replace(" ", "") === "migrations" ||
+                !databasesToRun.includes(db.name)) {
+                continue;
+            }
+            if (!db.$id) {
+                const databases = await this.database.list([
+                    Query.equal("name", db.name),
+                ]);
+                if (databases.databases.length > 0) {
+                    db.$id = databases.databases[0].$id;
+                }
+            }
+            console.log(`---------------------------------`);
+            console.log(`Starting import data for database: ${db.name}`);
+            console.log(`---------------------------------`);
+            await this.importCollections(db);
+            await resolveAndUpdateRelationships(db.$id, this.database, this.config);
+            await this.executePostImportActions();
+            console.log(`---------------------------------`);
+            console.log(`Finished import data for database: ${db.name}`);
+            console.log(`---------------------------------`);
+        }
+    }
+    async importCollections(db) {
+        const maxParallel = 3; // Maximum number of collections to process in parallel
+        let activePromises = []; // Array to keep track of active promises
+        for (const collection of this.config.collections) {
+            // Function that returns a promise for processing a single collection
+            const processCollection = async (col) => {
+                let isMembersCollection = false;
+                if (this.config.usersCollectionName.toLowerCase().replace(" ", "") ===
+                    col.name.toLowerCase().replace(" ", "")) {
+                    isMembersCollection = true;
+                }
+                const collectionExists = await checkForCollection(this.database, db.$id, col);
+                if (!collectionExists) {
+                    console.warn(`No collection found for ${col.name}`);
+                    return; // Skip this iteration
+                }
+                const updatedCollection = { ...col, $id: collectionExists.$id };
+                await this.processImportDefinitions(db, updatedCollection, isMembersCollection);
+            };
+            // Add the current collection's processing promise to the activePromises array
+            activePromises.push(processCollection(collection));
+            // If the number of active promises reaches the limit, wait for one to finish
+            if (activePromises.length >= maxParallel) {
+                await Promise.race(activePromises).then(() => {
+                    // Remove the promise that finished from the activePromises array
+                    activePromises = activePromises.filter((p) => p !== Promise.race(activePromises));
+                });
+            }
+        }
+        // After the loop, wait for the remaining promises to finish
+        await Promise.all(activePromises);
+    }
+    async processImportDefinitions(db, collection, isMembersCollection = false) {
+        this.documentCache.clear();
+        const updateDefs = collection.importDefs.filter((def) => def.type === "update");
+        const createDefs = collection.importDefs.filter((def) => def.type === "create" || !def.type);
+        // Process create import definitions first
+        for (const importDef of createDefs) {
+            const dataToImport = await this.loadData(importDef);
+            if (!dataToImport)
+                continue;
+            console.log(`Processing create definitions for collection ID: ${collection.$id}`);
+            await this.processBatch(db, collection, importDef, dataToImport, updateDefs, isMembersCollection);
+        }
+        // Process update import definitions
+        for (const importDef of updateDefs) {
+            const dataToImport = await this.loadData(importDef);
+            if (!dataToImport)
+                continue;
+            console.log(`Processing update definitions for collection ID: ${collection.$id}`);
+            await this.processBatch(db, collection, importDef, dataToImport);
+        }
+    }
+    async loadData(importDef) {
+        const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
+        if (!fs.existsSync(filePath)) {
+            console.error(`File not found: ${filePath}`);
+            return [];
+        }
+        const rawData = fs.readFileSync(filePath, "utf8");
+        return importDef.basePath
+            ? JSON.parse(rawData)[importDef.basePath]
+            : JSON.parse(rawData);
+    }
+    createContext(db, collection, item) {
+        return {
+            ...item, // Spread the item data for easy access to its properties
+            dbId: db.$id,
+            dbName: db.name,
+            collId: collection.$id,
+            collName: collection.name,
+            docId: "", // Initially empty, will be filled once the document is created or identified
+            createdDoc: {}, // Initially null, to be updated when the document is created
+        };
+    }
+    async transformData(item, attributeMappings) {
+        const convertedItem = convertObjectByAttributeMappings(item, attributeMappings);
+        return this.importDataActions.runConverterFunctions(convertedItem, attributeMappings);
+    }
+    async processBatch(db, collection, importDef, dataToImport, updateDefs = [], isMembersCollection = false) {
+        for (let i = 0; i < dataToImport.length; i += this.batchLimit) {
+            const batch = dataToImport.slice(i, i + this.batchLimit);
+            const results = await Promise.allSettled(batch.map(async (item) => {
+                let context = this.createContext(db, collection, item);
+                let finalItem = await this.transformData(item, importDef.attributeMappings);
+                let createIdToUse = undefined;
+                let associatedDoc;
+                if (isMembersCollection &&
+                    (finalItem.hasOwnProperty("email") || item.hasOwnProperty("phone"))) {
+                    console.log("Found members collection, creating user...");
+                    const usersController = new UsersController(this.config, this.database);
+                    const userToCreate = AuthUserCreateSchema.safeParse({
+                        ...finalItem,
+                    });
+                    if (!userToCreate.success) {
+                        console.error(userToCreate.error);
+                        return;
+                    }
+                    const user = await usersController.createUserAndReturn(userToCreate.data);
+                    createIdToUse = user.$id;
+                    context = { ...context, ...user };
+                    console.log("Created user, deleting keys in finalItem that exist in user...");
+                    const associatedDocFound = await this.database.listDocuments(db.$id, context.collId, [Query.equal("$id", createIdToUse)]);
+                    if (associatedDocFound.documents.length > 0) {
+                        associatedDoc = associatedDocFound.documents[0];
+                    }
+                    // Delete keys in finalItem that also exist in user
+                    let deletedKeys = [];
+                    Object.keys(finalItem).forEach((key) => {
+                        if (user.hasOwnProperty(key)) {
+                            delete finalItem[key];
+                            deletedKeys.push(key);
+                        }
+                    });
+                    console.log(`Set createIdToUse to ${createIdToUse}. Deleted keys: ${deletedKeys.join(", ")}.`);
+                }
+                else if (isMembersCollection) {
+                    console.log(`Skipping user & contact creation for ${item} due to lack of email...`);
+                }
+                context = { ...context, ...finalItem };
+                if (!(await this.importDataActions.validateItem(finalItem, importDef.attributeMappings, context))) {
+                    console.error("Validation failed for item:", finalItem);
+                    return;
+                }
+                let afterContext;
+                if ((importDef.type === "create" || !importDef.type) &&
+                    !associatedDoc) {
+                    const createdContext = await this.handleCreate(context, finalItem, updateDefs, createIdToUse);
+                    if (createdContext) {
+                        afterContext = createdContext;
+                    }
+                }
+                else {
+                    const updatedContext = await this.handleUpdate(context, finalItem, importDef);
+                    if (updatedContext) {
+                        afterContext = updatedContext;
+                    }
+                }
+                if (afterContext) {
+                    context = { ...context, ...afterContext };
+                }
+                const afterImportActionContext = structuredClone(context);
+                const attributeMappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, finalItem);
+                if (attributeMappingsWithActions.some((m) => m.postImportActions)) {
+                    this.postImportActionsQueue.push({
+                        context: afterImportActionContext,
+                        finalItem: finalItem,
+                        attributeMappings: attributeMappingsWithActions,
+                    });
+                }
+            }));
+            results.forEach((result) => {
+                if (result.status === "rejected") {
+                    console.error("A process batch promise was rejected:", result.reason);
+                }
+            });
+        }
+    }
+    async handleCreate(context, finalItem, updateDefs, id) {
+        const existing = await documentExists(this.database, context.dbId, context.collId, finalItem);
+        if (!existing) {
+            if (id) {
+                console.log(`Creating document with provided ID (member): ${id}`);
+            }
+            const createdDoc = await this.database.createDocument(context.dbId, context.collId, id || ID.unique(), finalItem);
+            context.docId = createdDoc.$id;
+            context.createdDoc = createdDoc;
+            context = { ...context, ...createdDoc };
+            // Populate document cache for updates
+            if (updateDefs) {
+                updateDefs.forEach((def) => {
+                    if (def.updateMapping) {
+                        this.documentCache.set(`${finalItem[def.updateMapping.targetField]}`, context);
+                    }
+                });
+            }
+            console.log(`Created document ID: ${createdDoc.$id}`);
+            return context;
+        }
+        else {
+            console.log("Document already exists, skipping creation.");
+            return existing;
+        }
+    }
+    async handleUpdate(context, finalItem, importDef) {
+        const updateMapping = importDef.updateMapping;
+        if (updateMapping) {
+            const keyToMatch = updateMapping.originalIdField;
+            const origId = context[keyToMatch];
+            const targetId = finalItem[updateMapping.targetField];
+            const cachedContext = this.documentCache.get(`${origId}`);
+            context = { ...context, ...cachedContext };
+            if (cachedContext) {
+                const updatedDoc = await this.database.updateDocument(context.dbId, context.collId, context.docId, finalItem);
+                context = { ...context, ...updatedDoc };
+                console.log(`Updated document ID: ${updatedDoc.$id}`);
+                return context;
+            }
+            else {
+                console.error(`Document to update not found in cache targeting ${keyToMatch}:${origId}`);
+                return;
+            }
+        }
+    }
+    getAttributeMappingsWithActions(attributeMappings, context, item) {
+        return attributeMappings.map((mapping) => {
+            if (mapping.fileData) {
+                console.log("Adding after-import action for fileData attribute");
+                let mappingFilePath = this.importDataActions.resolveTemplate(mapping.fileData.path, context, item);
+                if (!mappingFilePath.toLowerCase().startsWith("http")) {
+                    console.log(`Resolving file path: ${mappingFilePath}`);
+                    mappingFilePath = path.resolve(this.appwriteFolderPath, mappingFilePath);
+                }
+                const afterImportAction = {
+                    action: "createFileAndUpdateField",
+                    params: [
+                        "{dbId}",
+                        "{collId}",
+                        "{docId}",
+                        mapping.targetKey,
+                        `${this.config.documentBucketId}_${context.dbName
+                            .toLowerCase()
+                            .replace(" ", "")}`, // Assuming 'images' is your bucket ID
+                        mappingFilePath,
+                        mapping.fileData.name,
+                    ],
+                };
+                const postImportActions = mapping.postImportActions
+                    ? [...mapping.postImportActions, afterImportAction]
+                    : [afterImportAction];
+                return { ...mapping, postImportActions };
+            }
+            return mapping;
+        });
+    }
+    async executePostImportActions() {
+        const results = await Promise.allSettled(this.postImportActionsQueue.map(async (action) => {
+            const { context, finalItem, attributeMappings } = action;
+            console.log(`Executing post-import actions for document: ${context.docId}`);
+            return this.importDataActions.executeAfterImportActions(finalItem, attributeMappings, context);
+        }));
+        results.forEach((result) => {
+            if (result.status === "rejected") {
+                console.error("A post-import action promise was rejected:", result.reason);
+            }
+        });
+        this.postImportActionsQueue = [];
+    }
+}

package/dist/migrations/importDataActions.d.ts

@@ -0,0 +1,44 @@
+import { type Databases, type Storage } from "node-appwrite";
+import type { AppwriteConfig } from "./schema.js";
+import { type ValidationRules } from "./validationRules.js";
+import { type ConverterFunctions } from "./converters.js";
+import { type AfterImportActions } from "./afterImportActions.js";
+type AttributeMappings = AppwriteConfig["collections"][number]["importDefs"][number]["attributeMappings"];
+export declare class ImportDataActions {
+    private db;
+    private storage;
+    private config;
+    private converterDefinitions;
+    private validityRuleDefinitions;
+    private afterImportActionsDefinitions;
+    constructor(db: Databases, storage: Storage, config: AppwriteConfig, converterDefinitions: ConverterFunctions, validityRuleDefinitions: ValidationRules, afterImportActionsDefinitions: AfterImportActions);
+    runConverterFunctions(item: any, attributeMappings: AttributeMappings): Promise<any>;
+    /**
+     * Validates a single data item based on defined validation rules.
+     * @param item The data item to validate.
+     * @param context The context for resolving templated parameters in validation rules.
+     * @returns A promise that resolves to true if the item is valid, false otherwise.
+     */
+    validateItem(item: any, attributeMap: AttributeMappings, context: {
+        [key: string]: any;
+    }): Promise<boolean>;
+    executeAfterImportActions(item: any, attributeMap: AttributeMappings, context: {
+        [key: string]: any;
+    }): Promise<void>;
+    executeAction(actionName: string, params: any[], // Accepts any type, including objects
+    context: {
+        [key: string]: any;
+    }, item: any): Promise<void>;
+    /**
+     * Resolves a templated string or object using the provided context and current data item.
+     * If the template is a string that starts and ends with "{}", it replaces it with the corresponding value from item or context.
+     * If the template is an object, it recursively resolves its properties.
+     * @param template The templated string or object.
+     * @param context The context for resolving the template.
+     * @param item The current data item being processed.
+     */
+    resolveTemplate(template: any, context: {
+        [key: string]: any;
+    }, item: any): any;
+}
+export {};

package/dist/migrations/importDataActions.js

@@ -0,0 +1,219 @@
+import { ID, InputFile, Query, } from "node-appwrite";
+import { validationRules } from "./validationRules.js";
+import { converterFunctions, convertObjectBySchema, } from "./converters.js";
+import { afterImportActions, } from "./afterImportActions.js";
+import { logger } from "./logging.js";
+export class ImportDataActions {
+    db;
+    storage;
+    config;
+    converterDefinitions;
+    validityRuleDefinitions;
+    afterImportActionsDefinitions;
+    constructor(db, storage, config, converterDefinitions, validityRuleDefinitions, afterImportActionsDefinitions) {
+        this.db = db;
+        this.storage = storage;
+        this.config = config;
+        this.converterDefinitions = converterDefinitions;
+        this.validityRuleDefinitions = validityRuleDefinitions;
+        this.afterImportActionsDefinitions = afterImportActionsDefinitions;
+    }
+    async runConverterFunctions(item, attributeMappings) {
+        const conversionSchema = attributeMappings.reduce((schema, mapping) => {
+            schema[mapping.targetKey] = (originalValue) => {
+                return mapping.converters.reduce((value, converterName) => {
+                    let shouldProcessAsArray = false;
+                    if ((converterName.includes("[Arr]") ||
+                        converterName.includes("[arr]")) &&
+                        Array.isArray(value)) {
+                        shouldProcessAsArray = true;
+                        converterName = converterName
+                            .replace("[Arr]", "")
+                            .replace("[arr]", "");
+                    }
+                    else if ((!Array.isArray(value) && converterName.includes("[Arr]")) ||
+                        converterName.includes("[arr]")) {
+                        converterName = converterName
+                            .replace("[Arr]", "")
+                            .replace("[arr]", "");
+                    }
+                    const converterFunction = converterFunctions[converterName];
+                    if (converterFunction) {
+                        if (Array.isArray(value) && !shouldProcessAsArray) {
+                            return value.map((item) => converterFunction(item));
+                        }
+                        else {
+                            return converterFunction(value);
+                        }
+                    }
+                    else {
+                        logger.warn(`Converter function '${converterName}' is not defined.`);
+                        return value;
+                    }
+                }, originalValue);
+            };
+            return schema;
+        }, {});
+        // Convert the item using the constructed schema
+        const convertedItem = convertObjectBySchema(item, conversionSchema);
+        // Merge the converted item back into the original item object
+        Object.assign(item, convertedItem);
+        console.log("Converted item:", item);
+        return item;
+    }
+    /**
+     * Validates a single data item based on defined validation rules.
+     * @param item The data item to validate.
+     * @param context The context for resolving templated parameters in validation rules.
+     * @returns A promise that resolves to true if the item is valid, false otherwise.
+     */
+    async validateItem(item, attributeMap, context) {
+        for (const mapping of attributeMap) {
+            const { validationActions } = mapping;
+            if (!validationActions ||
+                !Array.isArray(validationActions) ||
+                !validationActions.length) {
+                console.warn("No validation actions defined for the item, assuming true");
+                return true; // Assume items without validation actions as valid.
+            }
+            for (const ruleDef of validationActions) {
+                const { action, params } = ruleDef;
+                const validationRule = validationRules[action];
+                if (!validationRule) {
+                    logger.warn(`Validation rule '${action}' is not defined.`);
+                    continue; // Optionally, consider undefined rules as a validation failure.
+                }
+                // Resolve templated parameters
+                const resolvedParams = params.map((param) => this.resolveTemplate(param, context, item));
+                // Apply the validation rule
+                let isValid = false;
+                if (Array.isArray(item)) {
+                    isValid = item.every((item) => validationRule(item, ...resolvedParams));
+                }
+                else {
+                    isValid = validationRule(item, ...resolvedParams);
+                }
+                if (!isValid) {
+                    logger.error(`Validation failed for rule '${action}' with params ${params.join(", ")}`);
+                    return false; // Stop validation on first failure
+                }
+            }
+        }
+        return true; // The item passed all validations
+    }
+    async executeAfterImportActions(item, attributeMap, context) {
+        for (const mapping of attributeMap) {
+            const { postImportActions } = mapping;
+            if (!postImportActions || !Array.isArray(postImportActions)) {
+                console.warn(`No post-import actions defined for attribute: ${mapping.targetKey}`, postImportActions);
+                continue; // Skip to the next attribute if no actions are defined
+            }
+            for (const actionDef of postImportActions) {
+                const { action, params } = actionDef;
+                console.log(`Executing post-import action '${action}' for attribute '${mapping.targetKey}' with params ${params.join(", ")}...`);
+                logger.info(`Executing post-import action '${action}' for attribute '${mapping.targetKey}' with params ${params.join(", ")}...`);
+                try {
+                    await this.executeAction(action, params, context, item);
+                }
+                catch (error) {
+                    logger.error(`Failed to execute post-import action '${action}' for attribute '${mapping.targetKey}':`, error);
+                }
+            }
+        }
+    }
+    async executeAction(actionName, params, // Accepts any type, including objects
+    context, item) {
+        const actionMethod = afterImportActions[actionName];
+        if (typeof actionMethod === "function") {
+            try {
+                // Resolve parameters, handling both strings and objects
+                const resolvedParams = params.map((param) => {
+                    // Directly resolve each param, whether it's an object or a string
+                    return this.resolveTemplate(param, context, item);
+                });
+                // Execute the action with resolved parameters
+                // Parameters are passed as-is, with objects treated as single parameters
+                logger.info(`Executing action '${actionName}' from context: ${JSON.stringify(context, null, 2)} with params:`, resolvedParams);
+                await actionMethod(this.config, ...resolvedParams);
+            }
+            catch (error) {
+                logger.error(`Error executing action '${actionName}':`, error);
+                throw new Error(`Execution failed for action '${actionName}': ${error.message}`);
+            }
+        }
+        else {
+            logger.warn(`Action '${actionName}' is not defined.`);
+            throw new Error(`Action '${actionName}' is not defined.`);
+        }
+    }
+    /**
+     * Resolves a templated string or object using the provided context and current data item.
+     * If the template is a string that starts and ends with "{}", it replaces it with the corresponding value from item or context.
+     * If the template is an object, it recursively resolves its properties.
+     * @param template The templated string or object.
+     * @param context The context for resolving the template.
+     * @param item The current data item being processed.
+     */
+    resolveTemplate(template, context, item) {
+        // Function to recursively resolve paths, including handling [any] notation
+        const resolvePath = (path, currentContext) => {
+            const anyKeyRegex = /\[any\]/g;
+            let pathParts = path.split(".").filter(Boolean);
+            return pathParts.reduce((acc, part, index) => {
+                // Handle [any] part by iterating over all elements if it's an object or an array
+                if (part === "[any]") {
+                    if (Array.isArray(acc)) {
+                        return acc
+                            .map((item) => item[pathParts[index + 1]])
+                            .filter((item) => item !== undefined);
+                    }
+                    else if (typeof acc === "object") {
+                        return Object.values(acc)
+                            .map((item) => item[pathParts[index + 1]])
+                            .filter((item) => item !== undefined);
+                    }
+                }
+                else {
+                    return acc?.[part];
+                }
+            }, currentContext);
+        };
+        if (typeof template === "string") {
+            // Matches placeholders in the template
+            const regex = /\{([^}]+)\}/g;
+            let match;
+            let resolvedString = template;
+            while ((match = regex.exec(template)) !== null) {
+                const path = match[1];
+                // Resolve the path, handling [any] notation and arrays/objects
+                const resolvedValue = resolvePath(path, { ...context, ...item });
+                if (resolvedValue !== undefined) {
+                    // If it's an array (from [any] notation), join the values; adjust as needed
+                    const value = Array.isArray(resolvedValue)
+                        ? resolvedValue.join(", ")
+                        : resolvedValue;
+                    resolvedString = resolvedString.replace(match[0], value);
+                }
+                else {
+                    logger.warn(`Failed to resolve ${template} in context: `, context);
+                }
+            }
+            // console.log(`Resolved string: ${resolvedString}`);
+            return resolvedString;
+        }
+        else if (typeof template === "object" && template !== null) {
+            // Recursively resolve templates for each property in the object
+            const resolvedObject = Array.isArray(template) ? [] : {};
+            for (const key in template) {
+                const resolvedValue = this.resolveTemplate(template[key], context, item);
+                if (resolvedValue !== undefined) {
+                    // Only assign if resolvedValue is not undefined
+                    resolvedObject[key] = resolvedValue;
+                }
+            }
+            return resolvedObject;
+        }
+        // console.log(`Template is not a string or object: ${template}`);
+        return template;
+    }
+}

package/dist/migrations/indexes.d.ts

@@ -0,0 +1,4 @@
+import { type Index } from "./schema.js";
+import { Databases, type Models } from "node-appwrite";
+export declare const createOrUpdateIndex: (dbId: string, db: Databases, collectionId: string, index: Index) => Promise<Models.Index>;
+export declare const createOrUpdateIndexes: (dbId: string, db: Databases, collectionId: string, indexes: Index[]) => Promise<void>;

package/dist/migrations/indexes.js

@@ -0,0 +1,18 @@
+import { indexSchema } from "./schema.js";
+import { Databases, Query } from "node-appwrite";
+// import {}
+export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {
+    const existingIndex = await db.listIndexes(dbId, collectionId, [
+        Query.equal("key", index.key),
+    ]);
+    if (existingIndex.total > 0) {
+        await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
+    }
+    const newIndex = await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, index.orders);
+    return newIndex;
+};
+export const createOrUpdateIndexes = async (dbId, db, collectionId, indexes) => {
+    for (const index of indexes) {
+        await createOrUpdateIndex(dbId, db, collectionId, index);
+    }
+};

package/dist/migrations/logging.d.ts

@@ -0,0 +1,2 @@
+import winston from "winston";
+export declare const logger: winston.Logger;

package/dist/migrations/logging.js

@@ -0,0 +1,14 @@
+import winston from "winston";
+export const logger = winston.createLogger({
+    level: "info",
+    format: winston.format.prettyPrint(),
+    defaultMeta: { service: "appwrite-utils-cli" },
+    transports: [
+        //
+        // - Write all logs with importance level of `error` or less to `error.log`
+        // - Write all logs with importance level of `info` or less to `combined.log`
+        //
+        new winston.transports.File({ filename: "error.log", level: "error" }),
+        new winston.transports.File({ filename: "combined.log" }),
+    ],
+});

package/dist/migrations/migrationHelper.d.ts

@@ -0,0 +1,18 @@
+import { type Databases } from "node-appwrite";
+export declare const findOrCreateOperation: (database: Databases, collectionId: string, operationType: string) => Promise<{
+    error: string;
+    status: "error" | "pending" | "in_progress" | "completed";
+    $id: string;
+    $createdAt: string;
+    $updatedAt: string;
+    collectionId: string;
+    operationType: string;
+    progress: number;
+    total: number;
+    data?: any;
+    batches?: string[] | undefined;
+}>;
+export declare const updateOperation: (database: Databases, operationId: string, updateFields: any) => Promise<void>;
+export declare const maxDataLength = 1073741820;
+export declare const maxBatchItems = 100;
+export declare const splitIntoBatches: (data: any[]) => any[][];