chore(): Reorganize modules (#7210)

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

packages/modules/workflow-engine-redis/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-redis/integration-tests/__fixtures__/workflow_1.ts

@@ -0,0 +1,63 @@
+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
+    }
+
+    console.log("reverted", compensateInput.compensate)
+    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-redis/integration-tests/__fixtures__/workflow_2.ts

@@ -0,0 +1,69 @@
+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
+    }
+
+    console.log("reverted", compensateInput.compensate)
+    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(
+  {
+    name: "workflow_2",
+    retentionTime: 1000,
+  },
+  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-redis/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-redis/integration-tests/__fixtures__/workflow_step_timeout.ts

@@ -0,0 +1,51 @@
+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 })
+  })
+)
+
+const step_1_async = createStep(
+  {
+    name: "step_1_async",
+    async: true,
+    timeout: 0.1, // 0.1 second
+  },
+
+  jest.fn(async (input) => {
+    return
+  })
+)
+
+createWorkflow(
+  {
+    name: "workflow_step_timeout",
+  },
+  function (input) {
+    const resp = step_1(input).config({
+      timeout: 0.1, // 0.1 second
+    })
+
+    return resp
+  }
+)
+
+createWorkflow(
+  {
+    name: "workflow_step_timeout_async",
+  },
+  function (input) {
+    const resp = step_1_async(input)
+
+    return resp
+  }
+)

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

@@ -0,0 +1,44 @@
+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({
+      executed: true,
+    })
+  }),
+  jest.fn()
+)
+
+createWorkflow(
+  {
+    name: "workflow_transaction_timeout",
+    timeout: 0.1, // 0.1 second
+  },
+  function (input) {
+    const resp = step_1(input)
+
+    return resp
+  }
+)
+
+createWorkflow(
+  {
+    name: "workflow_transaction_timeout_async",
+    timeout: 0.1, // 0.1 second
+  },
+  function (input) {
+    const resp = step_1(input).config({
+      async: true,
+    })
+
+    return resp
+  }
+)

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

