appwrite-utils-cli 0.0.285 → 0.9.0

package/dist/migrations/databases.js

@@ -1,7 +1,13 @@
-import { Databases, Query } from "node-appwrite";
+import { Client, Databases, IndexType, Query, } from "node-appwrite";
+import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
+import { transferDocumentsBetweenDbsLocalToLocal, transferDocumentsBetweenDbsLocalToRemote, } from "./collections.js";
+import { createOrUpdateAttribute } from "./attributes.js";
+import { parseAttribute } from "appwrite-utils";
 export const fetchAllDatabases = async (database) => {
-    const databases = await database.list([Query.limit(25)]);
+    const databases = await tryAwaitWithRetry(async () => await database.list([Query.limit(25)]));
     const allDatabases = databases.databases;
+    if (allDatabases.length === 0)
+        return [];
     let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
     if (databases.databases.length < 25) {
         return allDatabases;

package/dist/migrations/helper.d.ts

@@ -0,0 +1,3 @@
+import type { Databases, Models } from "node-appwrite";
+import type { OperationCreate } from "../storage/schemas.js";
+export declare const logOperation: (db: Databases, dbId: string, operationDetails: OperationCreate, operationId?: string) => Promise<Models.Document>;

package/dist/migrations/helper.js

@@ -0,0 +1,21 @@
+import { tryAwaitWithRetry } from "appwrite-utils";
+import { ulid } from "ulidx";
+export const logOperation = async (db, dbId, operationDetails, operationId) => {
+    try {
+        let operation;
+        if (operationId) {
+            // Update existing operation log
+            operation = await tryAwaitWithRetry(async () => await db.updateDocument("migrations", "currentOperations", operationId, operationDetails));
+        }
+        else {
+            // Create new operation log
+            operation = await db.createDocument("migrations", "currentOperations", ulid(), operationDetails);
+        }
+        console.log(`Operation logged: ${operation.$id}`);
+        return operation;
+    }
+    catch (error) {
+        console.error(`Error logging operation: ${error}`);
+        throw error;
+    }
+};

package/dist/migrations/importController.d.ts

@@ -1,4 +1,4 @@
-import { type Databases, type Storage } from "node-appwrite";
+import { type Databases, type Models, type Storage } from "node-appwrite";
 import type { AppwriteConfig, ConfigDatabase } from "appwrite-utils";
 import type { ImportDataActions } from "./importDataActions.js";
 import type { SetupOptions } from "../utilsController.js";
@@ -12,9 +12,12 @@ export declare class ImportController {
     private setupOptions;
     private documentCache;
     private batchLimit;
+    private hasImportedUsers;
     private postImportActionsQueue;
-    constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions);
+    private databasesToRun;
+    constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions, databasesToRun?: Models.Database[]);
     run(): Promise<void>;
+    updateOthersToFinalData(updatedDb: Models.Database, targetDb: Models.Database): Promise<void>;
     importCollections(db: ConfigDatabase, dataLoader: DataLoader): Promise<void>;
     executePostImportActions(dbId: string, dataLoader: DataLoader): Promise<void>;
 }

package/dist/migrations/importController.js

@@ -1,12 +1,13 @@
-import { ID, Query, } from "node-appwrite";
+import { AppwriteException, ID, Query, } from "node-appwrite";
 import _ from "lodash";
-import { areCollectionNamesSame } from "../utils/index.js";
+import { areCollectionNamesSame, tryAwaitWithRetry } from "../utils/index.js";
 import { resolveAndUpdateRelationships } from "./relationships.js";
 import { UsersController } from "./users.js";
 import { logger } from "./logging.js";
 import { updateOperation } from "./migrationHelper.js";
 import { BatchSchema, OperationCreateSchema, OperationSchema, } from "./backup.js";
 import { DataLoader } from "./dataLoader.js";
