@daiso-tech/core 0.16.0 → 0.17.4

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

@@ -1,102 +1,94 @@
 /**
  * @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;
-    };
-}>;
+import type { BaseEvent, Listener } from "../../event-bus/contracts/_shared";
 /**
  * @group Contracts
  */
-export type SelectEvent<TEvents extends BaseEvents, TEventName extends keyof TEvents> = {
-    [TEventName in keyof TEvents]: TEvents[TEventName] & {
-        type: TEventName;
-    };
-}[TEventName];
+export type EventClass<TEvents extends BaseEvent> = {
+    new (...arguments_: any[]): TEvents;
+};
 /**
  * @group Contracts
  */
-export type Unsubscribe = () => LazyPromise<void>;
+export type EventInstance<TEventClass extends EventClass<BaseEvent>> = TEventClass extends {
+    new (...arguments_: any[]): infer TInstance;
+} ? TInstance : never;
 /**
  * @group Contracts
  */
-export type AddListenerSettings = {
-    signal?: AbortSignal;
-};
+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<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
+    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: AllEvents<TEvents>): LazyPromise<void>;
+    dispatch(event: TEvents): LazyPromise<void>;
     /**
      * The <i>dispatchMany</i> method is used for dispatching multiple <i>event</i>.
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
-    dispatchMany(events: 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>getGroup</i> method returns the complete group.
      * @example
@@ -121,7 +113,7 @@ export type IEventBus<TEvents extends BaseEvents = BaseEvents> = IListenable<TEv
  * It commes with one extra method which is useful for multitennat applications compared to <i>IEventBus</i>.
  * @group Contracts
  */
