appwrite-utils-cli 0.9.981 → 0.9.983

package/README.md

@@ -125,6 +125,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.983: Fixed `afterImportActions` not resolving
 - 0.9.981: Try fixing `tryAwaitWithRetry` to catch `522` errors from Cloudflare, they were appearing for some users, also added a 1000ms delay to `tryAwaitWithRetry`
 - 0.9.98: Fixing some import errors reported by users
 - 0.9.95: Updated to include new version of `appwrite-utils`

package/dist/migrations/dataLoader.d.ts

@@ -708,27 +708,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
         attributes?: ({
             key: string;
             type?: "string" | undefined;
-            format
-            /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */
-            ? /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */: string | null | undefined;
+            format?: string | null | undefined;
             description?: string | Record<string, string> | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;
@@ -1392,27 +1372,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
         attributes?: ({
             key: string;
             type?: "string" | undefined;
-            format
-            /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */
-            ? /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */: string | null | undefined;
+            format?: string | null | undefined;
             description?: string | Record<string, string> | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;

package/dist/migrations/dataLoader.js

@@ -1077,20 +1077,29 @@ export class DataLoader {
             if (itemDataToUpdate) {
                 itemDataToUpdate.finalData = this.mergeObjects(itemDataToUpdate.finalData, transformedData);
                 itemDataToUpdate.context = context;
-                // Merge existing importDef with new importDef, focusing only on postImportActions
-                itemDataToUpdate.importDef = {
-                    ...itemDataToUpdate.importDef,
-                    attributeMappings: itemDataToUpdate.importDef?.attributeMappings.map((attrMapping, index) => ({
-                        ...attrMapping,
+                // Fix: Ensure we properly merge the attribute mappings and their actions
+                const mergedAttributeMappings = newImportDef.attributeMappings.map((newMapping) => {
+                    const existingMapping = itemDataToUpdate.importDef?.attributeMappings.find((m) => m.targetKey === newMapping.targetKey);
+                    return {
+                        ...newMapping,
                         postImportActions: [
-                            ...(attrMapping.postImportActions || []),
-                            ...(newImportDef.attributeMappings[index]
-                                ?.postImportActions || []),
-                        ],
-                    })) || [],
+                            ...(existingMapping?.postImportActions || []),
+                            ...(newMapping.postImportActions || [])
+                        ]
+                    };
+                });
+                itemDataToUpdate.importDef = {
+                    ...newImportDef,
+                    attributeMappings: mergedAttributeMappings
                 };
-                if (collection.name.toLowerCase() === "councils") {
-                    console.log(`Mappings in update councils: ${JSON.stringify(itemDataToUpdate.importDef.attributeMappings, null, 2)}`);
+                // Debug logging
+                if (mergedAttributeMappings.some(m => m.postImportActions?.length > 0)) {
+                    logger.info(`Post-import actions for ${collection.name}: ${JSON.stringify(mergedAttributeMappings
+                        .filter(m => m.postImportActions?.length > 0)
+                        .map(m => ({
+                        targetKey: m.targetKey,
+                        actions: m.postImportActions
+                    })), null, 2)}`);
                 }
             }
             else {

package/dist/migrations/importController.js

@@ -198,10 +198,13 @@ export class ImportController {
         }
     }
     async executePostImportActions(dbId, dataLoader, specificCollections) {
-        const collectionsToProcess = specificCollections || Array.from(dataLoader.importMap.keys());
+        console.log("Executing post-import actions...");
+        const collectionsToProcess = specificCollections && specificCollections.length > 0 ? specificCollections : (this.config.collections ? this.config.collections.map(c => c.name) : Array.from(dataLoader.importMap.keys()));
+        console.log("Collections to process:", collectionsToProcess);
         // Iterate over each collection in the importMap
         for (const [collectionKey, collectionData] of dataLoader.importMap.entries()) {
-            if (collectionsToProcess.includes(collectionKey)) {
+            const allCollectionKeys = collectionsToProcess.map(c => dataLoader.getCollectionKey(c));
+            if (allCollectionKeys.includes(collectionKey)) {
                 console.log(`Processing post-import actions for collection: ${collectionKey}`);
                 // Iterate over each item in the collectionData.data
                 for (const item of collectionData.data) {
@@ -221,6 +224,9 @@ export class ImportController {
                     }
                 }
             }
+            else {
+                console.log(`Skipping collection: ${collectionKey} because it's not valid for post-import actions`);
+            }
         }
     }
 }

package/dist/migrations/migrationHelper.d.ts

@@ -91,7 +91,6 @@ export declare const ContextObject: z.ZodObject<{
     context: z.ZodAny;
 }, "strip", z.ZodTypeAny, {
     collectionId: string;
-    dbId: string;
     attributeMappings: {
         targetKey: string;
         oldKey?: string | undefined;
@@ -111,11 +110,11 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
+    dbId: string;
     context?: any;
     finalItem?: any;
 }, {
     collectionId: string;
-    dbId: string;
     attributeMappings: {
         targetKey: string;
         oldKey?: string | undefined;
@@ -135,6 +134,7 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
+    dbId: string;
     context?: any;
     finalItem?: any;
 }>;

package/dist/migrations/users.d.ts

@@ -8,8 +8,8 @@ export declare class UsersController {
     constructor(config: AppwriteConfig, db: Databases);
     wipeUsers(): Promise<void>;
     getAllUsers(): Promise<Models.User<Models.Preferences>[]>;
-    createUsersAndReturn(items: AuthUserCreate[]): Promise<Models.User<Models.Preferences>[]>;
-    createUserAndReturn(item: AuthUserCreate, numAttempts?: number): Promise<Models.User<Models.Preferences>>;
+    createUsersAndReturn(items: AuthUserCreate[]): Promise<(Models.User<Models.Preferences> | undefined)[]>;
+    createUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
     createAndCheckForUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
     getUserIdByEmailOrPhone(email?: string, phone?: string): Promise<string | undefined>;
     transferUsersBetweenDbsLocalToRemote: (endpoint: string, projectId: string, apiKey: string) => Promise<void>;

package/dist/migrations/users.js

@@ -78,36 +78,26 @@ export class UsersController {
         const users = await Promise.all(items.map((item) => this.createUserAndReturn(item)));
         return users;
     }
-    async createUserAndReturn(item, numAttempts) {
+    async createUserAndReturn(item) {
         try {
-            const user = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
-                ? item.phone
-                : undefined, `changeMe${item.email?.toLowerCase()}` || `changeMePlease`, item.name || undefined);
-            if (item.labels) {
-                await this.users.updateLabels(user.$id, item.labels);
-            }
-            if (item.prefs) {
-                await this.users.updatePrefs(user.$id, item.prefs);
-            }
+            const user = await tryAwaitWithRetry(async () => {
+                const createdUser = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+                    ? item.phone
+                    : undefined, `changeMe${item.email?.toLowerCase()}` || `changeMePlease`, item.name || undefined);
+                if (item.labels) {
+                    await this.users.updateLabels(createdUser.$id, item.labels);
+                }
+                if (item.prefs) {
+                    await this.users.updatePrefs(createdUser.$id, item.prefs);
+                }
+                return createdUser;
+            }); // Set throwError to true since we want to handle errors
             return user;
         }
         catch (e) {
-            if (e instanceof AppwriteException) {
-                if (e.message.toLowerCase().includes("fetch failed") ||
-                    e.message.toLowerCase().includes("server error")) {
-                    const numberOfAttempts = numAttempts || 0;
-                    if (numberOfAttempts > 5) {
-                        throw e;
-                    }
-                    const user = await this.createUserAndReturn(item, numberOfAttempts + 1);
-                    return user;
-                }
-            }
             if (e instanceof Error) {
                 logger.error("FAILED CREATING USER: ", e.message, item);
             }
-            console.log("FAILED CREATING USER: ", e, item);
-            throw e;
         }
     }
     async createAndCheckForUserAndReturn(item) {

package/dist/utils/helperFunctions.js

@@ -106,7 +106,7 @@ export const tryAwaitWithRetry = async (createFunction, attemptNum = 0, throwErr
             if (attemptNum > 5) {
                 throw error;
             }
-            await delay(1000);
+            await delay(2500);
             return tryAwaitWithRetry(createFunction, attemptNum + 1);
         }
         if (throwError) {

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

package/src/migrations/dataLoader.ts

@@ -1480,26 +1480,37 @@ export class DataLoader {
           transformedData
         );
         itemDataToUpdate.context = context;
-        // Merge existing importDef with new importDef, focusing only on postImportActions
+        
+        // Fix: Ensure we properly merge the attribute mappings and their actions
+        const mergedAttributeMappings = newImportDef.attributeMappings.map((newMapping) => {
+          const existingMapping = itemDataToUpdate.importDef?.attributeMappings.find(
+            (m) => m.targetKey === newMapping.targetKey
+          );
+          
+          return {
+            ...newMapping,
+            postImportActions: [
+              ...(existingMapping?.postImportActions || []),
+              ...(newMapping.postImportActions || [])
+            ]
+          };
+        });
+      
         itemDataToUpdate.importDef = {
-          ...itemDataToUpdate.importDef,
-          attributeMappings:
-            itemDataToUpdate.importDef?.attributeMappings.map(
-              (attrMapping, index) => ({
-                ...attrMapping,
-                postImportActions: [
-                  ...(attrMapping.postImportActions || []),
-                  ...(newImportDef.attributeMappings[index]
-                    ?.postImportActions || []),
-                ],
-              })
-            ) || [],
-        } as ImportDef;
-
-        if (collection.name.toLowerCase() === "councils") {
-          console.log(
-            `Mappings in update councils: ${JSON.stringify(
-              itemDataToUpdate.importDef.attributeMappings,
+          ...newImportDef,
+          attributeMappings: mergedAttributeMappings
+        };
+      
+        // Debug logging
+        if (mergedAttributeMappings.some(m => m.postImportActions?.length > 0)) {
+          logger.info(
+            `Post-import actions for ${collection.name}: ${JSON.stringify(
+              mergedAttributeMappings
+                .filter(m => m.postImportActions?.length > 0)
+                .map(m => ({
+                  targetKey: m.targetKey,
+                  actions: m.postImportActions
+                })),
               null,
               2
             )}`

package/src/migrations/importController.ts

@@ -298,11 +298,13 @@ export class ImportController {
   }
 
   async executePostImportActions(dbId: string, dataLoader: DataLoader, specificCollections?: string[]) {
-    const collectionsToProcess = specificCollections || Array.from(dataLoader.importMap.keys());
-
+    console.log("Executing post-import actions...");
+    const collectionsToProcess = specificCollections && specificCollections.length > 0 ? specificCollections : (this.config.collections ? this.config.collections.map(c => c.name) : Array.from(dataLoader.importMap.keys()));
+    console.log("Collections to process:", collectionsToProcess);
     // Iterate over each collection in the importMap
     for (const [collectionKey, collectionData] of dataLoader.importMap.entries()) {
-      if (collectionsToProcess.includes(collectionKey)) {
+      const allCollectionKeys = collectionsToProcess.map(c => dataLoader.getCollectionKey(c));
+      if (allCollectionKeys.includes(collectionKey)) {
         console.log(
           `Processing post-import actions for collection: ${collectionKey}`
         );
@@ -330,6 +332,8 @@ export class ImportController {
             }
           }
         }
+      } else {
+        console.log(`Skipping collection: ${collectionKey} because it's not valid for post-import actions`);
       }
     }
   }

package/src/migrations/users.ts

@@ -111,44 +111,34 @@ export class UsersController {
     return users;
   }
 
-  async createUserAndReturn(item: AuthUserCreate, numAttempts?: number) {
+  async createUserAndReturn(item: AuthUserCreate) {
     try {
-      const user = await this.users.create(
-        item.userId || ID.unique(),
-        item.email || undefined,
-        item.phone && item.phone.length < 15 && item.phone.startsWith("+")
-          ? item.phone
-          : undefined,
-        `changeMe${item.email?.toLowerCase()}` || `changeMePlease`,
-        item.name || undefined
-      );
-      if (item.labels) {
-        await this.users.updateLabels(user.$id, item.labels);
-      }
-      if (item.prefs) {
-        await this.users.updatePrefs(user.$id, item.prefs);
-      }
+      const user = await tryAwaitWithRetry(async () => {
+        const createdUser = await this.users.create(
+          item.userId || ID.unique(),
+          item.email || undefined,
+          item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+            ? item.phone
+            : undefined,
+          `changeMe${item.email?.toLowerCase()}` || `changeMePlease`,
+          item.name || undefined
+        );
+  
+        if (item.labels) {
+          await this.users.updateLabels(createdUser.$id, item.labels);
+        }
+        if (item.prefs) {
+          await this.users.updatePrefs(createdUser.$id, item.prefs);
+        }
+        
+        return createdUser;
+      }); // Set throwError to true since we want to handle errors
+  
       return user;
     } catch (e) {
-      if (e instanceof AppwriteException) {
-        if (
-          e.message.toLowerCase().includes("fetch failed") ||
-          e.message.toLowerCase().includes("server error")
-        ) {
-          const numberOfAttempts = numAttempts || 0;
-          if (numberOfAttempts > 5) {
-            throw e;
-          }
-          const user: Models.User<Models.Preferences> =
-            await this.createUserAndReturn(item, numberOfAttempts + 1);
-          return user;
-        }
-      }
       if (e instanceof Error) {
         logger.error("FAILED CREATING USER: ", e.message, item);
       }
-      console.log("FAILED CREATING USER: ", e, item);
-      throw e;
     }
   }
 

package/src/utils/helperFunctions.ts

@@ -163,7 +163,7 @@ export const tryAwaitWithRetry = async <T>(
       if (attemptNum > 5) {
         throw error;
       }
-      await delay(1000);
+      await delay(2500);
       return tryAwaitWithRetry(createFunction, attemptNum + 1);
     }
     if (throwError) {