@daiso-tech/core 0.26.1 → 0.28.0

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

@@ -1,336 +1,132 @@
 /**
  * @module EventBus
  */
-import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
+import type { LazyPromiseSettingsBase } from "../../../../async/_module-exports.js";
 import { LazyPromise } from "../../../../async/_module-exports.js";
 import type { EventClass, EventInstance, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
 import { type IEventBus, type IGroupableEventBus, type IEventBusAdapter, type BaseEvent } from "../../../../event-bus/contracts/_module-exports.js";
-import type { Invokable, OneOrMore, TimeSpan } from "../../../../utilities/_module-exports.js";
+import type { Factoryable, Invokable, IKeyPrefixer, OneOrMore, Items } 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 EventBusSettings = {
-    adapter: IEventBusAdapter;
-    /**
-     * 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;
+export type EventBusSettingsBase = LazyPromiseSettingsBase & {
+    keyPrefixer: IKeyPrefixer;
+};
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
+ * @group Derivables
+ */
+export type EventBusAdapterFactoryable = Factoryable<string, IEventBusAdapter>;
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
+ * @group Derivables
+ */
+export type EventBusSettings = EventBusSettingsBase & {
+    adapter: EventBusAdapterFactoryable;
 };
 /**
  * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus"```
  * @group Derivables
  */
 export declare class EventBus<TEvents extends BaseEvent = BaseEvent> implements IGroupableEventBus<TEvents> {
-    private readonly adapter;
+    private readonly adapterFactoryable;
     private readonly retryAttempts;
     private readonly backoffPolicy;
     private readonly retryPolicy;
-    private readonly timeout;
-    private readonly listenerObjectMap;
+    private readonly retryTimeout;
+    private readonly totalTimeout;
+    private readonly store;
+    private readonly adapterPromise;
+    private keyPrefixer;
     /**
      * @example
      * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus";
+     * import { KeyPrefixer } from "@daiso-tech/utilities";
      *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const eventBus = new EventBus({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
+     *   adapter: new MemoryEventBusAdapter()
      * });
      * ```
-     */
-    constructor(settings: EventBusSettings);
-    private createLayPromise;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus, IEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * // Will print "@global"
-     * console.log(eventBus.getGroup());
      *
-     * const groupedEventBus: IEventBus = eventBus.withGroup("company-1");
-     *
-     * // Will print "@global/company-1"
-     * console.log(groupedEventBus.getGroup());
-     * ```
-     */
-    withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
-    /**
+     * You can pass factory function that will create an adapter for every group.
      * @example
      * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * // Will print "@global"
-     * console.log(eventBus.getGroup());
-     * ```
-     */
-    getGroup(): string;
-    private ensureListenerObject;
-    private resolveListener;
-    private deleteListener;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     *
-     * const listener: Invokable<AddEvent> = event => {
-     *   console.log(event);
+     * import type { IEventBusAdapter } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus";
+     * import { KeyPrefixer, type FactoryFn } from "@daiso-tech/utilities";
+     *
+     * 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;
+     *   }
      * }
-     * await eventBus.addListener(AddEvent, listener);
-     * await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
-     * ```
-     */
-    addListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";
      *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const store: Store = {}
+     * const eventBus = new EventBus({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
+     *   adapter: cahceAdapterFactory(store)
      * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     *
-     * const listener: Invokable<AddEvent> = event => {
-     *   console.log(event);
-     * }
-     * await eventBus.addListener(AddEvent, listener);
-     * await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
-     * await eventBus.removeListener(AddEvent, listener);
      * ```
-     */
-    removeListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     * class SubEvent extends BaseEvent<{ c: number, d: number }> {}
      *
-     * const listener: Invokable<AddEvent | SubEvent> = event => {
-     *   console.log(event)
-     * }
-     * await eventBus.addListenerMany([AddEvent, SubEvent], listener);
-     * await eventBus.dispatchMany([
-     *   new AddEvent({ a: 1, b: 2 }),
-     *   new SubEvent({ c: 1, d: 2 }),
-     * ]);
-     * ```
-     */
-    addListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
+     * You can also pass factory object that implements <i>{@link IFactoryObject}</i> contract. This useful for depedency injection libraries.
      * @example
      * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     * class SubEvent extends BaseEvent<{ c: number, d: number }> {}
-     *
-     * const listener: Invokable<AddEvent | SubEvent> = event => {
-     *   console.log(event);
+     * import type { IEventBusAdapter } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus";
+     * import { KeyPrefixer, type IFactoryObject, type Promiseable } from "@daiso-tech/utilities";
+     *
+     * type Store = Partial<Record<string, IEventBusAdapter>>;
+     *
+     * class EventBusAdapterFactory implements IFactoryObject<string, IEventBusAdapter> {
+     *   constructor(private readonly store: Store) {}
+     *
+     *   async use(prefix: string): Promiseable<IEventBusAdapter> {
+     *     let adapter = this.store[prefix];
+     *     if (adapter === undefined) {
+     *       adapter = new MemoryEventBusAdapter();
+     *       store[prefix] = adapter;
+     *     }
+     *     return adapter;
+     *   }
      * }
-     * await eventBus.addListenerMany([AddEvent, SubEvent], listener);
-     * await eventBus.dispatchMany([
-     *   new AddEvent({ a: 1, b: 2 }),
-     *   new SubEvent({ c: 1, d: 2 }),
-     * ]);
-     * await eventBus.removeListenerMany([AddEvent, SubEvent], listener);
-     * ```
-     */
-    removeListenerMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
      *
-     * await eventBus.listenOnce(AddEvent, event => {
-     *   console.log(event);
+     * const store: Store = {}
+     * const eventBus = new EventBus({
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
+     *   adapter: new EventBusAdapterFactory(store)
      * });
-     *
-     * await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
      * ```
      */
+    constructor(settings: EventBusSettings);
+    private createLazyPromise;
+    withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
+    getGroup(): string | null;
+    addListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClassArr extends EventClass<TEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
+    removeListenerMany<TEventClassArr extends EventClass<TEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
     listenOnce<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     *
-     * eventBus.asPromise(AddEvent).then(event => {
-     *   console.log(event);
-     * });
-     *
-     * await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
-     * ```
-     */
     asPromise<TEventClass extends EventClass<TEvents>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     *
-     * const unsubscribe = await eventBus.subscribe(AddEvent, event => {
-     *   console.log(event);
-     * });
-     * await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
-     * await unsubscribe();
-     * ```
-     */
     subscribe<TEventClass extends EventClass<TEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     * class SubEvent extends BaseEvent<{ c: number, d: number }> {}
-     *
-     * const unsubscribe = await eventBus.subscribeMany([AddEvent, SubEvent], event => {
-     *   console.log(event);
-     * });
-     * await eventBus.dispatchMany([
-     *   new AddEvent({ a: 1, b: 2 }),
-     *   new SubEvent({ c: 1, d: 2 }),
-     * ]);
-     * await unsubscribe();
-     * ```
-     */
-    subscribeMany<TEventClass extends EventClass<TEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     * class SubEvent extends BaseEvent<{ c: number, d: number }> {}
-     *
-     * await eventBus.dispatchMany([
-     *   new AddEvent({ a: 1, b: 2 }),
-     *   new SubEvent({ c: 1, d: 2 }),
-     * ]);
-     * ```
-     */
+    subscribeMany<TEventClassArr extends EventClass<TEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<Unsubscribe>;
     dispatchMany(events: TEvents[]): LazyPromise<void>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";
-     *
-     * const eventBus: IGroupableEventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     *
-     * class AddEvent extends BaseEvent<{ a: number, b: number }> {}
-     *
-     * await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
-     * ```
-     */
     dispatch(event: TEvents): LazyPromise<void>;
 }