appwrite-utils-cli 0.0.37 → 0.0.39

package/dist/migrations/dataLoader.js

@@ -65,6 +65,7 @@ export class DataLoader {
      * It iterates through the target object's keys and updates the source object if:
      * - The source object has the key.
      * - The target object's value for that key is not null, undefined, or an empty string.
+     * - If the target object has an array value, it concatenates the values and removes duplicates.
      *
      * @param source - The source object to be updated.
      * @param target - The target object with values to update the source object.
@@ -73,29 +74,51 @@ export class DataLoader {
     mergeObjects(source, update) {
         // Create a new object to hold the merged result
         const result = { ...source };
-        Object.keys(update).forEach((key) => {
-            const sourceValue = source[key];
-            const updateValue = update[key];
-            // If the update value is an array, concatenate and remove duplicates
-            if (Array.isArray(updateValue)) {
-                const sourceArray = Array.isArray(sourceValue) ? sourceValue : [];
-                result[key] = [...new Set([...sourceArray, ...updateValue])];
-            }
-            // If the update value is an object, recursively merge
-            else if (updateValue !== null &&
-                typeof updateValue === "object" &&
-                !(updateValue instanceof Date)) {
-                result[key] = this.mergeObjects(sourceValue, updateValue);
-            }
-            // If the update value is not nullish, overwrite the source value
-            else if (updateValue !== null && updateValue !== undefined) {
-                result[key] = updateValue;
-            }
-            // If the update value is nullish, keep the original value unless it doesn't exist
-            else if (sourceValue === undefined || sourceValue === null) {
-                result[key] = updateValue;
+        // Loop through the keys of the object we care about
+        for (const [key, value] of Object.entries(source)) {
+            // Check if the key exists in the target object
+            if (!Object.hasOwn(update, key)) {
+                // If the key doesn't exist, we can just skip it like bad cheese
+                continue;
             }
-        });
+            if (update[key] === value) {
+                continue;
+            }
+            // If the value ain't here, we can just do whatever man
+            if (value === undefined || value === null || value === "") {
+                // If the update key is defined
+                if (update[key] !== undefined &&
+                    update[key] !== null &&
+                    update[key] !== "") {
+                    // might as well use it eh?
+                    result[key] = update[key];
+                }
+                // ELSE if the value is an array, because it would then not be === to those things above
+            }
+            else if (Array.isArray(value)) {
+                // Get the update value
+                const updateValue = update[key];
+                // If the update value is an array, concatenate and remove duplicates
+                // and poopy data
+                if (Array.isArray(updateValue)) {
+                    result[key] = [...new Set([...value, ...updateValue])].filter((item) => item !== null && item !== undefined && item !== "");
+                }
+                else {
+                    // If the update value is not an array, just use it
+                    result[key] = [...value, updateValue].filter((item) => item !== null && item !== undefined && item !== "");
+                }
+            }
+            else if (typeof value === "object") {
+                // If the value is an object, we need to merge it
+                if (typeof update[key] === "object") {
+                    result[key] = this.mergeObjects(value, update[key]);
+                }
+            }
+            else {
+                // Finally, the source value is defined, and not an array, so we don't care about the update value
+                continue;
+            }
+        }
         return result;
     }
     // Method to load data from a file specified in the import definition
@@ -125,8 +148,19 @@ export class DataLoader {
     // Method to generate a unique ID that doesn't conflict with existing IDs
     getTrueUniqueId(collectionName) {
         let newId = ID.unique();
-        while (this.checkMapValuesForId(newId, collectionName)) {
+        let condition = this.checkMapValuesForId(newId, collectionName) ||
+            this.userExistsMap.has(newId) ||
+            this.importMap
+                .get(this.getCollectionKey("users"))
+                ?.data.some((user) => user.finalData.docId === newId || user.finalData.userId === newId);
+        while (condition) {
             newId = ID.unique();
+            condition =
+                this.checkMapValuesForId(newId, collectionName) ||
+                    this.userExistsMap.has(newId) ||
+                    this.importMap
+                        .get(this.getCollectionKey("users"))
+                        ?.data.some((user) => user.finalData.docId === newId || user.finalData.userId === newId);
         }
         return newId;
     }
@@ -153,6 +187,9 @@ export class DataLoader {
     transformData(item, attributeMappings) {
         // Convert the item using the attribute mappings provided
         const convertedItem = convertObjectByAttributeMappings(item, attributeMappings);
+        if (item["region"]) {
+            logger.info(`Converted item: ${JSON.stringify(convertedItem, null, 2)}`);
+        }
         // Run additional converter functions on the converted item, if any
         return this.importDataActions.runConverterFunctions(convertedItem, attributeMappings);
     }
@@ -209,6 +246,21 @@ export class DataLoader {
                 this.phoneToUserIdMap.set(user.phone, user.$id);
             }
             this.userExistsMap.set(user.$id, true);
+            let importData = this.importMap.get(this.getCollectionKey("users"));
+            if (!importData) {
+                importData = {
+                    data: [],
+                };
+            }
+            importData.data.push({
+                finalData: {
+                    ...user,
+                    userId: user.$id,
+                    docId: user.$id,
+                },
+                rawData: user,
+            });
+            this.importMap.set(this.getCollectionKey("users"), importData);
         }
         return allUsers;
     }
@@ -262,7 +314,7 @@ export class DataLoader {
                 }
             }
             console.log("Running update references");
-            this.dealWithMergedUsers();
+            // this.dealWithMergedUsers();
             this.updateOldReferencesForNew();
             console.log("Done running update references");
         }
@@ -280,8 +332,11 @@ export class DataLoader {
         const usersCollectionKey = this.getCollectionKey(this.config.usersCollectionName);
         const usersCollectionPrimaryKeyFields = new Set();
         if (!this.config.collections) {
+            console.log("No collections found in configuration.");
             return;
         }
+        let needsUpdate = false;
+        let numUpdates = 0;
         // Collect primary key fields from the users collection definitions
         this.config.collections.forEach((collection) => {
             if (this.getCollectionKey(collection.name) === usersCollectionKey) {
@@ -296,37 +351,61 @@ export class DataLoader {
                 });
             }
         });
+        console.log(`Primary key fields collected for users collection: ${[
+            ...usersCollectionPrimaryKeyFields,
+        ]}`);
         // Iterate over all collections to update references based on merged users
         this.config.collections.forEach((collection) => {
             const collectionData = this.importMap.get(this.getCollectionKey(collection.name));
-            if (!collectionData || !collectionData.data)
+            if (!collectionData || !collectionData.data) {
+                console.log(`No data found for collection ${collection.name}`);
                 return;
+            }
             const collectionImportDefs = collection.importDefs;
             if (!collectionImportDefs || !collectionImportDefs.length) {
+                console.log(`No import definitions found for collection ${collection.name}`);
                 return;
             }
             collectionImportDefs.forEach((importDef) => {
                 importDef.idMappings?.forEach((idMapping) => {
                     if (this.getCollectionKey(idMapping.targetCollection) ===
                         usersCollectionKey) {
+                        const fieldToSetKey = idMapping.fieldToSet || idMapping.sourceField;
                         const targetFieldKey = idMapping.targetFieldToMatch || idMapping.targetField;
                         if (usersCollectionPrimaryKeyFields.has(targetFieldKey)) {
+                            console.log(`Processing collection ${collection.name} with target field ${targetFieldKey}`);
                             // Process each item in the collection
                             collectionData.data.forEach((item) => {
-                                const oldId = item.context[idMapping.sourceField];
+                                const oldId = item.finalData[idMapping.sourceField] ||
+                                    item.context[idMapping.sourceField];
+                                if (oldId === undefined || oldId === null) {
+                                    console.log(`Skipping item with undefined or null oldId in collection ${collection.name}`);
+                                    return;
+                                }
                                 const newId = this.mergedUserMap.get(`${oldId}`);
                                 if (newId) {
+                                    needsUpdate = true;
+                                    numUpdates++;
+                                    console.log(`Updating old ID ${oldId} to new ID ${newId} in collection ${collection.name}`);
                                     // Update context to use new user ID
-                                    item.finalData[idMapping.fieldToSet || idMapping.sourceField] = newId;
+                                    item.finalData[fieldToSetKey] = newId;
+                                    item.context[fieldToSetKey] = newId;
+                                }
+                                else {
+                                    console.log(`No new ID found for old ID ${oldId} in mergedUserMap.`);
                                 }
                             });
                         }
                     }
                 });
             });
+            if (needsUpdate) {
+                console.log(`Updated ${numUpdates} references for collection ${collection.name}`);
+                this.importMap.set(this.getCollectionKey(collection.name), collectionData);
+            }
         });
     }
-    async updateOldReferencesForNew() {
+    updateOldReferencesForNew() {
         if (!this.config.collections) {
             return;
         }
@@ -348,7 +427,9 @@ export class DataLoader {
                                 const targetFieldKey = idMapping.targetFieldToMatch || idMapping.targetField;
                                 const valueToMatch = collectionData.data[i].context[idMapping.sourceField];
                                 // Skip if value to match is missing or empty
-                                if (!valueToMatch || _.isEmpty(valueToMatch))
+                                if (!valueToMatch ||
+                                    _.isEmpty(valueToMatch) ||
+                                    valueToMatch === null)
                                     continue;
                                 const isFieldToSetArray = collectionConfig.attributes.find((attribute) => attribute.key === fieldToSetKey)?.array;
                                 const targetCollectionData = this.importMap.get(targetCollectionKey);
@@ -467,7 +548,7 @@ export class DataLoader {
      * @param attributeMappings - The attribute mappings for the item.
      * @returns The transformed item with user-specific keys removed.
      */
-    async prepareUserData(item, attributeMappings, primaryKeyField, newId) {
+    prepareUserData(item, attributeMappings, primaryKeyField, newId) {
         let transformedItem = this.transformData(item, attributeMappings);
         const userData = AuthUserCreateSchema.safeParse(transformedItem);
         if (!userData.success) {
@@ -515,15 +596,23 @@ export class DataLoader {
             });
             if (userFound) {
                 userFound.finalData.userId = existingId;
+                userFound.finalData.docId = existingId;
+                this.userExistsMap.set(existingId, true);
             }
-            return [
+            const userKeys = ["email", "phone", "name", "labels", "prefs"];
+            userKeys.forEach((key) => {
+                if (transformedItem.hasOwnProperty(key)) {
+                    delete transformedItem[key];
+                }
+            });
+            return {
                 transformedItem,
                 existingId,
-                {
+                userData: {
                     rawData: userFound?.rawData,
                     finalData: userFound?.finalData,
                 },
-            ];
+            };
         }
         else {
             existingId = newId;
@@ -543,7 +632,11 @@ export class DataLoader {
         this.importMap.set(this.getCollectionKey("users"), {
             data: [...(usersMap?.data || []), userDataToAdd],
         });
-        return [transformedItem, existingId, userDataToAdd];
+        return {
+            transformedItem,
+            existingId,
+            userData: userDataToAdd,
+        };
     }
     /**
      * Prepares the data for creating user collection documents.
@@ -588,7 +681,7 @@ export class DataLoader {
         // Iterate through each item in the raw data
         for (const item of rawData) {
             // Prepare user data, check for duplicates, and remove user-specific keys
-            let [transformedItem, existingId, userData] = await this.prepareUserData(item, importDef.attributeMappings, importDef.primaryKeyField, this.getTrueUniqueId(this.getCollectionKey("users")));
+            let { transformedItem, existingId, userData } = this.prepareUserData(item, importDef.attributeMappings, importDef.primaryKeyField, this.getTrueUniqueId(this.getCollectionKey("users")));
             logger.info(`In create user -- transformedItem: ${JSON.stringify(transformedItem, null, 2)}`);
             // Generate a new unique ID for the item or use existing ID
             if (!existingId) {
@@ -620,15 +713,22 @@ export class DataLoader {
                     collectionOldIdToNewIdMap?.set(`${oldId}`, `${existingId}`);
                 }
             }
-            // Merge the final user data into the context
-            context = { ...context, ...userData.finalData };
             // Handle merging for currentUserData
             for (let i = 0; i < currentUserData.data.length; i++) {
-                if ((currentUserData.data[i].finalData.docId === existingId ||
-                    currentUserData.data[i].finalData.userId === existingId) &&
-                    !_.isEqual(currentUserData.data[i], userData)) {
-                    this.mergeObjects(currentUserData.data[i].finalData, userData.finalData);
-                    console.log("Merging user data", currentUserData.data[i].finalData);
+                const currentUserDataItem = currentUserData.data[i];
+                const samePhones = currentUserDataItem.finalData.phone &&
+                    transformedItem.phone &&
+                    currentUserDataItem.finalData.phone === transformedItem.phone;
+                const sameEmails = currentUserDataItem.finalData.email &&
+                    transformedItem.email &&
+                    currentUserDataItem.finalData.email === transformedItem.email;
+                if ((currentUserDataItem.finalData.docId === existingId ||
+                    currentUserDataItem.finalData.userId === existingId) &&
+                    (samePhones || sameEmails) &&
+                    currentUserDataItem.finalData &&
+                    userData.finalData) {
+                    const userDataMerged = this.mergeObjects(currentUserData.data[i].finalData, userData.finalData);
+                    currentUserData.data[i].finalData = userDataMerged;
                     this.importMap.set(this.getCollectionKey("users"), currentUserData);
                 }
             }
@@ -691,16 +791,23 @@ export class DataLoader {
                 .set(this.getCollectionKey(collection.name), oldIdToNewIdMapNew)
                 .get(this.getCollectionKey(collection.name));
         console.log(`${collection.name} -- collectionOldIdToNewIdMap: ${collectionOldIdToNewIdMap}`);
+        const isRegions = collection.name.toLowerCase() === "regions";
         // Iterate through each item in the raw data
         for (const item of rawData) {
             // Generate a new unique ID for the item
             const itemIdNew = this.getTrueUniqueId(this.getCollectionKey(collection.name));
+            if (isRegions) {
+                logger.info(`Creating region: ${JSON.stringify(item, null, 2)}`);
+            }
             // Retrieve the current collection data from the import map
             const currentData = this.importMap.get(this.getCollectionKey(collection.name));
             // Create a context object for the item, including the new ID
             let context = this.createContext(db, collection, item, itemIdNew);
             // Transform the item data based on the attribute mappings
             const transformedData = this.transformData(item, importDef.attributeMappings);
+            if (isRegions) {
+                logger.info(`Transformed region: ${JSON.stringify(transformedData, null, 2)}`);
+            }
             // If a primary key field is defined, handle the ID mapping and check for duplicates
             if (importDef.primaryKeyField) {
                 const oldId = item[importDef.primaryKeyField];
@@ -713,7 +820,7 @@ export class DataLoader {
             // Merge the transformed data into the context
             context = { ...context, ...transformedData };
             // Validate the item before proceeding
-            const isValid = await this.importDataActions.validateItem(transformedData, importDef.attributeMappings, context);
+            const isValid = this.importDataActions.validateItem(transformedData, importDef.attributeMappings, context);
             if (!isValid) {
                 continue;
             }
@@ -751,7 +858,7 @@ export class DataLoader {
      * @param collection - The collection configuration.
      * @param importDef - The import definition containing the attribute mappings and other relevant info.
      */
-    async prepareUpdateData(db, collection, importDef) {
+    prepareUpdateData(db, collection, importDef) {
         // Retrieve the current collection data and old-to-new ID map from the import map
         const currentData = this.importMap.get(this.getCollectionKey(collection.name));
         const oldIdToNewIdMap = this.oldIdToNewIdPerCollectionMap.get(this.getCollectionKey(collection.name));
@@ -773,12 +880,7 @@ export class DataLoader {
             let newId;
             let oldId;
             // Determine the new ID for the item based on the primary key field or update mapping
-            if (importDef.primaryKeyField) {
-                oldId = item[importDef.primaryKeyField];
-            }
-            else if (importDef.updateMapping) {
-                oldId = item[importDef.updateMapping.originalIdField];
-            }
+            oldId = item[importDef.primaryKeyField];
             if (oldId) {
                 newId = oldIdToNewIdMap?.get(`${oldId}`);
                 if (!newId &&
@@ -796,24 +898,31 @@ export class DataLoader {
                 logger.error(`No old ID found (to update another document with) in prepareUpdateData for ${collection.name}, ${JSON.stringify(item, null, 2)}`);
                 continue;
             }
+            const itemDataToUpdate = this.importMap
+                .get(this.getCollectionKey(collection.name))
+                ?.data.find((data) => `${data.context[importDef.primaryKeyField]}` === `${oldId}`);
             // Log an error and continue to the next item if no new ID is found
-            if (!newId) {
+            if (!newId && !itemDataToUpdate) {
                 logger.error(`No new id found for collection ${collection.name} for updateDef ${JSON.stringify(item, null, 2)} but it says it's supposed to have one...`);
                 continue;
             }
-            const itemDataToUpdate = this.importMap
-                .get(this.getCollectionKey(collection.name))
-                ?.data.find((data) => data.rawData[importDef.primaryKeyField] === oldId);
-            if (!itemDataToUpdate) {
-                logger.error(`No data found for collection ${collection.name} for updateDef ${JSON.stringify(item, null, 2)} but it says it's supposed to have one...`);
+            else if (itemDataToUpdate) {
+                newId = itemDataToUpdate.finalData.docId;
+                if (!newId) {
+                    logger.error(`No new id found for collection ${collection.name} for updateDef ${JSON.stringify(item, null, 2)} but it says it's supposed to have one...`);
+                    continue;
+                }
+            }
+            if (!itemDataToUpdate || !newId) {
+                logger.error(`No data or ID (docId) found for collection ${collection.name} for updateDef ${JSON.stringify(item, null, 2)} but it says it's supposed to have one...`);
                 continue;
             }
             transformedData = this.mergeObjects(itemDataToUpdate.finalData, transformedData);
             // Create a context object for the item, including the new ID and transformed data
             let context = this.createContext(db, collection, item, newId);
-            context = this.mergeObjects(context, transformedData);
+            context = { ...context, ...transformedData };
             // Validate the item before proceeding
-            const isValid = await this.importDataActions.validateItem(item, importDef.attributeMappings, context);
+            const isValid = this.importDataActions.validateItem(item, importDef.attributeMappings, context);
             // Log info and continue to the next item if it's invalid
             if (!isValid) {
                 logger.info(`Skipping item: ${JSON.stringify(item, null, 2)} because it's invalid`);
@@ -832,6 +941,7 @@ export class DataLoader {
                 itemDataToUpdate.finalData = this.mergeObjects(itemDataToUpdate.finalData, transformedData);
                 itemDataToUpdate.context = context;
                 itemDataToUpdate.importDef = newImportDef;
+                currentData.data.push(itemDataToUpdate);
             }
             else {
                 // If no existing item matches, then add the new item

package/dist/migrations/databases.js

@@ -1,6 +1,7 @@
 import { Databases, Query } from "node-appwrite";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 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;
     let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
     if (databases.databases.length < 25) {

package/dist/migrations/importController.js

@@ -1,6 +1,6 @@
-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";
@@ -71,7 +71,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 = 25;
                 const finalBatches = [];
                 for (let i = 0; i < finalData.length; i++) {
                     if (i % maxBatchLength === 0) {
@@ -109,7 +109,7 @@ export class ImportController {
                             .map((item) => {
                             return usersController.createUserAndReturn(item.finalData);
                         });
-                        await Promise.all(userBatchPromises);
+                        const promiseResults = await Promise.allSettled(userBatchPromises);
                         for (const item of batch) {
                             if (item && item.finalData) {
                                 dataLoader.userExistsMap.set(item.finalData.userId ||
@@ -118,26 +118,8 @@ export class ImportController {
                                     item.context.docId, true);
                             }
                         }
-                        console.log("Finished importing users batch", batch.length);
+                        console.log("Finished importing users batch");
                     }
-                    // for (let i = 0; i < usersData.length; i++) {
-                    //   const user = usersData[i];
-                    //   if (user.finalData) {
-                    //     const userId =
-                    //       user.finalData.userId ||
-                    //       user.context.userId ||
-                    //       user.context.docId;
-                    //     if (!dataLoader.userExistsMap.has(userId)) {
-                    //       if (!user.finalData.userId) {
-                    //         user.finalData.userId = userId;
-                    //       }
-                    //       await usersController.createUserAndReturn(user.finalData);
-                    //       dataLoader.userExistsMap.set(userId, true);
-                    //     } else {
-                    //       console.log("Skipped existing user: ", userId);
-                    //     }
-                    //   }
-                    // }
                     console.log("Finished importing users");
                 }
             }
@@ -173,7 +155,7 @@ export class ImportController {
                     if (!item.finalData) {
                         return Promise.resolve();
                     }
-                    return this.database.createDocument(db.$id, collection.$id, id, item.finalData);
+                    return tryAwaitWithRetry(async () => await this.database.createDocument(db.$id, collection.$id, id, item.finalData));
                 });
                 // Wait for all promises in the current batch to resolve
                 await Promise.allSettled(batchPromises);

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

@@ -5,6 +5,7 @@ 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 { 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/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 "src/utils/helperFunctions.js";
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions
@@ -90,7 +91,7 @@ export const findOrCreateOperation = async (database, collectionId, operationTyp
     }
 };
 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/queue.js

@@ -2,6 +2,7 @@ import { Query } from "node-appwrite";
 import { createOrUpdateAttribute } from "./attributes.js";
 import _ from "lodash";
 import { fetchAndCacheCollectionByName } from "./collections.js";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();
 export const enqueueOperation = (operation) => {
@@ -24,7 +25,7 @@ export const processQueue = async (db, dbId) => {
                 if (operation.collectionId) {
                     console.log(`\tFetching collection by ID: ${operation.collectionId}`);
                     try {
-                        collectionFound = await db.getCollection(dbId, operation.collectionId);
+                        collectionFound = await tryAwaitWithRetry(async () => await db.getCollection(dbId, operation.collectionId));
                     }
                     catch (e) {
                         console.log(`\tCollection not found by ID: ${operation.collectionId}`);
@@ -47,7 +48,7 @@ export const processQueue = async (db, dbId) => {
                 // Handle non-relationship operations with a specified collectionId
                 console.log(`\tFetching collection by ID: ${operation.collectionId}`);
                 try {
-                    collectionFound = await db.getCollection(dbId, operation.collectionId);
+                    collectionFound = await tryAwaitWithRetry(async () => await db.getCollection(dbId, operation.collectionId));
                 }
                 catch (e) {
                     console.log(`\tCollection not found by ID: ${operation.collectionId}`);