@daiso-tech/core 0.7.0 → 0.8.0

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

@@ -0,0 +1,23 @@
+/**
+ * @module EventBus
+ */
+import type { INamespacedEventBus, IEventBusAdapter, IEventBusManager, EventBusManagerUseSettings, IBaseEvent } from "../../../event-bus/contracts/_module";
+import { type EventBusSettings } from "../../../event-bus/implementations/event-bus/event-bus";
+/**
+ * @group Derivables
+ */
+export type EventBusManagerSettings<TAdapters extends string = string> = {
+    adapters: Record<TAdapters, IEventBusAdapter>;
+    defaultAdapter: NoInfer<TAdapters>;
+    adapterSettings?: Omit<EventBusSettings<any>, "validator">;
+};
+/**
+ * @group Derivables
+ */
+export declare class EventBusManager<TAdapters extends string = string> implements IEventBusManager<TAdapters> {
+    private readonly adapters;
+    private readonly defaultAdapter;
+    private readonly adapterSettings;
+    constructor(settings: EventBusManagerSettings<TAdapters>);
+    use<TEvents extends IBaseEvent = IBaseEvent>(adapterSettings: EventBusManagerUseSettings<TEvents, TAdapters>): INamespacedEventBus<TEvents>;
+}

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

@@ -0,0 +1,102 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { SelectEvent, Unsubscribe } from "../../../event-bus/contracts/_module";
+import { type IEventBus, type INamespacedEventBus, type IEventBusAdapter, type Listener, type IBaseEvent } from "../../../event-bus/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+/**
+ * @group Derivables
+ */
+export type EventBusSettings<TEvents extends IBaseEvent> = {
+    /**
+     * You can prefix all keys with a given <i>namespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * const eventBusA = new EventBus(new MemoryEventBusAdapter(), {
+     *   rootNamespace: "@a/"
+     * });
+     * const eventBusB = new EventBus(new MemoryEventBusAdapter(), {
+     *   rootNamespace: "@b/"
+     * });
+     *
+     * (async () => {
+     *   eventBusB.addListener("add", event => {
+     *     // This will never be logged because eventBusB has different namespace
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   eventBusB.addListener("add", event => {
+     *     // This will be logged
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   await eventBusA.dispatch([
+     *     { type: "add", a: 1, b: 2 }
+     *   ]);
+     * })();
+     * ```
+     */
+    rootNamespace?: string;
+    /**
+     * You can pass a custom <i>{@link Validator}</i> to validate, transform and sanitize your data.
+     * You could also use <i>{@link zodValidator}</i> which enables you to use zod for validating, transforming, and sanitizing.
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod";
+     *
+     * const addEventSchema = z.object({
+     *   type: z.literal("add"),
+     *   a: z.number(),
+     *   b: z.number(),
+     * });
+     *
+     * const subEventSchema = z.object({
+     *   type: z.literal("sub"),
+     *   c: z.number(),
+     *   d: z.number(),
+     * });
+     *
+     * const eventBus = new EventBus(new MemoryEventBusAdapter(), {
+     *   // Event type will be infered from validator
+     *   validator: zodValidator(addEventSchema.or(subEventSchema))
+     * });
+     *
+     * (async () => {
+     *   // An Typescript error will be seen and ValidationError will be thrown during runtime.
+     *   await eventBus.dispatch([
+     *     {
+     *       type: "none existing",
+     *       noneExistingField: 20
+     *     }
+     *   ]);
+     * })();
+     * ```
+     */
+    validator?: Validator<TEvents>;
+};
+/**
+ * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
+ * @group Derivables
+ */
+export declare class EventBus<TEvents extends IBaseEvent = IBaseEvent> implements INamespacedEventBus<TEvents> {
+    private readonly eventBusAdapter;
+    private readonly namespace_;
+    private readonly validator;
+    constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings<TEvents>);
+    withNamespace(namespace: string): IEventBus<TEvents>;
+    getNamespace(): string;
+    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
+}

