appwrite-utils-cli 0.0.32 → 0.0.34

package/dist/migrations/dataLoader.js

@@ -92,7 +92,7 @@ export class DataLoader {
                 result[key] = updateValue;
             }
             // If the update value is nullish, keep the original value unless it doesn't exist
-            else if (sourceValue === undefined) {
+            else if (sourceValue === undefined || sourceValue === null) {
                 result[key] = updateValue;
             }
         });
@@ -234,6 +234,10 @@ export class DataLoader {
                 // Determine if this is the users collection
                 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) => def.type === "create" || !def.type);
                 const updateDefs = collection.importDefs.filter((def) => def.type === "update");
@@ -258,8 +262,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) {
@@ -272,7 +276,7 @@ export class DataLoader {
             this.writeMapsToJsonFile();
         }
     }
-    async dealWithMergedUsers() {
+    dealWithMergedUsers() {
         const usersCollectionKey = this.getCollectionKey(this.config.usersCollectionName);
         const usersCollectionPrimaryKeyFields = new Set();
         if (!this.config.collections) {
@@ -281,7 +285,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);
                     }
@@ -293,19 +301,23 @@ export class DataLoader {
             const collectionData = this.importMap.get(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];
-                                const newId = this.mergedUserMap.get(oldId);
+                                const newId = this.mergedUserMap.get(`${oldId}`);
                                 if (newId) {
                                     // Update context to use new user ID
-                                    item.context[idMapping.fieldToSet || idMapping.targetField] =
-                                        newId;
+                                    item.finalData[idMapping.fieldToSet || idMapping.sourceField] = newId;
                                 }
                             });
                         }
