@daiso-tech/core 0.10.0 → 0.12.0

package/dist/types/cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @module Cache
+ */
+import type { IDeinitizable, IInitizable } from "../../../../_shared/types";
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { TimeSpan } from "../../../../utilities/_module";
+import { type Database } from "better-sqlite3";
+/**
+ * @group Adapters
+ */
+export type SqliteStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @group Adapters
+ */
+export declare class SqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly cacheAdapter;
+    constructor(database: Database, settings: SqliteStorageAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    deInit(): Promise<void>;
+    init(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/cache/implementations/derivables/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../../../cache/implementations/derivables/base-cache";
+export * from "../../../cache/implementations/derivables/cache";
+export * from "../../../cache/implementations/derivables/cache-factory";

package/dist/types/cache/implementations/derivables/base-cache.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module Cache
+ */
+import type { CacheEventNames, WithTtlValue } from "../../../cache/contracts/_module";
+import { type ICache } from "../../../cache/contracts/_module";
+import { type INamespacedCache, type AllCacheEvents } from "../../../cache/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+import { type AsyncLazyable, type GetOrAddValue } from "../../../_shared/types";
+import type { TimeSpan } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { Listener, SelectEvent, Unsubscribe, INamespacedEventBus } from "../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type BaseCacheSettings<TType> = {
+    namespace: string;
+    eventBus: INamespacedEventBus<AllCacheEvents<TType>>;
+};
+/**
+ * The BaseCache class serves as an abstract base class that provides implementations for redundant methods.
+ * It simplifies implementing the {@link INamespacedCache} interface without using an {@link ICacheAdapter}.
+ * @group Derivables
+ */
+export declare abstract class BaseCache<TType = unknown> implements INamespacedCache<TType> {
+    private readonly listenable;
+    constructor(settings: BaseCacheSettings<TType>);
+    addListener<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    abstract withNamespace(namespace: OneOrMore<string>): ICache<TType>;
+    abstract getNamespace(): string;
+    exists(key: string): LazyPromise<boolean>;
+    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    missing(key: string): LazyPromise<boolean>;
+    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    abstract get(key: string): LazyPromise<TType | null>;
+    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
+    getOrFail(key: string): LazyPromise<TType>;
+    abstract add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    abstract update(key: string, value: TType): LazyPromise<boolean>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    abstract put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    abstract remove(key: string): LazyPromise<boolean>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    getAndRemove(key: string): LazyPromise<TType | null>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, ttl?: TimeSpan): LazyPromise<TType>;
+    abstract increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    abstract clear(): LazyPromise<void>;
+}

package/dist/types/cache/implementations/derivables/cache-factory.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @module Cache
+ */
+import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
+import type { ICacheFactory, INamespacedCache, ICacheAdapter } from "../../../cache/contracts/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type CacheDrivers<TDrivers extends string> = Partial<Record<TDrivers, ICacheAdapter<any>>>;
+/**
+ * @group Derivables
+ */
+export type CacheFactorySettings<TDrivers extends string = string> = {
+    drivers: CacheDrivers<TDrivers>;
+    defaultDriver?: NoInfer<TDrivers>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
+     */
+    eventBus?: INamespacedEventBus<any>;
+    /**
+     * You can prefix all keys with a given <i>rootNamespace</i>.
+     */
+    rootNamespace?: string;
+};
+/**
+ * @group Derivables
+ * @example
+ * ```ts
+ * import { CacheFactory } from "@daiso-tech/core";
+ * import Redis from "ioredis"
+ *
+ * const cacheFactory = new CacheFactory({
+ *   drivers: {
+ *     memory: new MemoryCacheAdapter(),
+ *     redis: new RedisCacheAdapter(new Redis()),
+ *   },
+ *   defaultDriver: "memory",
+ *   rootNamespace: "@events"
+ * });
+ * ```
+ */
+export declare class CacheFactory<TDrivers extends string = string, TType = unknown> implements ICacheFactory<TDrivers, TType> {
+    private readonly rootNamespace?;
+    private readonly drivers;
+    private readonly defaultDriver?;
+    private readonly eventBus?;
+    private defaultTtl;
+    constructor(settings: CacheFactorySettings<TDrivers>);
+    use(driverName?: TDrivers | undefined): INamespacedCache<TType>;
+    withType<TOutput extends TType = TType>(): ICacheFactory<TDrivers, TOutput>;
+}

