chore(): Reorganize modules (#7210)

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

packages/modules/workflow-engine-inmemory/src/index.ts

@@ -0,0 +1,22 @@
+import { Modules } from "@medusajs/modules-sdk"
+import { ModulesSdkUtils } from "@medusajs/utils"
+import * as models from "@models"
+import { moduleDefinition } from "./module-definition"
+
+export default moduleDefinition
+
+const migrationScriptOptions = {
+  moduleName: Modules.WORKFLOW_ENGINE,
+  models: models,
+  pathToMigrations: __dirname + "/migrations",
+}
+
+export const runMigrations = ModulesSdkUtils.buildMigrationScript(
+  migrationScriptOptions
+)
+export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
+  migrationScriptOptions
+)
+
+export * from "./initialize"
+export * from "./loaders"

packages/modules/workflow-engine-inmemory/src/initialize/index.ts

@@ -0,0 +1,34 @@
+import {
+  ExternalModuleDeclaration,
+  InternalModuleDeclaration,
+  MODULE_PACKAGE_NAMES,
+  MedusaModule,
+  Modules,
+} from "@medusajs/modules-sdk"
+import { ModulesSdkTypes } from "@medusajs/types"
+import { IWorkflowEngineService } from "@medusajs/workflows-sdk"
+import { moduleDefinition } from "../module-definition"
+import { InitializeModuleInjectableDependencies } from "../types"
+
+export const initialize = async (
+  options?:
+    | ModulesSdkTypes.ModuleServiceInitializeOptions
+    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
+    | ExternalModuleDeclaration
+    | InternalModuleDeclaration,
+  injectedDependencies?: InitializeModuleInjectableDependencies
+): Promise<IWorkflowEngineService> => {
+  const loaded =
+    // eslint-disable-next-line max-len
+    await MedusaModule.bootstrap<IWorkflowEngineService>({
+      moduleKey: Modules.WORKFLOW_ENGINE,
+      defaultPath: MODULE_PACKAGE_NAMES[Modules.WORKFLOW_ENGINE],
+      declaration: options as
+        | InternalModuleDeclaration
+        | ExternalModuleDeclaration,
+      injectedDependencies,
+      moduleExports: moduleDefinition,
+    })
+
+  return loaded[Modules.WORKFLOW_ENGINE]
+}

packages/modules/workflow-engine-inmemory/src/joiner-config.ts

@@ -0,0 +1,34 @@
+import { Modules } from "@medusajs/modules-sdk"
+import { ModuleJoinerConfig } from "@medusajs/types"
+import { MapToConfig } from "@medusajs/utils"
+import { WorkflowExecution } from "@models"
+import moduleSchema from "./schema"
+
+export const LinkableKeys = {
+  workflow_execution_id: WorkflowExecution.name,
+}
+
+const entityLinkableKeysMap: MapToConfig = {}
+Object.entries(LinkableKeys).forEach(([key, value]) => {
+  entityLinkableKeysMap[value] ??= []
+  entityLinkableKeysMap[value].push({
+    mapTo: key,
+    valueFrom: key.split("_").pop()!,
+  })
+})
+
+export const entityNameToLinkableKeysMap: MapToConfig = entityLinkableKeysMap
+
+export const joinerConfig: ModuleJoinerConfig = {
+  serviceName: Modules.WORKFLOW_ENGINE,
+  primaryKeys: ["id"],
+  schema: moduleSchema,
+  linkableKeys: LinkableKeys,
+  alias: {
+    name: ["workflow_execution", "workflow_executions"],
+    args: {
+      entity: WorkflowExecution.name,
+      methodSuffix: "WorkflowExecution",
+    },
+  },
+}

packages/modules/workflow-engine-inmemory/src/loaders/connection.ts

@@ -0,0 +1,36 @@
+import {
+  InternalModuleDeclaration,
+  LoaderOptions,
+  Modules,
+} from "@medusajs/modules-sdk"
+import { ModulesSdkTypes } from "@medusajs/types"
+import { ModulesSdkUtils } from "@medusajs/utils"
+import { EntitySchema } from "@mikro-orm/core"
+import * as WorkflowOrchestratorModels from "../models"
+
+export default async (
+  {
+    options,
+    container,
+    logger,
+  }: LoaderOptions<
+    | ModulesSdkTypes.ModuleServiceInitializeOptions
+    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
+  >,
+  moduleDeclaration?: InternalModuleDeclaration
+): Promise<void> => {
+  const entities = Object.values(
+    WorkflowOrchestratorModels
+  ) as unknown as EntitySchema[]
+  const pathToMigrations = __dirname + "/../migrations"
+
+  await ModulesSdkUtils.mikroOrmConnectionLoader({
+    moduleName: Modules.WORKFLOW_ENGINE,
+    entities,
+    container,
+    options,
+    moduleDeclaration,
+    logger,
+    pathToMigrations,
+  })
+}

packages/modules/workflow-engine-inmemory/src/loaders/container.ts

@@ -0,0 +1,9 @@
+import { MikroOrmBaseRepository, ModulesSdkUtils } from "@medusajs/utils"
+import * as ModuleModels from "@models"
+import * as ModuleServices from "@services"
+
+export default ModulesSdkUtils.moduleContainerLoaderFactory({
+  moduleModels: ModuleModels,
+  moduleServices: ModuleServices,
+  moduleRepositories: { BaseRepository: MikroOrmBaseRepository },
+})

packages/modules/workflow-engine-inmemory/src/loaders/index.ts

@@ -0,0 +1,3 @@
+export * from "./connection"
+export * from "./container"
+export * from "./utils"

