appwrite-utils-cli 0.0.263 → 0.0.265

package/dist/migrations/appwriteToX.js

@@ -46,13 +46,35 @@ export class AppwriteToX {
         let updatedConfig = { ...config };
         // Loop through each database
         for (const database of databases) {
+            if (database.name.toLowerCase() === "migrations") {
+                continue;
+            }
             const collections = await fetchAllCollections(database.$id, db);
             // Loop through each collection in the current database
             for (const collection of collections) {
                 const existingCollectionIndex = updatedConfig.collections.findIndex((c) => c.name === collection.name);
                 // Parse the collection permissions and attributes
                 const collPermissions = this.parsePermissionsArray(collection.$permissions);
-                const collAttributes = attributesSchema.parse(collection.attributes);
+                const collAttributes = attributesSchema
+                    .parse(collection.attributes)
+                    .filter((attribute) => attribute.type === "relationship"
+                    ? attribute.side !== "child"
+                    : true);
+                for (const attribute of collAttributes) {
+                    if (attribute.type === "relationship" &&
+                        attribute.relatedCollection) {
+                        console.log(`Fetching related collection for ID: ${attribute.relatedCollection}`);
+                        try {
+                            const relatedCollectionPulled = await db.getCollection(database.$id, attribute.relatedCollection);
+                            console.log(`Fetched Collection Name: ${relatedCollectionPulled.name}`);
+                            attribute.relatedCollection = relatedCollectionPulled.name;
+                            console.log(`Updated attribute.relatedCollection to: ${attribute.relatedCollection}`);
+                        }
+                        catch (error) {
+                            console.log("Error fetching related collection:", error);
+                        }
+                    }
+                }
                 this.collToAttributeMap.set(collection.name, collAttributes);
                 const collIndexes = indexesSchema.parse(collection.indexes);
                 // Prepare the collection object to be added or updated

package/dist/migrations/dataLoader.d.ts

@@ -1573,7 +1573,7 @@ export declare class DataLoader {
      * @returns The updated source object.
      */
     mergeObjects(source: any, update: any): any;
-    loadData(importDef: ImportDef): Promise<any[]>;
+    loadData(importDef: ImportDef): any[];
     checkMapValuesForId(newId: string, collectionName: string): string | false;
     getTrueUniqueId(collectionName: string): string;
     createContext(db: ConfigDatabase, collection: ConfigCollection, item: any, docId: string): any;
@@ -1585,12 +1585,12 @@ export declare class DataLoader {
      * @param attributeMappings - The mappings that define how each attribute should be transformed.
      * @returns The transformed item.
      */
-    transformData(item: any, attributeMappings: AttributeMappings): Promise<any>;
+    transformData(item: any, attributeMappings: AttributeMappings): any;
     setupMaps(dbId: string): Promise<void>;
     getAllUsers(): Promise<import("node-appwrite").Models.User<import("node-appwrite").Models.Preferences>[]>;
     start(dbId: string): Promise<void>;
     updateReferencesInRelatedCollections(): Promise<void>;
-    findNewIdForOldId(oldId: string, idMapping: IdMapping): string | undefined;
+    findNewIdForOldId(oldId: string, idMapping: IdMapping, importDef: ImportDef): any;
     private writeMapsToJsonFile;
     /**
      * Prepares user data by checking for duplicates based on email or phone, adding to a duplicate map if found,

package/dist/migrations/dataLoader.js

@@ -99,7 +99,7 @@ export class DataLoader {
         return result;
     }
     // Method to load data from a file specified in the import definition
-    async loadData(importDef) {
+    loadData(importDef) {
         // Resolve the file path and check if the file exists
         const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
         if (!fs.existsSync(filePath)) {
@@ -150,7 +150,7 @@ export class DataLoader {
      * @param attributeMappings - The mappings that define how each attribute should be transformed.
      * @returns The transformed item.
      */
-    async transformData(item, attributeMappings) {
+    transformData(item, attributeMappings) {
         // Convert the item using the attribute mappings provided
         const convertedItem = convertObjectByAttributeMappings(item, attributeMappings);
         // Run additional converter functions on the converted item, if any
@@ -288,24 +288,19 @@ export class DataLoader {
                                 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)) {
+                                    let newIdForOldId = this.findNewIdForOldId(oldId, idMapping, importDef);
+                                    if (newIdForOldId && !resolvedNewIds.includes(newIdForOldId)) {
                                         resolvedNewIds.push(newIdForOldId);
                                     }
+                                    else {
+                                        logger.error(`No new ID found for old ID ${oldId} in collection ${collectionConfig.name}`);
+                                    }
                                 });
                                 if (resolvedNewIds.length) {
                                     const targetField = idMapping.fieldToSet || idMapping.targetField;
-                                    const isArray = collectionConfig.attributes.some((attribute) => attribute.key === targetField && attribute.array);
+                                    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];
-                                    }
+                                    item.finalData[targetField] = isArray ? resolvedNewIds : resolvedNewIds[0];
                                     needsUpdate = true;
                                 }
                             }
@@ -320,30 +315,47 @@ export class DataLoader {
             }
         }
     }
