@daiso-tech/core 0.26.1 → 0.28.0

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

@@ -2,137 +2,154 @@
  * @module EventBus
  */
 import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
-import { type IEventBusAdapter, type IGroupableEventBus, type IEventBusFactory, type BaseEvent } from "../../../../event-bus/contracts/_module-exports.js";
-import type { OneOrMore, TimeSpan } from "../../../../utilities/_module-exports.js";
-import type { IFlexibleSerde } from "../../../../serde/contracts/_module-exports.js";
+import { type IGroupableEventBus, type IEventBusFactory, type BaseEvent } from "../../../../event-bus/contracts/_module-exports.js";
+import { type EventBusAdapterFactoryable, type EventBusSettingsBase } from "../../../../event-bus/implementations/derivables/event-bus/_module.js";
+import type { KeyPrefixer, TimeSpan } from "../../../../utilities/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
  * @group Derivables
  */
-export type EventBusAdapters<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
+export type EventBusAdapters<TAdapters extends string = string> = Partial<Record<TAdapters, EventBusAdapterFactoryable>>;
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
  * @group Derivables
  */
-export type EventBusFactorySettings<TAdapters extends string = string> = {
-    /**
-     * You can pass one or more <i>{@link IFlexibleSerde}</i> that will be used to register all <i>{@link IGroupableEventBus}</i> related errors.
-     * @default {true}
-     */
-    serde: OneOrMore<IFlexibleSerde>;
-    /**
-     * If set to true, all <i>{@link IGroupableEventBus}</i> related errors will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
-     * This ensures that all <i>{@link IGroupableEventBus}</i> related errors will be serialized correctly.
-     * @default {true}
-     */
-    shouldRegisterErrors?: boolean;
+export type EventBusFactorySettings<TAdapters extends string = string> = EventBusSettingsBase & {
     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>.
-     * @default {null}
-     */
-    retryAttempts?: number | null;
-    /**
-     * The default backof policy to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    backoffPolicy?: BackoffPolicy | null;
-    /**
-     * The default retry policy to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    retryPolicy?: RetryPolicy | null;
-    /**
-     * The default timeout to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    timeout?: TimeSpan | null;
 };
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
  * @group Derivables
  */
 export declare class EventBusFactory<TAdapters extends string = string> implements IEventBusFactory<TAdapters> {
-    private readonly eventBusRecord;
-    private readonly serde;
-    private readonly defaultAdapter?;
-    private readonly retryAttempts?;
-    private readonly backoffPolicy?;
-    private readonly retryPolicy?;
-    private readonly timeout?;
-    private readonly shouldRegisterErrors?;
+    private readonly settings;
     /**
      * @example
      * ```ts
-     * import { EventBusFactory } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
+     * import { type IEventBusAdapter, BaseEvent } from "@daiso-tech/core/event-bus/contracts";
+     * import { EventBusFactory } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { KeyPrefixer, type IFactoryObject, type Promiseable, type FactoryFn } from "@daiso-tech/utilities";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
      * import Redis from "ioredis";
      *
+     * type Store = Partial<Record<string, IEventBusAdapter>> = {};
+     *
+     * async function cahceAdapterFactory(store: Store): FactoryFn<string, IEventBusAdapter> {
+     *   return (prefix) => {
+     *     let adapter = store[prefix];
+     *     if (adapter === undefined) {
+     *       adapter = new MemoryEventBusAdapter();
+     *       store[prefix] = adapter;
+     *     }
+     *     return adapter;
+     *   }
+     * }
+     *
      * const serde = new Serde(new SuperJsonSerdeAdapter());
-     * const cacheFactory = new EventBusFactory({
-     *   serde,
+     * const store: Store = {};
+     * const eventBusFactory = new EventBusFactory({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
      *   adapters: {
-     *     memory:new MemoryEventBusAdapter({
-     *       rootGroup: "@global"
-     *     }),
+     *     memory: new MemoryEventBusAdapter(),
+     *     memoryFactory: cahceAdapterFactory(store),
      *     redis: new RedisPubSubEventBusAdapter({
-     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
-     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
      *       serde,
-     *       rootGroup: "@global"
+     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
+     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
      *     }),
-     *     defaultAdapter: "memory"
-     *   }
+     *   },
+     *   defaultAdapter: "memory"
      * });
      * ```
      */
     constructor(settings: EventBusFactorySettings<TAdapters>);
-    private init;
+    setKeyPrefixer(keyPrefixer: KeyPrefixer): EventBusFactory<TAdapters>;
+    setRetryAttempts(attempts: number): EventBusFactory<TAdapters>;
+    setBackoffPolicy(policy: BackoffPolicy): EventBusFactory<TAdapters>;
+    setRetryPolicy(policy: RetryPolicy): EventBusFactory<TAdapters>;
+    setRetryTimeout(timeout: TimeSpan): EventBusFactory<TAdapters>;
+    setTotalTimeout(timeout: TimeSpan): EventBusFactory<TAdapters>;
     /**
      * @example
      * ```ts
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBusFactory } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
+     * import { type IEventBusAdapter, BaseEvent } from "@daiso-tech/core/event-bus/contracts";
+     * import { EventBusFactory } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { KeyPrefixer, type IFactoryObject, type Promiseable, type FactoryFn } from "@daiso-tech/utilities";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
      * import Redis from "ioredis";
      *
+     * type Store = Partial<Record<string, IEventBusAdapter>> = {};
+     *
+     * async function cahceAdapterFactory(store: Store): FactoryFn<string, IEventBusAdapter> {
+     *   return (prefix) => {
+     *     let adapter = store[prefix];
+     *     if (adapter === undefined) {
+     *       adapter = new MemoryEventBusAdapter();
+     *       store[prefix] = adapter;
+     *     }
+     *     return adapter;
+     *   }
+     * }
+     *
+     * const dispatcherClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const listenerClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
      * const serde = new Serde(new SuperJsonSerdeAdapter());
-     * const cacheFactory = new EventBusFactory({
-     *   serde,
+     * const store: Store = {};
+     * const eventBusFactory = new EventBusFactory({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
      *   adapters: {
-     *     memory:new MemoryEventBusAdapter({
-     *       rootGroup: "@global"
-     *     }),
+     *     memory: new MemoryEventBusAdapter(),
+     *     memoryFactory: cahceAdapterFactory(store),
      *     redis: new RedisPubSubEventBusAdapter({
-     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
-     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
      *       serde,
-     *       rootGroup: "@global"
+     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
+     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
      *     }),
-     *     defaultAdapter: "memory"
-     *   }
+     *   },
+     *   defaultAdapter: "memory"
      * });
      *
      * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     * serde.registerEvent(AddEvent);
      *
-     * // Will use the default adapter which is MemoryEventBusAdapter
-     * await cacheFactory.use().dispatch(new AddEvent({ a: 1, b: 2 }));
+     * // Will dispatch AddEvent using the default adapter which is MemoryEventBusAdapter
+     * await eventBusFactory
+     *   .use()
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // Will dispatch AddEvent using the redis adapter which is RedisPubSubEventBusAdapter
+     * await eventBusFactory
+     *   .use("redis")
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // You can change the default settings of the returned EventBus instance.
+     * await eventBusFactory
+     *   .setRetryAttempts(4)
+     *   .use("memoryFactory")
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // You can reuse the settings
+     * const retryableEventBusFactory = eventBusFactory
+     *   .setRetryAttempts(4);
+     *
+     * await retryableEventBusFactory
+     *   .use()
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // You can extend the settings
+     * const extendedEventBusFactory = retryableEventBusFactory
+     *   .setRetryTimeout(TimeSpan.fromSeconds(1));
      *
-     * // Will use the redis dapter which is RedisPubSubEventBusAdapter
-     * await cacheFactory.use("redis").dispatch(new AddEvent({ a: 1, b: 2 }));
+     * await extendedEventBusFactory
+     *   .use()
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
      * ```
      */
     use<TEvents extends BaseEvent = BaseEvent>(adapterName?: TAdapters | undefined): IGroupableEventBus<TEvents>;

package/dist/event-bus/implementations/derivables/event-bus-factory/event-bus-factory.js

@@ -1,127 +1,185 @@
 /**
  * @module EventBus
  */
-import { registerEventBusErrorsToSerde, } from "../../../../event-bus/contracts/_module-exports.js";
-import { EventBus } from "../../../../event-bus/implementations/derivables/event-bus/event-bus.js";
+import {} from "../../../../event-bus/contracts/_module-exports.js";
+import { EventBus, } from "../../../../event-bus/implementations/derivables/event-bus/_module.js";
 import { DefaultAdapterNotDefinedError, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
  * @group Derivables
  */
 export class EventBusFactory {
-    eventBusRecord = {};
-    serde;
-    defaultAdapter;
-    retryAttempts;
-    backoffPolicy;
-    retryPolicy;
-    timeout;
-    shouldRegisterErrors;
+    settings;
     /**
      * @example
      * ```ts
-     * import { EventBusFactory } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
+     * import { type IEventBusAdapter, BaseEvent } from "@daiso-tech/core/event-bus/contracts";
+     * import { EventBusFactory } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { KeyPrefixer, type IFactoryObject, type Promiseable, type FactoryFn } from "@daiso-tech/utilities";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
      * import Redis from "ioredis";
      *
+     * type Store = Partial<Record<string, IEventBusAdapter>> = {};
+     *
+     * async function cahceAdapterFactory(store: Store): FactoryFn<string, IEventBusAdapter> {
+     *   return (prefix) => {
+     *     let adapter = store[prefix];
+     *     if (adapter === undefined) {
+     *       adapter = new MemoryEventBusAdapter();
+     *       store[prefix] = adapter;
+     *     }
+     *     return adapter;
+     *   }
+     * }
+     *
      * const serde = new Serde(new SuperJsonSerdeAdapter());
-     * const cacheFactory = new EventBusFactory({
-     *   serde,
+     * const store: Store = {};
+     * const eventBusFactory = new EventBusFactory({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
      *   adapters: {
-     *     memory:new MemoryEventBusAdapter({
-     *       rootGroup: "@global"
-     *     }),
+     *     memory: new MemoryEventBusAdapter(),
+     *     memoryFactory: cahceAdapterFactory(store),
      *     redis: new RedisPubSubEventBusAdapter({
-     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
-     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
      *       serde,
-     *       rootGroup: "@global"
+     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
+     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
      *     }),
-     *     defaultAdapter: "memory"
-     *   }
+     *   },
+     *   defaultAdapter: "memory"
      * });
      * ```
      */
     constructor(settings) {
-        const { adapters, shouldRegisterErrors = true, serde, defaultAdapter, retryAttempts, backoffPolicy, retryPolicy, timeout, } = settings;
-        this.shouldRegisterErrors = shouldRegisterErrors;
-        this.serde = serde;
-        this.retryAttempts = retryAttempts;
-        this.backoffPolicy = backoffPolicy;
-        this.retryPolicy = retryPolicy;
-        this.timeout = timeout;
-        this.defaultAdapter = defaultAdapter;
-        this.eventBusRecord = this.init(adapters);
+        this.settings = settings;
     }
-    init(adapters) {
-        if (this.shouldRegisterErrors) {
-            registerEventBusErrorsToSerde(this.serde);
-        }
-        const eventBusRecord = {};
-        for (const key in adapters) {
-            const { [key]: adapter } = adapters;
-            if (adapter === undefined) {
-                continue;
-            }
-            eventBusRecord[key] = new EventBus({
-                adapter,
-                retryAttempts: this.retryAttempts,
-                backoffPolicy: this.backoffPolicy,
-                retryPolicy: this.retryPolicy,
-                timeout: this.timeout,
-            });
-        }
-        return eventBusRecord;
+    setKeyPrefixer(keyPrefixer) {
+        return new EventBusFactory({
+            ...this.settings,
+            keyPrefixer,
+        });
+    }
+    setRetryAttempts(attempts) {
+        return new EventBusFactory({
+            ...this.settings,
+            retryAttempts: attempts,
+        });
+    }
+    setBackoffPolicy(policy) {
+        return new EventBusFactory({
+            ...this.settings,
+            backoffPolicy: policy,
+        });
+    }
+    setRetryPolicy(policy) {
+        return new EventBusFactory({
+            ...this.settings,
+            retryPolicy: policy,
+        });
+    }
+    setRetryTimeout(timeout) {
+        return new EventBusFactory({
+            ...this.settings,
+            retryTimeout: timeout,
+        });
+    }
+    setTotalTimeout(timeout) {
+        return new EventBusFactory({
+            ...this.settings,
+            totalTimeout: timeout,
+        });
     }
     /**
      * @example
      * ```ts
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBusFactory } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
+     * import { type IEventBusAdapter, BaseEvent } from "@daiso-tech/core/event-bus/contracts";
+     * import { EventBusFactory } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter, RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { KeyPrefixer, type IFactoryObject, type Promiseable, type FactoryFn } from "@daiso-tech/utilities";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
      * import Redis from "ioredis";
      *
+     * type Store = Partial<Record<string, IEventBusAdapter>> = {};
+     *
+     * async function cahceAdapterFactory(store: Store): FactoryFn<string, IEventBusAdapter> {
+     *   return (prefix) => {
+     *     let adapter = store[prefix];
+     *     if (adapter === undefined) {
+     *       adapter = new MemoryEventBusAdapter();
+     *       store[prefix] = adapter;
+     *     }
+     *     return adapter;
+     *   }
+     * }
+     *
+     * const dispatcherClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const listenerClient = new Redis("YOUR_REDIS_CONNECTION_STRING");
      * const serde = new Serde(new SuperJsonSerdeAdapter());
-     * const cacheFactory = new EventBusFactory({
-     *   serde,
+     * const store: Store = {};
+     * const eventBusFactory = new EventBusFactory({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
      *   adapters: {
-     *     memory:new MemoryEventBusAdapter({
-     *       rootGroup: "@global"
-     *     }),
+     *     memory: new MemoryEventBusAdapter(),
+     *     memoryFactory: cahceAdapterFactory(store),
      *     redis: new RedisPubSubEventBusAdapter({
-     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
-     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
      *       serde,
-     *       rootGroup: "@global"
+     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
+     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION_STRING"),
      *     }),
-     *     defaultAdapter: "memory"
-     *   }
+     *   },
+     *   defaultAdapter: "memory"
      * });
      *
      * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     * serde.registerEvent(AddEvent);
      *
-     * // Will use the default adapter which is MemoryEventBusAdapter
-     * await cacheFactory.use().dispatch(new AddEvent({ a: 1, b: 2 }));
+     * // Will dispatch AddEvent using the default adapter which is MemoryEventBusAdapter
+     * await eventBusFactory
+     *   .use()
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // Will dispatch AddEvent using the redis adapter which is RedisPubSubEventBusAdapter
+     * await eventBusFactory
+     *   .use("redis")
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // You can change the default settings of the returned EventBus instance.
+     * await eventBusFactory
+     *   .setRetryAttempts(4)
+     *   .use("memoryFactory")
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // You can reuse the settings
+     * const retryableEventBusFactory = eventBusFactory
+     *   .setRetryAttempts(4);
+     *
+     * await retryableEventBusFactory
+     *   .use()
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
+     *
+     * // You can extend the settings
+     * const extendedEventBusFactory = retryableEventBusFactory
+     *   .setRetryTimeout(TimeSpan.fromSeconds(1));
      *
-     * // Will use the redis dapter which is RedisPubSubEventBusAdapter
-     * await cacheFactory.use("redis").dispatch(new AddEvent({ a: 1, b: 2 }));
+     * await extendedEventBusFactory
+     *   .use()
+     *   .dispatch(new AddEvent({ a: 1, b: 2 }));
      * ```
      */
-    use(adapterName = this.defaultAdapter) {
+    use(adapterName = this.settings.defaultAdapter) {
         if (adapterName === undefined) {
             throw new DefaultAdapterNotDefinedError(EventBusFactory.name);
         }
-        const eventBus = this.eventBusRecord[adapterName];
-        if (eventBus === undefined) {
+        const adapter = this.settings.adapters[adapterName];
+        if (adapter === undefined) {
             throw new UnregisteredAdapterError(adapterName);
         }
-        return eventBus;
+        return new EventBus({
+            adapter,
+            ...this.settings,
+        });
     }
 }
 //# sourceMappingURL=event-bus-factory.js.map

package/dist/event-bus/implementations/derivables/event-bus-factory/event-bus-factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"event-bus-factory.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/derivables/event-bus-factory/event-bus-factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAKH,6BAA6B,GAChC,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,+DAA+D,CAAC;AAEzF,OAAO,EACH,6BAA6B,EAC7B,wBAAwB,GAC3B,MAAM,gCAAgC,CAAC;AAwExC;;;;GAIG;AACH,MAAM,OAAO,eAAe;IAGP,cAAc,GAAG,EAA+B,CAAC;IACjD,KAAK,CAA4B;IACjC,cAAc,CAAa;IAC3B,aAAa,CAAiB;IAC9B,aAAa,CAAwB;IACrC,WAAW,CAAsB;IACjC,OAAO,CAAmB;IAC1B,oBAAoB,CAAW;IAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,YAAY,QAA4C;QACpD,MAAM,EACF,QAAQ,EACR,oBAAoB,GAAG,IAAI,EAC3B,KAAK,EACL,cAAc,EACd,aAAa,EACb,aAAa,EACb,WAAW,EACX,OAAO,GACV,GAAG,QAAQ,CAAC;QACb,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;QACjD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9C,CAAC;IAEO,IAAI,CACR,QAAqC;QAErC,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,6BAA6B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9C,CAAC;QACD,MAAM,cAAc,GAA8B,EAAE,CAAC;QACrD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YACzB,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,QAAQ,CAAC;YACpC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBACxB,SAAS;YACb,CAAC;YACD,cAAc,CAAC,GAAG,CAAC,GAAG,IAAI,QAAQ,CAAC;gBAC/B,OAAO;gBACP,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;aACxB,CAAC,CAAC;QACP,CAAC;QACD,OAAO,cAAc,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,cAAc;QAExD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAClE,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAClD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,QAAQ,CAAC;IACpB,CAAC;CACJ"}
+{"version":3,"file":"event-bus-factory.js","sourceRoot":"","sources":["../../../../../src/event-bus/implementations/derivables/event-bus-factory/event-bus-factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAIN,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACH,QAAQ,GAGX,MAAM,6DAA6D,CAAC;AAErE,OAAO,EACH,6BAA6B,EAC7B,wBAAwB,GAC3B,MAAM,gCAAgC,CAAC;AAuBxC;;;;GAIG;AACH,MAAM,OAAO,eAAe;IA6CH;IA1CrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,YACqB,QAA4C;QAA5C,aAAQ,GAAR,QAAQ,CAAoC;IAC9D,CAAC;IAEJ,cAAc,CAAC,WAAwB;QACnC,OAAO,IAAI,eAAe,CAAC;YACvB,GAAG,IAAI,CAAC,QAAQ;YAChB,WAAW;SACd,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,QAAgB;QAC7B,OAAO,IAAI,eAAe,CAAC;YACvB,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,QAAQ;SAC1B,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,MAAqB;QAClC,OAAO,IAAI,eAAe,CAAC;YACvB,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,MAAM;SACxB,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,MAAmB;QAC9B,OAAO,IAAI,eAAe,CAAC;YACvB,GAAG,IAAI,CAAC,QAAQ;YAChB,WAAW,EAAE,MAAM;SACtB,CAAC,CAAC;IACP,CAAC;IAED,eAAe,CAAC,OAAiB;QAC7B,OAAO,IAAI,eAAe,CAAC;YACvB,GAAG,IAAI,CAAC,QAAQ;YAChB,YAAY,EAAE,OAAO;SACxB,CAAC,CAAC;IACP,CAAC;IAED,eAAe,CAAC,OAAiB;QAC7B,OAAO,IAAI,eAAe,CAAC;YACvB,GAAG,IAAI,CAAC,QAAQ;YAChB,YAAY,EAAE,OAAO;SACxB,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4EG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,QAAQ,CAAC,cAAc;QAEjE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAClE,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,IAAI,QAAQ,CAAC;YAChB,OAAO;YACP,GAAG,IAAI,CAAC,QAAQ;SACnB,CAAC,CAAC;IACP,CAAC;CACJ"}

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

@@ -7,7 +7,7 @@ import { type Promisable } from "../../../utilities/_module-exports.js";
 import type { IFlexibleSerde } from "../../../serde/contracts/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/test-utilities"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus/test-utilities"```
  * @group Test utilities
  */
 export type EventBusAdapterTestSuiteSettings = {
@@ -21,53 +21,7 @@ export type EventBusAdapterTestSuiteSettings = {
 /**
  * The <i>eventBusAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBusAdapter}</i> with vitest.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/test-utilities"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus/test-utilities"```
  * @group Test utilities
- * @example
- * ```ts
- * import { describe, test, beforeEach, expect, afterEach } from "vitest";
- * import type { StartedRedisContainer } from "@testcontainers/redis";
- * import { RedisContainer } from "@testcontainers/redis";
- * import Redis from "ioredis";
- * import { RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
- * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
- * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
- * import { eventBusAdapterTestSuite } from "@daiso-tech/core/event-bus/implementations/test-utilities";
- *
- * const TIMEOUT = TimeSpan.fromMinutes(2);
- * describe("class: RedisPubSubEventBusAdapter", () => {
- *   let dispatcherClient: Redis;
- *   let listenerClient: Redis;
- *   let startedContainer: StartedRedisContainer;
- *   const serde = new Serde(new SuperJsonSerdeAdapter());
- *
- *   beforeEach(async () => {
- *     startedContainer = await new RedisContainer().start();
- *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
- *     listenerClient = new Redis(startedContainer.getConnectionUrl());
- *   }, TIMEOUT.toMilliseconds());
- *
- *   afterEach(async () => {
- *     await dispatcherClient.quit();
- *     await listenerClient.quit();
- *     await startedContainer.stop();
- *   }, TIMEOUT.toMilliseconds());
- *
- *   eventBusAdapterTestSuite({
- *     createAdapter: () =>
- *       new RedisPubSubEventBusAdapter({
- *         dispatcherClient,
- *         listenerClient,
- *         serde,
- *         rootGroup: "@global"
- *       }),
- *     serde,
- *     test,
- *     beforeEach,
- *     expect,
- *     describe,
- *   });
- * });
- * ```
  */
 export declare function eventBusAdapterTestSuite(settings: EventBusAdapterTestSuiteSettings): void;