package/dist/types/event-bus/implementations/event-bus/with-namespace-event-bus-adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithNamespaceEventBusAdapter implements IEventBusAdapter {
+    private readonly eventBusAdapter;
+    private readonly namespace;
+    private readonly listenerMap;
+    constructor(eventBusAdapter: IEventBusAdapter, namespace: string);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/event-bus/implementations/event-bus/with-validation-event-bus-adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithValidationEventBusAdapter implements IEventBusAdapter {
+    private readonly eventBusAdapter;
+    private readonly validator;
+    private readonly listenerMap;
+    constructor(eventBusAdapter: IEventBusAdapter, validator: Validator<IBaseEvent>);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import { EventEmitter } from "node:events";
+/**
+ * @group Adapters
+ */
+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>;
+}

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * @module EventBus
+ */
+import type { Listener, IBaseEvent } from "../../../_module";
+import type { IEventBusAdapter } from "../../../event-bus/contracts/event-bus-adapter.contract";
+/**
+ * This <i>NoOpEventBusAdapter</i> will do nothing and is used for easily mocking IEventBus for testing.
+ * @group Adapters
+ */
+export declare class NoOpEventBusAdapter implements IEventBusAdapter {
+    addListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(_events: IBaseEvent[]): Promise<void>;
+}

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * @module EventBus
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import type Redis from "ioredis";
+/**
+ * @group Adapters
+ */
+export type RedisEventBusAdapterSettings = {
+    dispatcherClient: Redis;
+    listenerClient: Redis;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class RedisEventBusAdapter implements IEventBusAdapter {
+    private readonly serializer;
+    private readonly dispatcherClient;
+    private readonly listenerClient;
+    private readonly eventEmitter;
+    constructor({ dispatcherClient, listenerClient, serializer, }: RedisEventBusAdapterSettings);
+    private redisListener;
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/storage/contracts/_module.d.ts

@@ -1,3 +1,5 @@
 export * from "../../storage/contracts/_shared";
 export * from "../../storage/contracts/storage.contract";
 export * from "../../storage/contracts/storage-adapter.contract";
+export * from "../../storage/contracts/storage-events.contract";
+export * from "../../storage/contracts/storage-manager.contract";

package/dist/types/storage/contracts/storage-adapter.contract.d.ts

@@ -2,6 +2,8 @@
  * @module Storage
  */
 /**
+ * The <i>IStorageAdapter</i> contract defines a way for storing data as key-value pairs independent of storage.
+ * This interface is not meant to be used directly, instead you should use <i>IStorage</i>
  * @throws {StorageError} {@link StorageError}
  * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
  * @throws {TypeStorageError} {@link TypeStorageError}
@@ -9,43 +11,46 @@
  */
 export type IStorageAdapter<TType> = {
     /**
-     * Returns the value for the keys that are found otherwise null will be returned.
+     * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
     /**
-     * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
+     * The <i>addMany</i> method adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     addMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
+     * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
+     * The <i>putMany</i> method replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     putMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
+     * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Will increment the existing key with value if found otherwise nonthing occurs. Returns true if key exists otherwise false will be returned.
+     * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
+     * Returns true if key exists otherwise false will be returned.
+     * An error will thrown if the key is not a number.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
     increment(key: string, value: number): PromiseLike<boolean>;
     /**
+     * The <i>clear</i> method removes all keys that starts <i>prefix</i>.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */

package/dist/types/storage/contracts/storage-events.contract.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @module Storage
+ */
+import type { IStorageAdapter } from "../../storage/contracts/storage-adapter.contract";
+/**
+ * Name of all the events of <i>{@link IStorage}</i>.
+ * @group Events
+ */
+export declare const STORAGE_EVENTS: {
+    readonly KEYS_FOUND: "keys_found";
+    readonly KEYS_NOT_FOUND: "keys_not_found";
+    readonly KEYS_ADDED: "keys_added";
+    readonly KEYS_UPDATED: "keys_updated";
+    readonly KEYS_REMOVED: "keys_removed";
+    readonly KEYS_CLEARED: "keys_cleared";
+    readonly KEY_INCREMENTED: "key_incremented";
+    readonly KEY_DECREMENTED: "key_decremented";
+};
+/**
+ * @group Events
+ */
+export type StorageEventNames = (typeof STORAGE_EVENTS)[keyof typeof STORAGE_EVENTS];
+/**
+ * @group Events
+ */
+export type StorageEvent = {
+    namespace: string;
+    adapter: IStorageAdapter<any>;
+};
+/**
+ * @group Events
+ */
+export type KeysFoundStorageEvent<TType> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_FOUND"];
+    values: Record<string, TType>;
+};
+/**
+ * @group Events
+ */
+export type KeysNotFoundStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_NOT_FOUND"];
+    keys: string[];
+};
+/**
+ * @group Events
+ */
+export type KeysAddedStorageEvent<TType> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_ADDED"];
+    values: Record<string, TType>;
+};
+/**
+ * @group Events
+ */
+export type KeysUpdatedStorageEvent<TType> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_UPDATED"];
+    values: Record<string, TType>;
+};
+/**
+ * @group Events
+ */
+export type KeyIncrementedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_INCREMENTED"];
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export type KeyDecrementedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_DECREMENTED"];
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export type KeysRemovedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_REMOVED"];
+    keys: string[];
+};
+/**
+ * @group Events
+ */
+export type KeysClearedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_CLEARED"];
+};
+/**
+ * @group Events
+ */
+export type AllStorageEvents<TType = unknown> = KeysFoundStorageEvent<TType> | KeysNotFoundStorageEvent | KeysAddedStorageEvent<TType> | KeysUpdatedStorageEvent<TType> | KeysRemovedStorageEvent | KeysClearedStorageEvent | KeyIncrementedStorageEvent | KeyDecrementedStorageEvent;

