appwrite-utils-cli 0.0.38 → 0.0.40

package/dist/migrations/converters.js

@@ -94,7 +94,12 @@ export const convertObjectByAttributeMappings = (obj, attributeMappings) => {
             const values = mapping.oldKeys
                 .map((oldKey) => resolveValue(obj, oldKey))
                 .flat(Infinity);
-            result[mapping.targetKey] = values.filter((value) => value !== undefined);
+            if (values.length > 0) {
+                result[mapping.targetKey] = values.filter((value) => value !== undefined);
+            }
+            else {
+                result[mapping.targetKey] = null;
+            }
         }
         else if (mapping.oldKey) {
             // Resolve single oldKey
@@ -104,6 +109,15 @@ export const convertObjectByAttributeMappings = (obj, attributeMappings) => {
                     ? value.flat(Infinity)
                     : value;
             }
+            else {
+                result[mapping.targetKey] = null;
+            }
+        }
+    }
+    // Ensure any keys in the original object that are not mapped are copied over
+    for (const key of Object.keys(obj)) {
+        if (!Object.keys(result).includes(key)) {
+            result[key] = obj[key];
         }
     }
     return result;

package/dist/migrations/dataLoader.d.ts

@@ -1747,7 +1747,7 @@ export declare class DataLoader {
      * @param collection - The collection configuration.
      * @param importDef - The import definition containing the attribute mappings and other relevant info.
      */
-    prepareUserCollectionCreateData(db: ConfigDatabase, collection: CollectionCreate, importDef: ImportDef): void;
+    prepareUserCollectionCreateData(db: ConfigDatabase, collection: CollectionCreate, importDef: ImportDef): Promise<void>;
     /**
      * Prepares the data for creating documents in a collection.
      * This involves loading the data, transforming it, and handling ID mappings.
@@ -1756,7 +1756,7 @@ export declare class DataLoader {
      * @param collection - The collection configuration.
      * @param importDef - The import definition containing the attribute mappings and other relevant info.
      */
-    prepareCreateData(db: ConfigDatabase, collection: CollectionCreate, importDef: ImportDef): void;
+    prepareCreateData(db: ConfigDatabase, collection: CollectionCreate, importDef: ImportDef): Promise<void>;
     /**
      * Prepares the data for updating documents within a collection.
      * This method loads the raw data based on the import definition, transforms it according to the attribute mappings,

package/dist/migrations/dataLoader.js

@@ -74,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
@@ -165,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);
     }
@@ -271,12 +296,12 @@ export class DataLoader {
                 for (const createDef of createDefs) {
                     if (!isUsersCollection) {
                         console.log(`${collection.name} is not users collection`);
-                        this.prepareCreateData(db, collection, createDef);
+                        await this.prepareCreateData(db, collection, createDef);
                     }
                     else {
                         // Special handling for users collection if needed
                         console.log(`${collection.name} is users collection`);
-                        this.prepareUserCollectionCreateData(db, collection, createDef);
+                        await this.prepareUserCollectionCreateData(db, collection, createDef);
                     }
                 }
                 for (const updateDef of updateDefs) {
@@ -285,7 +310,7 @@ export class DataLoader {
                         continue;
                     }
                     // Prepare the update data for the collection
-                    this.prepareUpdateData(db, collection, updateDef);
+                    await this.prepareUpdateData(db, collection, updateDef);
                 }
             }
             console.log("Running update references");
@@ -402,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);
@@ -620,7 +647,7 @@ export class DataLoader {
      * @param collection - The collection configuration.
      * @param importDef - The import definition containing the attribute mappings and other relevant info.
      */
-    prepareUserCollectionCreateData(db, collection, importDef) {
+    async prepareUserCollectionCreateData(db, collection, importDef) {
         // Load the raw data based on the import definition
         const rawData = this.loadData(importDef);
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
@@ -635,108 +662,107 @@ export class DataLoader {
         if (!operationId) {
             throw new Error(`No import operation found for collection ${collection.name}`);
         }
-        updateOperation(this.database, operationId, {
+        await updateOperation(this.database, operationId, {
             status: "ready",
             total: rawData.length,
-        }).then(() => {
-            // Retrieve the current user data and the current collection data from the import map
-            const currentUserData = this.importMap.get(this.getCollectionKey("users"));
-            const currentData = this.importMap.get(this.getCollectionKey(collection.name));
-            // Log errors if the necessary data is not found in the import map
-            if (!currentUserData) {
-                logger.error(`No data found for collection ${"users"} for createDef but it says it's supposed to have one...`);
-                return;
-            }
-            else if (!currentData) {
-                logger.error(`No data found for collection ${collection.name} for createDef but it says it's supposed to have one...`);
-                return;
+        });
+        // Retrieve the current user data and the current collection data from the import map
+        const currentUserData = this.importMap.get(this.getCollectionKey("users"));
+        const currentData = this.importMap.get(this.getCollectionKey(collection.name));
+        // Log errors if the necessary data is not found in the import map
+        if (!currentUserData) {
+            logger.error(`No data found for collection ${"users"} for createDef but it says it's supposed to have one...`);
+            return;
+        }
+        else if (!currentData) {
+            logger.error(`No data found for collection ${collection.name} for createDef but it says it's supposed to have one...`);
+            return;
+        }
+        // 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 } = 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) {
+                // No existing user ID, generate a new unique ID
+                existingId = this.getTrueUniqueId(this.getCollectionKey("users"));
+                transformedItem.docId = existingId; // Assign the new ID to the transformed data's docId field
             }
-            // 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 } = 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) {
-                    // No existing user ID, generate a new unique ID
-                    existingId = this.getTrueUniqueId(this.getCollectionKey("users"));
-                    transformedItem.docId = existingId; // Assign the new ID to the transformed data's docId field
-                }
-                // Create a context object for the item, including the new ID
-                let context = this.createContext(db, collection, item, existingId);
-                // Merge the transformed data into the context
-                context = { ...context, ...transformedItem, ...userData.finalData };
-                // If a primary key field is defined, handle the ID mapping and check for duplicates
-                if (importDef.primaryKeyField) {
-                    const oldId = item[importDef.primaryKeyField];
-                    // Check if the oldId already exists to handle potential duplicates
-                    if (this.oldIdToNewIdPerCollectionMap
-                        .get(this.getCollectionKey(collection.name))
-                        ?.has(`${oldId}`)) {
-                        // Found a duplicate oldId, now decide how to merge or handle these duplicates
-                        for (const data of currentData.data) {
-                            if (data.finalData.docId === oldId ||
-                                data.finalData.userId === oldId) {
-                                transformedItem = this.mergeObjects(data.finalData, transformedItem);
-                            }
+            // Create a context object for the item, including the new ID
+            let context = this.createContext(db, collection, item, existingId);
+            // Merge the transformed data into the context
+            context = { ...context, ...transformedItem, ...userData.finalData };
+            // If a primary key field is defined, handle the ID mapping and check for duplicates
+            if (importDef.primaryKeyField) {
+                const oldId = item[importDef.primaryKeyField];
+                // Check if the oldId already exists to handle potential duplicates
+                if (this.oldIdToNewIdPerCollectionMap
+                    .get(this.getCollectionKey(collection.name))
+                    ?.has(`${oldId}`)) {
+                    // Found a duplicate oldId, now decide how to merge or handle these duplicates
+                    for (const data of currentData.data) {
+                        if (data.finalData.docId === oldId ||
+                            data.finalData.userId === oldId) {
+                            transformedItem = this.mergeObjects(data.finalData, transformedItem);
                         }
                     }
-                    else {
-                        // No duplicate found, simply map the oldId to the new itemId
-                        collectionOldIdToNewIdMap?.set(`${oldId}`, `${existingId}`);
-                    }
                 }
-                // Handle merging for currentUserData
-                for (let i = 0; i < currentUserData.data.length; i++) {
-                    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);
-                    }
+                else {
+                    // No duplicate found, simply map the oldId to the new itemId
+                    collectionOldIdToNewIdMap?.set(`${oldId}`, `${existingId}`);
                 }
-                // Update the attribute mappings with any actions that need to be performed post-import
-                const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedItem);
-                // Update the import definition with the new attribute mappings
-                const newImportDef = {
-                    ...importDef,
-                    attributeMappings: mappingsWithActions,
-                };
-                let foundData = false;
-                for (let i = 0; i < currentData.data.length; i++) {
-                    if (currentData.data[i].finalData.docId === existingId ||
-                        currentData.data[i].finalData.userId === existingId) {
-                        currentData.data[i].finalData = this.mergeObjects(currentData.data[i].finalData, transformedItem);
-                        currentData.data[i].context = context;
-                        currentData.data[i].importDef = newImportDef;
-                        this.importMap.set(this.getCollectionKey(collection.name), currentData);
-                        this.oldIdToNewIdPerCollectionMap.set(this.getCollectionKey(collection.name), collectionOldIdToNewIdMap);
-                        foundData = true;
-                    }
+            }
+            // Handle merging for currentUserData
+            for (let i = 0; i < currentUserData.data.length; i++) {
+                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);
                 }
-                if (!foundData) {
-                    // Add new data to the associated collection
-                    currentData.data.push({
-                        rawData: item,
-                        context: context,
-                        importDef: newImportDef,
-                        finalData: transformedItem,
-                    });
+            }
+            // Update the attribute mappings with any actions that need to be performed post-import
+            const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedItem);
+            // Update the import definition with the new attribute mappings
+            const newImportDef = {
+                ...importDef,
+                attributeMappings: mappingsWithActions,
+            };
+            let foundData = false;
+            for (let i = 0; i < currentData.data.length; i++) {
+                if (currentData.data[i].finalData.docId === existingId ||
+                    currentData.data[i].finalData.userId === existingId) {
+                    currentData.data[i].finalData = this.mergeObjects(currentData.data[i].finalData, transformedItem);
+                    currentData.data[i].context = context;
+                    currentData.data[i].importDef = newImportDef;
                     this.importMap.set(this.getCollectionKey(collection.name), currentData);
                     this.oldIdToNewIdPerCollectionMap.set(this.getCollectionKey(collection.name), collectionOldIdToNewIdMap);
+                    foundData = true;
                 }
             }
-        });
+            if (!foundData) {
+                // Add new data to the associated collection
+                currentData.data.push({
+                    rawData: item,
+                    context: context,
+                    importDef: newImportDef,
+                    finalData: transformedItem,
+                });
+                this.importMap.set(this.getCollectionKey(collection.name), currentData);
+                this.oldIdToNewIdPerCollectionMap.set(this.getCollectionKey(collection.name), collectionOldIdToNewIdMap);
+            }
+        }
     }
     /**
      * Prepares the data for creating documents in a collection.
@@ -746,75 +772,81 @@ export class DataLoader {
      * @param collection - The collection configuration.
      * @param importDef - The import definition containing the attribute mappings and other relevant info.
      */
-    prepareCreateData(db, collection, importDef) {
+    async prepareCreateData(db, collection, importDef) {
         // Load the raw data based on the import definition
         const rawData = this.loadData(importDef);
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
         if (!operationId) {
             throw new Error(`No import operation found for collection ${collection.name}`);
         }
-        updateOperation(this.database, operationId, {
+        await updateOperation(this.database, operationId, {
             status: "ready",
             total: rawData.length,
-        }).then(() => {
-            // Initialize a new map for old ID to new ID mappings
-            const oldIdToNewIdMapNew = new Map();
-            // Retrieve or initialize the collection-specific old ID to new ID map
-            const collectionOldIdToNewIdMap = this.oldIdToNewIdPerCollectionMap.get(this.getCollectionKey(collection.name)) ||
-                this.oldIdToNewIdPerCollectionMap
-                    .set(this.getCollectionKey(collection.name), oldIdToNewIdMapNew)
-                    .get(this.getCollectionKey(collection.name));
-            console.log(`${collection.name} -- collectionOldIdToNewIdMap: ${collectionOldIdToNewIdMap}`);
-            // 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));
-                // 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 a primary key field is defined, handle the ID mapping and check for duplicates
-                if (importDef.primaryKeyField) {
-                    const oldId = item[importDef.primaryKeyField];
-                    if (collectionOldIdToNewIdMap?.has(`${oldId}`)) {
-                        logger.error(`Collection ${collection.name} has multiple documents with the same primary key ${oldId}`);
-                        continue;
-                    }
-                    collectionOldIdToNewIdMap?.set(`${oldId}`, `${itemIdNew}`);
-                }
-                // Merge the transformed data into the context
-                context = { ...context, ...transformedData };
-                // Validate the item before proceeding
-                const isValid = this.importDataActions.validateItem(transformedData, importDef.attributeMappings, context);
-                if (!isValid) {
-                    continue;
-                }
-                // Update the attribute mappings with any actions that need to be performed post-import
-                const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedData);
-                // Update the import definition with the new attribute mappings
-                const newImportDef = {
-                    ...importDef,
-                    attributeMappings: mappingsWithActions,
-                };
-                // If the current collection data exists, add the item with its context and final data
-                if (currentData && currentData.data) {
-                    currentData.data.push({
-                        rawData: item,
-                        context: context,
-                        importDef: newImportDef,
-                        finalData: transformedData,
-                    });
-                    this.importMap.set(this.getCollectionKey(collection.name), currentData);
-                    this.oldIdToNewIdPerCollectionMap.set(this.getCollectionKey(collection.name), collectionOldIdToNewIdMap);
-                }
-                else {
-                    logger.error(`No data found for collection ${collection.name} for createDef but it says it's supposed to have one...`);
+        });
+        // Initialize a new map for old ID to new ID mappings
+        const oldIdToNewIdMapNew = new Map();
+        // Retrieve or initialize the collection-specific old ID to new ID map
+        const collectionOldIdToNewIdMap = this.oldIdToNewIdPerCollectionMap.get(this.getCollectionKey(collection.name)) ||
+            this.oldIdToNewIdPerCollectionMap
+                .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];
+                if (collectionOldIdToNewIdMap?.has(`${oldId}`)) {
+                    logger.error(`Collection ${collection.name} has multiple documents with the same primary key ${oldId}`);
                     continue;
                 }
+                collectionOldIdToNewIdMap?.set(`${oldId}`, `${itemIdNew}`);
             }
-        });
+            // Merge the transformed data into the context
+            context = { ...context, ...transformedData };
+            // Validate the item before proceeding
+            const isValid = this.importDataActions.validateItem(transformedData, importDef.attributeMappings, context);
+            if (!isValid) {
+                continue;
+            }
+            // Update the attribute mappings with any actions that need to be performed post-import
+            const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedData);
+            // Update the import definition with the new attribute mappings
+            const newImportDef = {
+                ...importDef,
+                attributeMappings: mappingsWithActions,
+            };
+            // If the current collection data exists, add the item with its context and final data
+            if (currentData && currentData.data) {
+                currentData.data.push({
+                    rawData: item,
+                    context: context,
+                    importDef: newImportDef,
+                    finalData: transformedData,
+                });
+                this.importMap.set(this.getCollectionKey(collection.name), currentData);
+                this.oldIdToNewIdPerCollectionMap.set(this.getCollectionKey(collection.name), collectionOldIdToNewIdMap);
+            }
+            else {
+                logger.error(`No data found for collection ${collection.name} for createDef but it says it's supposed to have one...`);
+                continue;
+            }
+        }
     }
     /**
      * Prepares the data for updating documents within a collection.

package/dist/migrations/importDataActions.d.ts

@@ -11,10 +11,18 @@ 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.
      */

