@daiso-tech/core 0.9.0 → 0.11.0

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>;
+}

package/dist/types/event-bus/implementations/{event-bus → derivables}/event-bus.d.ts

@@ -18,11 +18,12 @@ export type EventBusSettings<TEvents extends IBaseEvent> = {
      * ```ts
      * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
      *
-     * const eventBusA = new EventBus(new MemoryEventBusAdapter(), {
-     *   rootNamespace: "@a/"
+     * const memoryEventBusAdapter = new MemoryEventBusAdapter();
+     * const eventBusA = new EventBus(memoryEventBusAdapter, {
+     *   rootNamespace: "@a"
      * });
-     * const eventBusB = new EventBus(new MemoryEventBusAdapter(), {
-     *   rootNamespace: "@b/"
+     * const eventBusB = new EventBus(memoryEventBusAdapter, {
+     *   rootNamespace: "@b"
      * });
      *
      * (async () => {
@@ -42,7 +43,7 @@ export type EventBusSettings<TEvents extends IBaseEvent> = {
      * })();
      * ```
      */
-    rootNamespace?: string;
+    rootNamespace?: OneOrMore<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.
@@ -87,16 +88,16 @@ export type EventBusSettings<TEvents extends IBaseEvent> = {
  */
 export declare class EventBus<TEvents extends IBaseEvent = IBaseEvent> implements INamespacedEventBus<TEvents> {
     private readonly eventBusAdapter;
-    private readonly namespace_;
+    private readonly namespace;
     private readonly validator;
     constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings<TEvents>);
-    withNamespace(namespace: string): IEventBus<TEvents>;
+    withNamespace(namespace: OneOrMore<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>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
     dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
 }

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

@@ -1 +1,2 @@
 export * from "../../serializer/contracts/serializer.contract";
+export * from "../../serializer/contracts/serializer.errors";

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

@@ -1,24 +1,6 @@
 /**
  * @module Serializer
  */
-/**
- * @group Errors
- */
-export declare class SerializerError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class SerializationError extends SerializerError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class DeserializationError extends SerializerError {
-    constructor(message: string, cause?: unknown);
-}
 /**
  * @group Contracts
  */
@@ -26,9 +8,9 @@ export type ISerializer<TSerialized = unknown> = {
     /**
      * @throws {SerializationError} {@link SerializationError}
      */
-    serialize<TValue>(value: TValue): Promise<TSerialized>;
+    serialize<TValue>(value: TValue): PromiseLike<TSerialized>;
     /**
      * @throws {DeserializationError} {@link DeserializationError}
      */
-    deserialize<TValue>(value: TSerialized): Promise<TValue>;
+    deserialize<TValue>(value: TSerialized): PromiseLike<TValue>;
 };

package/dist/types/serializer/contracts/serializer.errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Serializer
+ */
+/**
+ * @group Errors
+ */
+export declare class SerializerError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class SerializationError extends SerializerError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class DeserializationError extends SerializerError {
+    constructor(message: string, cause?: unknown);
+}

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

@@ -1,5 +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";
+export * from "../../storage/contracts/storage-factory.contract";
+export * from "../../storage/contracts/storage.contract";
+export * from "../../storage/contracts/storage.errors";
+export * from "../../storage/contracts/storage.events";

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

@@ -8,28 +8,28 @@
  */
 export type IStorageAdapter<TType = unknown> = {
     /**
-     * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
+     * The <i>get</i> returns the value of <i>keys</i> that are found otherwise null will be returned.
      */
-    getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
+    get(key: string): PromiseLike<TType | null>;
     /**
-     * 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.
+     * The <i>add</i> method add a new <i>key</i>. Returns true if the <i>key</i> where added otherwise false will be returned.
      */
-    addMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    add(key: string, value: TType): PromiseLike<boolean>;
     /**
-     * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
+     * The <i>update</i> method updates a <i>key</i>. Returns true if the <i>key</i> where updated otherwise false will be returned.
      */
-    updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    update(key: string, value: TType): PromiseLike<boolean>;
     /**
-     * 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.
+     * The <i>put</i> method replaces a <i>key</i> that exists or adds <i>key</i> that do not exists. Return true if the <i>key</i> where updated otherwise false is returned.
      */
-    putMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    put(key: string, value: TType): PromiseLike<boolean>;
     /**
-     * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
+     * The <i>remove</i> method removes a <i>key</i>. Returns true if the <i>key</i> is removed otherwise false is returned.
      */
-    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    remove(key: string): PromiseLike<boolean>;
     /**
      * 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.
+     * Returns true if key is incremented otherwise false will be returned.
      * An error will thrown if the key is not a number.
      * @throws {TypeStorageError} {@link TypeStorageError}
      */

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

@@ -0,0 +1,67 @@
+/**
+ * @module Storage
+ */
+import type { Validator } from "../../utilities/_module";
+import type { INamespacedStorage } from "../../storage/contracts/storage.contract";
+/**
+ * The <i>IStorageFactory</i> contract makes it easy to configure and switch between different <i>{@link INamespacedStorage}</i> dynamically.
+ * @group Contracts
+ */
+export type IStorageFactory<TDrivers extends string = string, TType = unknown> = {
+    /**
+     * 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 IStorageFactory } from "@daiso-tech/core";
+     *
+     * async function main(storageFactory: IStorageFactory): Promise<void> {
+     *   // Will add key using the default driver which is the memory addapter
+     *   await storageFactory
+     *     .use()
+     *     .add("a", 1);
+     *   // Will add key using the redis addapter
+     *   await storageFactory
+     *     .use("redis")
+     *     .add("a", 1);
+     * }
+     * ```
+     */
+    use(driverName?: TDrivers): INamespacedStorage<TType>;
+    /**
+     * The <i>withValidation</i> method is used to set a <i>validator</i>, which validates the storage values during runtime.
+     * The type is inferred from the provided <i>validator</i>.
+     * @example
+     * ```ts
+     * import { type IStorageFactory, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod"
+     *
+     * async function main(storageFactory: IStorageFactory): Promise<void> {
+     *   await storageFactory
+     *     .withValidation(zodValidator(z.string()))
+     *     .use()
+     *     // You will se an typescript error and get runtime erorr
+     *     .add("a", 1);
+     * }
+     * ```
+     */
+    withValidation<TOutput extends TType = TType>(validator: Validator<TOutput>): IStorageFactory<TDrivers, TOutput>;
+    /**
+     * The <i>withTypes</i> method is used to set the value types of the storage.
+     * @example
+     * ```ts
+     * import { type IStorageFactory zodValidator } from "@daiso-tech/core";
+     *
+     * async function main(storageFactory: IStorageFactory): Promise<void> {
+     *   await storageFactory
+     *     .withTypes<string>()
+     *     .use()
+     *     // You will se an typescript error
+     *     .add("a", 1)
+     * }
+     * ```
+     */
+    withType<TOutput extends TType = TType>(): IStorageFactory<TDrivers, TOutput>;
+};

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

@@ -2,9 +2,10 @@
  * @module Storage
  */
 import type { IListenable } from "../../event-bus/contracts/_module";
-import { type AnyFunction, type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
+import type { OneOrMore } from "../../_shared/types";
+import { type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
 import type { AllStorageEvents } from "../../storage/contracts/_module";
-export type StorageValue<T> = Exclude<T, AnyFunction | undefined | null>;
+import type { LazyPromise } from "../../utilities/_module";
 /**
  * The <i>IStorageListenable</i> contract defines a way for listening <i>{@link IStorage}</i> crud operations.
  */
@@ -19,106 +20,106 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    exists(key: string): PromiseLike<boolean>;
+    exists(key: string): LazyPromise<boolean>;
     /**
      * The <i>existsMany</i> method returns true for the <i>keys</i> that are found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>missing</i> method returns true when <i>key</i> is not found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missing(key: string): PromiseLike<boolean>;
+    missing(key: string): LazyPromise<boolean>;
     /**
      * The <i>missingMany</i> method returns true for the <i>keys</i> that are not found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>get</i> method returns the value when <i>key</i> is found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    get(key: string): PromiseLike<TType | null>;
+    get(key: string): LazyPromise<TType | null>;
     /**
      * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
+    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
     /**
      * The <i>getOr</i> method returns the value when <i>key</i> is found otherwise <i>defaultValue</i> will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOr(key: string, defaultValue: AsyncLazyable<TType>): PromiseLike<TType>;
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
     /**
      * The <i>getOrMany</i> method returns the value for the keys that are found otherwise defaultValue will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): PromiseLike<Record<TKeys, TType>>;
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
     /**
      * The <i>getOrFail</i> method returns the value when <i>key</i> is found otherwise an error will be thrown.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
      */
-    getOrFail(key: string): PromiseLike<TType>;
+    getOrFail(key: string): LazyPromise<TType>;
     /**
      * 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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    add(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    add(key: string, value: TType): LazyPromise<boolean>;
     /**
-     * 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.
+     * The <i>addMany</i> method adds new keys. Returns true for the keys that where added otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * 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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    update(key: string, value: TType): PromiseLike<boolean>;
+    update(key: string, value: TType): LazyPromise<boolean>;
     /**
-     * The <i>updateMany</i> method updates the given keys. 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 where updated otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * 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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    put(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    put(key: string, value: TType): LazyPromise<boolean>;
     /**
-     * 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.
+     * The <i>putMany</i> method replaces the keys that exists. Adds keys that do not exists. Return true for all the keys that where updated otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * 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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    remove(key: string): PromiseLike<boolean>;
+    remove(key: string): LazyPromise<boolean>;
     /**
-     * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
+     * The <i>removeMany</i> method removes keys. Returns true for the keys that are removed otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>getAndRemove</i> method removes the given <i>key</i> and returns it when found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getAndRemove(key: string): PromiseLike<TType | null>;
+    getAndRemove(key: string): LazyPromise<TType | null>;
     /**
      * The <i>getOrAdd</i> method will retrieve the given <i>key</i> if found otherwise <i>valueToAdd</i> will be added and returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): PromiseLike<TType>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>): LazyPromise<TType>;
     /**
      * 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.
+     * Returns true if key is incremented otherwise false will be returned.
      * An error will thrown if the key is not a number.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
-    increment(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * 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.
@@ -127,27 +128,27 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * @throws {TypeStorageError} {@link TypeStorageError}
      * An error will thrown if the key is not a number.
      */
-    decrement(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * The <i>clear</i> method removes all the keys in the storage.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    clear(): PromiseLike<void>;
+    clear(): LazyPromise<void>;
     /**
-     * The <i>getNamespace</i> method return the complete namespace.
+     * The <i>getNamespace</i> method returns the complete namespace.
      * @example
      * ```ts
-     *   const storage = new Storage(new MemoryStorageAdapter(), {
-     *     rootNamespace: "@root/"
-     *   });
+     * import type { IStorage } from "@daiso-tech/core";
      *
-     *   // Will be "@root/"
+     * async function main(storage: IStorage) {
+     *   // Will be "@root"
      *   console.log(storage.getNamespace())
      *
-     *   const storageA = storage.withNamespace("a/");
+     *   const storageA = storage.withNamespace("a");
      *
-     *   // Will be "@root/a/"
+     *   // Will be "@root/a"
      *   console.log(storageA.getNamespace())
+     * }
      * ```
      */
     getNamespace(): string;
@@ -163,11 +164,9 @@ export type INamespacedStorage<TType = unknown> = IStorage<TType> & {
      * This useful for multitennat applications.
      * @example
      * ```ts
-     * import { Storage, MemoryStorageAdapter } from "@daiso-tech/core";
-     *
-     * (async () => {
-     *   const storage = new Storage(new MemoryStorageAdapter());
+     * import { type IStorage } from "@daiso-tech/core";
      *
+     * async function main(storage: IStorage): Promise<void> {
      *   const storageA = storage.withNamespace("a");
      *   await storageA.add("a", 1);
      *
@@ -176,9 +175,8 @@ export type INamespacedStorage<TType = unknown> = IStorage<TType> & {
      *
      *   // Will print { a: 1, b: null }
      *   console.log(await storageA.getMany(["a", "b"]));
-     * })();
-     *
+     * }
      * ```
      */
-    withNamespace(namespace: string): IStorage<TType>;
+    withNamespace(namespace: OneOrMore<string>): IStorage<TType>;
 };

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

@@ -7,11 +7,11 @@ import type { IStorageAdapter } from "../../storage/contracts/storage-adapter.co
  * @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 KEY_FOUND: "key_found";
+    readonly KEY_NOT_FOUND: "key_not_found";
+    readonly KEY_ADDED: "key_added";
+    readonly KEY_UPDATED: "key_updated";
+    readonly KEY_REMOVED: "key_removed";
     readonly KEYS_CLEARED: "keys_cleared";
     readonly KEY_INCREMENTED: "key_incremented";
     readonly KEY_DECREMENTED: "key_decremented";
@@ -30,30 +30,33 @@ export type StorageEvent = {
 /**
  * @group Events
  */
-export type KeysFoundStorageEvent<TType> = StorageEvent & {
-    type: (typeof STORAGE_EVENTS)["KEYS_FOUND"];
-    values: Record<string, TType>;
+export type KeyFoundStorageEvent<TType = unknown> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_FOUND"];
+    key: string;
+    value: TType;
 };
 /**
  * @group Events
  */
-export type KeysNotFoundStorageEvent = StorageEvent & {
-    type: (typeof STORAGE_EVENTS)["KEYS_NOT_FOUND"];
-    keys: string[];
+export type KeyNotFoundStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_NOT_FOUND"];
+    key: string;
 };
 /**
  * @group Events
  */
-export type KeysAddedStorageEvent<TType> = StorageEvent & {
-    type: (typeof STORAGE_EVENTS)["KEYS_ADDED"];
-    values: Record<string, TType>;
+export type KeyAddedStorageEvent<TType = unknown> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_ADDED"];
+    key: string;
+    value: TType;
 };
 /**
  * @group Events
  */
-export type KeysUpdatedStorageEvent<TType> = StorageEvent & {
-    type: (typeof STORAGE_EVENTS)["KEYS_UPDATED"];
-    values: Record<string, TType>;
+export type KeyUpdatedStorageEvent<TType = unknown> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_UPDATED"];
+    key: string;
+    value: TType;
 };
 /**
  * @group Events
@@ -74,9 +77,9 @@ export type KeyDecrementedStorageEvent = StorageEvent & {
 /**
  * @group Events
  */
-export type KeysRemovedStorageEvent = StorageEvent & {
-    type: (typeof STORAGE_EVENTS)["KEYS_REMOVED"];
-    keys: string[];
+export type KeyRemovedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_REMOVED"];
+    key: string;
 };
 /**
  * This event will be triggered when storage is cleared.
@@ -88,4 +91,4 @@ export type KeysClearedStorageEvent = StorageEvent & {
 /**
  * @group Events
  */
-export type AllStorageEvents<TType = unknown> = KeysFoundStorageEvent<TType> | KeysNotFoundStorageEvent | KeysAddedStorageEvent<TType> | KeysUpdatedStorageEvent<TType> | KeysRemovedStorageEvent | KeysClearedStorageEvent | KeyIncrementedStorageEvent | KeyDecrementedStorageEvent;
+export type AllStorageEvents<TType> = KeyFoundStorageEvent<TType> | KeyNotFoundStorageEvent | KeyAddedStorageEvent<TType> | KeyUpdatedStorageEvent<TType> | KeyRemovedStorageEvent | KeysClearedStorageEvent | KeyIncrementedStorageEvent | KeyDecrementedStorageEvent;

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

@@ -1,6 +1,3 @@
-export * from "../../storage/implementations/storage/_module";
+export * from "../../storage/implementations/derivables/_module";
+export * from "../../storage/implementations/adapters/_module";
 export * from "../../storage/implementations/_shared/test-utilities/_module";
-export * from "../../storage/implementations/memory-storage-adapter/_module";
-export * from "../../storage/implementations/mongodb-storage-adapter/_module";
-export * from "../../storage/implementations/redis-storage-adapter/_module";
-export * from "../../storage/implementations/sqlite/_module";

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

@@ -0,0 +1,4 @@
+export * from "../../../storage/implementations/adapters/memory-storage-adapter/_module";
+export * from "../../../storage/implementations/adapters/mongodb-storage-adapter/_module";
+export * from "../../../storage/implementations/adapters/redis-storage-adapter/_module";
+export * from "../../../storage/implementations/adapters/sqlite/_module";

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../../storage/contracts/storage-adapter.contract";
+/**
+ * @group Adapters
+ */
+export declare class MemoryStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly map;
+    constructor(map?: Map<string, TType>);
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/implementations/adapters/mongodb-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export { MongodbStorageAdapter, type MongodbStorageAdapterSettings, } from "../../../../storage/implementations/adapters/mongodb-storage-adapter/mongodb-storage-adapter";