packages/modules/workflow-engine-inmemory/src/loaders/utils.ts

@@ -0,0 +1,10 @@
+import { asClass } from "awilix"
+import { InMemoryDistributedTransactionStorage } from "../utils"
+
+export default async ({ container }): Promise<void> => {
+  container.register({
+    inMemoryDistributedTransactionStorage: asClass(
+      InMemoryDistributedTransactionStorage
+    ).singleton(),
+  })
+}

packages/modules/workflow-engine-inmemory/src/migrations/Migration20231228143900.ts

@@ -0,0 +1,41 @@
+import { Migration } from "@mikro-orm/migrations"
+
+export class Migration20231221104256 extends Migration {
+  async up(): Promise<void> {
+    this.addSql(
+      `
+      CREATE TABLE IF NOT EXISTS workflow_execution
+        (
+            id character varying NOT NULL,
+            workflow_id character varying NOT NULL,
+            transaction_id character varying NOT NULL,
+            execution jsonb NULL,
+            context jsonb NULL,
+            state character varying NOT NULL,
+            created_at timestamp WITHOUT time zone NOT NULL DEFAULT Now(),
+            updated_at timestamp WITHOUT time zone NOT NULL DEFAULT Now(),
+            deleted_at timestamp WITHOUT time zone NULL,
+            CONSTRAINT "PK_workflow_execution_workflow_id_transaction_id" PRIMARY KEY ("workflow_id", "transaction_id")
+        );
+        
+        CREATE UNIQUE INDEX IF NOT EXISTS "IDX_workflow_execution_id" ON "workflow_execution" ("id");
+        CREATE INDEX IF NOT EXISTS "IDX_workflow_execution_workflow_id" ON "workflow_execution" ("workflow_id") WHERE deleted_at IS NULL;
+        CREATE INDEX IF NOT EXISTS "IDX_workflow_execution_transaction_id" ON "workflow_execution" ("transaction_id") WHERE deleted_at IS NULL;
+        CREATE INDEX IF NOT EXISTS "IDX_workflow_execution_state" ON "workflow_execution" ("state") WHERE deleted_at IS NULL;
+      `
+    )
+  }
+
+  async down(): Promise<void> {
+    this.addSql(
+      `
+        DROP INDEX "IDX_workflow_execution_id";
+        DROP INDEX "IDX_workflow_execution_workflow_id";
+        DROP INDEX "IDX_workflow_execution_transaction_id";
+        DROP INDEX "IDX_workflow_execution_state";
+
+        DROP TABLE IF EXISTS workflow_execution;
+      `
+    )
+  }
+}

packages/modules/workflow-engine-inmemory/src/models/index.ts

@@ -0,0 +1 @@
+export { default as WorkflowExecution } from "./workflow-execution"

packages/modules/workflow-engine-inmemory/src/models/workflow-execution.ts

@@ -0,0 +1,76 @@
+import { TransactionState } from "@medusajs/orchestration"
+import { DALUtils, generateEntityId } from "@medusajs/utils"
+import {
+  BeforeCreate,
+  Entity,
+  Enum,
+  Filter,
+  Index,
+  OnInit,
+  OptionalProps,
+  PrimaryKey,
+  Property,
+  Unique,
+} from "@mikro-orm/core"
+
+type OptionalFields = "deleted_at"
+
+@Entity()
+@Unique({
+  name: "IDX_workflow_execution_workflow_id_transaction_id_unique",
+  properties: ["workflow_id", "transaction_id"],
+})
+@Filter(DALUtils.mikroOrmSoftDeletableFilterOptions)
+export default class WorkflowExecution {
+  [OptionalProps]?: OptionalFields
+
+  @Property({ columnType: "text", nullable: false })
+  @Index({ name: "IDX_workflow_execution_id" })
+  id!: string
+
+  @Index({ name: "IDX_workflow_execution_workflow_id" })
+  @PrimaryKey({ columnType: "text" })
+  workflow_id: string
+
+  @Index({ name: "IDX_workflow_execution_transaction_id" })
+  @PrimaryKey({ columnType: "text" })
+  transaction_id: string
+
+  @Property({ columnType: "jsonb", nullable: true })
+  execution: Record<string, unknown> | null = null
+
+  @Property({ columnType: "jsonb", nullable: true })
+  context: Record<string, unknown> | null = null
+
+  @Index({ name: "IDX_workflow_execution_state" })
+  @Enum(() => TransactionState)
+  state: TransactionState
+
+  @Property({
+    onCreate: () => new Date(),
+    columnType: "timestamptz",
+    defaultRaw: "now()",
+  })
+  created_at: Date
+
+  @Property({
+    onCreate: () => new Date(),
+    onUpdate: () => new Date(),
+    columnType: "timestamptz",
+    defaultRaw: "now()",
+  })
+  updated_at: Date
+
+  @Property({ columnType: "timestamptz", nullable: true })
+  deleted_at: Date | null = null
+
+  @BeforeCreate()
+  onCreate() {
+    this.id = generateEntityId(this.id, "wf_exec")
+  }
+
+  @OnInit()
+  onInit() {
+    this.id = generateEntityId(this.id, "wf_exec")
+  }
+}

packages/modules/workflow-engine-inmemory/src/module-definition.ts

@@ -0,0 +1,13 @@
+import { ModuleExports } from "@medusajs/types"
+import { WorkflowsModuleService } from "@services"
+import loadConnection from "./loaders/connection"
+import loadContainer from "./loaders/container"
+import loadUtils from "./loaders/utils"
+
+const service = WorkflowsModuleService
+const loaders = [loadContainer, loadConnection, loadUtils] as any
+
+export const moduleDefinition: ModuleExports = {
+  service,
+  loaders,
+}

