appwrite-utils-cli 0.0.261 → 0.0.263

package/dist/migrations/dataLoader.js

@@ -10,6 +10,7 @@ import { findOrCreateOperation, updateOperation } from "./migrationHelper.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
 import _ from "lodash";
 import { UsersController } from "./users.js";
+import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({
     // Optional collection creation schema
@@ -69,17 +70,33 @@ export class DataLoader {
      * @param target - The target object with values to update the source object.
      * @returns The updated source object.
      */
-    mergeObjects(source, target) {
-        Object.keys(target).forEach((key) => {
-            const targetValue = target[key];
-            if (source.hasOwnProperty(key) &&
-                targetValue !== null &&
-                targetValue !== undefined &&
-                targetValue !== "") {
-                source[key] = targetValue;
+    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) {
+                result[key] = updateValue;
             }
         });
-        return source;
+        return result;
     }
     // Method to load data from a file specified in the import definition
     async loadData(importDef) {
@@ -255,6 +272,7 @@ export class DataLoader {
             const collectionData = this.importMap.get(collectionKey);
             if (!collectionData || !collectionData.data)
                 continue;
+            console.log(`Updating references for collection: ${collectionConfig.name}`);
             // Iterate over each data item in the current collection
             for (const item of collectionData.data) {
                 let needsUpdate = false;
@@ -264,91 +282,56 @@ export class DataLoader {
                         if (importDef.idMappings) {
                             // Iterate over each idMapping defined for the current import definition
                             for (const idMapping of importDef.idMappings) {
-                                const oldId = item.context[idMapping.sourceField];
-                                if (oldId) {
-                                    let newIdForOldId;
-                                    // Your existing logic to resolve newIdForOldId here...
-                                    if (newIdForOldId) {
-                                        // Determine the field to update, handling arrays appropriately
-                                        const fieldToUpdate = idMapping.fieldToSet || idMapping.targetField;
-                                        if (Array.isArray(item.finalData[fieldToUpdate])) {
-                                            // If the target field is an array, append the new ID
-                                            item.finalData[fieldToUpdate].push(newIdForOldId);
-                                        }
-                                        else {
-                                            // Otherwise, directly set the new ID
-                                            item.finalData[fieldToUpdate] = newIdForOldId;
-                                        }
-                                        console.log(`Updated ${oldId} to ${newIdForOldId}`);
-                                        needsUpdate = true;
+                                const oldIds = Array.isArray(item.context[idMapping.sourceField])
+                                    ? item.context[idMapping.sourceField]
+                                    : [item.context[idMapping.sourceField]];
+                                const resolvedNewIds = [];
+                                oldIds.forEach((oldId) => {
+                                    // Attempt to find a new ID for the old ID
+                                    let newIdForOldId = this.findNewIdForOldId(oldId, idMapping);
+                                    // Check if a new ID was found and it's not already included
+                                    if (newIdForOldId &&
+                                        !resolvedNewIds.includes(newIdForOldId)) {
+                                        resolvedNewIds.push(newIdForOldId);
                                     }
+                                });
+                                if (resolvedNewIds.length) {
+                                    const targetField = idMapping.fieldToSet || idMapping.targetField;
+                                    const isArray = collectionConfig.attributes.some((attribute) => attribute.key === targetField && attribute.array);
+                                    // Set the target field based on whether it's an array or single value
+                                    if (isArray) {
+                                        item.finalData[targetField] = resolvedNewIds;
+                                    }
+                                    else {
+                                        // In case of a single value, use the first resolved ID
+                                        item.finalData[targetField] = resolvedNewIds[0];
+                                    }
+                                    needsUpdate = true;
                                 }
                             }
                         }
                     }
                 }
+                // Update the importMap if changes were made to the item
                 if (needsUpdate) {
-                    // Re-transform the item's finalData using its attribute mappings
-                    const importDef = item.importDef; // Assuming importDef is available in the item
-                    if (importDef && importDef.attributeMappings) {
-                        item.finalData = await this.transformData(item.finalData, importDef.attributeMappings);
-                    }
                     this.importMap.set(collectionKey, collectionData);
+                    logger.info(`Updated item: ${JSON.stringify(item.finalData, undefined, 2)}`);
                 }
             }
         }
     }
-    // async updateReferencesInRelatedCollections() {
-    //   // Process each collection defined in the config
-    //   for (const collection of this.config.collections) {
-    //     // Ensure we handle only those definitions with idMappings and a primaryKeyField defined
-    //     for (const importDef of collection.importDefs) {
-    //       if (!importDef.idMappings || !importDef.primaryKeyField) continue;
-    //       // Load data for this particular import definition
-    //       const collectionData = this.importMap.get(
-    //         this.getCollectionKey(collection.name)
-    //       )?.data;
-    //       if (!collectionData) continue;
-    //       // Iterate over each item in the collection data
-    //       for (const item of collectionData) {
-    //         let needsUpdate = false;
-    //         // Go through each idMapping defined for the collection
-    //         for (const mapping of importDef.idMappings) {
-    //           const oldReferenceId =
-    //             item[mapping.targetField as keyof typeof item]; // Get the current reference ID from the item
-    //           const referenceCollectionMap =
-    //             this.oldIdToNewIdPerCollectionMap.get(
-    //               this.getCollectionKey(mapping.targetCollection)
-    //             );
-    //           if (
-    //             referenceCollectionMap &&
-    //             referenceCollectionMap.has(oldReferenceId)
-    //           ) {
-    //             // Update the target field with the new reference ID from the mapped collection
-    //             item[mapping.sourceField as keyof typeof item] =
-    //               referenceCollectionMap.get(oldReferenceId);
-    //             needsUpdate = true;
-    //             console.log(
-    //               `Updated item with ${mapping.sourceField} = ${JSON.stringify(
-    //                 item,
-    //                 null,
-    //                 undefined
-    //               )}.`
-    //             );
-    //           }
-    //         }
-    //         // Save changes if any reference was updated
-    //         if (needsUpdate) {
-    //           await this.saveUpdatedItem(
-    //             collection.name,
-    //             item,
-    //             importDef.primaryKeyField
-    //           );
-    //         }
-    //       }
-    //     }
-    //   }
-    // }
+    findNewIdForOldId(oldId, idMapping) {
+        // First, check if the old ID has been merged into a new one
+        for (const [newUserId, oldIds] of this.mergedUserMap.entries()) {
+            if (oldIds.includes(oldId)) {
+                return newUserId;
+            }
+        }
+        // If not merged, look for a direct mapping from old to new ID
+        const targetCollectionKey = this.getCollectionKey(idMapping.targetCollection);
+        const targetOldIdToNewIdMap = this.oldIdToNewIdPerCollectionMap.get(targetCollectionKey);
+        return targetOldIdToNewIdMap?.get(oldId);
+    }
     writeMapsToJsonFile() {
         const outputDir = path.resolve(process.cwd());
         const outputFile = path.join(outputDir, "dataLoaderOutput.json");
@@ -401,7 +384,6 @@ export class DataLoader {
         // Check for duplicate email and add to emailToUserIdMap if not found
         if (email && email.length > 0) {
             if (this.emailToUserIdMap.has(email)) {
-                logger.error(`Duplicate email found or user exists already: ${email}`);
                 existingId = this.emailToUserIdMap.get(email);
             }
             else {
@@ -411,7 +393,6 @@ export class DataLoader {
         // Check for duplicate phone and add to phoneToUserIdMap if not found
         if (phone && phone.length > 0) {
             if (this.phoneToUserIdMap.has(phone)) {
-                logger.error(`Duplicate phone found: ${phone}`);
                 existingId = this.phoneToUserIdMap.get(phone);
             }
             else {

package/dist/migrations/databases.d.ts

@@ -0,0 +1,2 @@
+import { Databases, type Models } from "node-appwrite";
+export declare const fetchAllDatabases: (database: Databases) => Promise<Models.Database[]>;

package/dist/migrations/databases.js

@@ -0,0 +1,23 @@
+import { Databases, Query } from "node-appwrite";
+export const fetchAllDatabases = async (database) => {
+    const databases = await database.list([Query.limit(25)]);
+    const allDatabases = databases.databases;
+    let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
+    if (databases.databases.length < 25) {
+        return allDatabases;
+    }
+    else {
+        while (lastDatabaseId) {
+            const databases = await database.list([
+                Query.limit(25),
+                Query.cursorAfter(lastDatabaseId),
+            ]);
+            allDatabases.push(...databases.databases);
+            if (databases.databases.length < 25) {
+                break;
+            }
+            lastDatabaseId = databases.databases[databases.databases.length - 1].$id;
+        }
+    }
+    return allDatabases;
+};

package/dist/migrations/importController.js

@@ -159,6 +159,9 @@ export class ImportController {
                     if (item.finalData.hasOwnProperty("docId")) {
                         delete item.finalData.docId;
                     }
+                    if (!item.finalData) {
+                        return Promise.resolve();
+                    }
                     return this.database
                         .createDocument(db.$id, collection.$id, id, item.finalData)
                         .then(() => {

package/dist/migrations/importDataActions.d.ts

@@ -12,7 +12,7 @@ export declare class ImportDataActions {
     private validityRuleDefinitions;
     private afterImportActionsDefinitions;
     constructor(db: Databases, storage: Storage, config: AppwriteConfig, converterDefinitions: ConverterFunctions, validityRuleDefinitions: ValidationRules, afterImportActionsDefinitions: AfterImportActions);
-    runConverterFunctions(item: any, attributeMappings: AttributeMappings): Promise<any>;
+    runConverterFunctions(item: any, attributeMappings: AttributeMappings): any;
     /**
      * Validates a single data item based on defined validation rules.
      * @param item The data item to validate.

package/dist/migrations/importDataActions.js

@@ -18,7 +18,7 @@ export class ImportDataActions {
         this.validityRuleDefinitions = validityRuleDefinitions;
         this.afterImportActionsDefinitions = afterImportActionsDefinitions;
     }
-    async runConverterFunctions(item, attributeMappings) {
+    runConverterFunctions(item, attributeMappings) {
         const conversionSchema = attributeMappings.reduce((schema, mapping) => {
             schema[mapping.targetKey] = (originalValue) => {
                 return mapping.converters.reduce((value, converterName) => {