appwrite-utils-cli 0.0.262 → 0.0.264

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
@@ -285,28 +285,24 @@ export class DataLoader {
                                 const oldIds = Array.isArray(item.context[idMapping.sourceField])
                                     ? item.context[idMapping.sourceField]
                                     : [item.context[idMapping.sourceField]];
+                                const resolvedNewIds = [];
                                 oldIds.forEach((oldId) => {
-                                    let newIdForOldId;
-                                    // Handling users merged into a new ID
-                                    newIdForOldId = this.findNewIdForOldId(oldId, idMapping);
-                                    if (newIdForOldId) {
-                                        const targetField = idMapping.fieldToSet || idMapping.targetField;
-                                        const isArray = collectionConfig.attributes.some((attribute) => attribute.key === targetField && attribute.array);
-                                        // Properly update the target field based on whether it should be an array
-                                        if (isArray) {
-                                            if (!Array.isArray(item.finalData[targetField])) {
-                                                item.finalData[targetField] = [newIdForOldId];
-                                            }
-                                            else if (!item.finalData[targetField].includes(newIdForOldId)) {
-                                                item.finalData[targetField].push(newIdForOldId);
-                                            }
-                                        }
-                                        else {
-                                            item.finalData[targetField] = newIdForOldId;
-                                        }
-                                        needsUpdate = true;
+                                    // 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);
+                                    }
+                                    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);
+                                    // Set the target field based on whether it's an array or single value
+                                    item.finalData[targetField] = isArray ? resolvedNewIds : resolvedNewIds[0];
+                                    needsUpdate = true;
+                                }
                             }
                         }
                     }
@@ -319,37 +315,47 @@ export class DataLoader {
             }
         }
     }
-    findNewIdForOldId(oldId, idMapping) {
-        // Check merged users first for any corresponding new ID
-        let newIdForOldId;
-        for (const [newUserId, oldIds] of this.mergedUserMap.entries()) {
-            if (oldIds.includes(oldId)) {
-                newIdForOldId = newUserId;
-                break;
+    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 no new ID found in merged users, check the old-to-new ID map for the target collection
-        if (!newIdForOldId) {
-            const targetCollectionKey = this.getCollectionKey(idMapping.targetCollection);
-            const targetOldIdToNewIdMap = this.oldIdToNewIdPerCollectionMap.get(targetCollectionKey);
-            if (targetOldIdToNewIdMap && targetOldIdToNewIdMap.has(oldId)) {
-                newIdForOldId = 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
             }
         }
-        return newIdForOldId;
+        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()),
         };
@@ -378,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)}`);
@@ -444,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();
@@ -562,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}`);
@@ -588,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];
@@ -650,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/databases.d.ts

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

package/dist/migrations/databases.js

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

package/dist/migrations/indexes.js

@@ -8,6 +8,13 @@ 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") {
+        // @ts-ignore
+        index.attributes = index.attributes[0];
+    }
     const newIndex = await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, index.orders);
     return newIndex;
 };