@@ -333,123 +345,83 @@ export class DataLoader {
                             for (const idMapping of importDef.idMappings) {
                                 const targetCollectionKey = this.getCollectionKey(idMapping.targetCollection);
                                 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];
+                                // Find matching data in the target collection
+                                const foundData = targetCollectionData.data.filter(({ context }) => {
+                                    const targetValue = context[targetFieldKey];
                                     const isMatch = `${targetValue}` === `${valueToMatch}`;
-                                    // Debugging output to understand what's being compared
-                                    logger.warn(`Comparing target: ${targetValue} with match: ${valueToMatch} - Result: ${isMatch}`);
-                                    return isMatch;
+                                    // 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}`);
+                                    console.log(`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(idMapping, null, 2)}`);
                                     continue;
                                 }
                                 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);
+                                const getCurrentDataFiltered = (currentData) => {
+                                    if (Array.isArray(currentData.finalData[fieldToSetKey])) {
+                                        return currentData.finalData[fieldToSetKey].filter((data) => `${data}` !== `${valueToMatch}`);
+                                    }
+                                    return currentData.finalData[fieldToSetKey];
+                                };
+                                // Get the current data to be updated
+                                const currentDataFiltered = getCurrentDataFiltered(collectionData.data[i]);
+                                // Extract the new data to set
+                                const newData = foundData.map((data) => data.context[idMapping.targetField]);
+                                // 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 {
+                                        // Merge arrays if new data is non-empty array and filter for uniqueness
+                                        collectionData.data[i].finalData[fieldToSetKey] = [
+                                            ...new Set([...currentDataFiltered, ...newData].filter((value) => `${value}` !== `${valueToMatch}`)),
+                                        ];
+                                    }
                                 }
                                 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}`);
-            // 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 = [];
-                                oldIds.forEach((oldId) => {
-                                    // Attempt to find a new ID for the old ID
-                                    let newIdForOldId = this.findNewIdForOldId(oldId, idMapping, importDef);
-                                    if (newIdForOldId &&
-                                        !resolvedNewIds.includes(newIdForOldId)) {
-                                        resolvedNewIds.push(newIdForOldId);
+                                    if (!currentDataFiltered) {
+                                        // Set new data if current data is undefined
+                                        collectionData.data[i].finalData[fieldToSetKey] =
+                                            Array.isArray(newData) ? newData[0] : newData;
                                     }
-                                    else {
-                                        logger.error(`No new ID found for old ID ${oldId} in collection ${collectionConfig.name}`);
+                                    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
+                                        // and take the first value, because it's an array and the attribute is not an array
+                                        collectionData.data[i].finalData[fieldToSetKey] = [
+                                            ...new Set([currentDataFiltered, ...newData].filter((value) => `${value}` !== `${valueToMatch}`)),
+                                        ].slice(0, 1)[0];
+                                    }
+                                    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, 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 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
     }
     writeMapsToJsonFile() {
         const outputDir = path.resolve(process.cwd());
@@ -496,7 +468,6 @@ export class DataLoader {
      * @returns The transformed item with user-specific keys removed.
      */
     async prepareUserData(item, attributeMappings, primaryKeyField, newId) {
-        // Transform the item data based on the attribute mappings
         let transformedItem = this.transformData(item, attributeMappings);
         const userData = AuthUserCreateSchema.safeParse(transformedItem);
         if (!userData.success) {
@@ -506,35 +477,58 @@ export class DataLoader {
         const email = userData.data.email;
         const phone = userData.data.phone;
         let existingId;
-        // Check for duplicate email and add to emailToUserIdMap if not found
-        if (email && email.length > 0) {
-            if (this.emailToUserIdMap.has(email)) {
-                existingId = this.emailToUserIdMap.get(email);
-            }
-            else {
-                this.emailToUserIdMap.set(email, newId);
-            }
+        // Check for duplicate email and phone
+        if (email && this.emailToUserIdMap.has(email)) {
+            existingId = this.emailToUserIdMap.get(email);
         }
-        // Check for duplicate phone and add to phoneToUserIdMap if not found
-        if (phone && phone.length > 0) {
-            if (this.phoneToUserIdMap.has(phone)) {
-                existingId = this.phoneToUserIdMap.get(phone);
-            }
-            else {
-                this.phoneToUserIdMap.set(phone, newId);
-            }
+        else if (phone && this.phoneToUserIdMap.has(phone)) {
+            existingId = this.phoneToUserIdMap.get(phone);
         }
-        if (!existingId) {
-            existingId = newId;
+        else {
+            if (email)
+                this.emailToUserIdMap.set(email, newId);
+            if (phone)
+                this.phoneToUserIdMap.set(phone, newId);
         }
-        // If existingId is found, add to mergedUserMap
         if (existingId) {
             userData.data.userId = existingId;
             const mergedUsers = this.mergedUserMap.get(existingId) || [];
             mergedUsers.push(`${item[primaryKeyField]}`);
             this.mergedUserMap.set(existingId, mergedUsers);
+            const userFound = this.importMap
+                .get(this.getCollectionKey("users"))
+                ?.data.find((userDataExisting) => {
+                let userIdToMatch;
+                if (userDataExisting?.finalData?.userId) {
+                    userIdToMatch = userDataExisting?.finalData?.userId;
+                }
+                else if (userDataExisting?.finalData?.docId) {
+                    userIdToMatch = userDataExisting?.finalData?.docId;
+                }
+                else if (userDataExisting?.context?.userId) {
+                    userIdToMatch = userDataExisting.context.userId;
+                }
+                else if (userDataExisting?.context?.docId) {
+                    userIdToMatch = userDataExisting.context.docId;
+                }
+                return userIdToMatch === existingId;
+            });
+            if (userFound) {
+                userFound.finalData.userId = existingId;
+            }
+            return [
+                transformedItem,
+                existingId,
+                {
+                    rawData: userFound?.rawData,
+                    finalData: userFound?.finalData,
+                },
+            ];
+        }
+        else {
+            existingId = newId;
+            userData.data.userId = existingId;
         }
-        // Remove user-specific keys from the transformed item
         const userKeys = ["email", "phone", "name", "labels", "prefs"];
         userKeys.forEach((key) => {
             if (transformedItem.hasOwnProperty(key)) {
@@ -546,7 +540,6 @@ export class DataLoader {
             rawData: item,
             finalData: userData.data,
         };
-        // Directly update the importMap with the new user data, without pushing to usersMap.data first
         this.importMap.set(this.getCollectionKey("users"), {
             data: [...(usersMap?.data || []), userDataToAdd],
         });
@@ -601,12 +594,12 @@ 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) {
                 const oldId = item[importDef.primaryKeyField];

package/dist/migrations/importController.js

@@ -86,44 +86,58 @@ export class ImportController {
                 const usersData = usersDataMap?.data;
                 const usersController = new UsersController(this.config, this.database);
                 if (usersData) {
-                    console.log("Found users data");
-                    const userBatchesAll = createBatches(usersData);
-                    console.log(`${userBatchesAll.length} user batches`);
-                    for (let i = 0; i < userBatchesAll.length; i++) {
-                        const userBatches = userBatchesAll[i];
-                        console.log(`Processing user batch ${i + 1} of ${userBatchesAll.length}`);
-                        const userBatchPromises = userBatches
-                            .map((userBatch) => {
-                            if (userBatch.finalData && userBatch.finalData.length > 0) {
-                                const userId = userBatch.finalData.userId;
-                                if (dataLoader.userExistsMap.has(userId)) {
-                                    // We only are storing the existing user ID's as true, so we need to check for that
-                                    if (!(dataLoader.userExistsMap.get(userId) === true)) {
-                                        const userId = userBatch.finalData.userId ||
-                                            userBatch.context.userId ||
-                                            userBatch.context.docId;
-                                        if (!userBatch.finalData.userId) {
-                                            userBatch.finalData.userId = userId;
-                                        }
-                                        return usersController
-                                            .createUserAndReturn(userBatch.finalData)
-                                            .then(() => console.log("Created user"))
-                                            .catch((error) => {
-                                            logger.error("Error creating user:", error, "\nUser data is ", userBatch.finalData);
-                                        });
-                                    }
-                                    else {
-                                        console.log("Skipped existing user: ", userId);
-                                        return Promise.resolve();
-                                    }
-                                }
+                    console.log("Found users data", usersData.length);
+                    const userDataBatches = createBatches(usersData);
+                    for (const batch of userDataBatches) {
+                        console.log("Importing users batch", batch.length);
+                        const userBatchPromises = batch
+                            .filter((item) => {
+                            let itemId;
+                            if (item.finalData.userId) {
+                                itemId = item.finalData.userId;
                             }
+                            else if (item.finalData.docId) {
+                                itemId = item.finalData.docId;
+                            }
+                            if (!itemId) {
+                                return false;
+                            }
+                            return (item &&
+                                item.finalData &&
+                                !dataLoader.userExistsMap.has(itemId));
                         })
-                            .flat();
-                        // Wait for all promises in the current user batch to resolve
-                        await Promise.allSettled(userBatchPromises);
-                        console.log(`Completed user batch ${i + 1} of ${userBatchesAll.length}`);
+                            .map((item) => {
+                            return usersController.createUserAndReturn(item.finalData);
+                        });
+                        await Promise.all(userBatchPromises);
+                        for (const item of batch) {
+                            if (item && item.finalData) {
+                                dataLoader.userExistsMap.set(item.finalData.userId ||
+                                    item.finalData.docId ||
+                                    item.context.userId ||
+                                    item.context.docId, true);
+                            }
+                        }
+                        console.log("Finished importing users batch", batch.length);
                     }
+                    // for (let i = 0; i < usersData.length; i++) {
+                    //   const user = usersData[i];
+                    //   if (user.finalData) {
+                    //     const userId =
+                    //       user.finalData.userId ||
+                    //       user.context.userId ||
+                    //       user.context.docId;
+                    //     if (!dataLoader.userExistsMap.has(userId)) {
+                    //       if (!user.finalData.userId) {
+                    //         user.finalData.userId = userId;
+                    //       }
+                    //       await usersController.createUserAndReturn(user.finalData);
+                    //       dataLoader.userExistsMap.set(userId, true);
+                    //     } else {
+                    //       console.log("Skipped existing user: ", userId);
+                    //     }
+                    //   }
+                    // }
                     console.log("Finished importing users");
                 }
             }
@@ -146,10 +160,10 @@ export class ImportController {
                 const batches = dataSplit[i];
                 console.log(`Processing batch ${i + 1} of ${dataSplit.length}`);
                 const batchPromises = batches.map((item) => {
-                    const id = item.context.docId ||
-                        item.context.userId ||
-                        item.finalData.docId ||
-                        item.finalData.userId;
+                    const id = item.finalData.docId ||
+                        item.finalData.userId ||
+                        item.context.docId ||
+                        item.context.userId;
                     if (item.finalData.hasOwnProperty("userId")) {
                         delete item.finalData.userId;
                     }
@@ -159,17 +173,7 @@ export class ImportController {
                     if (!item.finalData) {
                         return Promise.resolve();
                     }
-                    return this.database
-                        .createDocument(db.$id, collection.$id, id, item.finalData)
-                        .then(() => {
-                        processedItems++;
-                        console.log("Created item");
-                    })
-                        .catch((error) => {
-                        console.error(`Error creating item in ${collection.name}:`, error, "\nItem data is ", item.finalData);
-                        throw error;
-                        // Optionally, log the failed item for retry or review
-                    });
+                    return this.database.createDocument(db.$id, collection.$id, id, item.finalData);
                 });
                 // Wait for all promises in the current batch to resolve
                 await Promise.allSettled(batchPromises);

package/dist/migrations/schemaStrings.js

@@ -17,25 +17,25 @@ export class SchemaGenerator {
         const collections = this.config.collections;
         delete this.config.collections;
         const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
-        const configContent = `import { type AppwriteConfig } from "appwrite-utils";
-  
-  const appwriteConfig: AppwriteConfig = {
-    appwriteEndpoint: "${this.config.appwriteEndpoint}",
-    appwriteProject: "${this.config.appwriteProject}",
-    appwriteKey: "${this.config.appwriteKey}",
-    enableDevDatabase: ${this.config.enableDevDatabase},
-    enableBackups: ${this.config.enableBackups},
-    backupInterval: ${this.config.backupInterval},
-    backupRetention: ${this.config.backupRetention},
-    enableBackupCleanup: ${this.config.enableBackupCleanup},
-    enableMockData: ${this.config.enableMockData},
-    enableWipeOtherDatabases: ${this.config.enableWipeOtherDatabases},
-    documentBucketId: "${this.config.documentBucketId}",
-    usersCollectionName: "${this.config.usersCollectionName}",
-    databases: ${JSON.stringify(this.config.databases)}
-  };
-  
-  export default appwriteConfig;
+        const configContent = `import { type AppwriteConfig } from "appwrite-utils";
+  
+  const appwriteConfig: AppwriteConfig = {
+    appwriteEndpoint: "${this.config.appwriteEndpoint}",
+    appwriteProject: "${this.config.appwriteProject}",
+    appwriteKey: "${this.config.appwriteKey}",
+    enableDevDatabase: ${this.config.enableDevDatabase},
+    enableBackups: ${this.config.enableBackups},
+    backupInterval: ${this.config.backupInterval},
+    backupRetention: ${this.config.backupRetention},
+    enableBackupCleanup: ${this.config.enableBackupCleanup},
+    enableMockData: ${this.config.enableMockData},
+    enableWipeOtherDatabases: ${this.config.enableWipeOtherDatabases},
+    documentBucketId: "${this.config.documentBucketId}",
+    usersCollectionName: "${this.config.usersCollectionName}",
+    databases: ${JSON.stringify(this.config.databases)}
+  };
+  
+  export default appwriteConfig;
   `;
         fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
         const collectionsFolderPath = path.join(this.appwriteFolderPath, "collections");
