chore(orchestration): modules method context (#9669)

** What **
* Test to check if the MedusaContext is being injected when calling a Module's method

integration-tests/modules/__tests__/__fixtures__/testing-module/index.ts

@@ -0,0 +1,11 @@
+import { ModuleExports } from "@medusajs/types"
+import { ModuleService } from "./services/module-service"
+
+const moduleExports: ModuleExports = {
+  service: ModuleService,
+}
+
+export * from "./models"
+export * from "./services/module-service"
+
+export default moduleExports

integration-tests/modules/__tests__/__fixtures__/testing-module/models/dml-entity.ts

@@ -0,0 +1,6 @@
+import { model } from "@medusajs/utils"
+
+export const dmlEntity = model.define("dmlEntity", {
+  id: model.id().primaryKey(),
+  name: model.text(),
+})

integration-tests/modules/__tests__/__fixtures__/testing-module/models/index.ts

@@ -0,0 +1 @@
+export * from "./dml-entity"

integration-tests/modules/__tests__/__fixtures__/testing-module/services/module-service.ts

@@ -0,0 +1,17 @@
+import { IModuleService } from "@medusajs/types"
+import { MedusaContext } from "@medusajs/utils"
+
+// @ts-expect-error
+export class ModuleService implements IModuleService {
+  public property = "value"
+  public dynProperty
+
+  constructor() {
+    this.dynProperty = {
+      key: "key value",
+    }
+  }
+  async methodName(input, @MedusaContext() context) {
+    return input + " called"
+  }
+}

integration-tests/modules/__tests__/workflow-engine/workflow-engine.ts

@@ -0,0 +1,93 @@
+import { Modules } from "@medusajs/framework/utils"
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowData,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk"
+import { medusaIntegrationTestRunner } from "@medusajs/test-utils"
+import {
+  adminHeaders,
+  createAdminUser,
+} from "../../../helpers/create-admin-user"
+
+jest.setTimeout(50000)
+
+medusaIntegrationTestRunner({
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("Workflow Engine API", () => {
+      let medusaContainer
+
+      beforeAll(() => {
+        medusaContainer = getContainer()
+      })
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, medusaContainer)
+      })
+
+      describe("Testing WorkflowEngine.run", () => {
+        beforeAll(async () => {
+          const step1 = createStep(
+            {
+              name: "my-step",
+            },
+            async (input: { initial: string }, { container }) => {
+              const testMod = container.resolve("testingModule") as any
+
+              return new StepResponse(testMod.methodName(input.initial))
+            }
+          )
+
+          createWorkflow(
+            {
+              name: "my-workflow-name",
+            },
+            function (input: WorkflowData<{ initial: string }>) {
+              const stepRes = step1(input)
+
+              return new WorkflowResponse(stepRes)
+            }
+          )
+        })
+
+        it("Should invoke modules passing the current medusa context as argument", async () => {
+          const testMod = medusaContainer.resolve("testingModule") as any
+
+          const methodSpy = jest.spyOn(testMod, "methodName")
+
+          const engine = medusaContainer.resolve(Modules.WORKFLOW_ENGINE)
+
+          const res = await engine.run("my-workflow-name", {
+            transactionId: "trx-id",
+            input: {
+              initial: "abc",
+            },
+            context: {
+              meta: {
+                myStuff: "myStuff",
+              },
+            },
+          })
+
+          expect(res.result).toEqual("abc called")
+
+          expect(methodSpy).toHaveBeenCalledTimes(1)
+          expect(methodSpy).toHaveBeenCalledWith(
+            "abc",
+            expect.objectContaining({
+              transactionId: "trx-id",
+              __type: "MedusaContext",
+              eventGroupId: expect.any(String),
+              idempotencyKey: "my-workflow-name:trx-id:my-step:invoke",
+              meta: {
+                myStuff: "myStuff",
+              },
+            })
+          )
+        })
+      })
+    })
+  },
+})

integration-tests/modules/medusa-config.js

@@ -39,6 +39,9 @@ module.exports = {
     medusa_v2: enableMedusaV2,
   },
   modules: {
+    testingModule: {
+      resolve: "__tests__/__fixtures__/testing-module",
+    },
     [Modules.AUTH]: {
       resolve: "@medusajs/auth",
       options: {

packages/core/orchestration/src/workflow/local-workflow.ts

@@ -107,12 +107,9 @@ export class LocalWorkflow {
         return resolved
       }
 
-      const nonWrappable = Object.getOwnPropertyNames(resolved)
       return new Proxy(resolved, {
         get: function (target, prop) {
-          const shouldWrap = !nonWrappable.includes(prop as string)
-
-          if (!shouldWrap) {
+          if (typeof target[prop] !== "function") {
             return target[prop]
           }