chore(): Reorganize modules (#7210)

**What**
Move all modules to the modules directory

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/index.ts

@@ -0,0 +1,5 @@
+export * from "./workflow_1"
+export * from "./workflow_2"
+export * from "./workflow_async"
+export * from "./workflow_step_timeout"
+export * from "./workflow_transaction_timeout"

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_1.ts

@@ -0,0 +1,62 @@
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+} from "@medusajs/workflows-sdk"
+
+const step_1 = createStep(
+  "step_1",
+  jest.fn((input) => {
+    input.test = "test"
+    return new StepResponse(input, { compensate: 123 })
+  }),
+  jest.fn((compensateInput) => {
+    if (!compensateInput) {
+      return
+    }
+
+    return new StepResponse({
+      reverted: true,
+    })
+  })
+)
+
+const step_2 = createStep(
+  "step_2",
+  jest.fn((input, context) => {
+    if (input) {
+      return new StepResponse({ notAsyncResponse: input.hey })
+    }
+  }),
+  jest.fn((_, context) => {
+    return new StepResponse({
+      step: context.metadata.action,
+      idempotency_key: context.metadata.idempotency_key,
+      reverted: true,
+    })
+  })
+)
+
+const step_3 = createStep(
+  "step_3",
+  jest.fn((res) => {
+    return new StepResponse({
+      done: {
+        inputFromSyncStep: res.notAsyncResponse,
+      },
+    })
+  })
+)
+
+createWorkflow("workflow_1", function (input) {
+  step_1(input)
+
+  const ret2 = step_2({ hey: "oh" })
+
+  step_2({ hey: "async hello" }).config({
+    name: "new_step_name",
+    async: true,
+  })
+
+  return step_3(ret2)
+})

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_2.ts

@@ -0,0 +1,67 @@
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+} from "@medusajs/workflows-sdk"
+
+const step_1 = createStep(
+  "step_1",
+  jest.fn((input) => {
+    input.test = "test"
+    return new StepResponse(input, { compensate: 123 })
+  }),
+  jest.fn((compensateInput) => {
+    if (!compensateInput) {
+      return
+    }
+
+    return new StepResponse({
+      reverted: true,
+    })
+  })
+)
+
+export const workflow2Step2Invoke = jest.fn((input, context) => {
+  if (input) {
+    return new StepResponse({ notAsyncResponse: input.hey })
+  }
+})
+const step_2 = createStep(
+  "step_2",
+  workflow2Step2Invoke,
+  jest.fn((_, context) => {
+    return new StepResponse({
+      step: context.metadata.action,
+      idempotency_key: context.metadata.idempotency_key,
+      reverted: true,
+    })
+  })
+)
+
+export const workflow2Step3Invoke = jest.fn((res) => {
+  return new StepResponse({
+    done: {
+      inputFromSyncStep: res.notAsyncResponse,
+    },
+  })
+})
+const step_3 = createStep("step_3", workflow2Step3Invoke)
+
+createWorkflow(
+  {
+    name: "workflow_2",
+    retentionTime: 1000,
+  },
+  function (input) {
+    step_1(input)
+
+    step_2({ hey: "oh" })
+
+    const ret2_async = step_2({ hey: "async hello" }).config({
+      name: "new_step_name",
+      async: true,
+    })
+
+    return step_3(ret2_async)
+  }
+)

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_async.ts

@@ -0,0 +1,29 @@
+import {
+  StepResponse,
+  createStep,
+  createWorkflow,
+} from "@medusajs/workflows-sdk"
+import { setTimeout } from "timers/promises"
+
+const step_1_background = createStep(
+  {
+    name: "step_1_background",
+    async: true,
+  },
+  jest.fn(async (input) => {
+    await setTimeout(200)
+
+    return new StepResponse(input)
+  })
+)
+
+createWorkflow(
+  {
+    name: "workflow_async_background",
+  },
+  function (input) {
+    const resp = step_1_background(input)
+
+    return resp
+  }
+)

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_step_timeout.ts

@@ -0,0 +1,29 @@
+import {
+  StepResponse,
+  createStep,
+  createWorkflow,
+} from "@medusajs/workflows-sdk"
+import { setTimeout } from "timers/promises"
+
+const step_1 = createStep(
+  "step_1",
+  jest.fn(async (input) => {
+    await setTimeout(200)
+
+    return new StepResponse(input, { compensate: 123 })
+  }),
+  jest.fn(() => {})
+)
+
+createWorkflow(
+  {
+    name: "workflow_step_timeout",
+  },
+  function (input) {
+    const resp = step_1(input).config({
+      timeout: 0.1, // 0.1 second
+    })
+
+    return resp
+  }
+)

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_transaction_timeout.ts

