chore(): Reorganize modules (#7210)

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

packages/modules/event-bus-local/src/index.ts

@@ -0,0 +1,14 @@
+import { ModuleExports } from "@medusajs/modules-sdk"
+import Loader from "./loaders"
+import LocalEventBus from "./services/event-bus-local"
+
+export const service = LocalEventBus
+export const loaders = [Loader]
+
+const moduleDefinition: ModuleExports = {
+  service,
+  loaders,
+}
+
+export default moduleDefinition
+export * from "./initialize"

packages/modules/event-bus-local/src/initialize/index.ts

@@ -0,0 +1,12 @@
+import { MedusaModule, Modules } from "@medusajs/modules-sdk"
+import { IEventBusService } from "@medusajs/types"
+
+export const initialize = async (): Promise<IEventBusService> => {
+  const serviceKey = Modules.EVENT_BUS
+  const loaded = await MedusaModule.bootstrap<IEventBusService>({
+    moduleKey: serviceKey,
+    defaultPath: "@medusajs/event-bus-local",
+  })
+
+  return loaded[serviceKey]
+}

packages/modules/event-bus-local/src/loaders/index.ts

@@ -0,0 +1,7 @@
+import { LoaderOptions } from "@medusajs/modules-sdk"
+
+export default async ({ logger }: LoaderOptions): Promise<void> => {
+  logger?.warn(
+    "Local Event Bus installed. This is not recommended for production."
+  )
+}

packages/modules/event-bus-local/src/services/__tests__/event-bus-local.js

@@ -0,0 +1,70 @@
+import LocalEventBusService from "../event-bus-local"
+
+jest.genMockFromModule("events")
+jest.mock("events")
+
+const loggerMock = {
+  info: jest.fn().mockReturnValue(console.log),
+  warn: jest.fn().mockReturnValue(console.log),
+  error: jest.fn().mockReturnValue(console.log),
+}
+
+const moduleDeps = {
+  logger: loggerMock,
+}
+
+describe("LocalEventBusService", () => {
+  let eventBus
+
+  describe("emit", () => {
+    describe("Successfully emits events", () => {
+      beforeEach(() => {
+        jest.clearAllMocks()
+      })
+
+      it("Emits an event", () => {
+        eventBus = new LocalEventBusService(
+          moduleDeps,
+          {},
+          {
+            resources: "shared",
+          }
+        )
+
+        eventBus.eventEmitter_.emit.mockImplementationOnce((data) => data)
+
+        eventBus.emit("eventName", { hi: "1234" })
+
+        expect(eventBus.eventEmitter_.emit).toHaveBeenCalledTimes(1)
+        expect(eventBus.eventEmitter_.emit).toHaveBeenCalledWith("eventName", {
+          hi: "1234",
+        })
+      })
+
+      it("Emits multiple events", () => {
+        eventBus = new LocalEventBusService(
+          moduleDeps,
+          {},
+          {
+            resources: "shared",
+          }
+        )
+
+        eventBus.eventEmitter_.emit.mockImplementationOnce((data) => data)
+
+        eventBus.emit([
+          { eventName: "event-1", data: { hi: "1234" } },
+          { eventName: "event-2", data: { hi: "5678" } },
+        ])
+
+        expect(eventBus.eventEmitter_.emit).toHaveBeenCalledTimes(2)
+        expect(eventBus.eventEmitter_.emit).toHaveBeenCalledWith("event-1", {
+          hi: "1234",
+        })
+        expect(eventBus.eventEmitter_.emit).toHaveBeenCalledWith("event-2", {
+          hi: "5678",
+        })
+      })
+    })
+  })
+})

packages/modules/event-bus-local/src/services/event-bus-local.ts

@@ -0,0 +1,113 @@
+import { MedusaContainer } from "@medusajs/modules-sdk"
+import {
+  EmitData,
+  EventBusTypes,
+  Logger,
+  Message,
+  Subscriber,
+} from "@medusajs/types"
+import { AbstractEventBusModuleService } from "@medusajs/utils"
+import { EventEmitter } from "events"
+import { ulid } from "ulid"
+
+type InjectedDependencies = {
+  logger: Logger
+}
+
+const eventEmitter = new EventEmitter()
+eventEmitter.setMaxListeners(Infinity)
+
+// eslint-disable-next-line max-len
+export default class LocalEventBusService extends AbstractEventBusModuleService {
+  protected readonly logger_?: Logger
+  protected readonly eventEmitter_: EventEmitter
+
+  constructor({ logger }: MedusaContainer & InjectedDependencies) {
+    // @ts-ignore
+    // eslint-disable-next-line prefer-rest-params
+    super(...arguments)
+
+    this.logger_ = logger
+    this.eventEmitter_ = eventEmitter
+  }
+
+  async emit<T>(
+    eventName: string,
+    data: T,
+    options: Record<string, unknown>
+  ): Promise<void>
+
+  /**
+   * Emit a number of events
+   * @param {EmitData} data - the data to send to the subscriber.
+   */
+  async emit<T>(data: EmitData<T>[]): Promise<void>
+
+  async emit<T>(data: Message<T>[]): Promise<void>
+
+  async emit<T, TInput extends string | EmitData<T>[] | Message<T>[] = string>(
+    eventOrData: TInput,
+    data?: T,
+    options: Record<string, unknown> = {}
+  ): Promise<void> {
+    const isBulkEmit = Array.isArray(eventOrData)
+
+    const events: EmitData[] | Message<T>[] = isBulkEmit
+      ? eventOrData
+      : [{ eventName: eventOrData, data }]
+
+    for (const event of events) {
+      const eventListenersCount = this.eventEmitter_.listenerCount(
+        event.eventName
+      )
+
+      this.logger_?.info(
+        `Processing ${event.eventName} which has ${eventListenersCount} subscribers`
+      )
+
+      if (eventListenersCount === 0) {
+        continue
+      }
+
+      const data = (event as EmitData).data ?? (event as Message<T>).body
+      this.eventEmitter_.emit(event.eventName, data)
+    }
+  }
+
+  subscribe(event: string | symbol, subscriber: Subscriber): this {
+    const randId = ulid()
+    this.storeSubscribers({ event, subscriberId: randId, subscriber })
+    this.eventEmitter_.on(event, async (...args) => {
+      try {
+        // @ts-ignore
+        await subscriber(...args)
+      } catch (e) {
+        this.logger_?.error(
+          `An error occurred while processing ${event.toString()}: ${e}`
+        )
+      }
+    })
+    return this
+  }
+
+  unsubscribe(
+    event: string | symbol,
+    subscriber: Subscriber,
+    context?: EventBusTypes.SubscriberContext
+  ): this {
+    const existingSubscribers = this.eventToSubscribersMap_.get(event)
+
+    if (existingSubscribers?.length) {
+      const subIndex = existingSubscribers?.findIndex(
+        (sub) => sub.id === context?.subscriberId
+      )
+
+      if (subIndex !== -1) {
+        this.eventToSubscribersMap_.get(event)?.splice(subIndex as number, 1)
+      }
+    }
+
+    this.eventEmitter_.off(event, subscriber)
+    return this
+  }
+}