+import { transferDatabaseLocalToLocal, transferStorageLocalToLocal, } from "./transfer.js";
 export class ImportController {
     config;
     database;
@@ -16,8 +17,10 @@ export class ImportController {
     setupOptions;
     documentCache;
     batchLimit = 25; // Define batch size limit
+    hasImportedUsers = false;
     postImportActionsQueue = [];
-    constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions) {
+    databasesToRun;
+    constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions, databasesToRun) {
         this.config = config;
         this.database = database;
         this.storage = storage;
@@ -25,43 +28,54 @@ export class ImportController {
         this.importDataActions = importDataActions;
         this.setupOptions = setupOptions;
         this.documentCache = new Map();
+        this.databasesToRun = databasesToRun || [];
     }
     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)) {
+        let databasesToProcess;
+        if (this.databasesToRun.length > 0) {
+            // Use the provided databases
+            databasesToProcess = this.databasesToRun;
+        }
+        else {
+            // If no databases are specified, fetch all databases
+            const allDatabases = await this.database.list();
+            databasesToProcess = allDatabases.databases;
+        }
+        let dataLoader;
+        let databaseRan;
+        for (let db of databasesToProcess) {
+            if (db.name.toLowerCase().trim().replace(" ", "") === "migrations") {
                 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);
-            const dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
-            await dataLoader.start(db.$id);
-            await this.importCollections(db, dataLoader);
-            await resolveAndUpdateRelationships(db.$id, this.database, this.config);
-            await this.executePostImportActions(db.$id, dataLoader);
+            if (!databaseRan) {
+                databaseRan = db;
+                dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
+                await dataLoader.start(db.$id);
+                await this.importCollections(db, dataLoader);
+                await resolveAndUpdateRelationships(db.$id, this.database, this.config);
+                await this.executePostImportActions(db.$id, dataLoader);
+            }
+            else if (databaseRan.$id !== db.$id) {
+                await this.updateOthersToFinalData(databaseRan, db);
+            }
             console.log(`---------------------------------`);
             console.log(`Finished import data for database: ${db.name}`);
             console.log(`---------------------------------`);
         }
     }