packages/modules/workflow-engine-inmemory/src/repositories/index.ts

@@ -0,0 +1,2 @@
+export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
+export { WorkflowExecutionRepository } from "./workflow-execution"

packages/modules/workflow-engine-inmemory/src/repositories/workflow-execution.ts

@@ -0,0 +1,7 @@
+import { DALUtils } from "@medusajs/utils"
+import { WorkflowExecution } from "@models"
+
+// eslint-disable-next-line max-len
+export class WorkflowExecutionRepository extends DALUtils.mikroOrmBaseRepositoryFactory(
+  WorkflowExecution
+) {}

packages/modules/workflow-engine-inmemory/src/schema/index.ts

@@ -0,0 +1,26 @@
+export default `
+scalar DateTime
+scalar JSON
+
+enum TransactionState {
+  NOT_STARTED
+  INVOKING
+  WAITING_TO_COMPENSATE
+  COMPENSATING
+  DONE
+  REVERTED
+  FAILED
+}
+
+type WorkflowExecution {
+  id: ID!
+  created_at: DateTime!
+  updated_at: DateTime!
+  deleted_at: DateTime
+  workflow_id: string
+  transaction_id: string
+  execution: JSON
+  context: JSON
+  state: TransactionState
+}
+`

packages/modules/workflow-engine-inmemory/src/services/index.ts

@@ -0,0 +1,2 @@
+export * from "./workflow-orchestrator"
+export * from "./workflows-module"

packages/modules/workflow-engine-inmemory/src/services/workflow-orchestrator.ts