@@ -0,0 +1,36 @@
+import {
+  StepResponse,
+  createStep,
+  createWorkflow,
+} from "@medusajs/workflows-sdk"
+
+const step_1 = createStep(
+  "step_1",
+  jest.fn((input) => {
+    input.test = "test"
+    return new StepResponse(input, { compensate: 123 })
+  }),
+  jest.fn((compensateInput) => {
+    if (!compensateInput) {
+      return
+    }
+
+    return new StepResponse({
+      reverted: true,
+    })
+  })
+)
+
+createWorkflow(
+  {
+    name: "workflow_transaction_timeout",
+    timeout: 0.1, // 0.1 second
+  },
+  function (input) {
+    const resp = step_1(input).config({
+      async: true,
+    })
+
+    return resp
+  }
+)

packages/modules/workflow-engine-inmemory/integration-tests/__tests__/index.spec.ts

@@ -0,0 +1,204 @@
+import { MedusaApp } from "@medusajs/modules-sdk"
+import { RemoteJoinerQuery } from "@medusajs/types"
+import { TransactionHandlerType } from "@medusajs/utils"
+import { IWorkflowEngineService } from "@medusajs/workflows-sdk"
+import { knex } from "knex"
+import { setTimeout } from "timers/promises"
+import "../__fixtures__"
+import { workflow2Step2Invoke, workflow2Step3Invoke } from "../__fixtures__"
+import { DB_URL, TestDatabase } from "../utils"
+
+const sharedPgConnection = knex<any, any>({
+  client: "pg",
+  searchPath: process.env.MEDUSA_WORKFLOW_ENGINE_DB_SCHEMA,
+  connection: {
+    connectionString: DB_URL,
+    debug: false,
+  },
+})
+
+const afterEach_ = async () => {
+  await TestDatabase.clearTables(sharedPgConnection)
+}
+
+jest.setTimeout(50000)
+
+describe("Workflow Orchestrator module", function () {
+  describe("Testing basic workflow", function () {
+    let workflowOrcModule: IWorkflowEngineService
+    let query: (
+      query: string | RemoteJoinerQuery | object,
+      variables?: Record<string, unknown>
+    ) => Promise<any>
+
+    afterEach(afterEach_)
+
+    beforeAll(async () => {
+      const {
+        runMigrations,
+        query: remoteQuery,
+        modules,
+      } = await MedusaApp({
+        sharedResourcesConfig: {
+          database: {
+            connection: sharedPgConnection,
+          },
+        },
+        modulesConfig: {
+          workflows: {
+            resolve: __dirname + "/../..",
+          },
+        },
+      })
+
+      query = remoteQuery
+
+      await runMigrations()
+
+      workflowOrcModule = modules.workflows as unknown as IWorkflowEngineService
+    })
+
+    afterEach(afterEach_)
+
+    it("should return a list of workflow executions and remove after completed when there is no retentionTime set", async () => {
+      await workflowOrcModule.run("workflow_1", {
+        input: {
+          value: "123",
+        },
+        throwOnError: true,
+      })
+
+      let executionsList = await query({
+        workflow_executions: {
+          fields: ["workflow_id", "transaction_id", "state"],
+        },
+      })
+
+      expect(executionsList).toHaveLength(1)
+
+      const { result } = await workflowOrcModule.setStepSuccess({
+        idempotencyKey: {
+          action: TransactionHandlerType.INVOKE,
+          stepId: "new_step_name",
+          workflowId: "workflow_1",
+          transactionId: executionsList[0].transaction_id,
+        },
+        stepResponse: { uhuuuu: "yeaah!" },
+      })
+
+      executionsList = await query({
+        workflow_executions: {
+          fields: ["id"],
+        },
+      })
+
+      expect(executionsList).toHaveLength(0)
+      expect(result).toEqual({
+        done: {
+          inputFromSyncStep: "oh",
+        },
+      })
+    })
+
+    it("should return a list of workflow executions and keep it saved when there is a retentionTime set", async () => {
+      await workflowOrcModule.run("workflow_2", {
+        input: {
+          value: "123",
+        },
+        throwOnError: true,
+        transactionId: "transaction_1",
+      })
+
+      let executionsList = await query({
+        workflow_executions: {
+          fields: ["id"],
+        },
+      })
+
+      expect(executionsList).toHaveLength(1)
+
+      await workflowOrcModule.setStepSuccess({
+        idempotencyKey: {
+          action: TransactionHandlerType.INVOKE,
+          stepId: "new_step_name",
+          workflowId: "workflow_2",
+          transactionId: "transaction_1",
+        },
+        stepResponse: { uhuuuu: "yeaah!" },
+      })
+
+      expect(workflow2Step2Invoke).toBeCalledTimes(2)
+      expect(workflow2Step2Invoke.mock.calls[0][0]).toEqual({ hey: "oh" })
+      expect(workflow2Step2Invoke.mock.calls[1][0]).toEqual({
+        hey: "async hello",
+      })
+
+      expect(workflow2Step3Invoke).toBeCalledTimes(1)
+      expect(workflow2Step3Invoke.mock.calls[0][0]).toEqual({
+        uhuuuu: "yeaah!",
+      })
+
+      executionsList = await query({
+        workflow_executions: {
+          fields: ["id"],
+        },
+      })
+
+      expect(executionsList).toHaveLength(1)
+    })
+
+    it("should revert the entire transaction when a step timeout expires", async () => {
+      const { transaction } = await workflowOrcModule.run(
+        "workflow_step_timeout",
+        {
+          input: {},
+          throwOnError: false,
+        }
+      )
+
+      expect(transaction.flow.state).toEqual("reverted")
+    })
+
+    it("should revert the entire transaction when the transaction timeout expires", async () => {
+      const { transaction } = await workflowOrcModule.run(
+        "workflow_transaction_timeout",
+        {
+          input: {},
+          throwOnError: false,
+        }
+      )
+
+      await setTimeout(200)
+
+      expect(transaction.flow.state).toEqual("reverted")
+    })
+
+    it("should subsctibe to a async workflow and receive the response when it finishes", (done) => {
+      const transactionId = "trx_123"
+
+      const onFinish = jest.fn(() => {
+        done()
+      })
+
+      void workflowOrcModule.subscribe({
+        workflowId: "workflow_async_background",
+        transactionId,
+        subscriber: (event) => {
+          if (event.eventType === "onFinish") {
+            onFinish()
+          }
+        },
+      })
+
+      void workflowOrcModule.run("workflow_async_background", {
+        input: {
+          myInput: "123",
+        },
+        transactionId,
+        throwOnError: false,
+      })
+
+      expect(onFinish).toHaveBeenCalledTimes(0)
+    })
+  })
+})

