appwrite-utils-cli 0.0.32 → 0.0.33

package/src/main.ts

@@ -1,83 +1,83 @@
-#!/usr/bin/env node
-import { program } from "commander";
-import { UtilsController } from "./utilsController.js";
-
-// Setup the main CLI program
-program
-  .version("1.0.0")
-  .description("Utility CLI for Appwrite configurations and operations")
-  .option("--endpoint <endpoint>", "Set the Appwrite endpoint", undefined)
-  .option("--project <project>", "Set the Appwrite project ID", undefined)
-  .option("--key <key>", "Set the Appwrite API key", undefined)
-  .option("--backup", "Perform a backup before executing the command", false)
-  .option("--dev", "Run in development environment", false)
-  .option("--prod", "Run in production environment", false)
-  .option("--staging", "Run in staging environment", false)
-  .option("--sync", "Synchronize configurations", false)
-  .option("--wipe", "Wipe databases", false)
-  .option("--wipe-docs", "Wipe documents", false)
-  .option("--wipe-users", "Wipe users", false)
-  .option("--generate", "Generate schemas", false)
-  .option("--import", "Import data", false)
-  .option("--write-data", "Write data to file", false)
-  .option("-h, --help", "Display help for command", false);
-
-program.on("--help", () => {
-  console.log("");
-  console.log("Examples:");
-  console.log(
-    "  $ npx appwrite-utils-cli appwrite-migrate --sync --endpoint https://appwrite.example.com --project 123456 --key 7890"
-  );
-  console.log(
-    "  $ npx appwrite-utils-cli appwrite-migrate --sync --dev --backup"
-  );
-  console.log(
-    "  $ npx appwrite-utils-cli appwrite-migrate --wipe --wipe-docs --wipe-users --dev"
-  );
-  console.log(
-    "  $ npx appwrite-utils-cli appwrite-migrate --generate --import --write-data --dev"
-  );
-  console.log(
-    "  $ npx appwrite-utils-cli appwrite-migrate --sync --generate --import --write-data --dev --backup"
-  );
-  console.log("  $ npx appwrite-utils-cli appwrite-create");
-  console.log(
-    "For more information, visit https://github.com/zachhandley/appwrite-utils"
-  );
-  console.log("");
-});
-
-// Parse and handle options
-program.action(async (options) => {
-  const currentUserDir = process.cwd();
-  const controller = new UtilsController(currentUserDir);
-  try {
-    // Convert Commander options to the format expected by UtilsController
-    const setupOptions = {
-      sync: options.sync,
-      runProd: options.prod,
-      runStaging: options.staging,
-      runDev: options.dev,
-      doBackup: options.backup,
-      wipeDatabases: options.wipe,
-      wipeDocumentStorage: options.wipeDocs,
-      wipeUsers: options.wipeUsers,
-      generateSchemas: options.generate,
-      generateMockData: false, // Assuming this needs to be set based on other conditions
-      importData: options.import,
-      checkDuplicates: false, // Assuming this needs to be set based on other conditions
-      shouldWriteFile: options.writeData,
-      endpoint: options.endpoint,
-      project: options.project,
-      key: options.key,
-    };
-    console.log("Running operation...", setupOptions);
-
-    await controller.run(setupOptions);
-    console.log("Operation completed successfully.");
-  } catch (error) {
-    console.error("Error during operation:", error);
-  }
-});
-
-program.parse(process.argv);
+#!/usr/bin/env node
+import { program } from "commander";
+import { UtilsController } from "./utilsController.js";
+
+// Setup the main CLI program
+program
+  .version("1.0.0")
+  .description("Utility CLI for Appwrite configurations and operations")
+  .option("--endpoint <endpoint>", "Set the Appwrite endpoint", undefined)
+  .option("--project <project>", "Set the Appwrite project ID", undefined)
+  .option("--key <key>", "Set the Appwrite API key", undefined)
+  .option("--backup", "Perform a backup before executing the command", false)
+  .option("--dev", "Run in development environment", false)
+  .option("--prod", "Run in production environment", false)
+  .option("--staging", "Run in staging environment", false)
+  .option("--sync", "Synchronize configurations", false)
+  .option("--wipe", "Wipe databases", false)
+  .option("--wipe-docs", "Wipe documents", false)
+  .option("--wipe-users", "Wipe users", false)
+  .option("--generate", "Generate schemas", false)
+  .option("--import", "Import data", false)
+  .option("--write-data", "Write data to file", false)
+  .option("-h, --help", "Display help for command", false);
+
+program.on("--help", () => {
+  console.log("");
+  console.log("Examples:");
+  console.log(
+    "  $ npx appwrite-utils-cli appwrite-migrate --sync --endpoint https://appwrite.example.com --project 123456 --key 7890"
+  );
+  console.log(
+    "  $ npx appwrite-utils-cli appwrite-migrate --sync --dev --backup"
+  );
+  console.log(
+    "  $ npx appwrite-utils-cli appwrite-migrate --wipe --wipe-docs --wipe-users --dev"
+  );
+  console.log(
+    "  $ npx appwrite-utils-cli appwrite-migrate --generate --import --write-data --dev"
+  );
+  console.log(
+    "  $ npx appwrite-utils-cli appwrite-migrate --sync --generate --import --write-data --dev --backup"
+  );
+  console.log("  $ npx appwrite-utils-cli appwrite-create");
+  console.log(
+    "For more information, visit https://github.com/zachhandley/appwrite-utils"
+  );
+  console.log("");
+});
+
+// Parse and handle options
+program.action(async (options) => {
+  const currentUserDir = process.cwd();
+  const controller = new UtilsController(currentUserDir);
+  try {
+    // Convert Commander options to the format expected by UtilsController
+    const setupOptions = {
+      sync: options.sync,
+      runProd: options.prod,
+      runStaging: options.staging,
+      runDev: options.dev,
+      doBackup: options.backup,
+      wipeDatabases: options.wipe,
+      wipeDocumentStorage: options.wipeDocs,
+      wipeUsers: options.wipeUsers,
+      generateSchemas: options.generate,
+      generateMockData: false, // Assuming this needs to be set based on other conditions
+      importData: options.import,
+      checkDuplicates: false, // Assuming this needs to be set based on other conditions
+      shouldWriteFile: options.writeData,
+      endpoint: options.endpoint,
+      project: options.project,
+      key: options.key,
+    };
+    console.log("Running operation...", setupOptions);
+
+    await controller.run(setupOptions);
+    console.log("Operation completed successfully.");
+  } catch (error) {
+    console.error("Error during operation:", error);
+  }
+});
+
+program.parse(process.argv);

