@daiso-tech/core 0.15.0 → 0.16.0

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

@@ -2,51 +2,59 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
-import type { TimeSpan, IInitizable, IDeinitizable } from "../../../../utilities/_module";
+import type { ISerde } from "../../../../serde/contracts/_module";
+import type { TimeSpan, IInitizable, IDeinitizable, OneOrMore } from "../../../../utilities/_module";
 import { type Database } from "better-sqlite3";
 /**
  * @group Adapters
  */
 export type SqliteStorageAdapterSettings = {
     tableName?: string;
-    serializer: ISerializer<string>;
+    serde: ISerde<string>;
     enableTransactions?: boolean;
     expiredKeysRemovalInterval?: TimeSpan;
     shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
 };
 /**
- * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
+ * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  * @example
  * ```ts
- * import { SqliteCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
+ * import { SqliteCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
  * import Sqlite from "better-sqlite3";
  *
  * const client = new Sqlite("local.db");
- * const serializer = new SuperJsonSerializer();
+ * const serde = new SuperJsonSerde();
  * const cacheAdapter = new SqliteCacheAdapter(client, {
- *   serializer,
+ *   serde,
+ *   rootGroup: "@global"
  * });
+ *
+ * (async () => {
  *   // You only need to call it once before using the adapter.
  *   await cacheAdapter.init();
  *   await cacheAdapter.add("a", 1);
  *
  *   // Will remove the cache
  *   await cacheAdapter.deInit();
+ * })();
  * ```
  */
 export declare class SqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly cacheAdapter;
     constructor(database: Database, settings: SqliteStorageAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     removeExpiredKeys(): Promise<void>;
     deInit(): Promise<void>;
     init(): Promise<void>;
+    exists(key: string): Promise<boolean>;
     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>;
+    clear(): Promise<void>;
 }

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

@@ -1,3 +1,2 @@
-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/cache-factory.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module Cache
  */
-import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
-import type { ICacheFactory, INamespacedCache, ICacheAdapter } from "../../../cache/contracts/_module";
+import type { IGroupableEventBus } from "../../../event-bus/contracts/_module";
+import type { ICacheFactory, IGroupableCache, ICacheAdapter } from "../../../cache/contracts/_module";
 import type { TimeSpan } from "../../../utilities/_module";
 /**
  * @group Derivables
@@ -19,13 +19,9 @@ export type CacheFactorySettings<TDrivers extends string = string> = {
      */
     defaultTtl?: TimeSpan;
     /**
-     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
      */
-    eventBus?: INamespacedEventBus<any>;
-    /**
-     * You can prefix all keys with a given <i>rootNamespace</i>.
-     */
-    rootNamespace?: string;
+    eventBus?: IGroupableEventBus<any>;
 };
 /**
  * @group Derivables
@@ -40,17 +36,15 @@ export type CacheFactorySettings<TDrivers extends string = string> = {
  *     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>;
+    use(driverName?: TDrivers | undefined): IGroupableCache<TType>;
     withType<TOutput extends TType = TType>(): ICacheFactory<TDrivers, TOutput>;
 }

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

@@ -1,51 +1,22 @@
 /**
  * @module Cache
  */
-import type { CacheEvents } from "../../../cache/contracts/_module";
+import type { CacheEvents, WithTtlValue } from "../../../cache/contracts/_module";
 import { type ICache, type ICacheAdapter } from "../../../cache/contracts/_module";
-import { type INamespacedCache } from "../../../cache/contracts/_module";
-import type { OneOrMore } from "../../../utilities/_module";
+import { type IGroupableCache } from "../../../cache/contracts/_module";
+import type { AsyncLazyable, GetOrAddValue, OneOrMore } from "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
 import type { LazyPromiseSettings } from "../../../async/_module";