-export type IGroupableEventBus<TEvents extends BaseEvents = BaseEvents> = IEventBus<TEvents> & {
+export type IGroupableEventBus<TEvents extends BaseEvent = BaseEvent> = IEventBus<TEvents> & {
     /**
      * 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.

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

@@ -4,11 +4,13 @@
 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;
@@ -26,7 +28,7 @@ export type EventBusAdapterTestSuiteSettings = {
  * import Redis from "ioredis";
  * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, eventBusAdapterTestSuite } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: RedisPubSubEventBusAdapter", () => {
  *   let dispatcherClient: Redis;
  *   let listenerClient: Redis;
@@ -36,12 +38,12 @@ export type EventBusAdapterTestSuiteSettings = {
  *     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({
  *      createAdapterA: () =>
  *        new RedisPubSubEventBusAdapter({
@@ -57,6 +59,7 @@ export type EventBusAdapterTestSuiteSettings = {
  *          serde,
  *          rootGroup: "@global"
  *        }),
+ *      serde,
  *      test,
  *      beforeEach,
  *      expect,

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

@@ -4,11 +4,13 @@
 import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
 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,9 +26,9 @@ export type EventBusTestSuiteSettings = {
  * import type { StartedRedisContainer } from "@testcontainers/redis";
  * import { RedisContainer } from "@testcontainers/redis";
  * import Redis from "ioredis";
- * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, 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;
@@ -36,12 +38,12 @@ export type EventBusTestSuiteSettings = {
  *     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(
@@ -49,8 +51,8 @@ export type EventBusTestSuiteSettings = {
  *            dispatcherClient,
  *            listenerClient,
  *            serde,
- *          }),
- *          { rootGroup: "@a" }
+ *            rootGroup: "@global"
+ *          })
  *        ),
  *      createEventBusB: () =>
  *        new EventBus(
@@ -58,9 +60,10 @@ export type EventBusTestSuiteSettings = {
  *            dispatcherClient,
  *            listenerClient,
  *            serde,
+ *            rootGroup: "@global"
  *          }),
- *          { rootGroup: "@b" }
  *        ),
+ *      serde,
  *      test,
  *      beforeEach,
  *      expect,

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

@@ -2,35 +2,61 @@
  * @module EventBus
  */
 import { type OneOrMore } from "../../../../utilities/_module";
-import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
-import { EventEmitter } from "node:events";
+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("@global", eventEmitter);
- * ```
  */
 export declare class MemoryEventBusAdapter implements IEventBusAdapter {
-    private readonly eventEmiter;
+    /**
+     * @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;
-    constructor(defaultGroup: OneOrMore<string>, eventEmiter?: EventEmitter<[never]>);
+    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<IBaseEvent>): Promise<void>;
-    removeListener(eventName: string, listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(event: IBaseEvent): Promise<void>;
+    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

@@ -2,7 +2,7 @@
  * @module EventBus
  */
 import type { OneOrMore } from "../../../../utilities/_module";
-import type { Listener, IBaseEvent } from "../../../../event-bus/contracts/_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.
@@ -11,7 +11,7 @@ import type { IEventBusAdapter } from "../../../../event-bus/contracts/_module";
 export declare class NoOpEventBusAdapter implements IEventBusAdapter {
     getGroup(): string;
     withGroup(_group: OneOrMore<string>): IEventBusAdapter;
-    addListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
-    removeListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(_event: IBaseEvent): Promise<void>;
+    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

@@ -1 +1,2 @@
-export * from "../../../../event-bus/implementations/adapters/memory-event-bus-adapter/_module";
+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;
+}

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

@@ -1,50 +1,62 @@
 /**
  * @module EventBus
  */
-import { type ISerde } from "../../../../serde/contracts/_module";
-import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
-import type Redis from "ioredis";
+import type { BaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
 import type { OneOrMore } from "../../../../utilities/_module";
+import type { RedisPubSubEventBusAdapterSettings } from "../../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter-settings";
+import { RedisPubSubEventBusAdapterSettingsBuilder } from "../../../../event-bus/implementations/adapters/redis-pub-sub-event-bus-adapter/redis-pub-sub-event-bus-adapter-settings";
 /**
+ * To utilize the <i>RedisPubSubEventBusAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
-export type RedisPubSubEventBusAdapterSettings = {
-    dispatcherClient: Redis;
-    listenerClient: Redis;
-    serde: ISerde<string>;
-    rootGroup: OneOrMore<string>;
-};
-/**
- * To utilize the <i>RedisPubSubEventBusAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { RedisPubSubEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
- * import Redis from "ioredis";
- *
- * const dispatcherClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
- * const listenerClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
- * const serde = new SuperJsonSerde();
- * const eventBusAdapter = new RedisPubSubEventBusAdapter({
- *   dispatcherClient,
- *   listenerClient,
- *   serde,
- * });
- * ```
- */
 export declare class RedisPubSubEventBusAdapter implements IEventBusAdapter {
+    /**
+     * @example
+     * ```ts
+     * import { RedisPubSubEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheAdapter = new RedisPubSubEventBusAdapter(
+     *   RedisPubSubEventBusAdapter
+     *     .settings()
+     *     .setDispatcherClient(new Redis("YOUR REDIS CONNECTION"))
+     *     .setListenerClient(new Redis("YOUR REDIS CONNECTION"))
+     *     .setSerde(new SuperJsonSerde())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<RedisPubSubEventBusAdapterSettings>>(): RedisPubSubEventBusAdapterSettingsBuilder<TSettings>;
     private readonly group;
-    private readonly serde;
+    private readonly baseSerde;
     private readonly redisSerde;
     private readonly dispatcherClient;
     private readonly listenerClient;
     private readonly eventEmitter;
+    /**
+     * @example
+     * ```ts
+     * import { RedisPubSubEventBusAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const dispatcherClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const listenerClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const serde = new SuperJsonSerde();
+     * const eventBusAdapter = new RedisPubSubEventBusAdapter({
+     *   dispatcherClient,
+     *   listenerClient,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     * ```
+     */
     constructor({ dispatcherClient, listenerClient, serde, rootGroup, }: RedisPubSubEventBusAdapterSettings);
     getGroup(): string;
     withGroup(group: OneOrMore<string>): IEventBusAdapter;
     private withPrefix;
     private redisListener;
-    addListener(eventName: string, listener: Listener<IBaseEvent>): Promise<void>;
-    removeListener(eventName: string, listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(event: IBaseEvent): Promise<void>;
+    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/derivables/_module.d.ts

@@ -1,2 +1,4 @@
-export * from "../../../event-bus/implementations/derivables/event-bus";
+export * from "../../../event-bus/implementations/derivables/event-bus-factory-settings";
 export * from "../../../event-bus/implementations/derivables/event-bus-factory";
+export * from "../../../event-bus/implementations/derivables/event-bus-settings";
+export * from "../../../event-bus/implementations/derivables/event-bus";

package/dist/types/event-bus/implementations/derivables/event-bus-factory-settings.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @module EventBus
+ */
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import type { IGroupableEventBus, IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type EventBusAdapters<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
+/**
+ * The <i>EventBusFactorySettings</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export type EventBusFactorySettings<TAdapters extends string = string> = {
+    adapters: EventBusAdapters<TAdapters>;
+    defaultAdapter?: NoInfer<TAdapters>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * The <i>EventBusFactorySettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export declare class EventBusFactorySettingsBuilder<TSettings extends EventBusFactorySettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setEventBus(eventBus: IGroupableEventBus<any>): EventBusFactorySettingsBuilder<TSettings & {
+        eventBus: IGroupableEventBus<any>;
+    }>;
+    setRetryAttempts(attempts: number | null): EventBusFactorySettingsBuilder<TSettings & {
+        retryAttempts: number | null;
+    }>;
+    setBackoffPolicy(policy: BackoffPolicy | null): EventBusFactorySettingsBuilder<TSettings & {
+        backoffPolicy: BackoffPolicy | null;
+    }>;
+    setRetryPolicy(policy: RetryPolicy | null): EventBusFactorySettingsBuilder<TSettings & {
+        retryPolicy: RetryPolicy | null;
+    }>;
+    setTimeout(time: TimeSpan | null): EventBusFactorySettingsBuilder<TSettings & {
+        timeout: TimeSpan | null;
+    }>;
+    setAdapter<TName extends string>(name: TName, adapter: IEventBusAdapter): EventBusFactorySettingsBuilder<TSettings & {
+        adapters: {
+            readonly [x: string]: IEventBusAdapter | undefined;
+        };
+    }>;
+    setDefaultAdapter(adapter: string): EventBusFactorySettingsBuilder<TSettings & {
+        defaultAdapter: string;
+    }>;
+    build(this: EventBusFactorySettingsBuilder<EventBusFactorySettings>): EventBusFactorySettings;
+}