@@ -0,0 +1,300 @@
+import { MedusaApp } from "@medusajs/modules-sdk"
+import {
+  TransactionStepTimeoutError,
+  TransactionTimeoutError,
+} from "@medusajs/orchestration"
+import { RemoteQueryFunction } from "@medusajs/types"
+import { TransactionHandlerType, TransactionStepState } from "@medusajs/utils"
+import { IWorkflowEngineService } from "@medusajs/workflows-sdk"
+import { knex } from "knex"
+import { setTimeout } from "timers/promises"
+import "../__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)
+}
+
+describe("Workflow Orchestrator module", function () {
+  describe("Testing basic workflow", function () {
+    let workflowOrcModule: IWorkflowEngineService
+    let query: RemoteQueryFunction
+
+    afterEach(afterEach_)
+
+    beforeAll(async () => {
+      const {
+        runMigrations,
+        query: remoteQuery,
+        modules,
+      } = await MedusaApp({
+        sharedResourcesConfig: {
+          database: {
+            connection: sharedPgConnection,
+          },
+        },
+        modulesConfig: {
+          workflows: {
+            resolve: __dirname + "/../..",
+            options: {
+              redis: {
+                url: "localhost:6379",
+              },
+            },
+          },
+        },
+      })
+
+      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!" },
+      })
+
+      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, result, errors } = await workflowOrcModule.run(
+        "workflow_step_timeout",
+        {
+          input: {
+            myInput: "123",
+          },
+          throwOnError: false,
+        }
+      )
+
+      expect(transaction.flow.state).toEqual("reverted")
+      expect(result).toEqual({
+        myInput: "123",
+      })
+      expect(errors).toHaveLength(1)
+      expect(errors[0].action).toEqual("step_1")
+      expect(errors[0].error).toBeInstanceOf(TransactionStepTimeoutError)
+    })
+
+    it("should revert the entire transaction when the transaction timeout expires", async () => {
+      const { transaction, result, errors } = await workflowOrcModule.run(
+        "workflow_transaction_timeout",
+        {
+          input: {},
+          transactionId: "trx",
+          throwOnError: false,
+        }
+      )
+
+      expect(transaction.flow.state).toEqual("reverted")
+      expect(result).toEqual({ executed: true })
+      expect(errors).toHaveLength(1)
+      expect(errors[0].action).toEqual("step_1")
+      expect(
+        TransactionTimeoutError.isTransactionTimeoutError(errors[0].error)
+      ).toBe(true)
+    })
+
+    it("should revert the entire transaction when a step timeout expires in a async step", async () => {
+      await workflowOrcModule.run("workflow_step_timeout_async", {
+        input: {
+          myInput: "123",
+        },
+        transactionId: "transaction_1",
+        throwOnError: false,
+      })
+
+      await setTimeout(200)
+
+      const { transaction, result, errors } = await workflowOrcModule.run(
+        "workflow_step_timeout_async",
+        {
+          input: {
+            myInput: "123",
+          },
+          transactionId: "transaction_1",
+          throwOnError: false,
+        }
+      )
+
+      expect(transaction.flow.state).toEqual("reverted")
+      expect(result).toEqual(undefined)
+      expect(errors).toHaveLength(1)
+      expect(errors[0].action).toEqual("step_1_async")
+      expect(
+        TransactionStepTimeoutError.isTransactionStepTimeoutError(
+          errors[0].error
+        )
+      ).toBe(true)
+    })
+
+    it("should revert the entire transaction when the transaction timeout expires in a transaction containing an async step", async () => {
+      await workflowOrcModule.run("workflow_transaction_timeout_async", {
+        input: {},
+        transactionId: "transaction_1",
+        throwOnError: false,
+      })
+
+      await setTimeout(200)
+
+      const { transaction, result, errors } = await workflowOrcModule.run(
+        "workflow_transaction_timeout_async",
+        {
+          input: {},
+          transactionId: "transaction_1",
+          throwOnError: false,
+        }
+      )
+
+      expect(transaction.flow.state).toEqual("reverted")
+      expect(result).toEqual(undefined)
+      expect(errors).toHaveLength(1)
+      expect(errors[0].action).toEqual("step_1")
+      expect(
+        TransactionTimeoutError.isTransactionTimeoutError(errors[0].error)
+      ).toBe(true)
+    })
+
+    it("should complete an async workflow that returns a StepResponse", async () => {
+      const { transaction, result } = await workflowOrcModule.run(
+        "workflow_async_background",
+        {
+          input: {
+            myInput: "123",
+          },
+          transactionId: "transaction_1",
+          throwOnError: false,
+        }
+      )
+
+      expect(transaction.flow.state).toEqual(TransactionStepState.INVOKING)
+      expect(result).toEqual(undefined)
+
+      await setTimeout(205)
+
+      const trx = await workflowOrcModule.run("workflow_async_background", {
+        input: {
+          myInput: "123",
+        },
+        transactionId: "transaction_1",
+        throwOnError: false,
+      })
+
+      expect(trx.transaction.flow.state).toEqual(TransactionStepState.DONE)
+      expect(trx.result).toEqual({
+        myInput: "123",
+      })
+    })
+
+    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.run("workflow_async_background", {
+        input: {
+          myInput: "123",
+        },
+        transactionId,
+        throwOnError: false,
+      })
+
+      void workflowOrcModule.subscribe({
+        workflowId: "workflow_async_background",
+        transactionId,
+        subscriber: (event) => {
+          if (event.eventType === "onFinish") {
+            onFinish()
+          }
+        },
+      })
+
+      expect(onFinish).toHaveBeenCalledTimes(0)
+    })
+  })
+})

packages/modules/workflow-engine-redis/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-redis-${tempName}`
+}
+
+process.env.MEDUSA_WORKFLOW_ENGINE_DB_SCHEMA = "public"

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

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

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

@@ -0,0 +1,53 @@
+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}`
+
+const Redis = require("ioredis")
+
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379"
+const redis = new Redis(redisUrl)
+
+interface TestDatabase {
+  clearTables(knex): Promise<void>
+}
+
+export const TestDatabase: TestDatabase = {
+  clearTables: async (knex) => {
+    await knex.raw(`
+      TRUNCATE TABLE workflow_execution CASCADE;
+    `)
+
+    await cleanRedis()
+  },
+}
+
+async function deleteKeysByPattern(pattern) {
+  const stream = redis.scanStream({
+    match: pattern,
+    count: 100,
+  })
+
+  for await (const keys of stream) {
+    if (keys.length) {
+      const pipeline = redis.pipeline()
+      keys.forEach((key) => pipeline.del(key))
+      await pipeline.exec()
+    }
+  }
+}
+
+async function cleanRedis() {
+  try {
+    await deleteKeysByPattern("bull:*")
+    await deleteKeysByPattern("dtrans:*")
+  } catch (error) {
+    console.error("Error:", error)
+  }
+}

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

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