package/src/migrations/dataLoader.ts

@@ -298,6 +298,10 @@ export class DataLoader {
         let isUsersCollection =
           this.getCollectionKey(this.config.usersCollectionName) ===
           this.getCollectionKey(collection.name);
+        const collectionDefs = collection.importDefs;
+        if (!collectionDefs || !collectionDefs.length) {
+          continue;
+        }
         // Process create and update definitions for the collection
         const createDefs = collection.importDefs.filter(
           (def: ImportDef) => def.type === "create" || !def.type
@@ -331,8 +335,8 @@ export class DataLoader {
         }
       }
       console.log("Running update references");
-      await this.dealWithMergedUsers();
-      await this.updateOldReferencesForNew();
+      this.dealWithMergedUsers();
+      this.updateOldReferencesForNew();
       console.log("Done running update references");
     }
     // for (const collection of this.config.collections) {
@@ -346,7 +350,7 @@ export class DataLoader {
     }
   }
 
-  async dealWithMergedUsers() {
+  dealWithMergedUsers() {
     const usersCollectionKey = this.getCollectionKey(
       this.config.usersCollectionName
     );
@@ -357,7 +361,11 @@ export class DataLoader {
     // Collect primary key fields from the users collection definitions
     this.config.collections.forEach((collection) => {
       if (this.getCollectionKey(collection.name) === usersCollectionKey) {
-        collection.importDefs.forEach((importDef) => {
+        const collectionImportDefs = collection.importDefs;
+        if (!collectionImportDefs || !collectionImportDefs.length) {
+          return;
+        }
+        collectionImportDefs.forEach((importDef) => {
           if (importDef.primaryKeyField) {
             usersCollectionPrimaryKeyFields.add(importDef.primaryKeyField);
           }
@@ -371,14 +379,19 @@ export class DataLoader {
         this.getCollectionKey(collection.name)
       );
       if (!collectionData || !collectionData.data) return;
-
-      collection.importDefs.forEach((importDef) => {
+      const collectionImportDefs = collection.importDefs;
+      if (!collectionImportDefs || !collectionImportDefs.length) {
+        return;
+      }
+      collectionImportDefs.forEach((importDef) => {
         importDef.idMappings?.forEach((idMapping) => {
           if (
             this.getCollectionKey(idMapping.targetCollection) ===
             usersCollectionKey
           ) {
-            if (usersCollectionPrimaryKeyFields.has(idMapping.targetField)) {
+            const targetFieldKey =
+              idMapping.targetFieldToMatch || idMapping.targetField;
+            if (usersCollectionPrimaryKeyFields.has(targetFieldKey)) {
               // Process each item in the collection
               collectionData.data.forEach((item) => {
                 const oldId = item.context[idMapping.sourceField];
@@ -386,8 +399,7 @@ export class DataLoader {
 
                 if (newId) {
                   // Update context to use new user ID
-                  item.context[idMapping.fieldToSet || idMapping.targetField] =
-                    newId;
+                  item.context[idMapping.fieldToSet || targetFieldKey] = newId;
                 }
               });
             }
@@ -401,6 +413,7 @@ export class DataLoader {
     if (!this.config.collections) {
       return;
     }
+
     for (const collectionConfig of this.config.collections) {
       const collectionKey = this.getCollectionKey(collectionConfig.name);
       const collectionData = this.importMap.get(collectionKey);
@@ -424,29 +437,41 @@ export class DataLoader {
                 );
                 const fieldToSetKey =
                   idMapping.fieldToSet || idMapping.sourceField;
+                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)) continue;
 
+                const isFieldToSetArray = collectionConfig.attributes.find(
+                  (attribute) => attribute.key === fieldToSetKey
+                )?.array;
+
                 const targetCollectionData =
                   this.importMap.get(targetCollectionKey);
                 if (!targetCollectionData || !targetCollectionData.data)
                   continue;
 
-                const foundData = targetCollectionData.data.filter((data) => {
-                  const targetValue = data.context[idMapping.targetField];
-                  const isMatch = `${targetValue}` === `${valueToMatch}`;
-                  // Debugging output to understand what's being compared
-                  logger.warn(
-                    `Comparing target: ${targetValue} with match: ${valueToMatch} - Result: ${isMatch}`
-                  );
-                  return isMatch;
-                });
+                // Find matching data in the target collection
+                const foundData = targetCollectionData.data.filter(
+                  ({ context }) => {
+                    const targetValue = context[targetFieldKey];
+                    const isMatch = `${targetValue}` === `${valueToMatch}`;
+                    // Ensure the targetValue is defined and not null
+                    return (
+                      isMatch &&
+                      targetValue !== undefined &&
+                      targetValue !== null
+                    );
+                  }
+                );
 
+                // Log and skip if no matching data found
                 if (!foundData.length) {
                   console.log(
-                    `No data found for collection: ${targetCollectionKey} with value: ${valueToMatch} for field: ${fieldToSetKey}`
+                    `No data found for collection ${collectionConfig.name}:\nTarget collection: ${targetCollectionKey}\nValue to match: ${valueToMatch}\nField to set: ${fieldToSetKey}\nTarget field to match: ${targetFieldKey}\nTarget field value: ${idMapping.targetField}`
                   );
                   logger.error(
                     `No data found for collection: ${targetCollectionKey} with value: ${valueToMatch} for field: ${fieldToSetKey} -- idMapping: ${JSON.stringify(
@@ -460,143 +485,71 @@ export class DataLoader {
 
                 needsUpdate = true;
 
-                // Properly handle arrays and non-arrays
-                if (
-                  Array.isArray(collectionData.data[i].finalData[fieldToSetKey])
-                ) {
-                  collectionData.data[i].finalData[fieldToSetKey] =
-                    foundData.map((data) => data.finalData);
-                } else {
-                  collectionData.data[i].finalData[fieldToSetKey] =
-                    foundData[0].finalData;
-                }
-              }
-            }
-          }
-        }
-      }
-
-      if (needsUpdate) {
-        this.importMap.set(collectionKey, collectionData);
-      }
-    }
-  }
-
-  async updateReferencesInRelatedCollections() {
-    if (!this.config.collections) {
-      return;
-    }
-    // Iterate over each collection configuration
-    for (const collectionConfig of this.config.collections) {
-      const collectionKey = this.getCollectionKey(collectionConfig.name);
-      const collectionData = this.importMap.get(collectionKey);
-
-      if (!collectionData || !collectionData.data) continue;
-
-      console.log(
-        `Updating references for collection: ${collectionConfig.name}`
-      );
+                const getCurrentDataFiltered = (currentData: any) => {
+                  if (Array.isArray(currentData.finalData[fieldToSetKey])) {
+                    return currentData.finalData[fieldToSetKey].filter(
+                      (data: any) => `${data}` !== `${valueToMatch}`
+                    );
+                  }
+                  return currentData.finalData[fieldToSetKey];
+                };
 
-      // Iterate over each data item in the current collection
-      for (const item of collectionData.data) {
-        let needsUpdate = false;
+                // Get the current data to be updated
+                const currentDataFiltered = getCurrentDataFiltered(
+                  collectionData.data[i]
+                );
 
-        // Check if the current collection has import definitions with idMappings
-        if (collectionConfig.importDefs) {
-          for (const importDef of collectionConfig.importDefs) {
-            if (importDef.idMappings) {
-              // Iterate over each idMapping defined for the current import definition
-              for (const idMapping of importDef.idMappings) {
-                const oldIds = Array.isArray(
-                  item.context[idMapping.sourceField]
-                )
-                  ? item.context[idMapping.sourceField]
-                  : [item.context[idMapping.sourceField]];
-                const resolvedNewIds: string[] = [];
-
-                oldIds.forEach((oldId: any) => {
-                  // Attempt to find a new ID for the old ID
-                  let newIdForOldId = this.findNewIdForOldId(
-                    oldId,
-                    idMapping,
-                    importDef
-                  );
+                // Extract the new data to set
+                const newData = foundData.map(
+                  (data) => data.context[idMapping.targetField]
+                );
 
-                  if (
-                    newIdForOldId &&
-                    !resolvedNewIds.includes(newIdForOldId)
-                  ) {
-                    resolvedNewIds.push(newIdForOldId);
+                // Handle cases where current data is an array
+                if (isFieldToSetArray) {
+                  if (!currentDataFiltered) {
+                    // Set new data if current data is undefined
+                    collectionData.data[i].finalData[fieldToSetKey] =
+                      Array.isArray(newData) ? newData : [newData];
                   } else {
-                    logger.error(
-                      `No new ID found for old ID ${oldId} in collection ${collectionConfig.name}`
-                    );
+                    // Merge arrays if new data is non-empty array and filter for uniqueness
+                    collectionData.data[i].finalData[fieldToSetKey] = [
+                      ...new Set(
+                        [...currentDataFiltered, ...newData].filter(
+                          (value: any) => `${value}` !== `${valueToMatch}`
+                        )
+                      ),
+                    ];
+                  }
+                } else {
+                  if (!currentDataFiltered) {
+                    // Set new data if current data is undefined
+                    collectionData.data[i].finalData[fieldToSetKey] =
+                      Array.isArray(newData) ? newData : [newData];
+                  } else if (Array.isArray(newData) && newData.length > 0) {
+                    // Convert current data to array and merge if new data is non-empty array, then filter for uniqueness
+                    collectionData.data[i].finalData[fieldToSetKey] = [
+                      ...new Set(
+                        [currentDataFiltered, ...newData].filter(
+                          (value: any) => `${value}` !== `${valueToMatch}`
+                        )
+                      ),
+                    ];
+                  } else if (!Array.isArray(newData) && newData !== undefined) {
+                    // Simply update the field if new data is not an array and defined
+                    collectionData.data[i].finalData[fieldToSetKey] = newData;
                   }
-                });
-
-                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
-                  item.finalData[targetField] = isArray
-                    ? resolvedNewIds
-                    : resolvedNewIds[0];
-                  needsUpdate = true;
                 }
               }
             }
           }
         }
-
-        // Update the importMap if changes were made to the item
-        if (needsUpdate) {
-          this.importMap.set(collectionKey, collectionData);
-          logger.info(
-            `Updated item: ${JSON.stringify(item.finalData, undefined, 2)}`
-          );
-        }
       }
-    }
-  }
 
-  findNewIdForOldId(oldId: string, idMapping: IdMapping, importDef: ImportDef) {
-    // First, check if this ID mapping is related to the users collection.
-    const targetCollectionKey = this.getCollectionKey(
-      idMapping.targetCollection
-    );
-    const isUsersCollection =
-      targetCollectionKey ===
-      this.getCollectionKey(this.config.usersCollectionName);
-
-    // If handling users, check the mergedUserMap for any existing new ID.
-    if (isUsersCollection) {
-      for (const [newUserId, oldIds] of this.mergedUserMap.entries()) {
-        if (oldIds.includes(oldId)) {
-          return newUserId;
-        }
-      }
-    }
-
-    // If not a user or no merged ID found, check the regular ID mapping from old to new.
-    const targetCollectionData = this.importMap.get(targetCollectionKey);
-    if (targetCollectionData) {
-      const foundEntry = targetCollectionData.data.find(
-        (entry) => entry.context[importDef.primaryKeyField] === oldId
-      );
-      if (foundEntry) {
-        return foundEntry.context.docId; // Assuming `docId` stores the new ID after import
+      // Update the import map if any changes were made
+      if (needsUpdate) {
+        this.importMap.set(collectionKey, collectionData);
       }
     }
-
-    logger.error(
-      `No corresponding new ID found for ${oldId} in ${targetCollectionKey}`
-    );
-    return null; // Return null if no new ID is found
   }
 
   private writeMapsToJsonFile() {
@@ -808,14 +761,14 @@ export class DataLoader {
       if (!existingId) {
         // No existing user ID, generate a new unique ID
         existingId = this.getTrueUniqueId(this.getCollectionKey("users"));
-        transformedItem.userId = existingId; // Assign the new ID to the transformed data's userId field
+        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 };
+      context = { ...context, ...transformedItem, ...userData.finalData };
 
       // If a primary key field is defined, handle the ID mapping and check for duplicates
       if (importDef.primaryKeyField) {