chore(): Reorganize modules (#7210)

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

packages/modules/workflow-engine-redis/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-redis/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-redis/src/loaders/index.ts

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

packages/modules/workflow-engine-redis/src/loaders/redis.ts

@@ -0,0 +1,88 @@
+import { LoaderOptions } from "@medusajs/modules-sdk"
+import { asValue } from "awilix"
+import Redis from "ioredis"
+import { RedisWorkflowsOptions } from "../types"
+
+export default async ({
+  container,
+  logger,
+  options,
+  dataLoaderOnly,
+}: LoaderOptions): Promise<void> => {
+  const {
+    url,
+    options: redisOptions,
+    pubsub,
+  } = options?.redis as RedisWorkflowsOptions
+
+  // TODO: get default from ENV VAR
+  if (!url) {
+    throw Error(
+      "No `redis.url` provided in `workflowOrchestrator` module options. It is required for the Workflow Orchestrator Redis."
+    )
+  }
+
+  const cnnPubSub = pubsub ?? { url, options: redisOptions }
+
+  const queueName = options?.queueName ?? "medusa-workflows"
+
+  let connection
+  let redisPublisher
+  let redisSubscriber
+  let workerConnection
+
+  try {
+    connection = await getConnection(url, redisOptions)
+    workerConnection = await getConnection(url, {
+      ...(redisOptions ?? {}),
+      maxRetriesPerRequest: null,
+    })
+    logger?.info(
+      `Connection to Redis in module 'workflow-engine-redis' established`
+    )
+  } catch (err) {
+    logger?.error(
+      `An error occurred while connecting to Redis in module 'workflow-engine-redis': ${err}`
+    )
+  }
+
+  try {
+    redisPublisher = await getConnection(cnnPubSub.url, cnnPubSub.options)
+    redisSubscriber = await getConnection(cnnPubSub.url, cnnPubSub.options)
+    logger?.info(
+      `Connection to Redis PubSub in module 'workflow-engine-redis' established`
+    )
+  } catch (err) {
+    logger?.error(
+      `An error occurred while connecting to Redis PubSub in module 'workflow-engine-redis': ${err}`
+    )
+  }
+
+  container.register({
+    partialLoading: asValue(true),
+    redisConnection: asValue(connection),
+    redisWorkerConnection: asValue(workerConnection),
+    redisPublisher: asValue(redisPublisher),
+    redisSubscriber: asValue(redisSubscriber),
+    redisQueueName: asValue(queueName),
+    redisDisconnectHandler: asValue(async () => {
+      connection.disconnect()
+      workerConnection.disconnect()
+      redisPublisher.disconnect()
+      redisSubscriber.disconnect()
+    }),
+  })
+}
+
+async function getConnection(url, redisOptions) {
+  const connection = new Redis(url, {
+    lazyConnect: true,
+    ...(redisOptions ?? {}),
+  })
+
+  await new Promise(async (resolve) => {
+    await connection.connect(resolve)
+  })
+
+  return connection
+}

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

@@ -0,0 +1,11 @@
+import { asClass, asValue } from "awilix"
+import { RedisDistributedTransactionStorage } from "../utils"
+
+export default async ({ container, dataLoaderOnly }): Promise<void> => {
+  container.register({
+    redisDistributedTransactionStorage: asClass(
+      RedisDistributedTransactionStorage
+    ).singleton(),
+    dataLoaderOnly: asValue(!!dataLoaderOnly),
+  })
+}