package/dist/types/storage/contracts/storage-manager.contract.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module Storage
+ */
+import type { Validator } from "../../utilities/_module";
+import type { INamespacedStorage } from "../../storage/contracts/storage.contract";
+/**
+ * @group Contracts
+ */
+export type StorageManagerUseSettings<TType, TAdapters extends string = string> = {
+    adapter?: TAdapters;
+    validator?: Validator<TType>;
+};
+/**
+ * The <i>IStorageManager</i> contract makes it easy to switch between different <i>{@link IStorageAdapter | storage adapters}</i> dynamically.
+ * @group Contracts
+ */
+export type IStorageManager<TAdapters extends string = string> = {
+    use<TType>(settings?: StorageManagerUseSettings<TType, TAdapters>): INamespacedStorage<TType>;
+};

package/dist/types/storage/contracts/storage.contract.d.ts

@@ -1,151 +1,176 @@
 /**
  * @module Storage
  */
+import type { IListenable } from "../../event-bus/contracts/_module";
 import { type AnyFunction, type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
+import type { AllStorageEvents } from "../../storage/contracts/_module";
 export type StorageValue<T> = Exclude<T, AnyFunction | undefined | null>;
 /**
+ * The <i>IStorage</i> contract defines a way for storing data as key-value pairs independent of storage.
+ * It commes with more convient methods compared to <i>IStorageAdapter</i>.
  * @throws {StorageError} {@link StorageError}
  * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
  * @throws {TypeStorageError} {@link TypeStorageError}
  * @group Contracts
  */
-export type IStorage<TType = unknown> = {
+export type IStorage<TType = unknown> = IListenable<AllStorageEvents<TType>> & {
     /**
-     * Return a new instance of <i>IStorage</i> prefixed with given <i>name</i>
-     */
-    namespace(name: string): IStorage<TType>;
-    /**
-     * Returns true when key is found otherwise false will be returned.
+     * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     exists(key: string): PromiseLike<boolean>;
     /**
-     * Returns true for the keys that are found otherwise false will be returned.
+     * The <i>existsMany</i> method returns true for the <i>keys</i> that are found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Returns true when key is not found otherwise false will be returned.
+     * The <i>missing</i> method returns true when <i>key</i> is not found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     missing(key: string): PromiseLike<boolean>;
     /**
-     * Returns true for the keys that are not found otherwise false will be returned.
+     * The <i>missingMany</i> method returns true for the <i>keys</i> that are not found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Returns the value when key is found otherwise null will be returned.
+     * The <i>get</i> method returns the value when <i>key</i> is found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     get(key: string): PromiseLike<TType | null>;
     /**
-     * Returns the value for the keys that are found otherwise null will be returned.
+     * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
     /**
-     * Returns the value when key is found otherwise defaultValue will be returned.
+     * The <i>getOr</i> method returns the value when <i>key</i> is found otherwise <i>defaultValue</i> will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getOr(key: string, defaultValue: AsyncLazyable<TType>): PromiseLike<TType>;
     /**
-     * Returns the value for the keys that are found otherwise defaultValue will be returned.
+     * The <i>getOrMany</i> method returns the value for the keys that are found otherwise defaultValue will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): PromiseLike<Record<TKeys, TType>>;
     /**
-     * Returns the value when key is found otherwise an error will be thrown.
+     * The <i>getOrFail</i> method returns the value when <i>key</i> is found otherwise an error will be thrown.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
      */
     getOrFail(key: string): PromiseLike<TType>;
     /**
-     * Adds a key when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
+     * The <i>add</i> method adds a <i>key</i> with given <i>value</i> when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     add(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
     /**
-     * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
+     * The <i>addMany</i> method adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Updates a keys that exists. Returns true when key otherwise false will be returned.
+     * The <i>update</i> method updates the given <i>key</i> with given <i>value</i>. Returns true when key otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     update(key: string, value: TType): PromiseLike<boolean>;
     /**
-     * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
+     * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * If the key is found it will replaced. If the key is not found it will just be added. True is returned if the key is found otherwise false will be returned.
+     * The <i>put</i> method replaces the key with given <i>value</i> if found. If the <i>key</i> is not found it will just be added. True is returned if the key is found otherwise false will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     put(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
     /**
-     * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
+     * The <i>putMany</i> method replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Removes the key when found. Returns true if the key is found otherwise false is returned.
+     * The <i>remove</i> method removes the given <i>key</i> when found. Returns true if the key is found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     remove(key: string): PromiseLike<boolean>;
     /**
-     * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
+     * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * If the key is found the value be returned and key will be removed otherwise null will be returned.
+     * The <i>getAndRemove</i> method removes the given <i>key</i> and returns it when found otherwise null will be returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getAndRemove(key: string): PromiseLike<TType | null>;
     /**
-     * If the key is found the value be returned otherwise valueToAdd will be added and returned.
+     * The <i>getOrAdd</i> method will retrieve the given <i>key</i> if found otherwise <i>valueToAdd</i> will be added and returned.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): PromiseLike<TType>;
     /**
-     * Will increment the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
+     * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
+     * Returns true if key exists otherwise false will be returned.
+     * An error will thrown if the key is not a number.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
     increment(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
     /**
-     * Will decrement the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
+     * The <i>decrement</i> method will decrement the given <i>key</i> if found otherwise nonthing will occur.
+     * Returns true if key exists otherwise false will be returned.
+     * An error will thrown if the key is not a number.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
+     * An error will thrown if the key is not a number.
      */
     decrement(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
     /**
+     * The <i>clear</i> method removes all the keys in the storage.
      * @throws {StorageError} {@link StorageError}
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     clear(): PromiseLike<void>;
 };
+/**
+ * The <i>INamespacedStorage</i> contract defines a way for storing data as key-value pairs independent of storage.
+ * It commes with one extra method which is useful for multitennat applications compared to <i>IStorage</i>.
+ * @throws {StorageError} {@link StorageError}
+ * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+ * @throws {TypeStorageError} {@link TypeStorageError}
+ * @group Contracts
+ */
+export type INamespacedStorage<TType = unknown> = IStorage<TType> & {
+    /**
+     * The <i>withNamespace</i> method returns new instance of <i>{@link IStorage}</i> where all the keys will be prefixed with a given <i>namespace</i>.
+     * This useful for multitennat applications.
+     */
+    withNamespace(namespace: string): IStorage<TType>;
+    /**
+     * The <i>getNamespace</i> method return the complete namespace.
+     */
+    getNamespace(): string;
+};

package/dist/types/storage/implementations/storage/_module.d.ts

@@ -1 +1,2 @@
 export * from "../../../storage/implementations/storage/storage";
+export * from "../../../storage/implementations/storage/storage-manager";

package/dist/types/storage/implementations/storage/storage-manager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module Storage
+ */
+import type { INamespacedStorage, IStorageAdapter, IStorageManager, StorageManagerUseSettings } from "../../../storage/contracts/_module";
+import { type StorageSettings } from "../../../storage/implementations/storage/storage";
+/**
+ * @group Derivables
+ */
+export type StorageManagerSettings<TAdapters extends string = string> = {
+    adapters: Record<TAdapters, IStorageAdapter<any>>;
+    defaultAdapter: NoInfer<TAdapters>;
+    adapterSettings?: Omit<StorageSettings<any>, "validator">;
+};
+/**
+ * @group Derivables
+ */
+export declare class StorageManager<TAdapters extends string = string> implements IStorageManager<TAdapters> {
+    private readonly adapters;
+    private readonly defaultAdapter;
+    private readonly adapterSettings;
+    constructor(settings: StorageManagerSettings<TAdapters>);
+    use<TType>(adapterSettings?: StorageManagerUseSettings<TType, TAdapters>): INamespacedStorage<TType>;
+}