-    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;
+    findNewIdForOldId(oldId, idMapping, 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 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);
+        // 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
+            }
+        }
+        logger.error(`No corresponding new ID found for ${oldId} in ${targetCollectionKey}`);
+        return null; // Return null if no new ID is found
     }
     writeMapsToJsonFile() {
         const outputDir = path.resolve(process.cwd());
         const outputFile = path.join(outputDir, "dataLoaderOutput.json");
         const dataToWrite = {
+            // Convert Maps to arrays of entries for serialization
+            oldIdToNewIdPerCollectionMap: Array.from(this.oldIdToNewIdPerCollectionMap.entries()).map(([key, value]) => {
+                return {
+                    collection: key,
+                    data: Array.from(value.entries()),
+                };
+            }),
+            mergedUserMap: Array.from(this.mergedUserMap.entries()),
             dataFromCollections: Array.from(this.importMap.entries()).map(([key, value]) => {
                 return {
                     collection: key,
                     data: value.data.map((item) => item.finalData),
                 };
             }),
-            // Convert Maps to arrays of entries for serialization
-            mergedUserMap: Array.from(this.mergedUserMap.entries()),
             // emailToUserIdMap: Array.from(this.emailToUserIdMap.entries()),
             // phoneToUserIdMap: Array.from(this.phoneToUserIdMap.entries()),
         };
@@ -372,7 +384,7 @@ export class DataLoader {
      */
     async prepareUserData(item, attributeMappings, primaryKeyField, newId) {
         // Transform the item data based on the attribute mappings
-        let transformedItem = await this.transformData(item, attributeMappings);
+        let transformedItem = this.transformData(item, attributeMappings);
         const userData = AuthUserCreateSchema.safeParse(transformedItem);
         if (!userData.success) {
             logger.error(`Invalid user data: ${JSON.stringify(userData.error.errors, undefined, 2)}`);
@@ -438,7 +450,7 @@ export class DataLoader {
      */
     async prepareUserCollectionCreateData(db, collection, importDef) {
         // Load the raw data based on the import definition
-        const rawData = await this.loadData(importDef);
+        const rawData = this.loadData(importDef);
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
         // Initialize a new map for old ID to new ID mappings
         const oldIdToNewIdMap = new Map();
@@ -556,7 +568,7 @@ export class DataLoader {
      */
     async prepareCreateData(db, collection, importDef) {
         // Load the raw data based on the import definition
-        const rawData = await this.loadData(importDef);
+        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}`);
@@ -582,7 +594,7 @@ export class DataLoader {
             // 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 = await this.transformData(item, importDef.attributeMappings);
+            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];
@@ -644,14 +656,14 @@ export class DataLoader {
             return;
         }
         // Load the raw data based on the import definition
-        const rawData = await this.loadData(importDef);
+        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}`);
         }
         for (const item of rawData) {
             // Transform the item data based on the attribute mappings
-            let transformedData = await this.transformData(item, importDef.attributeMappings);
+            let transformedData = this.transformData(item, importDef.attributeMappings);
             let newId;
             let oldId;
             // Determine the new ID for the item based on the primary key field or update mapping

package/dist/migrations/indexes.js

@@ -8,6 +8,12 @@ export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {
     if (existingIndex.total > 0) {
         await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
     }
+    if (index.type === "fulltext" && index.attributes.length > 1) {
+        throw new Error(`Fulltext index can only be created on a single attribute. Index: ${index.key}`);
+    }
+    else if (index.type === "fulltext") {
+        index.attributes = [index.attributes[0]];
+    }
     const newIndex = await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, index.orders);
     return newIndex;
 };

package/dist/migrations/schemaStrings.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import fs from "fs";
 import path from "path";
 import { dump } from "js-yaml";
+import { getDatabaseFromConfig } from "./afterImportActions.js";
 export class SchemaGenerator {
     relationshipMap = new Map();
     config;
@@ -49,6 +50,7 @@ export class SchemaGenerator {
                             break;
                     }
                     this.addRelationship(collection.name, relationshipAttr.relatedCollection, attr.key, relationshipAttr.twoWayKey, isArrayParent, isArrayChild);
+                    console.log(`Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`);
                 }
             });
         });
@@ -89,7 +91,14 @@ export class SchemaGenerator {
         let imports = `import { z } from "zod";\n`;
         // Use the relationshipMap to find related collections
         const relationshipDetails = this.relationshipMap.get(name) || [];
-        const relatedCollections = relationshipDetails.map((detail) => {
+        const relatedCollections = relationshipDetails
+            .filter((detail, index, self) => {
+            const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
+            return (index ===
+                self.findIndex((obj) => `${obj.parentCollection}-${obj.childCollection}-${obj.parentKey}-${obj.childKey}` ===
+                    uniqueKey));
+        })
+            .map((detail) => {
             const relatedCollectionName = detail.isChild
                 ? detail.parentCollection
                 : detail.childCollection;
@@ -102,8 +111,9 @@ export class SchemaGenerator {
         let curNum = 0;
         let maxNum = relatedCollections.length;
         relatedCollections.forEach((relatedCollection) => {
-            const relatedPascalName = toPascalCase(relatedCollection[0]);
-            const relatedCamelName = toCamelCase(relatedCollection[0]);
+            console.log(relatedCollection);
+            let relatedPascalName = toPascalCase(relatedCollection[0]);
+            let relatedCamelName = toCamelCase(relatedCollection[0]);
             curNum++;
             let endNameTypes = relatedPascalName;
             let endNameLazy = `${relatedPascalName}Schema`;
@@ -172,10 +182,20 @@ export class SchemaGenerator {
             case "integer":
                 baseSchemaCode = "z.number().int()";
                 if (attribute.min !== undefined) {
-                    baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+                    if (BigInt(attribute.min) === BigInt(-9223372036854776000)) {
+                        delete attribute.min;
+                    }
+                    else {
+                        baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+                    }
                 }
                 if (attribute.max !== undefined) {
-                    baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+                    if (BigInt(attribute.max) === BigInt(9223372036854776000)) {
+                        delete attribute.max;
+                    }
+                    else {
+                        baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+                    }
                 }
                 if (attribute.xdefault !== undefined) {
                     baseSchemaCode += `.default(${attribute.xdefault})`;

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.263",
+  "version": "0.0.265",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/migrations/appwriteToX.ts

@@ -65,6 +65,9 @@ export class AppwriteToX {
 
     // Loop through each database
     for (const database of databases) {
+      if (database.name.toLowerCase() === "migrations") {
+        continue;
+      }
       const collections = await fetchAllCollections(database.$id, db);
 
       // Loop through each collection in the current database
@@ -77,7 +80,38 @@ export class AppwriteToX {
         const collPermissions = this.parsePermissionsArray(
           collection.$permissions
         );
-        const collAttributes = attributesSchema.parse(collection.attributes);
+        const collAttributes = attributesSchema
+          .parse(collection.attributes)
+          .filter((attribute) =>
+            attribute.type === "relationship"
+              ? attribute.side !== "child"
+              : true
+          );
+        for (const attribute of collAttributes) {
+          if (
+            attribute.type === "relationship" &&
+            attribute.relatedCollection
+          ) {
+            console.log(
+              `Fetching related collection for ID: ${attribute.relatedCollection}`
+            );
+            try {
+              const relatedCollectionPulled = await db.getCollection(
+                database.$id,
+                attribute.relatedCollection
+              );
+              console.log(
+                `Fetched Collection Name: ${relatedCollectionPulled.name}`
+              );
+              attribute.relatedCollection = relatedCollectionPulled.name;
+              console.log(
+                `Updated attribute.relatedCollection to: ${attribute.relatedCollection}`
+              );
+            } catch (error) {
+              console.log("Error fetching related collection:", error);
+            }
+          }
+        }
         this.collToAttributeMap.set(collection.name, collAttributes);
         const collIndexes = indexesSchema.parse(collection.indexes);
 

package/src/migrations/dataLoader.ts

@@ -133,7 +133,7 @@ export class DataLoader {
   }
 
   // Method to load data from a file specified in the import definition
-  async loadData(importDef: ImportDef): Promise<any[]> {
+  loadData(importDef: ImportDef): any[] {
     // Resolve the file path and check if the file exists
     const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
     if (!fs.existsSync(filePath)) {
@@ -194,10 +194,7 @@ export class DataLoader {
    * @param attributeMappings - The mappings that define how each attribute should be transformed.
    * @returns The transformed item.
    */
-  async transformData(
-    item: any,
-    attributeMappings: AttributeMappings
-  ): Promise<any> {
+  transformData(item: any, attributeMappings: AttributeMappings): any {
     // Convert the item using the attribute mappings provided
     const convertedItem = convertObjectByAttributeMappings(
       item,
@@ -345,99 +342,111 @@ export class DataLoader {
   async updateReferencesInRelatedCollections() {
     // Iterate over each collection configuration
     for (const collectionConfig of this.config.collections) {
-      const collectionKey = this.getCollectionKey(collectionConfig.name);
-      const collectionData = this.importMap.get(collectionKey);
+        const collectionKey = this.getCollectionKey(collectionConfig.name);
+        const collectionData = this.importMap.get(collectionKey);
 
-      if (!collectionData || !collectionData.data) continue;
+        if (!collectionData || !collectionData.data) continue;
 
-      console.log(
-        `Updating references for collection: ${collectionConfig.name}`
-      );
+        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;
+        // Iterate over each data item in the current collection
+        for (const item of collectionData.data) {
+            let needsUpdate = false;
 
-        // 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[] = [];
+            // 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);
+                            oldIds.forEach((oldId: any) => {
+                                // Attempt to find a new ID for the old ID
+                                let newIdForOldId = this.findNewIdForOldId(
+                                    oldId,
+                                    idMapping,
+                                    importDef
+                                );
 
-                  // 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
-                  );
+                                if (newIdForOldId && !resolvedNewIds.includes(newIdForOldId)) {
+                                    resolvedNewIds.push(newIdForOldId);
+                                } else {
+                                    logger.error(`No new ID found for old ID ${oldId} in collection ${collectionConfig.name}`);
+                                }
+                            });
 
-                  // 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;
+                            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)}`
-          );
+            // 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);
 
-  findNewIdForOldId(oldId: string, idMapping: 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 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 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);
+  // 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
+      }
   }
 
+  logger.error(`No corresponding new ID found for ${oldId} in ${targetCollectionKey}`);
+  return null; // Return null if no new ID is found
+}
+
+
+
   private writeMapsToJsonFile() {
     const outputDir = path.resolve(process.cwd());
     const outputFile = path.join(outputDir, "dataLoaderOutput.json");
 
     const dataToWrite = {
+      // Convert Maps to arrays of entries for serialization
+      oldIdToNewIdPerCollectionMap: Array.from(
+        this.oldIdToNewIdPerCollectionMap.entries()
+      ).map(([key, value]) => {
+        return {
+          collection: key,
+          data: Array.from(value.entries()),
+        };
+      }),
+      mergedUserMap: Array.from(this.mergedUserMap.entries()),
       dataFromCollections: Array.from(this.importMap.entries()).map(
         ([key, value]) => {
           return {
@@ -446,8 +455,6 @@ export class DataLoader {
           };
         }
       ),
-      // Convert Maps to arrays of entries for serialization
-      mergedUserMap: Array.from(this.mergedUserMap.entries()),
       // emailToUserIdMap: Array.from(this.emailToUserIdMap.entries()),
       // phoneToUserIdMap: Array.from(this.phoneToUserIdMap.entries()),
     };
@@ -489,7 +496,7 @@ export class DataLoader {
     newId: string
   ): Promise<any> {
     // Transform the item data based on the attribute mappings
-    let transformedItem = await this.transformData(item, attributeMappings);
+    let transformedItem = this.transformData(item, attributeMappings);
     const userData = AuthUserCreateSchema.safeParse(transformedItem);
     if (!userData.success) {
       logger.error(
@@ -569,7 +576,7 @@ export class DataLoader {
     importDef: ImportDef
   ): Promise<void> {
     // Load the raw data based on the import definition
-    const rawData = await this.loadData(importDef);
+    const rawData = this.loadData(importDef);
     const operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
@@ -754,7 +761,7 @@ export class DataLoader {
     importDef: ImportDef
   ): Promise<void> {
     // Load the raw data based on the import definition
-    const rawData = await this.loadData(importDef);
+    const rawData = this.loadData(importDef);
     const operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
@@ -793,7 +800,7 @@ export class DataLoader {
       // 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 = await this.transformData(
+      const transformedData = this.transformData(
         item,
         importDef.attributeMappings
       );
@@ -884,7 +891,7 @@ export class DataLoader {
       return;
     }
     // Load the raw data based on the import definition
-    const rawData = await this.loadData(importDef);
+    const rawData = this.loadData(importDef);
     const operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
@@ -895,7 +902,7 @@ export class DataLoader {
     }
     for (const item of rawData) {
       // Transform the item data based on the attribute mappings
-      let transformedData = await this.transformData(
+      let transformedData = this.transformData(
         item,
         importDef.attributeMappings
       );

package/src/migrations/indexes.ts

@@ -14,6 +14,13 @@ export const createOrUpdateIndex = async (
   if (existingIndex.total > 0) {
     await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
   }
+  if (index.type === "fulltext" && index.attributes.length > 1) {
+    throw new Error(
+      `Fulltext index can only be created on a single attribute. Index: ${index.key}`
+    );
+  } else if (index.type === "fulltext") {
+    index.attributes = [index.attributes[0]];
+  }
   const newIndex = await db.createIndex(
     dbId,
     collectionId,

package/src/migrations/schemaStrings.ts

@@ -8,6 +8,7 @@ import { z } from "zod";
 import fs from "fs";
 import path from "path";
 import { dump } from "js-yaml";
+import { getDatabaseFromConfig } from "./afterImportActions.js";
 
 interface RelationshipDetail {
   parentCollection: string;
@@ -74,6 +75,9 @@ export class SchemaGenerator {
             isArrayParent,
             isArrayChild
           );
+          console.log(
+            `Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`
+          );
         }
       });
     });
@@ -133,22 +137,35 @@ export class SchemaGenerator {
 
     // Use the relationshipMap to find related collections
     const relationshipDetails = this.relationshipMap.get(name) || [];
-    const relatedCollections = relationshipDetails.map((detail) => {
-      const relatedCollectionName = detail.isChild
-        ? detail.parentCollection
-        : detail.childCollection;
-      const key = detail.isChild ? detail.childKey : detail.parentKey;
-      const isArray = detail.isArray ? "array" : "";
-      return [relatedCollectionName, key, isArray];
-    });
+    const relatedCollections = relationshipDetails
+      .filter((detail, index, self) => {
+        const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
+        return (
+          index ===
+          self.findIndex(
+            (obj) =>
+              `${obj.parentCollection}-${obj.childCollection}-${obj.parentKey}-${obj.childKey}` ===
+              uniqueKey
+          )
+        );
+      })
+      .map((detail) => {
+        const relatedCollectionName = detail.isChild
+          ? detail.parentCollection
+          : detail.childCollection;
+        const key = detail.isChild ? detail.childKey : detail.parentKey;
+        const isArray = detail.isArray ? "array" : "";
+        return [relatedCollectionName, key, isArray];
+      });
 
     let relatedTypes = "";
     let relatedTypesLazy = "";
     let curNum = 0;
     let maxNum = relatedCollections.length;
     relatedCollections.forEach((relatedCollection) => {
-      const relatedPascalName = toPascalCase(relatedCollection[0]);
-      const relatedCamelName = toCamelCase(relatedCollection[0]);
+      console.log(relatedCollection);
+      let relatedPascalName = toPascalCase(relatedCollection[0]);
+      let relatedCamelName = toCamelCase(relatedCollection[0]);
       curNum++;
       let endNameTypes = relatedPascalName;
       let endNameLazy = `${relatedPascalName}Schema`;
@@ -218,10 +235,18 @@ export class SchemaGenerator {
       case "integer":
         baseSchemaCode = "z.number().int()";
         if (attribute.min !== undefined) {
-          baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+          if (BigInt(attribute.min) === BigInt(-9223372036854776000)) {
+            delete attribute.min;
+          } else {
+            baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+          }
         }
         if (attribute.max !== undefined) {
-          baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+          if (BigInt(attribute.max) === BigInt(9223372036854776000)) {
+            delete attribute.max;
+          } else {
+            baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+          }
         }
         if (attribute.xdefault !== undefined) {
           baseSchemaCode += `.default(${attribute.xdefault})`;