@@ -45,19 +45,19 @@ export class SchemaGenerator {
         collections?.forEach((collection) => {
             const { databaseId, ...collectionWithoutDbId } = collection; // Destructure to exclude databaseId
             const collectionFilePath = path.join(collectionsFolderPath, `${collection.name}.ts`);
-            const collectionContent = `import { type CollectionCreate } from "appwrite-utils";
-  
-  const ${collection.name}Config: Partial<CollectionCreate> = {
-    name: "${collection.name}",
-    $id: "${collection.$id}",
-    enabled: ${collection.enabled},
-    documentSecurity: ${collection.documentSecurity},
-    $permissions: [
+            const collectionContent = `import { type CollectionCreate } from "appwrite-utils";
+  
+  const ${collection.name}Config: Partial<CollectionCreate> = {
+    name: "${collection.name}",
+    $id: "${collection.$id}",
+    enabled: ${collection.enabled},
+    documentSecurity: ${collection.documentSecurity},
+    $permissions: [
       ${collection.$permissions
                 .map((permission) => `{ permission: "${permission.permission}", target: "${permission.target}" }`)
-                .join(",\n    ")}
-    ],
-    attributes: [
+                .join(",\n    ")}
+    ],
+    attributes: [
       ${collection.attributes
                 .map((attr) => {
                 return `{ ${Object.entries(attr)
@@ -85,9 +85,9 @@ export class SchemaGenerator {
                 })
                     .join(", ")} }`;
             })
-                .join(",\n    ")}
-    ],
-    indexes: [
+                .join(",\n    ")}
+    ],
+    indexes: [
       ${(collection.indexes?.map((index) => {
                 // Map each attribute to ensure it is properly quoted
                 const formattedAttributes = index.attributes.map((attr) => `"${attr}"`).join(", ") ?? "";
@@ -95,11 +95,11 @@ export class SchemaGenerator {
                     ?.filter((order) => order !== null)
                     .map((order) => `"${order}"`)
                     .join(", ") ?? ""}] }`;
-            }) ?? []).join(",\n    ")}
-    ]
-  };
-  
-  export default ${collection.name}Config;
+            }) ?? []).join(",\n    ")}
+    ]
+  };
+  
+  export default ${collection.name}Config;
   `;
             fs.writeFileSync(collectionFilePath, collectionContent, {
                 encoding: "utf-8",

package/dist/migrations/users.js

@@ -69,6 +69,9 @@ export class UsersController {
     async getAllUsers() {
         const allUsers = [];
         const users = await this.users.list([Query.limit(200)]);
+        if (users.users.length === 0) {
+            return [];
+        }
         if (users.users.length === 200) {
             let lastDocumentId = users.users[users.users.length - 1].$id;
             allUsers.push(...users.users);
@@ -112,6 +115,7 @@ export class UsersController {
             if (e instanceof Error) {
                 logger.error("FAILED CREATING USER: ", e.message);
             }
+            console.log("FAILED CREATING USER: ", e);
             throw e;
         }
     }