packages/modules/workflow-engine-inmemory/integration-tests/setup-env.js

@@ -0,0 +1,6 @@
+if (typeof process.env.DB_TEMP_NAME === "undefined") {
+  const tempName = parseInt(process.env.JEST_WORKER_ID || "1")
+  process.env.DB_TEMP_NAME = `medusa-workflow-engine-inmemory-${tempName}`
+}
+
+process.env.MEDUSA_WORKFLOW_ENGINE_DB_SCHEMA = "public"

packages/modules/workflow-engine-inmemory/integration-tests/setup.js

@@ -0,0 +1,3 @@
+import { JestUtils } from "medusa-test-utils"
+
+JestUtils.afterAllHookDropDatabase()

packages/modules/workflow-engine-inmemory/integration-tests/utils/database.ts

@@ -0,0 +1,22 @@
+import * as process from "process"
+
+const DB_HOST = process.env.DB_HOST ?? "localhost"
+const DB_USERNAME = process.env.DB_USERNAME ?? ""
+const DB_PASSWORD = process.env.DB_PASSWORD
+const DB_NAME = process.env.DB_TEMP_NAME
+
+export const DB_URL = `postgres://${DB_USERNAME}${
+  DB_PASSWORD ? `:${DB_PASSWORD}` : ""
+}@${DB_HOST}/${DB_NAME}`
+
+interface TestDatabase {
+  clearTables(knex): Promise<void>
+}
+
+export const TestDatabase: TestDatabase = {
+  clearTables: async (knex) => {
+    await knex.raw(`
+      TRUNCATE TABLE workflow_execution CASCADE;
+    `)
+  },
+}

packages/modules/workflow-engine-inmemory/integration-tests/utils/index.ts

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