package/dist/types/cache/implementations/derivables/cache.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @module Cache
+ */
+import { type ICache, type ICacheAdapter } from "../../../cache/contracts/_module";
+import { type INamespacedCache, type AllCacheEvents } from "../../../cache/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+import type { TimeSpan } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
+import { BaseCache } from "../../../cache/implementations/derivables/base-cache";
+/**
+ * @group Derivables
+ */
+export type CacheSettings<TType> = {
+    /**
+     * You can prefix all keys with a given <i>rootNamespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { Cache, MemoryCacheAdapter } from "@daiso-tech/core";
+     *
+     * const memoryCacheAdapter = new MemoryCacheAdapter();
+     * const cacheA = new Cache(memoryCacheAdapter, {
+     *   rootNamespace: "@a"
+     * });
+     * const cacheB = new Cache(memoryCacheAdapter, {
+     *   rootNamespace: "@b"
+     * });
+     *
+     * (async () => {
+     *   await cacheA.add("a", 1);
+     *
+     *   // Will be "a"
+     *   console.log(await cacheA.get("a"));
+     *
+     *   // Will be "null"
+     *   console.log(await cacheB.get("a"));
+     * })();
+     * ```
+     */
+    rootNamespace?: OneOrMore<string>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
+     */
+    eventBus?: INamespacedEventBus<AllCacheEvents<TType>>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan | null;
+};
+/**
+ * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
+ * @group Derivables
+ * @example
+ * ```ts
+ * import { Cache, MemoryCacheAdapter } from "@daiso-tech/core";
+ *
+ * const cache = new Cache(new MemoryCacheAdapter());
+ * ```
+ */
+export declare class Cache<TType = unknown> extends BaseCache<TType> implements INamespacedCache<TType> {
+    private readonly namespace;
+    private readonly namespacedEventBus;
+    private readonly eventBus;
+    private readonly cacheAdapter;
+    private readonly eventAttributes;
+    private readonly defaultTtl;
+    constructor(cacheAdapter: ICacheAdapter<any>, settings?: CacheSettings<TType>);
+    private createKeyFoundEvent;
+    private createKeyNotFoundEvent;
+    private createKeyAddedEvent;
+    private createKeyUpdatedEvent;
+    private createKeyRemovedEvent;
+    private createKeysClearedEvent;
+    private createKeyIncrementedEvent;
+    private createKeyDecrementedEvent;
+    private keyWithNamespace;
+    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
+    getNamespace(): string;
+    get(key: string): LazyPromise<TType | null>;
+    add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    update(key: string, value: TType): LazyPromise<boolean>;
+    put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    remove(key: string): LazyPromise<boolean>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    clear(): LazyPromise<void>;
+}

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-error-handler-iterable.d.ts

@@ -1,6 +1,9 @@
 /**
  * @module Collection
  */
