@daiso-tech/core 0.15.0 → 0.17.4

package/dist/types/event-bus/contracts/event-bus-factory.contract.d.ts

@@ -1,53 +1,59 @@
 /**
  * @module EventBus
  */
-import type { BaseEvents, INamespacedEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { IGroupableEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { BaseEvent } from "../../event-bus/contracts/_shared";
 /**
- * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link INamespacedEventBus}</i> dynamically.
+ * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableEventBus}</i> dynamically.
  * @group Contracts
  */
-export type IEventBusFactory<TDrivers extends string = string, TEvents extends BaseEvents = BaseEvents> = {
+export type IEventBusFactory<TAdapters extends string = string> = {
     /**
-     * The <i>use</i> method will throw an error if you provide it unregisted driver.
-     * If no default driver is defined an error will be thrown by <i>use</i> method.
-     * @throws {UnregisteredDriverError} {@link UnregisteredDriverError}
-     * @throws {DefaultDriverNotDefinedError} {@link DefaultDriverNotDefinedError}
+     * The <i>use</i> method will throw an error if you provide it unregisted adapter.
+     * If no default adapter is defined an error will be thrown by <i>use</i> method.
+     * @throws {UnregisteredAdapterError} {@link UnregisteredAdapterError}
+     * @throws {DefaultAdapterNotDefinedError} {@link DefaultAdapterNotDefinedError}
      * @example
      * ```ts
      * import { type IEventBusFactory } from "@daiso-tech/core";
      *
+     * type SerializedAddEvent = {
+     *   a: number;
+     *   b: number;
+     * };
+     *
+     * class AddEvent extends BaseEvent<SerializedAddEvent> {
+     *   // This needed for adapters that need to deserialize like the redis dapter.
+     *   static override deserialize({ a, b }: SerializedAddEvent): AddEvent {
+     *     return new AddEvent(a, b);
+     *   }
+     *
+     *   constructor(public readonly a: number, public readonly b: number) {
+     *     super();
+     *   }
+     *
+     *   // This needed for adapters that need to serialize like the redis adapter.
+     *   override serialize(): SerializedAddEvent {
+     *     return {
+     *       a: this.a,
+     *       b: this.b
+     *     };
+     *   }
+     * }
+     *
+     * // Asume the inputed eventFactory has registered both a memory and Redis IEventBusAdapter.
+     * // The memory IEventBusAdapter adapter is the default.
      * async function main(eventFactory: IEventBusFactory): Promise<void> {
-     *   // Will dispatch envent using the default driver
+     *   // Will dispatch envent using the default adapter
      *   await eventBusFactory
      *     .use()
-     *     .dispatch({ type: "add", a: 1, b: 2 });
+     *     .dispatch(new AddEvent(1, 2));
      *   // Will dispatch envent using the redis addapter
      *   await eventBusFactory
      *     .use("redis")
-     *     .dispatch({ type: "add", a: 1, b: 2 });
-     * }
-     * ```
-     */
-    use(driverName?: TDrivers): INamespacedEventBus<TEvents>;
-    /**
-     * The <i>withTypes</i> method is used to set the event types of the <i>{@link IEventBus}</i>.
-     * @example
-     * ```ts
-     * import { type IEventBusFactory } from "@daiso-tech/core";
-     *
-     * async function main(eventBusFactory: IEventBusFactory): Promise<void> {
-     *   type AddEvent = {
-     *     type: "add";
-     *     a: number;
-     *     b: number;
-     *   };
-     *   await eventBusFactory
-     *     .withTypes<AddEvent>()
-     *     .use()
-     *     // You will se an typescript error
-     *     .dispatch({ type: "add" });
+     *     .dispatch(new AddEvent(1, 2));
      * }
      * ```
      */
-    withType<TOutput extends TEvents = TEvents>(): IEventBusFactory<TDrivers, TOutput>;
+    use<TEvents extends BaseEvent = BaseEvent>(adapterName?: TAdapters): IGroupableEventBus<TEvents>;
 };

package/dist/types/event-bus/contracts/event-bus.contract.d.ts

@@ -1,119 +1,134 @@
 /**
  * @module EventBus
  */
-import type { OneOrMore, Values } from "../../utilities/_module";
+import type { OneOrMore } from "../../utilities/_module";
 import type { LazyPromise } from "../../async/_module";
-import type { Listener } from "../../event-bus/contracts/_shared";
-export type BaseEvents = Record<string, Record<string, unknown>>;
-export type AllEvents<TEvents extends BaseEvents> = Values<{
-    [TEventName in keyof TEvents]: TEvents[TEventName] & {
-        type: TEventName;
-    };
-}>;
-export type SelectEvent<TEvents extends BaseEvents, TEventName extends keyof TEvents> = {
-    [TEventName in keyof TEvents]: TEvents[TEventName] & {
-        type: TEventName;
-    };
-}[TEventName];
+import type { BaseEvent, Listener } from "../../event-bus/contracts/_shared";
+/**
+ * @group Contracts
+ */
+export type EventClass<TEvents extends BaseEvent> = {
+    new (...arguments_: any[]): TEvents;
+};
+/**
+ * @group Contracts
+ */
+export type EventInstance<TEventClass extends EventClass<BaseEvent>> = TEventClass extends {
+    new (...arguments_: any[]): infer TInstance;
+} ? TInstance : never;
+/**
+ * @group Contracts
+ */
 export type Unsubscribe = () => LazyPromise<void>;
 /**
- * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
+ * The <i>IEventListener</i> contract defines a way listening to events independent of underlying technology
  * @group Contracts
  */
-export type IListenable<TEvents extends BaseEvents = BaseEvents> = {
+export type IEventListener<TEvents extends BaseEvent = BaseEvent> = {
     /**
      * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
-    addListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
+    addListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
      * The <i>addListenerMany</i> method is used for adding multiple <i>{@link Listener | listeners}</i> for certain <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
-    addListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
      * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
-    removeListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
      * The <i>removeListener</i> method is used for removing multiple <i>{@link Listener | listeners}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
-    removeListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * The <i>listenOnce</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i> that is trigged only once.
+     * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+     */
+    listenOnce<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
      * The <i>subscribe</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      */
-    subscribe<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    subscribe<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
     /**
      * The <i>subscribeMany</i> method is used for adding <i>{@link Listener | listener}</i> for multiple <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      */
-    subscribeMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
 };
 /**
- * The <i>IDispatcher</i> contract defines a way for dispatching to events independent of underlying technology.
+ * The <i>IEventDispatcher</i> contract defines a way for dispatching to events independent of underlying technology.
  * @group Contracts
  */
-export type IDispatcher<TEvents extends BaseEvents = BaseEvents> = {
+export type IEventDispatcher<TEvents extends BaseEvent = BaseEvent> = {
+    /**
+     * The <i>dispatch</i> method is used for dispatching a <i>event</i>.
+
+     * @throws {DispatchEventBusError} {@link DispatchEventBusError}
+     */
+    dispatch(event: TEvents): LazyPromise<void>;
     /**
-     * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
+     * The <i>dispatchMany</i> method is used for dispatching multiple <i>event</i>.
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
-    dispatch(events: OneOrMore<AllEvents<TEvents>>): LazyPromise<void>;
+    dispatchMany(events: TEvents[]): LazyPromise<void>;
 };
 /**
  * The <i>IEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with more convient methods compared to <i>IEventBusAdapter</i>.
  * @group Contracts
  */
-export type IEventBus<TEvents extends BaseEvents = BaseEvents> = IListenable<TEvents> & IDispatcher<TEvents> & {
+export type IEventBus<TEvents extends BaseEvent = BaseEvent> = IEventListener<TEvents> & IEventDispatcher<TEvents> & {
     /**
-     * The <i>getNamespace</i> method returns the complete namespace.
+     * The <i>getGroup</i> method returns the complete group.
      * @example
      * ```ts
      * import { type IEventBus } from "@daiso-tech/core";
      *
      * async function main(eventBus: IEventBus): Promise<void> {
      *   // Will be "@root"
-     *   console.log(eventBus.getNamespace())
+     *   console.log(eventBus.getGroup())
      *
-     *   const eventBusA = eventBus.withNamespace("a");
+     *   const eventBusA = eventBus.withGroup("a");
      *
      *   // Will be "@root/a"
-     *   console.log(eventBusA.getNamespace())
+     *   console.log(eventBusA.getGroup())
      * }
      * ```
      */
-    getNamespace(): string;
+    getGroup(): string;
 };
 /**
- * The <i>INamespacedEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
+ * The <i>IGroupableEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with one extra method which is useful for multitennat applications compared to <i>IEventBus</i>.
  * @group Contracts
  */
-export type INamespacedEventBus<TEvents extends BaseEvents = BaseEvents> = IEventBus<TEvents> & {
+export type IGroupableEventBus<TEvents extends BaseEvent = BaseEvent> = IEventBus<TEvents> & {
     /**
-     * The <i>withNamespace</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>namespace</i>.
+     * The <i>withGroup</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>group</i>.
      * This useful for multitennat applications.
      * @example
      * ```ts
      * import { type IEventBus } from "@daiso-tech/core";
      *
      * async function main(eventBus: IEventBus): Promise<void> {
-     *   const eventBusA = eventBus.withNamespace("a");
+     *   const eventBusA = eventBus.withGroup("a");
      *   await eventBusA.subscribe("add", (event) => {
      *     // This will be logged
      *     console.log("eventBusA:", event);
      *   });
      *
-     *   const eventBusB = eventBus.withNamespace("b");
+     *   const eventBusB = eventBus.withGroup("b");
      *   await eventBusB.subscribe("add", (event) => {
      *     // This will never be logged
      *     console.log("eventBusB:", event);
@@ -127,5 +142,5 @@ export type INamespacedEventBus<TEvents extends BaseEvents = BaseEvents> = IEven
      * }
      * ```
      */
-    withNamespace(namespace: OneOrMore<string>): IEventBus<TEvents>;
+    withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
 };

package/dist/types/event-bus/implementations/_shared/event-bus-adapter.test-suite.d.ts

@@ -4,15 +4,18 @@
 import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
 import type { IEventBusAdapter } from "../../../event-bus/contracts/_module";
 import { type Promisable } from "../../../utilities/_module";
+import type { IFlexibleSerde } from "../../../serde/contracts/_module";
 /**
  * @group Utilities
  */
 export type EventBusAdapterTestSuiteSettings = {
     expect: ExpectStatic;
+    serde?: IFlexibleSerde;
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createAdapter: () => Promisable<IEventBusAdapter>;
+    createAdapterA: () => Promisable<IEventBusAdapter>;
+    createAdapterB: () => Promisable<IEventBusAdapter>;
 };
 /**
  * The <i>eventBusAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBusAdapter}</i> with vitest.
@@ -23,31 +26,40 @@ export type EventBusAdapterTestSuiteSettings = {
  * import type { StartedRedisContainer } from "@testcontainers/redis";
  * import { RedisContainer } from "@testcontainers/redis";
  * import Redis from "ioredis";
- * import { SuperJsonSerializer, TimeSpan, RedisEventBusAdapter, eventBusAdapterTestSuite } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, eventBusAdapterTestSuite } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
- * describe("class: RedisEventBusAdapter", () => {
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
+ * describe("class: RedisPubSubEventBusAdapter", () => {
  *   let dispatcherClient: Redis;
  *   let listenerClient: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const serializer = new SuperJsonSerializer();
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer().start();
  *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
  *     listenerClient = new Redis(startedContainer.getConnectionUrl());
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *   afterEach(async () => {
  *     await dispatcherClient.quit();
  *     await listenerClient.quit();
  *     await startedContainer.stop();
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *    eventBusAdapterTestSuite({
- *      createAdapter: () =>
- *        new RedisEventBusAdapter({
+ *      createAdapterA: () =>
+ *        new RedisPubSubEventBusAdapter({
  *          dispatcherClient,
  *          listenerClient,
- *          serializer,
+ *          serde,
+ *          rootGroup: "@global"
  *        }),
+ *      createAdapterB: () =>
+ *        new RedisPubSubEventBusAdapter({
+ *          dispatcherClient,
+ *          listenerClient,
+ *          serde,
+ *          rootGroup: "@global"
+ *        }),
+ *      serde,
  *      test,
  *      beforeEach,
  *      expect,

package/dist/types/event-bus/implementations/_shared/event-bus.test-suite.d.ts

@@ -2,13 +2,15 @@
  * @module EventBus
  */
 import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
-import type { IEventBus } from "../../../event-bus/contracts/_module";
+import { type IEventBus } from "../../../event-bus/contracts/_module";
 import { type Promisable } from "../../../utilities/_module";
+import type { IFlexibleSerde } from "../../../serde/contracts/_module";
 /**
  * @group Utilities
  */
 export type EventBusTestSuiteSettings = {
     expect: ExpectStatic;
+    serde?: IFlexibleSerde;
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
@@ -24,43 +26,44 @@ export type EventBusTestSuiteSettings = {
  * import type { StartedRedisContainer } from "@testcontainers/redis";
  * import { RedisContainer } from "@testcontainers/redis";
  * import Redis from "ioredis";
- * import { SuperJsonSerializer, TimeSpan, RedisEventBusAdapter, eventBusTestSuite } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, eventBusTestSuite, serde } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: EventBus", () => {
  *   let dispatcherClient: Redis;
  *   let listenerClient: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const serializer = new SuperJsonSerializer();
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer().start();
  *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
  *     listenerClient = new Redis(startedContainer.getConnectionUrl());
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *   afterEach(async () => {
  *     await dispatcherClient.quit();
  *     await listenerClient.quit();
  *     await startedContainer.stop();
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *    eventBusTestSuite({
  *      createEventBusA: () =>
  *        new EventBus(
- *          new RedisEventBusAdapter({
+ *          new RedisPubSubEventBusAdapter({
  *            dispatcherClient,
  *            listenerClient,
- *            serializer,
- *          }),
- *          { rootNamespace: "@a" }
+ *            serde,
+ *            rootGroup: "@global"
+ *          })
  *        ),
  *      createEventBusB: () =>
  *        new EventBus(
- *          new RedisEventBusAdapter({
+ *          new RedisPubSubEventBusAdapter({
  *            dispatcherClient,
  *            listenerClient,
- *            serializer,
+ *            serde,
+ *            rootGroup: "@global"
  *          }),
- *          { rootNamespace: "@b" }
  *        ),
+ *      serde,
  *      test,
  *      beforeEach,
  *      expect,

package/dist/types/event-bus/implementations/adapters/_module.d.ts

@@ -1,3 +1,3 @@
 export * from "../../../event-bus/implementations/adapters/memory-event-bus-adapter/_module";
 export * from "../../../event-bus/implementations/adapters/no-op-event-bus-adapter/_module";
-export * from "../../../event-bus/implementations/adapters/redis-event-bus-adapter/_module";
+export * from "../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/_module";

package/dist/types/event-bus/implementations/adapters/memory-event-bus-adapter/_module.d.ts

@@ -1 +1,2 @@
-export * from "../../../../event-bus/implementations/adapters/memory-event-bus-adapter/_module";
+export * from "../../../../event-bus/implementations/adapters/memory-event-bus-adapter/memory-event-bus-adapter-settings";
+export * from "../../../../event-bus/implementations/adapters/memory-event-bus-adapter/memory-event-bus-adapter";

package/dist/types/event-bus/implementations/adapters/memory-event-bus-adapter/memory-event-bus-adapter-settings.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module EventBus
+ */
+import type { IBuildable } from "../../../../utilities/_module";
+import type { OneOrMore } from "../../../../utilities/_module";
+import type { EventEmitter } from "node:events";
+/**
+ * @group Adapters
+ */
+export type MemoryEventBusAdapterSettings = {
+    rootGroup: OneOrMore<string>;
+    eventEmitter?: EventEmitter;
+};
+/**
+ * The <i>MemoryEventBusAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class MemoryEventBusAdapterSettingsBuilder<TSettings extends Partial<MemoryEventBusAdapterSettings>> implements IBuildable<MemoryEventBusAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setEventEmitter(eventEmitter: EventEmitter): MemoryEventBusAdapterSettingsBuilder<TSettings & {
+        eventEmitter: EventEmitter<[never]>;
+    }>;
+    setRootGroup(group: OneOrMore<string>): MemoryEventBusAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: MemoryEventBusAdapterSettingsBuilder<MemoryEventBusAdapterSettings>): MemoryEventBusAdapterSettings;
+}

package/dist/types/event-bus/implementations/adapters/memory-event-bus-adapter/memory-event-bus-adapter.d.ts

@@ -1,31 +1,62 @@
 /**
  * @module EventBus
  */
-import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
-import { EventEmitter } from "node:events";
+import { type OneOrMore } from "../../../../utilities/_module";
+import type { BaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
+import type { MemoryEventBusAdapterSettings } from "../../../../event-bus/implementations/adapters/memory-event-bus-adapter/memory-event-bus-adapter-settings";
+import { MemoryEventBusAdapterSettingsBuilder } from "../../../../event-bus/implementations/adapters/memory-event-bus-adapter/memory-event-bus-adapter-settings";
 /**
  * To utilize the <i>MemoryEventBusAdapter</i>, you must create instance of it.
  * @group Adapters
- * @example
- * ```ts
- * import { MemoryEventBusAdapter } from "@daiso-tech/core";
- *
- * const eventBusAdapter = new MemoryEventBusAdapter(client);
- * ```
- * You can also provide an <i>EVentEmitter</i>.
- * @example
- * ```ts
- * import { MemoryCacheAdapter } from "@daiso-tech/core";
- * import { EventEmitter } from "node:events";
- *
- * const eventEmitter = new EventEmitter();
- * const eventBusAdapter = new MemoryCacheAdapter(eventEmitter);
- * ```
  */
 export declare class MemoryEventBusAdapter implements IEventBusAdapter {
-    private readonly eventEmiter;
-    constructor(eventEmiter?: EventEmitter<[never]>);
-    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
-    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(events: IBaseEvent[]): Promise<void>;
+    /**
+     * @example
+     * ```ts
+     * import { MemoryEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { EventEmitter } from "node:events";
+     *
+     * const cacheAdapter = new MemoryEventBusAdapter(
+     *   MemoryEventBusAdapter
+     *     .settings()
+     *     .setEventEmitter(new EventEmitter())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<MemoryEventBusAdapterSettings>>(): MemoryEventBusAdapterSettingsBuilder<TSettings>;
+    private readonly group;
+    private readonly eventEmitter;
+    /**
+     * @example
+     * ```ts
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import { EventEmitter } from "node:events";
+     *
+     * const eventEmitter = new EventEmitter();
+     * const eventBusAdapter = new MemoryEventBusAdapter({
+     *   eventEmitter
+     * });
+     * ```
+     * You can also provide an <i>EVentEmitter</i>.
+     * @example
+     * ```ts
+     * import { MemoryCacheAdapter } from "@daiso-tech/core";
+     * import { EventEmitter } from "node:events";
+     *
+     * const eventEmitter = new EventEmitter();
+     * const eventBusAdapter = new MemoryEventBusAdapter({
+     *   rootGroup: "@global",
+     *   eventEmitter
+     * });
+     * ```
+     */
+    constructor(settings: MemoryEventBusAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): IEventBusAdapter;
+    private withPrefix;
+    addListener(eventName: string, listener: Listener<BaseEvent>): Promise<void>;
+    removeListener(eventName: string, listener: Listener<BaseEvent>): Promise<void>;
+    dispatch(eventName: string, eventData: BaseEvent): Promise<void>;
 }

package/dist/types/event-bus/implementations/adapters/no-op-event-bus-adapter/no-op-event-bus-adapter.d.ts

@@ -1,14 +1,17 @@
 /**
  * @module EventBus
  */
-import type { Listener, IBaseEvent } from "../../../../event-bus/contracts/_module";
+import type { OneOrMore } from "../../../../utilities/_module";
+import type { BaseEvent, Listener } from "../../../../event-bus/contracts/_module";
 import type { IEventBusAdapter } from "../../../../event-bus/contracts/_module";
 /**
  * This <i>NoOpEventBusAdapter</i> will do nothing and is used for easily mocking {@link IEventBus} for testing.
  * @group Adapters
  */
 export declare class NoOpEventBusAdapter implements IEventBusAdapter {
-    addListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
-    removeListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(_events: IBaseEvent[]): Promise<void>;
+    getGroup(): string;
+    withGroup(_group: OneOrMore<string>): IEventBusAdapter;
+    addListener(_eventName: string, _listener: Listener<BaseEvent>): PromiseLike<void>;
+    removeListener(_eventName: string, _listener: Listener<BaseEvent>): PromiseLike<void>;
+    dispatch(_eventName: string, _eventData: BaseEvent): PromiseLike<void>;
 }

package/dist/types/event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter-settings";
+export * from "../../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter";

package/dist/types/event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter-settings.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module EventBus
+ */
+import { type ISerde } from "../../../../serde/contracts/_module";
+import type Redis from "ioredis";
+import type { IBuildable, OneOrMore } from "../../../../utilities/_module";
+/**
+ * @group Adapters
+ */
+export type RedisPubSubEventBusAdapterSettings = {
+    dispatcherClient: Redis;
+    listenerClient: Redis;
+    serde: ISerde<string>;
+    rootGroup: OneOrMore<string>;
+};
+/**
+ * The <i>RedisPubSubEventBusAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class RedisPubSubEventBusAdapterSettingsBuilder<TSettings extends Partial<RedisPubSubEventBusAdapterSettings>> implements IBuildable<RedisPubSubEventBusAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setDispatcherClient(client: Redis): RedisPubSubEventBusAdapterSettingsBuilder<TSettings & {
+        dispatcherClient: Redis;
+    }>;
+    setListenerClient(client: Redis): RedisPubSubEventBusAdapterSettingsBuilder<TSettings & {
+        listenerClient: Redis;
+    }>;
+    setSerde(serde: ISerde<string>): RedisPubSubEventBusAdapterSettingsBuilder<TSettings & {
+        serde: ISerde<string>;
+    }>;
+    setRootGroup(group: OneOrMore<string>): RedisPubSubEventBusAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: RedisPubSubEventBusAdapterSettingsBuilder<RedisPubSubEventBusAdapterSettings>): RedisPubSubEventBusAdapterSettings;
+}