-import type { LazyPromise } from "../../../async/_module";
-import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
-import { BaseCache } from "../../../cache/implementations/derivables/base-cache";
+import { LazyPromise } from "../../../async/_module";
+import type { IGroupableEventBus, Listener, SelectEvent, Unsubscribe } from "../../../event-bus/contracts/_module";
 /**
  * @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"));
-     * })();
-     * ```
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
      */
-    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<CacheEvents<TType>>;
+    eventBus?: IGroupableEventBus<CacheEvents<TType>>;
     /**
      * You can decide the default ttl value. If null is passed then no ttl will be used by default.
      */
@@ -62,14 +33,14 @@ export type CacheSettings<TType> = {
  * const cache = new Cache(new MemoryCacheAdapter());
  * ```
  */
-export declare class Cache<TType = unknown> extends BaseCache<TType> implements INamespacedCache<TType> {
-    private readonly namespace;
-    private readonly namespacedEventBus;
+export declare class Cache<TType = unknown> implements IGroupableCache<TType> {
+    private readonly groupdEventBus;
     private readonly eventBus;
     private readonly cacheAdapter;
-    private readonly eventAttributes;
     private readonly defaultTtl;
+    private readonly lazyPromiseSettings?;
     constructor(cacheAdapter: ICacheAdapter<any>, settings?: CacheSettings<TType>);
+    private createLayPromise;
     private createKeyFoundEvent;
     private createKeyNotFoundEvent;
     private createKeyAddedEvent;
@@ -78,9 +49,8 @@ export declare class Cache<TType = unknown> extends BaseCache<TType> implements
     private createKeysClearedEvent;
     private createKeyIncrementedEvent;
     private createKeyDecrementedEvent;
-    private keyWithNamespace;
-    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
-    getNamespace(): string;
+    withGroup(group: OneOrMore<string>): ICache<TType>;
+    getGroup(): string;
     get(key: string): LazyPromise<TType | null>;
     add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
     update(key: string, value: TType): LazyPromise<boolean>;
@@ -88,4 +58,26 @@ export declare class Cache<TType = unknown> extends BaseCache<TType> implements
     remove(key: string): LazyPromise<boolean>;
     increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     clear(): LazyPromise<void>;
+    addListener<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    addListenerMany<TEventName extends keyof CacheEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    removeListener<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    removeListenerMany<TEventName extends keyof CacheEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    listenOnce<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    subscribe<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventName extends keyof CacheEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    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>>;
+    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>;
+    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, 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>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
 }

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

@@ -5,9 +5,8 @@ import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */
-export declare class AsyncMergeIterable<TInput, TExtended> implements AsyncIterable<TInput | TExtended> {
-    private iterableA;
-    private iterableB;
-    constructor(iterableA: AsyncIterableValue<TInput>, iterableB: AsyncIterableValue<TExtended>);
-    [Symbol.asyncIterator](): AsyncIterator<TInput | TExtended>;
+export declare class AsyncMergeIterable<TInput> implements AsyncIterable<TInput> {
+    private readonly iterables;
+    constructor(iterables: AsyncIterableValue<AsyncIterableValue<TInput>>);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
 }

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

@@ -5,6 +5,7 @@ import type { EnsureMap, EnsureRecord } from "../../../collection/contracts/_mod
 import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type AsyncIterableValue, type AsyncLazyable } from "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
+import type { LazyPromiseSettings } from "../../../async/_module";
 import { LazyPromise } from "../../../async/_module";
 /**
  * All methods that return <i>{@link IAsyncCollection}</i> are executed lazly.
@@ -14,13 +15,17 @@ import { LazyPromise } from "../../../async/_module";
  */
 export declare class AsyncIterableCollection<TInput> implements IAsyncCollection<TInput> {
     private readonly iterable;
-    private static createLazyPromise;
+    private readonly settings;
+    static concat<TValue>(iterables: AsyncIterableValue<AsyncIterableValue<TValue>>): IAsyncCollection<TValue>;
+    static difference<TValue, TSelect>(iterableA: AsyncIterableValue<TValue>, iterableB: AsyncIterableValue<TValue>, selectFn?: AsyncMap<TValue, IAsyncCollection<TValue>, TSelect>): IAsyncCollection<TValue>;
+    static zip<TValueA, TValueB>(iterableA: AsyncIterableValue<TValueA>, iterableB: AsyncIterableValue<TValueB>): IAsyncCollection<[TValueA, TValueB]>;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i> or <i>{@link AsyncIterable}</i>.
      */
-    constructor(iterable?: AsyncIterableValue<TInput>);
+    constructor(iterable?: AsyncIterableValue<TInput>, settings?: LazyPromiseSettings);
+    private createLazyPromise;
     [Symbol.asyncIterator](): AsyncIterator<TInput>;
     toIterator(): AsyncIterator<TInput, void>;
     entries(): IAsyncCollection<[number, TInput]>;

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

@@ -4,9 +4,8 @@
 /**
  * @internal
  */
-export declare class MergeIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
-    private iterableA;
-    private iterableB;
-    constructor(iterableA: Iterable<TInput>, iterableB: Iterable<TExtended>);
-    [Symbol.iterator](): Iterator<TInput | TExtended>;
+export declare class MergeIterable<TInput> implements Iterable<TInput> {
+    private iterables;
+    constructor(iterables: Iterable<Iterable<TInput>>);
+    [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/implementations/iterable-collection/iterable-collection.d.ts

@@ -11,6 +11,9 @@ import { type Lazyable } from "../../../utilities/_module";
  */
 export declare class IterableCollection<TInput> implements ICollection<TInput> {
     private readonly iterable;
+    static concat<TValue>(iterables: Iterable<Iterable<TValue>>): ICollection<TValue>;
+    static difference<TValue, TSelect>(iterableA: Iterable<TValue>, iterableB: Iterable<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
+    static zip<TValueA, TValueB>(iterableA: Iterable<TValueA>, iterableB: Iterable<TValueB>): ICollection<[TValueA, TValueB]>;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
     /**

package/dist/types/collection/implementations/list-collection/list-collection.d.ts

@@ -9,6 +9,9 @@ import { type Lazyable } from "../../../utilities/_module";
  * @group Adapters
  */
 export declare class ListCollection<TInput> implements ICollection<TInput> {
+    static concat<TValue>(iterables: Iterable<Iterable<TValue>>): ICollection<TValue>;
+    static difference<TValue, TSelect>(iterableA: Iterable<TValue>, iterableB: Iterable<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
+    static zip<TValueA, TValueB>(iterableA: Iterable<TValueA>, iterableB: Iterable<TValueB>): ICollection<[TValueA, TValueB]>;
     private array;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i>.

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

@@ -2,6 +2,7 @@
  * @module EventBus
  */
 import type { Listener } from "../../event-bus/contracts/_shared";
+import type { OneOrMore } from "../../utilities/_module";
 export type IBaseEvent = {
     type: string;
 };
@@ -12,15 +13,17 @@ export type IBaseEvent = {
  */
 export type IEventBusAdapter = {
     /**
-     * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>eventName</i>.
      */
-    addListener(event: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    addListener(eventName: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
     /**
-     * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>eventName</i>.
      */
-    removeListener(event: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    removeListener(eventName: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
     /**
      * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
      */
-    dispatch(events: IBaseEvent[]): PromiseLike<void>;
+    dispatch(event: IBaseEvent): PromiseLike<void>;
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): IEventBusAdapter;
 };

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

@@ -1,9 +1,9 @@
 /**
  * @module EventBus
  */
-import type { BaseEvents, INamespacedEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { BaseEvents, IGroupableEventBus } from "../../event-bus/contracts/event-bus.contract";
 /**
- * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link INamespacedEventBus}</i> dynamically.
+ * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableEventBus}</i> dynamically.
  * @group Contracts
  */
 export type IEventBusFactory<TDrivers extends string = string, TEvents extends BaseEvents = BaseEvents> = {
@@ -28,7 +28,7 @@ export type IEventBusFactory<TDrivers extends string = string, TEvents extends B
      * }
      * ```
      */
-    use(driverName?: TDrivers): INamespacedEventBus<TEvents>;
+    use(driverName?: TDrivers): IGroupableEventBus<TEvents>;
     /**
      * The <i>withTypes</i> method is used to set the event types of the <i>{@link IEventBus}</i>.
      * @example

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

@@ -10,12 +10,24 @@ export type AllEvents<TEvents extends BaseEvents> = Values<{
         type: TEventName;
     };
 }>;
+/**
+ * @group Contracts
+ */
 export type SelectEvent<TEvents extends BaseEvents, TEventName extends keyof TEvents> = {
     [TEventName in keyof TEvents]: TEvents[TEventName] & {
         type: TEventName;
     };
 }[TEventName];
+/**
+ * @group Contracts
+ */
 export type Unsubscribe = () => LazyPromise<void>;
+/**
+ * @group Contracts
+ */
+export type AddListenerSettings = {
+    signal?: AbortSignal;
+};
 /**
  * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
  * @group Contracts
@@ -45,6 +57,11 @@ export type IListenable<TEvents extends BaseEvents = BaseEvents> = {
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
     removeListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): 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>;
     /**
      * 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.
@@ -62,11 +79,17 @@ export type IListenable<TEvents extends BaseEvents = BaseEvents> = {
  */
 export type IDispatcher<TEvents extends BaseEvents = BaseEvents> = {
     /**
-     * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
+     * The <i>dispatch</i> method is used for dispatching a <i>event</i>.
+
+     * @throws {DispatchEventBusError} {@link DispatchEventBusError}
+     */
+    dispatch(event: AllEvents<TEvents>): LazyPromise<void>;
+    /**
+     * The <i>dispatchMany</i> method is used for dispatching multiple <i>event</i>.
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
-    dispatch(events: OneOrMore<AllEvents<TEvents>>): LazyPromise<void>;
+    dispatchMany(events: AllEvents<TEvents>[]): LazyPromise<void>;
 };
 /**
  * The <i>IEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
@@ -75,45 +98,45 @@ export type IDispatcher<TEvents extends BaseEvents = BaseEvents> = {
  */
 export type IEventBus<TEvents extends BaseEvents = BaseEvents> = IListenable<TEvents> & IDispatcher<TEvents> & {
     /**
-     * The <i>getNamespace</i> method returns the complete namespace.
+     * The <i>getGroup</i> method returns the complete group.
      * @example
      * ```ts
      * import { type IEventBus } from "@daiso-tech/core";
      *
      * async function main(eventBus: IEventBus): Promise<void> {
      *   // Will be "@root"
-     *   console.log(eventBus.getNamespace())
+     *   console.log(eventBus.getGroup())
      *
-     *   const eventBusA = eventBus.withNamespace("a");
+     *   const eventBusA = eventBus.withGroup("a");
      *
      *   // Will be "@root/a"
-     *   console.log(eventBusA.getNamespace())
+     *   console.log(eventBusA.getGroup())
      * }
      * ```
      */
-    getNamespace(): string;
+    getGroup(): string;
 };
 /**
- * The <i>INamespacedEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
+ * The <i>IGroupableEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with one extra method which is useful for multitennat applications compared to <i>IEventBus</i>.
  * @group Contracts
  */
-export type INamespacedEventBus<TEvents extends BaseEvents = BaseEvents> = IEventBus<TEvents> & {
+export type IGroupableEventBus<TEvents extends BaseEvents = BaseEvents> = IEventBus<TEvents> & {
     /**
-     * The <i>withNamespace</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>namespace</i>.
+     * The <i>withGroup</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>group</i>.
      * This useful for multitennat applications.
      * @example
      * ```ts
      * import { type IEventBus } from "@daiso-tech/core";
      *
      * async function main(eventBus: IEventBus): Promise<void> {
-     *   const eventBusA = eventBus.withNamespace("a");
+     *   const eventBusA = eventBus.withGroup("a");
      *   await eventBusA.subscribe("add", (event) => {
      *     // This will be logged
      *     console.log("eventBusA:", event);
      *   });
      *
-     *   const eventBusB = eventBus.withNamespace("b");
+     *   const eventBusB = eventBus.withGroup("b");
      *   await eventBusB.subscribe("add", (event) => {
      *     // This will never be logged
      *     console.log("eventBusB:", event);
@@ -127,5 +150,5 @@ export type INamespacedEventBus<TEvents extends BaseEvents = BaseEvents> = IEven
      * }
      * ```
      */
-    withNamespace(namespace: OneOrMore<string>): IEventBus<TEvents>;
+    withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
 };

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

@@ -12,7 +12,8 @@ export type EventBusAdapterTestSuiteSettings = {
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createAdapter: () => Promisable<IEventBusAdapter>;
+    createAdapterA: () => Promisable<IEventBusAdapter>;
+    createAdapterB: () => Promisable<IEventBusAdapter>;
 };
 /**
  * The <i>eventBusAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBusAdapter}</i> with vitest.
@@ -23,14 +24,14 @@ export type EventBusAdapterTestSuiteSettings = {
  * import type { StartedRedisContainer } from "@testcontainers/redis";
  * import { RedisContainer } from "@testcontainers/redis";
  * import Redis from "ioredis";
- * import { SuperJsonSerializer, TimeSpan, RedisEventBusAdapter, eventBusAdapterTestSuite } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, eventBusAdapterTestSuite } from "@daiso-tech/core";
  *
  * const timeout = TimeSpan.fromMinutes(2);
- * describe("class: RedisEventBusAdapter", () => {
+ * describe("class: RedisPubSubEventBusAdapter", () => {
  *   let dispatcherClient: Redis;
  *   let listenerClient: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const serializer = new SuperJsonSerializer();
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer().start();
  *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
@@ -42,11 +43,19 @@ export type EventBusAdapterTestSuiteSettings = {
  *     await startedContainer.stop();
  *   }, timeout.toMilliseconds());
  *    eventBusAdapterTestSuite({
- *      createAdapter: () =>
- *        new RedisEventBusAdapter({
+ *      createAdapterA: () =>
+ *        new RedisPubSubEventBusAdapter({
  *          dispatcherClient,
  *          listenerClient,
- *          serializer,
+ *          serde,
+ *          rootGroup: "@global"
+ *        }),
+ *      createAdapterB: () =>
+ *        new RedisPubSubEventBusAdapter({
+ *          dispatcherClient,
+ *          listenerClient,
+ *          serde,
+ *          rootGroup: "@global"
  *        }),
  *      test,
  *      beforeEach,

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

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

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

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

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

@@ -1,6 +1,7 @@
 /**
  * @module EventBus
  */
+import { type OneOrMore } from "../../../../utilities/_module";
 import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../../event-bus/contracts/_module";
 import { EventEmitter } from "node:events";
 /**
@@ -19,13 +20,17 @@ import { EventEmitter } from "node:events";
  * import { EventEmitter } from "node:events";
  *
  * const eventEmitter = new EventEmitter();
- * const eventBusAdapter = new MemoryCacheAdapter(eventEmitter);
+ * const eventBusAdapter = new MemoryCacheAdapter("@global", eventEmitter);
  * ```
  */
 export declare class MemoryEventBusAdapter implements IEventBusAdapter {
     private readonly eventEmiter;
-    constructor(eventEmiter?: EventEmitter<[never]>);
-    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
-    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
-    dispatch(events: IBaseEvent[]): Promise<void>;
+    private readonly group;
+    constructor(defaultGroup: OneOrMore<string>, eventEmiter?: EventEmitter<[never]>);
+    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>;
 }