package/dist/migrations/importDataActions.js

@@ -21,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]") ||
@@ -66,6 +76,7 @@ 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.
      */

package/dist/migrations/migrationHelper.js

@@ -3,7 +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";
+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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/migrations/converters.ts

@@ -108,7 +108,13 @@ export const convertObjectByAttributeMappings = (
       const values = mapping.oldKeys
         .map((oldKey) => resolveValue(obj, oldKey))
         .flat(Infinity);
-      result[mapping.targetKey] = values.filter((value) => value !== undefined);
+      if (values.length > 0) {
+        result[mapping.targetKey] = values.filter(
+          (value) => value !== undefined
+        );
+      } else {
+        result[mapping.targetKey] = null;
+      }
     } else if (mapping.oldKey) {
       // Resolve single oldKey
       const value = resolveValue(obj, mapping.oldKey);
@@ -116,9 +122,19 @@ export const convertObjectByAttributeMappings = (
         result[mapping.targetKey] = Array.isArray(value)
           ? value.flat(Infinity)
           : value;
+      } else {
+        result[mapping.targetKey] = null;
       }
     }
   }
+
+  // Ensure any keys in the original object that are not mapped are copied over
+  for (const key of Object.keys(obj)) {
+    if (!Object.keys(result).includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+
   return result;
 };