@@ -0,0 +1,550 @@
+import {
+  DistributedTransaction,
+  DistributedTransactionEvents,
+  TransactionHandlerType,
+  TransactionStep,
+} from "@medusajs/orchestration"
+import { ContainerLike, Context, MedusaContainer } from "@medusajs/types"
+import { InjectSharedContext, isString, MedusaContext } from "@medusajs/utils"
+import {
+  type FlowRunOptions,
+  MedusaWorkflow,
+  resolveValue,
+  ReturnWorkflow,
+} from "@medusajs/workflows-sdk"
+import { ulid } from "ulid"
+import { InMemoryDistributedTransactionStorage } from "../utils"
+
+export type WorkflowOrchestratorRunOptions<T> = Omit<
+  FlowRunOptions<T>,
+  "container"
+> & {
+  transactionId?: string
+  container?: ContainerLike
+}
+
+type RegisterStepSuccessOptions<T> = Omit<
+  WorkflowOrchestratorRunOptions<T>,
+  "transactionId" | "input"
+>
+
+type IdempotencyKeyParts = {
+  workflowId: string
+  transactionId: string
+  stepId: string
+  action: "invoke" | "compensate"
+}
+
+type NotifyOptions = {
+  eventType: keyof DistributedTransactionEvents
+  workflowId: string
+  transactionId?: string
+  step?: TransactionStep
+  response?: unknown
+  result?: unknown
+  errors?: unknown[]
+}
+
+type WorkflowId = string
+type TransactionId = string
+
+type SubscriberHandler = {
+  (input: NotifyOptions): void
+} & {
+  _id?: string
+}
+
+type SubscribeOptions = {
+  workflowId: string
+  transactionId?: string
+  subscriber: SubscriberHandler
+  subscriberId?: string
+}
+
+type UnsubscribeOptions = {
+  workflowId: string
+  transactionId?: string
+  subscriberOrId: string | SubscriberHandler
+}
+
+type TransactionSubscribers = Map<TransactionId, SubscriberHandler[]>
+type Subscribers = Map<WorkflowId, TransactionSubscribers>
+
+const AnySubscriber = "any"
+
+export class WorkflowOrchestratorService {
+  private subscribers: Subscribers = new Map()
+
+  constructor({
+    inMemoryDistributedTransactionStorage,
+  }: {
+    inMemoryDistributedTransactionStorage: InMemoryDistributedTransactionStorage
+    workflowOrchestratorService: WorkflowOrchestratorService
+  }) {
+    inMemoryDistributedTransactionStorage.setWorkflowOrchestratorService(this)
+    DistributedTransaction.setStorage(inMemoryDistributedTransactionStorage)
+  }
+
+  @InjectSharedContext()
+  async run<T = unknown>(
+    workflowIdOrWorkflow: string | ReturnWorkflow<any, any, any>,
+    options?: WorkflowOrchestratorRunOptions<T>,
+    @MedusaContext() sharedContext: Context = {}
+  ) {
+    let {
+      input,
+      context,
+      transactionId,
+      resultFrom,
+      throwOnError,
+      events: eventHandlers,
+      container,
+    } = options ?? {}
+
+    const workflowId = isString(workflowIdOrWorkflow)
+      ? workflowIdOrWorkflow
+      : workflowIdOrWorkflow.getName()
+
+    if (!workflowId) {
+      throw new Error("Workflow ID is required")
+    }
+
+    context ??= {}
+    context.transactionId ??= transactionId ?? ulid()
+
+    const events: FlowRunOptions["events"] = this.buildWorkflowEvents({
+      customEventHandlers: eventHandlers,
+      workflowId,
+      transactionId: context.transactionId,
+    })
+
+    const exportedWorkflow: any = MedusaWorkflow.getWorkflow(workflowId)
+    if (!exportedWorkflow) {
+      throw new Error(`Workflow with id "${workflowId}" not found.`)
+    }
+
+    const flow = exportedWorkflow(container as MedusaContainer)
+
+    const ret = await flow.run({
+      input,
+      throwOnError,
+      resultFrom,
+      context,
+      events,
+    })
+
+    // TODO: temporary
+    const acknowledgement = {
+      transactionId: context.transactionId,
+      workflowId: workflowId,
+    }
+
+    if (ret.transaction.hasFinished()) {
+      const { result, errors } = ret
+      this.notify({
+        eventType: "onFinish",
+        workflowId,
+        transactionId: context.transactionId,
+        result,
+        errors,
+      })
+    }
+
+    return { acknowledgement, ...ret }
+  }
+
+  @InjectSharedContext()
+  async getRunningTransaction(
+    workflowId: string,
+    transactionId: string,
+    options?: WorkflowOrchestratorRunOptions<undefined>,
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<DistributedTransaction> {
+    let { context, container } = options ?? {}
+
+    if (!workflowId) {
+      throw new Error("Workflow ID is required")
+    }
+
+    if (!transactionId) {
+      throw new Error("TransactionId ID is required")
+    }
+
+    context ??= {}
+    context.transactionId ??= transactionId
+
+    const exportedWorkflow: any = MedusaWorkflow.getWorkflow(workflowId)
+    if (!exportedWorkflow) {
+      throw new Error(`Workflow with id "${workflowId}" not found.`)
+    }
+
+    const flow = exportedWorkflow(container as MedusaContainer)
+
+    const transaction = await flow.getRunningTransaction(transactionId, context)
+
+    return transaction
+  }
+
+  @InjectSharedContext()
+  async setStepSuccess<T = unknown>(
+    {
+      idempotencyKey,
+      stepResponse,
+      options,
+    }: {
+      idempotencyKey: string | IdempotencyKeyParts
+      stepResponse: unknown
+      options?: RegisterStepSuccessOptions<T>
+    },
+    @MedusaContext() sharedContext: Context = {}
+  ) {
+    const {
+      context,
+      throwOnError,
+      resultFrom,
+      container,
+      events: eventHandlers,
+    } = options ?? {}
+
+    const [idempotencyKey_, { workflowId, transactionId }] =
+      this.buildIdempotencyKeyAndParts(idempotencyKey)
+
+    const exportedWorkflow: any = MedusaWorkflow.getWorkflow(workflowId)
+    if (!exportedWorkflow) {
+      throw new Error(`Workflow with id "${workflowId}" not found.`)
+    }
+
+    const flow = exportedWorkflow(container as MedusaContainer)
+
+    const events = this.buildWorkflowEvents({
+      customEventHandlers: eventHandlers,
+      transactionId,
+      workflowId,
+    })
+
+    const ret = await flow.registerStepSuccess({
+      idempotencyKey: idempotencyKey_,
+      context,
+      resultFrom,
+      throwOnError,
+      events,
+      response: stepResponse,
+    })
+
+    if (ret.transaction.hasFinished()) {
+      const { result, errors } = ret
+      this.notify({
+        eventType: "onFinish",
+        workflowId,
+        transactionId,
+        result,
+        errors,
+      })
+    }
+
+    return ret
+  }
+
+  @InjectSharedContext()
+  async setStepFailure<T = unknown>(
+    {
+      idempotencyKey,
+      stepResponse,
+      options,
+    }: {
+      idempotencyKey: string | IdempotencyKeyParts
+      stepResponse: unknown
+      options?: RegisterStepSuccessOptions<T>
+    },
+    @MedusaContext() sharedContext: Context = {}
+  ) {
+    const {
+      context,
+      throwOnError,
+      resultFrom,
+      container,
+      events: eventHandlers,
+    } = options ?? {}
+
+    const [idempotencyKey_, { workflowId, transactionId }] =
+      this.buildIdempotencyKeyAndParts(idempotencyKey)
+
+    const exportedWorkflow: any = MedusaWorkflow.getWorkflow(workflowId)
+    if (!exportedWorkflow) {
+      throw new Error(`Workflow with id "${workflowId}" not found.`)
+    }
+
+    const flow = exportedWorkflow(container as MedusaContainer)
+
+    const events = this.buildWorkflowEvents({
+      customEventHandlers: eventHandlers,
+      transactionId,
+      workflowId,
+    })
+
+    const ret = await flow.registerStepFailure({
+      idempotencyKey: idempotencyKey_,
+      context,
+      resultFrom,
+      throwOnError,
+      events,
+      response: stepResponse,
+    })
+
+    if (ret.transaction.hasFinished()) {
+      const { result, errors } = ret
+      this.notify({
+        eventType: "onFinish",
+        workflowId,
+        transactionId,
+        result,
+        errors,
+      })
+    }
+
+    return ret
+  }
+
+  @InjectSharedContext()
+  subscribe(
+    { workflowId, transactionId, subscriber, subscriberId }: SubscribeOptions,
+    @MedusaContext() sharedContext: Context = {}
+  ) {
+    subscriber._id = subscriberId
+    const subscribers = this.subscribers.get(workflowId) ?? new Map()
+
+    const handlerIndex = (handlers) => {
+      return handlers.indexOf((s) => s === subscriber || s._id === subscriberId)
+    }
+
+    if (transactionId) {
+      const transactionSubscribers = subscribers.get(transactionId) ?? []
+      const subscriberIndex = handlerIndex(transactionSubscribers)
+      if (subscriberIndex !== -1) {
+        transactionSubscribers.slice(subscriberIndex, 1)
+      }
+
+      transactionSubscribers.push(subscriber)
+      subscribers.set(transactionId, transactionSubscribers)
+      this.subscribers.set(workflowId, subscribers)
+      return
+    }
+
+    const workflowSubscribers = subscribers.get(AnySubscriber) ?? []
+    const subscriberIndex = handlerIndex(workflowSubscribers)
+    if (subscriberIndex !== -1) {
+      workflowSubscribers.slice(subscriberIndex, 1)
+    }
+
+    workflowSubscribers.push(subscriber)
+    subscribers.set(AnySubscriber, workflowSubscribers)
+    this.subscribers.set(workflowId, subscribers)
+  }
+
+  @InjectSharedContext()
+  unsubscribe(
+    { workflowId, transactionId, subscriberOrId }: UnsubscribeOptions,
+    @MedusaContext() sharedContext: Context = {}
+  ) {
+    const subscribers = this.subscribers.get(workflowId) ?? new Map()
+
+    const filterSubscribers = (handlers: SubscriberHandler[]) => {
+      return handlers.filter((handler) => {
+        return handler._id
+          ? handler._id !== (subscriberOrId as string)
+          : handler !== (subscriberOrId as SubscriberHandler)
+      })
+    }
+
+    if (transactionId) {
+      const transactionSubscribers = subscribers.get(transactionId) ?? []
+      const newTransactionSubscribers = filterSubscribers(
+        transactionSubscribers
+      )
+      subscribers.set(transactionId, newTransactionSubscribers)
+      this.subscribers.set(workflowId, subscribers)
+      return
+    }
+
+    const workflowSubscribers = subscribers.get(AnySubscriber) ?? []
+    const newWorkflowSubscribers = filterSubscribers(workflowSubscribers)
+    subscribers.set(AnySubscriber, newWorkflowSubscribers)
+    this.subscribers.set(workflowId, subscribers)
+  }
+
+  private notify(options: NotifyOptions) {
+    const {
+      eventType,
+      workflowId,
+      transactionId,
+      errors,
+      result,
+      step,
+      response,
+    } = options
+
+    const subscribers: TransactionSubscribers =
+      this.subscribers.get(workflowId) ?? new Map()
+
+    const notifySubscribers = (handlers: SubscriberHandler[]) => {
+      handlers.forEach((handler) => {
+        handler({
+          eventType,
+          workflowId,
+          transactionId,
+          step,
+          response,
+          result,
+          errors,
+        })
+      })
+    }
+
+    if (transactionId) {
+      const transactionSubscribers = subscribers.get(transactionId) ?? []
+      notifySubscribers(transactionSubscribers)
+    }
+
+    const workflowSubscribers = subscribers.get(AnySubscriber) ?? []
+    notifySubscribers(workflowSubscribers)
+  }
+
+  private buildWorkflowEvents({
+    customEventHandlers,
+    workflowId,
+    transactionId,
+  }): DistributedTransactionEvents {
+    const notify = ({
+      eventType,
+      step,
+      result,
+      response,
+      errors,
+    }: {
+      eventType: keyof DistributedTransactionEvents
+      step?: TransactionStep
+      response?: unknown
+      result?: unknown
+      errors?: unknown[]
+    }) => {
+      this.notify({
+        workflowId,
+        transactionId,
+        eventType,
+        response,
+        step,
+        result,
+        errors,
+      })
+    }
+
+    return {
+      onTimeout: ({ transaction }) => {
+        customEventHandlers?.onTimeout?.({ transaction })
+        notify({ eventType: "onTimeout" })
+      },
+
+      onBegin: ({ transaction }) => {
+        customEventHandlers?.onBegin?.({ transaction })
+        notify({ eventType: "onBegin" })
+      },
+      onResume: ({ transaction }) => {
+        customEventHandlers?.onResume?.({ transaction })
+        notify({ eventType: "onResume" })
+      },
+      onCompensateBegin: ({ transaction }) => {
+        customEventHandlers?.onCompensateBegin?.({ transaction })
+        notify({ eventType: "onCompensateBegin" })
+      },
+      onFinish: ({ transaction, result, errors }) => {
+        // TODO: unsubscribe transaction handlers on finish
+        customEventHandlers?.onFinish?.({ transaction, result, errors })
+      },
+
+      onStepBegin: ({ step, transaction }) => {
+        customEventHandlers?.onStepBegin?.({ step, transaction })
+
+        notify({ eventType: "onStepBegin", step })
+      },
+      onStepSuccess: async ({ step, transaction }) => {
+        const stepName = step.definition.action!
+        const response = await resolveValue(
+          transaction.getContext().invoke[stepName],
+          transaction
+        )
+        customEventHandlers?.onStepSuccess?.({ step, transaction, response })
+
+        notify({ eventType: "onStepSuccess", step, response })
+      },
+      onStepFailure: ({ step, transaction }) => {
+        const stepName = step.definition.action!
+        const errors = transaction
+          .getErrors(TransactionHandlerType.INVOKE)
+          .filter((err) => err.action === stepName)
+
+        customEventHandlers?.onStepFailure?.({ step, transaction, errors })
+
+        notify({ eventType: "onStepFailure", step, errors })
+      },
+      onStepAwaiting: ({ step, transaction }) => {
+        customEventHandlers?.onStepAwaiting?.({ step, transaction })
+
+        notify({ eventType: "onStepAwaiting", step })
+      },
+
+      onCompensateStepSuccess: ({ step, transaction }) => {
+        const stepName = step.definition.action!
+        const response = transaction.getContext().compensate[stepName]
+        customEventHandlers?.onCompensateStepSuccess?.({
+          step,
+          transaction,
+          response,
+        })
+
+        notify({ eventType: "onCompensateStepSuccess", step, response })
+      },
+      onCompensateStepFailure: ({ step, transaction }) => {
+        const stepName = step.definition.action!
+        const errors = transaction
+          .getErrors(TransactionHandlerType.COMPENSATE)
+          .filter((err) => err.action === stepName)
+
+        customEventHandlers?.onStepFailure?.({ step, transaction, errors })
+
+        notify({ eventType: "onCompensateStepFailure", step, errors })
+      },
+    }
+  }
+
+  private buildIdempotencyKeyAndParts(
+    idempotencyKey: string | IdempotencyKeyParts
+  ): [string, IdempotencyKeyParts] {
+    const parts: IdempotencyKeyParts = {
+      workflowId: "",
+      transactionId: "",
+      stepId: "",
+      action: "invoke",
+    }
+    let idempotencyKey_ = idempotencyKey as string
+
+    const setParts = (workflowId, transactionId, stepId, action) => {
+      parts.workflowId = workflowId
+      parts.transactionId = transactionId
+      parts.stepId = stepId
+      parts.action = action
+    }
+
+    if (!isString(idempotencyKey)) {
+      const { workflowId, transactionId, stepId, action } =
+        idempotencyKey as IdempotencyKeyParts
+      idempotencyKey_ = [workflowId, transactionId, stepId, action].join(":")
+      setParts(workflowId, transactionId, stepId, action)
+    } else {
+      const [workflowId, transactionId, stepId, action] =
+        idempotencyKey_.split(":")
+      setParts(workflowId, transactionId, stepId, action)
+    }
+
+    return [idempotencyKey_, parts]
+  }
+}

packages/modules/workflow-engine-inmemory/src/services/workflows-module.ts

@@ -0,0 +1,271 @@
+import {
+  Context,
+  DAL,
+  FindConfig,
+  InternalModuleDeclaration,
+  ModuleJoinerConfig,
+  ModulesSdkTypes,
+} from "@medusajs/types"
+import {
+  InjectManager,
+  InjectSharedContext,
+  isString,
+  MedusaContext,
+  MedusaError,
+} from "@medusajs/utils"
+import type {
+  IWorkflowEngineService,
+  ReturnWorkflow,
+  UnwrapWorkflowInputDataType,
+  WorkflowOrchestratorTypes,
+} from "@medusajs/workflows-sdk"
+import { WorkflowOrchestratorService } from "@services"
+import { joinerConfig } from "../joiner-config"
+
+type InjectedDependencies = {
+  baseRepository: DAL.RepositoryService
+  workflowExecutionService: ModulesSdkTypes.InternalModuleService<any>
+  workflowOrchestratorService: WorkflowOrchestratorService
+}
+
+export class WorkflowsModuleService implements IWorkflowEngineService {
+  protected baseRepository_: DAL.RepositoryService
+  protected workflowExecutionService_: ModulesSdkTypes.InternalModuleService<any>
+  protected workflowOrchestratorService_: WorkflowOrchestratorService
+
+  constructor(
+    {
+      baseRepository,
+      workflowExecutionService,
+      workflowOrchestratorService,
+    }: InjectedDependencies,
+    protected readonly moduleDeclaration: InternalModuleDeclaration
+  ) {
+    this.baseRepository_ = baseRepository
+    this.workflowExecutionService_ = workflowExecutionService
+    this.workflowOrchestratorService_ = workflowOrchestratorService
+  }
+
+  __joinerConfig(): ModuleJoinerConfig {
+    return joinerConfig
+  }
+
+  @InjectManager("baseRepository_")
+  async retrieveWorkflowExecution(
+    idOrObject:
+      | string
+      | {
+          workflow_id: string
+          transaction_id: string
+        },
+    config: FindConfig<WorkflowOrchestratorTypes.WorkflowExecutionDTO> = {},
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<WorkflowOrchestratorTypes.WorkflowExecutionDTO> {
+    const objValue = isString(idOrObject)
+      ? { id: idOrObject }
+      : {
+          workflow_id: idOrObject.workflow_id,
+          transaction_id: idOrObject.transaction_id,
+        }
+
+    const wfExecution = await this.workflowExecutionService_.list(
+      objValue,
+      config,
+      sharedContext
+    )
+
+    if (wfExecution.length === 0) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `WorkflowExecution with ${Object.keys(objValue).join(
+          ", "
+        )}: ${Object.values(objValue).join(", ")} was not found`
+      )
+    }
+
+    // eslint-disable-next-line max-len
+    return await this.baseRepository_.serialize<WorkflowOrchestratorTypes.WorkflowExecutionDTO>(
+      wfExecution[0],
+      {
+        populate: true,
+      }
+    )
+  }
+
+  @InjectManager("baseRepository_")
+  async listWorkflowExecution(
+    filters: WorkflowOrchestratorTypes.FilterableWorkflowExecutionProps = {},
+    config: FindConfig<WorkflowOrchestratorTypes.WorkflowExecutionDTO> = {},
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<WorkflowOrchestratorTypes.WorkflowExecutionDTO[]> {
+    if (filters.transaction_id) {
+      if (Array.isArray(filters.transaction_id)) {
+        filters.transaction_id = {
+          $in: filters.transaction_id,
+        }
+      }
+    }
+
+    if (filters.workflow_id) {
+      if (Array.isArray(filters.workflow_id)) {
+        filters.workflow_id = {
+          $in: filters.workflow_id,
+        }
+      }
+    }
+
+    const wfExecutions = await this.workflowExecutionService_.list(
+      filters,
+      config,
+      sharedContext
+    )
+
+    return await this.baseRepository_.serialize<
+      WorkflowOrchestratorTypes.WorkflowExecutionDTO[]
+    >(wfExecutions, {
+      populate: true,
+    })
+  }
+
+  @InjectManager("baseRepository_")
+  async listAndCountWorkflowExecution(
+    filters: WorkflowOrchestratorTypes.FilterableWorkflowExecutionProps = {},
+    config: FindConfig<WorkflowOrchestratorTypes.WorkflowExecutionDTO> = {},
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<[WorkflowOrchestratorTypes.WorkflowExecutionDTO[], number]> {
+    if (filters.transaction_id) {
+      if (Array.isArray(filters.transaction_id)) {
+        filters.transaction_id = {
+          $in: filters.transaction_id,
+        }
+      }
+    }
+
+    if (filters.workflow_id) {
+      if (Array.isArray(filters.workflow_id)) {
+        filters.workflow_id = {
+          $in: filters.workflow_id,
+        }
+      }
+    }
+
+    const [wfExecutions, count] =
+      await this.workflowExecutionService_.listAndCount(
+        filters,
+        config,
+        sharedContext
+      )
+
+    return [
+      await this.baseRepository_.serialize<
+        WorkflowOrchestratorTypes.WorkflowExecutionDTO[]
+      >(wfExecutions, {
+        populate: true,
+      }),
+      count,
+    ]
+  }
+
+  @InjectSharedContext()
+  async run<TWorkflow extends string | ReturnWorkflow<any, any, any>>(
+    workflowIdOrWorkflow: TWorkflow,
+    options: WorkflowOrchestratorTypes.WorkflowOrchestratorRunDTO<
+      TWorkflow extends ReturnWorkflow<any, any, any>
+        ? UnwrapWorkflowInputDataType<TWorkflow>
+        : unknown
+    > = {},
+    @MedusaContext() context: Context = {}
+  ) {
+    const ret = await this.workflowOrchestratorService_.run<
+      TWorkflow extends ReturnWorkflow<any, any, any>
+        ? UnwrapWorkflowInputDataType<TWorkflow>
+        : unknown
+    >(workflowIdOrWorkflow, options, context)
+
+    return ret as any
+  }
+
+  @InjectSharedContext()
+  async getRunningTransaction(
+    workflowId: string,
+    transactionId: string,
+    @MedusaContext() context: Context = {}
+  ) {
+    return await this.workflowOrchestratorService_.getRunningTransaction(
+      workflowId,
+      transactionId,
+      context
+    )
+  }
+
+  @InjectSharedContext()
+  async setStepSuccess(
+    {
+      idempotencyKey,
+      stepResponse,
+      options,
+    }: {
+      idempotencyKey: string | object
+      stepResponse: unknown
+      options?: Record<string, any>
+    },
+    @MedusaContext() context: Context = {}
+  ) {
+    return await this.workflowOrchestratorService_.setStepSuccess(
+      {
+        idempotencyKey,
+        stepResponse,
+        options,
+      } as any,
+      context
+    )
+  }
+
+  @InjectSharedContext()
+  async setStepFailure(
+    {
+      idempotencyKey,
+      stepResponse,
+      options,
+    }: {
+      idempotencyKey: string | object
+      stepResponse: unknown
+      options?: Record<string, any>
+    },
+    @MedusaContext() context: Context = {}
+  ) {
+    return await this.workflowOrchestratorService_.setStepFailure(
+      {
+        idempotencyKey,
+        stepResponse,
+        options,
+      } as any,
+      context
+    )
+  }
+
+  @InjectSharedContext()
+  async subscribe(
+    args: {
+      workflowId: string
+      transactionId?: string
+      subscriber: Function
+      subscriberId?: string
+    },
+    @MedusaContext() context: Context = {}
+  ) {
+    return this.workflowOrchestratorService_.subscribe(args as any, context)
+  }
+
+  @InjectSharedContext()
+  async unsubscribe(
+    args: {
+      workflowId: string
+      transactionId?: string
+      subscriberOrId: string | Function
+    },
+    @MedusaContext() context: Context = {}
+  ) {
+    return this.workflowOrchestratorService_.unsubscribe(args as any, context)
+  }
+}

packages/modules/workflow-engine-inmemory/src/types/index.ts

@@ -0,0 +1,5 @@
+import { Logger } from "@medusajs/types"
+
+export type InitializeModuleInjectableDependencies = {
+  logger?: Logger
+}

packages/modules/workflow-engine-inmemory/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./workflow-orchestrator-storage"

packages/modules/workflow-engine-inmemory/src/utils/workflow-orchestrator-storage.ts

@@ -0,0 +1,218 @@
+import {
+  DistributedTransaction,
+  DistributedTransactionStorage,
+  TransactionCheckpoint,
+  TransactionStep,
+} from "@medusajs/orchestration"
+import { ModulesSdkTypes } from "@medusajs/types"
+import { TransactionState } from "@medusajs/utils"
+import { WorkflowOrchestratorService } from "@services"
+
+// eslint-disable-next-line max-len
+export class InMemoryDistributedTransactionStorage extends DistributedTransactionStorage {
+  private workflowExecutionService_: ModulesSdkTypes.InternalModuleService<any>
+  private workflowOrchestratorService_: WorkflowOrchestratorService
+
+  private storage: Map<string, TransactionCheckpoint> = new Map()
+  private retries: Map<string, unknown> = new Map()
+  private timeouts: Map<string, unknown> = new Map()
+
+  constructor({
+    workflowExecutionService,
+  }: {
+    workflowExecutionService: ModulesSdkTypes.InternalModuleService<any>
+  }) {
+    super()
+
+    this.workflowExecutionService_ = workflowExecutionService
+  }
+
+  setWorkflowOrchestratorService(workflowOrchestratorService) {
+    this.workflowOrchestratorService_ = workflowOrchestratorService
+  }
+
+  private async saveToDb(data: TransactionCheckpoint) {
+    await this.workflowExecutionService_.upsert([
+      {
+        workflow_id: data.flow.modelId,
+        transaction_id: data.flow.transactionId,
+        execution: data.flow,
+        context: {
+          data: data.context,
+          errors: data.errors,
+        },
+        state: data.flow.state,
+      },
+    ])
+  }
+
+  private async deleteFromDb(data: TransactionCheckpoint) {
+    await this.workflowExecutionService_.delete([
+      {
+        workflow_id: data.flow.modelId,
+        transaction_id: data.flow.transactionId,
+      },
+    ])
+  }
+
+  /*private stringifyWithSymbol(key, value) {
+    if (key === "__type" && typeof value === "symbol") {
+      return Symbol.keyFor(value)
+    }
+
+    return value
+  }
+
+  private jsonWithSymbol(key, value) {
+    if (key === "__type" && typeof value === "string") {
+      return Symbol.for(value)
+    }
+
+    return value
+  }*/
+
+  async get(key: string): Promise<TransactionCheckpoint | undefined> {
+    return this.storage.get(key)
+  }
+
+  async list(): Promise<TransactionCheckpoint[]> {
+    return Array.from(this.storage.values())
+  }
+
+  async save(
+    key: string,
+    data: TransactionCheckpoint,
+    ttl?: number
+  ): Promise<void> {
+    this.storage.set(key, data)
+
+    let retentionTime
+
+    /**
+     * Store the retention time only if the transaction is done, failed or reverted.
+     * From that moment, this tuple can be later on archived or deleted after the retention time.
+     */
+    const hasFinished = [
+      TransactionState.DONE,
+      TransactionState.FAILED,
+      TransactionState.REVERTED,
+    ].includes(data.flow.state)
+
+    if (hasFinished) {
+      retentionTime = data.flow.options?.retentionTime
+      Object.assign(data, {
+        retention_time: retentionTime,
+      })
+    }
+
+    const stringifiedData = JSON.stringify(data)
+    const parsedData = JSON.parse(stringifiedData)
+
+    if (hasFinished && !retentionTime) {
+      await this.deleteFromDb(parsedData)
+    } else {
+      await this.saveToDb(parsedData)
+    }
+
+    if (hasFinished) {
+      this.storage.delete(key)
+    }
+  }
+
+  async scheduleRetry(
+    transaction: DistributedTransaction,
+    step: TransactionStep,
+    timestamp: number,
+    interval: number
+  ): Promise<void> {
+    const { modelId: workflowId, transactionId } = transaction
+
+    const inter = setTimeout(async () => {
+      await this.workflowOrchestratorService_.run(workflowId, {
+        transactionId,
+        throwOnError: false,
+      })
+    }, interval * 1e3)
+
+    const key = `${workflowId}:${transactionId}:${step.id}`
+    this.retries.set(key, inter)
+  }
+
+  async clearRetry(
+    transaction: DistributedTransaction,
+    step: TransactionStep
+  ): Promise<void> {
+    const { modelId: workflowId, transactionId } = transaction
+
+    const key = `${workflowId}:${transactionId}:${step.id}`
+    const inter = this.retries.get(key)
+    if (inter) {
+      clearTimeout(inter as NodeJS.Timeout)
+      this.retries.delete(key)
+    }
+  }
+
+  async scheduleTransactionTimeout(
+    transaction: DistributedTransaction,
+    timestamp: number,
+    interval: number
+  ): Promise<void> {
+    const { modelId: workflowId, transactionId } = transaction
+
+    const inter = setTimeout(async () => {
+      await this.workflowOrchestratorService_.run(workflowId, {
+        transactionId,
+        throwOnError: false,
+      })
+    }, interval * 1e3)
+
+    const key = `${workflowId}:${transactionId}`
+    this.timeouts.set(key, inter)
+  }
+
+  async clearTransactionTimeout(
+    transaction: DistributedTransaction
+  ): Promise<void> {
+    const { modelId: workflowId, transactionId } = transaction
+
+    const key = `${workflowId}:${transactionId}`
+    const inter = this.timeouts.get(key)
+    if (inter) {
+      clearTimeout(inter as NodeJS.Timeout)
+      this.timeouts.delete(key)
+    }
+  }
+
+  async scheduleStepTimeout(
+    transaction: DistributedTransaction,
+    step: TransactionStep,
+    timestamp: number,
+    interval: number
+  ): Promise<void> {
+    const { modelId: workflowId, transactionId } = transaction
+
+    const inter = setTimeout(async () => {
+      await this.workflowOrchestratorService_.run(workflowId, {
+        transactionId,
+        throwOnError: false,
+      })
+    }, interval * 1e3)
+
+    const key = `${workflowId}:${transactionId}:${step.id}`
+    this.timeouts.set(key, inter)
+  }
+
+  async clearStepTimeout(
+    transaction: DistributedTransaction,
+    step: TransactionStep
+  ): Promise<void> {
+    const { modelId: workflowId, transactionId } = transaction
+
+    const key = `${workflowId}:${transactionId}:${step.id}`
+    const inter = this.timeouts.get(key)
+    if (inter) {
+      clearTimeout(inter as NodeJS.Timeout)
+      this.timeouts.delete(key)
+    }
+  }
+}