+/**
+ * @internal
+ */
 export declare class AsyncErrorHandlerIterable<TInput> implements AsyncIterable<TInput> {
     private readonly iterable;
     private readonly errorPasser;

package/dist/types/collection/implementations/iterable-collection/_shared/cross-join-iterable.d.ts

@@ -2,6 +2,9 @@
  * @module Collection
  */
 import type { CrossJoinResult, ICollection } from "../../../../collection/contracts/_module";
+/**
+ * @internal
+ */
 export declare class CrossJoinIterable<TInput, TExtended = TInput> implements Iterable<CrossJoinResult<TInput, TExtended>> {
     private collection;
     private iterable;

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

@@ -1,4 +1,5 @@
 export * from "../../event-bus/contracts/_shared";
+export * from "../../event-bus/contracts/event-bus.errors";
 export * from "../../event-bus/contracts/event-bus.contract";
 export * from "../../event-bus/contracts/event-bus-adapter.contract";
-export * from "../../event-bus/contracts/event-bus-manager.contract";
+export * from "../../event-bus/contracts/event-bus-factory.contract";

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

@@ -6,33 +6,3 @@ export type IBaseEvent = {
     type: string;
 };
 export type Listener<TEvent extends IBaseEvent> = (event: TEvent) => Promisable<void>;
-/**
- * @group Errors
- */
-export declare class EventBusError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class UnexpectedEventBusError extends EventBusError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class RemoveListenerEventBusError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class AddListenerEventBusError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class DispatchEventBusError extends Error {
-    constructor(message: string, cause?: unknown);
-}

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

@@ -0,0 +1,78 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../utilities/_module";
+import type { INamespacedEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { IBaseEvent } from "../../event-bus/contracts/_shared";
+/**
+ * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link INamespacedEventBus}</i> dynamically.
+ * @group Contracts
+ */
+export type IEventBusFactory<TDrivers extends string = string, TEvents extends IBaseEvent = IBaseEvent> = {
+    /**
+     * 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}
+     * @example
+     * ```ts
+     * import { type IEventBusFactory } from "@daiso-tech/core";
+     *
+     * async function main(eventFactory: IEventBusFactory): Promise<void> {
+     *   // Will dispatch envent using the default driver
+     *   await eventBusFactory
+     *     .use()
+     *     .dispatch({ type: "add", a: 1, b: 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>withValidation</i> method is used to set a <i>validator</i>, which validates the event during runtime.
+     * The type is inferred from the provided <i>validator</i>.
+     * @example
+     * ```ts
+     * import { type IEventBusFactory, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod"
+     *
+     * async function main(eventBusFactory: IEventBusFactory): Promise<void> {
+     *   const addEventSchema = z.zod({
+     *     type: z.literal("add"),
+     *     a: z.number(),
+     *     b: z.number(),
+     *   });
+     *   await eventBusFactory
+     *     .withValidation(zodValidator(addEventSchema))
+     *     .use()
+     *     // You will se an typescript error and get runtime erorr
+     *     .dispatch({ type: "add" });
+     * }
+     * ```
+     */
+    withValidation<TOutput extends TEvents = TEvents>(validator: Validator<TOutput>): IEventBusFactory<TDrivers, TOutput>;
+    /**
+     * The <i>withTypes</i> method is used to set the event types of the <i>{@link IEventBus}</i>.
+     * @example
+     * ```ts
+     * import { type IEventBusFactory, zodValidator } 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" });
+     * }
+     * ```
+     */
+    withType<TOutput extends TEvents = TEvents>(): IEventBusFactory<TDrivers, TOutput>;
+};

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

@@ -1,7 +1,7 @@
 /**
  * @module EventBus
  */
-import type { LazyPromise } from "../../_module";
+import type { LazyPromise } from "../../utilities/_module";
 import type { OneOrMore } from "../../_shared/types";
 import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
 export type SelectEvent<TEvents extends IBaseEvent, TEventType extends TEvents["type"]> = Extract<TEvents, {
@@ -49,32 +49,38 @@ export type IListenable<TEvents extends IBaseEvent = IBaseEvent> = {
     subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
 };
 /**
- * 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>.
+ * The <i>IDispatcher</i> contract defines a way for dispatching to events independent of underlying technology.
  * @group Contracts
  */
-export type IEventBus<TEvents extends IBaseEvent = IBaseEvent> = IListenable<TEvents> & {
+export type IDispatcher<TEvents extends IBaseEvent = IBaseEvent> = {
     /**
      * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
     dispatch(events: OneOrMore<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 IBaseEvent = IBaseEvent> = IListenable<TEvents> & IDispatcher<TEvents> & {
     /**
-     * The <i>getNamespace</i> method return the complete namespace.
+     * The <i>getNamespace</i> method returns the complete namespace.
      * @example
      * ```ts
-     *   const eventBus = new EventBus(new MemoryEventBusAdapter(), {
-     *     rootNamespace: "@root/"
-     *   });
+     * import { type IEventBus } from "@daiso-tech/core";
      *
-     *   // Will be "@root/"
+     * async function main(eventBus: IEventBus): Promise<void> {
+     *   // Will be "@root"
      *   console.log(eventBus.getNamespace())
      *
-     *   const eventBusA = eventBus.withNamespace("a/");
+     *   const eventBusA = eventBus.withNamespace("a");
      *
-     *   // Will be "@root/a/"
+     *   // Will be "@root/a"
      *   console.log(eventBusA.getNamespace())
+     * }
      * ```
      */
     getNamespace(): string;
@@ -90,11 +96,9 @@ export type INamespacedEventBus<TEvents extends IBaseEvent = IBaseEvent> = IEven
      * This useful for multitennat applications.
      * @example
      * ```ts
-     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
-     *
-     * (async () => {
-     *   const eventBus = new EventBus(new MemoryEventBusAdapter());
+     * import { type IEventBus } from "@daiso-tech/core";
      *
+     * async function main(eventBus: IEventBus): Promise<void> {
      *   const eventBusA = eventBus.withNamespace("a");
      *   await eventBusA.subscribe("add", (event) => {
      *     // This will be logged
@@ -112,9 +116,8 @@ export type INamespacedEventBus<TEvents extends IBaseEvent = IBaseEvent> = IEven
      *     a: 1,
      *     b: 2
      *   })
-     * })();
-     *
+     * }
      * ```
      */
-    withNamespace(namespace: string): IEventBus<TEvents>;
+    withNamespace(namespace: OneOrMore<string>): IEventBus<TEvents>;
 };

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

@@ -0,0 +1,33 @@
+/**
+ * @module EventBus
+ */
+/**
+ * @group Errors
+ */
+export declare class EventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class UnexpectedEventBusError extends EventBusError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class RemoveListenerEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class AddListenerEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class DispatchEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}

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

@@ -1,5 +1,3 @@
 export * from "../../event-bus/implementations/_shared/test-utilities/_module";
-export * from "../../event-bus/implementations/event-bus/_module";
-export * from "../../event-bus/implementations/memory-event-bus-adapter/_module";
-export * from "../../event-bus/implementations/redis-event-bus-adapter/_module";
-export * from "../../event-bus/implementations/no-op-event-bus-adapter/_module";
+export * from "../../event-bus/implementations/derivables/_module";
+export * from "../../event-bus/implementations/adapters/_module";

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

@@ -0,0 +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";

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

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

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

@@ -1,7 +1,7 @@
 /**
  * @module EventBus
  */
-import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
 import { EventEmitter } from "node:events";
 /**
  * @group Adapters

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

@@ -0,0 +1 @@
+export * from "../../../../event-bus/implementations/adapters/no-op-event-bus-adapter/no-op-event-bus-adapter";

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

@@ -1,10 +1,10 @@
 /**
  * @module EventBus
  */
-import type { Listener, IBaseEvent } from "../../../_module";
-import type { IEventBusAdapter } from "../../../event-bus/contracts/event-bus-adapter.contract";
+import type { Listener, IBaseEvent } 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 IEventBus for testing.
+ * 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 {

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

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

package/dist/types/event-bus/implementations/{redis-event-bus-adapter → adapters/redis-event-bus-adapter}/redis-event-bus-adapter.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module EventBus
  */
-import { type ISerializer } from "../../../serializer/contracts/_module";
-import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import { type ISerializer } from "../../../../serializer/contracts/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
 import type Redis from "ioredis";
 /**
  * @group Adapters

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

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

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

@@ -0,0 +1,47 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import type { INamespacedEventBus, IEventBusAdapter, IBaseEvent, IEventBusFactory } from "../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type EventBusDrivers<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
+/**
+ * @group Derivables
+ */
+export type EventBusFactorySettings<TAdapters extends string = string> = {
+    drivers: EventBusDrivers<TAdapters>;
+    defaultDriver?: NoInfer<TAdapters>;
+    rootNamespace?: string;
+};
+/**
+ * @group Derivables
+ * @example
+ * ```ts
+ * import { EventBusFactory } from "@daiso-tech/core";
+ * import Redis from "ioredis"
+ *
+ * const eventBusFactory = new EventBusFactory({
+ *   drivers: {
+ *     memory: new MemoryEventBusAdapter(),
+ *     redis: new RedisEventBusAdapter({
+ *       dispatcherClient: new Redis(),
+ *       listenerClient: new Redis(),
+ *     }),
+ *   },
+ *   defaultDriver: "memory",
+ *   rootNamespace: "@events"
+ * });
+ * ```
+ */
+export declare class EventBusFactory<TAdapters extends string = string, TEvent extends IBaseEvent = IBaseEvent> implements IEventBusFactory<TAdapters> {
+    private readonly drivers;
+    private readonly defaultDriver?;
+    private readonly rootNamespace?;
+    private validator;
+    constructor(settings: EventBusFactorySettings<TAdapters>);
+    use(driverName?: TAdapters | undefined): INamespacedEventBus<TEvent>;
+    withValidation<TOutput extends IBaseEvent = IBaseEvent>(validator: Validator<TOutput>): IEventBusFactory<TAdapters, TOutput>;
+    withType<TOutput extends IBaseEvent = IBaseEvent>(): IEventBusFactory<TAdapters, TOutput>;
+}