+    async updateOthersToFinalData(updatedDb, targetDb) {
+        await transferDatabaseLocalToLocal(this.database, updatedDb.$id, targetDb.$id);
+        // Find the corresponding database configs
+        const updatedDbConfig = this.config.databases.find((db) => db.$id === updatedDb.$id);
+        const targetDbConfig = this.config.databases.find((db) => db.$id === targetDb.$id);
+        // Transfer database-specific bucket if both databases have a bucket defined
+        if (updatedDbConfig?.bucket && targetDbConfig?.bucket) {
+            await transferStorageLocalToLocal(this.storage, updatedDbConfig.bucket.$id, targetDbConfig.bucket.$id);
+        }
+    }
     async importCollections(db, dataLoader) {
         if (!this.config.collections) {
             return;
@@ -71,7 +85,7 @@ export class ImportController {
                 dataLoader.getCollectionKey(collection.name);
             const importOperationId = dataLoader.collectionImportOperations.get(dataLoader.getCollectionKey(collection.name));
             const createBatches = (finalData) => {
-                let maxBatchLength = 50;
+                let maxBatchLength = 100;
                 const finalBatches = [];
                 for (let i = 0; i < finalData.length; i++) {
                     if (i % maxBatchLength === 0) {
@@ -81,49 +95,50 @@ export class ImportController {
                 }
                 return finalBatches;
             };
-            if (isUsersCollection) {
+            if (isUsersCollection && !this.hasImportedUsers) {
                 const usersDataMap = dataLoader.importMap.get(dataLoader.getCollectionKey("users"));
                 const usersData = usersDataMap?.data;
                 const usersController = new UsersController(this.config, this.database);
                 if (usersData) {
-                    console.log("Found users data");
-                    const userBatchesAll = createBatches(usersData);
-                    console.log(`${userBatchesAll.length} user batches`);
-                    for (let i = 0; i < userBatchesAll.length; i++) {
-                        const userBatches = userBatchesAll[i];
-                        console.log(`Processing user batch ${i + 1} of ${userBatchesAll.length}`);
-                        const userBatchPromises = userBatches
-                            .map((userBatch) => {
-                            if (userBatch.finalData && userBatch.finalData.length > 0) {
-                                const userId = userBatch.finalData.userId;
-                                if (dataLoader.userExistsMap.has(userId)) {
-                                    // We only are storing the existing user ID's as true, so we need to check for that
-                                    if (!(dataLoader.userExistsMap.get(userId) === true)) {
-                                        const userId = userBatch.finalData.userId ||
-                                            userBatch.context.userId ||
-                                            userBatch.context.docId;
-                                        if (!userBatch.finalData.userId) {
-                                            userBatch.finalData.userId = userId;
-                                        }
-                                        return usersController
-                                            .createUserAndReturn(userBatch.finalData)
-                                            .then(() => console.log("Created user"))
-                                            .catch((error) => {
-                                            logger.error("Error creating user:", error, "\nUser data is ", userBatch.finalData);
-                                        });
-                                    }
-                                    else {
-                                        console.log("Skipped existing user: ", userId);
-                                        return Promise.resolve();
-                                    }
-                                }
+                    console.log("Found users data", usersData.length);
+                    const userDataBatches = createBatches(usersData);
+                    for (const batch of userDataBatches) {
+                        console.log("Importing users batch", batch.length);
+                        const userBatchPromises = batch
+                            .filter((item) => {
+                            let itemId;
+                            if (item.finalData.userId) {
+                                itemId = item.finalData.userId;
+                            }
+                            else if (item.finalData.docId) {
+                                itemId = item.finalData.docId;
                             }
+                            if (!itemId) {
+                                return false;
+                            }
+                            return (item &&
+                                item.finalData &&
+                                !dataLoader.userExistsMap.has(itemId));
                         })
-                            .flat();
-                        // Wait for all promises in the current user batch to resolve
-                        await Promise.allSettled(userBatchPromises);
-                        console.log(`Completed user batch ${i + 1} of ${userBatchesAll.length}`);
+                            .map((item) => {
+                            dataLoader.userExistsMap.set(item.finalData.userId ||
+                                item.finalData.docId ||
+                                item.context.userId ||
+                                item.context.docId, true);
+                            return usersController.createUserAndReturn(item.finalData);
+                        });
+                        const promiseResults = await Promise.allSettled(userBatchPromises);
+                        for (const item of batch) {
+                            if (item && item.finalData) {
+                                dataLoader.userExistsMap.set(item.finalData.userId ||
+                                    item.finalData.docId ||
+                                    item.context.userId ||
+                                    item.context.docId, true);
+                            }
+                        }
+                        console.log("Finished importing users batch");
                     }
+                    this.hasImportedUsers = true;
                     console.log("Finished importing users");
                 }
             }
@@ -136,6 +151,7 @@ export class ImportController {
                 status: "in_progress",
             });
             const collectionData = dataLoader.importMap.get(dataLoader.getCollectionKey(collection.name));
+            console.log(`Processing collection: ${collection.name}...`);
             if (!collectionData) {
                 console.log("No collection data for ", collection.name);
                 continue;
@@ -145,34 +161,55 @@ export class ImportController {
             for (let i = 0; i < dataSplit.length; i++) {
                 const batches = dataSplit[i];
                 console.log(`Processing batch ${i + 1} of ${dataSplit.length}`);
-                const batchPromises = batches.map((item) => {
-                    const id = item.context.docId ||
-                        item.context.userId ||
-                        item.finalData.docId ||
-                        item.finalData.userId;
-                    if (item.finalData.hasOwnProperty("userId")) {
-                        delete item.finalData.userId;
-                    }
-                    if (item.finalData.hasOwnProperty("docId")) {
-                        delete item.finalData.docId;
+                // const documentExistsPromises = batches.map(async (item) => {
+                //   try {
+                //     const id =
+                //       item.finalData.docId ||
+                //       item.finalData.userId ||
+                //       item.context.docId ||
+                //       item.context.userId;
+                //     if (!item.finalData) {
+                //       return Promise.resolve(null);
+                //     }
+                //     return tryAwaitWithRetry(
+                //       async () =>
+                //         await documentExists(
+                //           this.database,
+                //           db.$id,
+                //           collection.$id,
+                //           item.finalData
+                //         )
+                //     );
+                //   } catch (error) {
+                //     console.error(error);
+                //     return Promise.resolve(null);
+                //   }
+                // });
+                // const documentExistsResults = await Promise.all(documentExistsPromises);
+                const batchPromises = batches.map((item, index) => {
+                    try {
+                        const id = item.finalData.docId ||
+                            item.finalData.userId ||
+                            item.context.docId ||
+                            item.context.userId;
+                        if (item.finalData.hasOwnProperty("userId")) {
+                            delete item.finalData.userId;
+                        }
+                        if (item.finalData.hasOwnProperty("docId")) {
+                            delete item.finalData.docId;
+                        }
+                        if (!item.finalData) {
+                            return Promise.resolve();
+                        }
+                        return tryAwaitWithRetry(async () => await this.database.createDocument(db.$id, collection.$id, id, item.finalData));
                     }
-                    if (!item.finalData) {
+                    catch (error) {
+                        console.error(error);
                         return Promise.resolve();
                     }
-                    return this.database
-                        .createDocument(db.$id, collection.$id, id, item.finalData)
-                        .then(() => {
-                        processedItems++;
-                        console.log("Created item");
-                    })
-                        .catch((error) => {
-                        console.error(`Error creating item in ${collection.name}:`, error, "\nItem data is ", item.finalData);
-                        throw error;
-                        // Optionally, log the failed item for retry or review
-                    });
                 });
                 // Wait for all promises in the current batch to resolve
-                await Promise.allSettled(batchPromises);
+                await Promise.all(batchPromises);
                 console.log(`Completed batch ${i + 1} of ${dataSplit.length}`);
                 await updateOperation(this.database, importOperation.$id, {
                     progress: processedItems,

package/dist/migrations/importDataActions.d.ts

@@ -11,16 +11,24 @@ export declare class ImportDataActions {
     private validityRuleDefinitions;
     private afterImportActionsDefinitions;
     constructor(db: Databases, storage: Storage, config: AppwriteConfig, converterDefinitions: ConverterFunctions, validityRuleDefinitions: ValidationRules, afterImportActionsDefinitions: AfterImportActions);
+    /**
+     * Runs converter functions on the item based on the provided attribute mappings.
+     *
+     * @param item - The item to be transformed.
+     * @param attributeMappings - The mappings that define how each attribute should be transformed.
+     * @returns The transformed item.
+     */
     runConverterFunctions(item: any, attributeMappings: AttributeMappings): any;
     /**
      * Validates a single data item based on defined validation rules.
      * @param item The data item to validate.
+     * @param attributeMap The attribute mappings for the data item.
      * @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>;
+    }): boolean;
     executeAfterImportActions(item: any, attributeMap: AttributeMappings, context: {
         [key: string]: any;
     }): Promise<void>;

package/dist/migrations/importDataActions.js

@@ -1,10 +1,11 @@
-import { ID, InputFile, Query, } from "node-appwrite";
+import {} from "node-appwrite";
 import { validationRules, } from "appwrite-utils";
 import { converterFunctions } from "appwrite-utils";
 import { convertObjectBySchema } from "./converters.js";
 import {} from "appwrite-utils";
 import { afterImportActions } from "./afterImportActions.js";
 import { logger } from "./logging.js";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 export class ImportDataActions {
     db;
     storage;
@@ -20,9 +21,19 @@ export class ImportDataActions {
         this.validityRuleDefinitions = validityRuleDefinitions;
         this.afterImportActionsDefinitions = afterImportActionsDefinitions;
     }
+    /**
+     * Runs converter functions on the item based on the provided attribute mappings.
+     *
+     * @param item - The item to be transformed.
+     * @param attributeMappings - The mappings that define how each attribute should be transformed.
+     * @returns The transformed item.
+     */
     runConverterFunctions(item, attributeMappings) {
         const conversionSchema = attributeMappings.reduce((schema, mapping) => {
             schema[mapping.targetKey] = (originalValue) => {
+                if (!mapping.converters) {
+                    return originalValue;
+                }
                 return mapping.converters?.reduce((value, converterName) => {
                     let shouldProcessAsArray = false;
                     if ((converterName.includes("[Arr]") ||
@@ -65,10 +76,11 @@ export class ImportDataActions {
     /**
      * Validates a single data item based on defined validation rules.
      * @param item The data item to validate.
+     * @param attributeMap The attribute mappings for the data item.
      * @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) {
+    validateItem(item, attributeMap, context) {
         for (const mapping of attributeMap) {
             const { validationActions } = mapping;
             if (!validationActions ||
@@ -111,7 +123,7 @@ export class ImportDataActions {
                 const { action, params } = actionDef;
                 console.log(`Executing post-import action '${action}' for attribute '${mapping.targetKey}' with params ${params.join(", ")}...`);
                 try {
-                    await this.executeAction(action, params, context, item);
+                    await tryAwaitWithRetry(async () => await this.executeAction(action, params, context, item));
                 }
                 catch (error) {
                     logger.error(`Failed to execute post-import action '${action}' for attribute '${mapping.targetKey}':`, error);

package/dist/migrations/indexes.js

@@ -1,5 +1,6 @@
 import { indexSchema } from "appwrite-utils";
-import { Databases, Query } from "node-appwrite";
+import { Databases, IndexType, Query } from "node-appwrite";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 // import {}
 export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {
     const existingIndex = await db.listIndexes(dbId, collectionId, [
@@ -13,6 +14,6 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {
 };
 export const createOrUpdateIndexes = async (dbId, db, collectionId, indexes) => {
     for (const index of indexes) {
-        await createOrUpdateIndex(dbId, db, collectionId, index);
+        await tryAwaitWithRetry(async () => await createOrUpdateIndex(dbId, db, collectionId, index));
     }
 };

package/dist/migrations/logging.js

@@ -1,15 +1,27 @@
 import winston from "winston";
+import fs from "fs";
+import path from "path";
+// Ensure the logs directory exists
+const logDir = path.join(process.cwd(), "zlogs");
+if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir);
+}
 export const logger = winston.createLogger({
-    level: "info",
+    level: "debug",
     format: winston.format.json({ space: 2 }),
     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: "warn.log", level: "warn" }),
-        new winston.transports.File({ filename: "combined.log" }),
+        new winston.transports.File({
+            filename: path.join(logDir, "error.log"),
+            level: "error",
+        }),
+        new winston.transports.File({
+            filename: path.join(logDir, "warn.log"),
+            level: "warn",
+        }),
+        new winston.transports.File({
+            filename: path.join(logDir, "info.log"),
+            level: "info",
+        }),
     ],
 });

package/dist/migrations/migrationHelper.d.ts

@@ -19,6 +19,7 @@ export declare const ContextObject: z.ZodObject<{
         oldKey: z.ZodOptional<z.ZodString>;
         oldKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         targetKey: z.ZodString;
+        valueToSet: z.ZodOptional<z.ZodAny>;
         fileData: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             path: z.ZodString;
@@ -54,6 +55,7 @@ export declare const ContextObject: z.ZodObject<{
         targetKey: string;
         oldKey?: string | undefined;
         oldKeys?: string[] | undefined;
+        valueToSet?: any;
         fileData?: {
             path: string;
             name: string;
@@ -71,6 +73,7 @@ export declare const ContextObject: z.ZodObject<{
         targetKey: string;
         oldKey?: string | undefined;
         oldKeys?: string[] | undefined;
+        valueToSet?: any;
         fileData?: {
             path: string;
             name: string;
@@ -93,6 +96,7 @@ export declare const ContextObject: z.ZodObject<{
         targetKey: string;
         oldKey?: string | undefined;
         oldKeys?: string[] | undefined;
+        valueToSet?: any;
         fileData?: {
             path: string;
             name: string;
@@ -107,8 +111,8 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
-    finalItem?: any;
     context?: any;
+    finalItem?: any;
 }, {
     collectionId: string;
     dbId: string;
@@ -116,6 +120,7 @@ export declare const ContextObject: z.ZodObject<{
         targetKey: string;
         oldKey?: string | undefined;
         oldKeys?: string[] | undefined;
+        valueToSet?: any;
         fileData?: {
             path: string;
             name: string;
@@ -130,18 +135,18 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
-    finalItem?: any;
     context?: any;
+    finalItem?: any;
 }>;
 export type ContextObject = z.infer<typeof ContextObject>;
 export declare const createOrFindAfterImportOperation: (database: Databases, collectionId: string, context: ContextObject) => Promise<void>;
 export declare const addBatch: (database: Databases, data: string) => Promise<string>;
 export declare const getAfterImportOperations: (database: Databases, collectionId: string) => Promise<{
-    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
     status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
+    error: string;
     collectionId: string;
     operationType: string;
     progress: number;
@@ -150,11 +155,11 @@ export declare const getAfterImportOperations: (database: Databases, collectionI
     batches?: string[] | undefined;
 }[]>;
 export declare const findOrCreateOperation: (database: Databases, collectionId: string, operationType: string, additionalQueries?: string[]) => Promise<{
-    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
     status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
+    error: string;
     collectionId: string;
     operationType: string;
     progress: number;

package/dist/migrations/migrationHelper.js

@@ -3,6 +3,7 @@ import { BatchSchema, OperationSchema } from "./backup.js";
 import { AttributeMappingsSchema } from "appwrite-utils";
 import { z } from "zod";
 import { logger } from "./logging.js";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions
@@ -66,18 +67,18 @@ export const getAfterImportOperations = async (database, collectionId) => {
     return allOps;
 };
 export const findOrCreateOperation = async (database, collectionId, operationType, additionalQueries) => {
-    const operations = await database.listDocuments("migrations", "currentOperations", [
+    const operations = await tryAwaitWithRetry(async () => await database.listDocuments("migrations", "currentOperations", [
         Query.equal("collectionId", collectionId),
         Query.equal("operationType", operationType),
         Query.equal("status", "pending"),
         ...(additionalQueries || []),
-    ]);
+    ]));
     if (operations.documents.length > 0) {
         return OperationSchema.parse(operations.documents[0]); // Assuming the first document is the operation we want
     }
     else {
         // Create a new operation document
-        const op = await database.createDocument("migrations", "currentOperations", ID.unique(), {
+        const op = await tryAwaitWithRetry(async () => await database.createDocument("migrations", "currentOperations", ID.unique(), {
             operationType,
             collectionId,
             status: "pending",
@@ -85,12 +86,12 @@ export const findOrCreateOperation = async (database, collectionId, operationTyp
             progress: 0,
             total: 0,
             error: "",
-        });
+        }));
         return OperationSchema.parse(op);
     }
 };
 export const updateOperation = async (database, operationId, updateFields) => {
-    await database.updateDocument("migrations", "currentOperations", operationId, updateFields);
+    await tryAwaitWithRetry(async () => await database.updateDocument("migrations", "currentOperations", operationId, updateFields));
 };
 // Actual max 1073741824
 export const maxDataLength = 1073741820;

package/dist/migrations/openapi.d.ts

@@ -1,4 +1,4 @@
 import { type AppwriteConfig } from "appwrite-utils";
 import { z } from "zod";
 export declare const generateOpenApi: (config: AppwriteConfig) => Promise<void>;
-export declare function transformTypeToOpenApi<T extends z.ZodTypeAny>(schema: T): z.infer<T>;
+export declare function transformTypeToOpenApi<T extends z.ZodTypeAny>(schema: T, description?: string | Record<string, any> | null | undefined): T;