fix: action module fetching logic to resolve correct module IDs (#1340)

* fix: action module fetching logic and add tests

- src/tools/auth0/handlers/actions.ts: simplify module fetching logic by removing redundant checks for actionModules
- test/tools/auth0/handlers/actions.tests.js: add test to ensure modules are fetched from API even when actionModules are provided

* add error handling for missing module version id

* add error handling for missing module version id

* test: add error handling for missing module version id in actions tests

* lint fix

Author: kushalshit27

src/tools/auth0/handlers/actions.ts

@@ -247,7 +247,7 @@ export default class ActionHandler extends DefaultAPIHandler {
   }
 
   async calcChanges(assets: Assets): Promise<CalculatedChanges> {
-    let { actions, actionModules } = assets;
+    let { actions } = assets;
 
     // Do nothing if not set
     if (!actions)
@@ -259,19 +259,15 @@ export default class ActionHandler extends DefaultAPIHandler {
       };
 
     let modules: ActionModule[] | null = null;
-    if (actionModules && actionModules.length > 0) {
-      modules = actionModules;
-    } else {
-      try {
-        modules = await paginate<ActionModule>(this.client.actions.modules.list, {
-          paginate: true,
-        });
-      } catch {
-        log.debug(
-          'Skipping actions modules enrichment because action modules could not be retrieved.'
-        );
-        modules = null;
-      }
+    try {
+      modules = await paginate<ActionModule>(this.client.actions.modules.list, {
+        paginate: true,
+      });
+    } catch {
+      log.debug(
+        'Skipping actions modules enrichment because action modules could not be retrieved.'
+      );
+      modules = null;
     }
 
     if (modules != null) {
@@ -313,13 +309,20 @@ export default class ActionHandler extends DefaultAPIHandler {
               allModuleVersions.push(...moduleVersions.data);
             }
 
+            const moduleVersionId = allModuleVersions?.find(
+              (v) => v.version_number === module.module_version_number
+            )?.id;
+            if (!moduleVersionId) {
+              throw new Error(
+                `Could not find action module version id for module '${module.module_name}' version '${module.module_version_number}'`
+              );
+            }
+
             return {
               module_name: module.module_name,
               module_id: foundModule.id,
               module_version_number: module.module_version_number,
-              module_version_id:
-                allModuleVersions?.find((v) => v.version_number === module.module_version_number)
-                  ?.id || '',
+              module_version_id: moduleVersionId,
             };
           }
           return module;

test/tools/auth0/handlers/actions.tests.js

@@ -551,6 +551,160 @@ describe('#actions handler', () => {
       await stageFn.apply(handler, [{ actions: [action] }]);
     });
 
+    it('should fetch modules from API even when actionModules are provided in assets', async () => {
+      const actionId = 'action-with-modules-id';
+      const moduleId = 'module-id-from-api';
+      const moduleVersionId = 'version-uuid-from-api';
+
+      const action = {
+        name: 'action-with-modules',
+        supported_triggers: [{ id: 'post-login', version: 'v1' }],
+        modules: [{ module_name: 'test-module', module_version_number: 1 }],
+      };
+
+      // Local config module — has no `id` field (desired state only)
+      const localConfigModule = { name: 'test-module', code: 'module.exports = {};' };
+
+      let modulesListCalled = false;
+      let createCalledWith = null;
+
+      const auth0 = {
+        actions: {
+          get: () => Promise.resolve({ data: { ...action, id: actionId } }),
+          create: (data) => {
+            createCalledWith = data;
+            return Promise.resolve({ data: { ...data, id: actionId } });
+          },
+          update: () => Promise.resolve({ data: [] }),
+          delete: () => Promise.resolve({ data: [] }),
+          list: () => {
+            if (!auth0.listCalled) {
+              auth0.listCalled = true;
+              return mockPagedData({ include_totals: true }, 'actions', []);
+            }
+            return mockPagedData({ include_totals: true }, 'actions', [
+              { name: action.name, supported_triggers: action.supported_triggers, id: actionId },
+            ]);
+          },
+          createVersion: () =>
+            Promise.resolve({
+              data: {
+                code: 'action-code',
+                dependencies: [],
+                id: 'version-id',
+                runtime: 'node12',
+                secrets: [],
+              },
+            }),
+          modules: {
+            list: () => {
+              modulesListCalled = true;
+              return mockPagedData({ paginate: true }, 'modules', [
+                { id: moduleId, name: 'test-module', code: 'module.exports = {};' },
+              ]);
+            },
+            versions: {
+              list: () =>
+                Promise.resolve(
+                  mockPagedData({ paginate: true }, 'versions', [
+                    { id: moduleVersionId, version_number: 1 },
+                  ])
+                ),
+            },
+          },
+        },
+        pool: {
+          addEachTask: (data) => {
+            const results = data.data.map(data.generator);
+            return { promise: () => Promise.all(results) };
+          },
+        },
+        listCalled: false,
+      };
+
+      const handler = new actions.default({ client: pageClient(auth0), config });
+      const stageFn = Object.getPrototypeOf(handler).processChanges;
+
+      // Pass both actions and actionModules in assets (the bug scenario)
+      await stageFn.apply(handler, [{ actions: [action], actionModules: [localConfigModule] }]);
+
+      // API must have been called to resolve module IDs — not the local config shortcut
+      expect(modulesListCalled).to.equal(true);
+
+      // The created action must have a valid module_version_id, not undefined or ''
+      expect(createCalledWith.modules[0].module_version_id).to.equal(moduleVersionId);
+      expect(createCalledWith.modules[0].module_id).to.equal(moduleId);
+    });
+
+    it('should throw an error when the requested module version number is not found in API', async () => {
+      const actionId = 'action-missing-version-id';
+      const moduleId = 'module-id-from-api';
+
+      const action = {
+        name: 'action-missing-version',
+        supported_triggers: [{ id: 'post-login', version: 'v1' }],
+        // references version 99 which does not exist in the API
+        modules: [{ module_name: 'test-module', module_version_number: 99 }],
+      };
+
+      const auth0 = {
+        actions: {
+          get: () => Promise.resolve({ data: { ...action, id: actionId } }),
+          create: (data) => Promise.resolve({ data: { ...data, id: actionId } }),
+          update: () => Promise.resolve({ data: [] }),
+          delete: () => Promise.resolve({ data: [] }),
+          list: () => {
+            if (!auth0.listCalled) {
+              auth0.listCalled = true;
+              return mockPagedData({ include_totals: true }, 'actions', []);
+            }
+            return mockPagedData({ include_totals: true }, 'actions', [
+              { name: action.name, supported_triggers: action.supported_triggers, id: actionId },
+            ]);
+          },
+          createVersion: () =>
+            Promise.resolve({
+              data: {
+                code: 'action-code',
+                dependencies: [],
+                id: 'version-id',
+                runtime: 'node12',
+                secrets: [],
+              },
+            }),
+          modules: {
+            list: () =>
+              mockPagedData({ paginate: true }, 'modules', [
+                { id: moduleId, name: 'test-module', code: 'module.exports = {};' },
+              ]),
+            versions: {
+              list: () =>
+                Promise.resolve(
+                  // Only version 1 exists — version 99 is absent
+                  mockPagedData({ paginate: true }, 'versions', [
+                    { id: 'v1-uuid', version_number: 1 },
+                  ])
+                ),
+            },
+          },
+        },
+        pool: {
+          addEachTask: (data) => {
+            const results = data.data.map(data.generator);
+            return { promise: () => Promise.all(results) };
+          },
+        },
+        listCalled: false,
+      };
+
+      const handler = new actions.default({ client: pageClient(auth0), config });
+      const stageFn = Object.getPrototypeOf(handler).processChanges;
+
+      await expect(stageFn.apply(handler, [{ actions: [action] }])).to.be.rejectedWith(
+        /Could not find action module version id for module 'test-module' version '99'/
+      );
+    });
+
     it('should handle actions without modules', async () => {
       const actionId = 'action-no-modules-id';
       const action = {