@daiso-tech/core 0.6.0 → 0.8.0

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/serializer/contracts/_module.d.ts

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

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

@@ -0,0 +1,5 @@
+export * from "../../serializer/implementations/_shared/test-utilities/_module";
+export * from "../../serializer/implementations/mongodb-serializer/_module";
+export * from "../../serializer/implementations/redis-serializer/_module";
+export * from "../../serializer/implementations/sql-serializer/_module";
+export * from "../../serializer/implementations/super-json-serializer/_module";

package/dist/types/serializer/implementations/_shared/test-utilities/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../serializer/implementations/_shared/test-utilities/serializer.test-suite";

package/dist/types/serializer/implementations/_shared/test-utilities/serializer.test-suite.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module Serializer
+ */
+import { type TestAPI, type ExpectStatic } from "vitest";
+import { type ISerializer } from "../../../../serializer/contracts/_module";
+import { type Promisable } from "../../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type SerializerSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    createAdapter: () => Promisable<ISerializer>;
+};
+/**
+ * @group Utilities
+ */
+export declare function serializerTestSuite(settings: SerializerSuiteSettings): void;

package/dist/types/serializer/implementations/mongodb-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/mongodb-serializer/mongodb-serializer";

package/dist/types/serializer/implementations/mongodb-serializer/mongodb-serializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+/**
+ * @internal
+ */
+export declare class MongodbSerializer implements ISerializer<string | number> {
+    private readonly serializer;
+    constructor(serializer: ISerializer<string>);
+    serialize<TValue>(value: TValue): Promise<string | number>;
+    deserialize<TValue>(value: string | number): Promise<TValue>;
+}

package/dist/types/serializer/implementations/redis-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/redis-serializer/redis-serializer";

package/dist/types/serializer/implementations/redis-serializer/redis-serializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+/**
+ * @internal
+ */
+export declare class RedisSerializer implements ISerializer<string> {
+    private readonly serializer;
+    constructor(serializer: ISerializer<string>);
+    serialize<TValue>(value: TValue): Promise<string>;
+    deserialize<TValue>(value: string): Promise<TValue>;
+}

package/dist/types/serializer/implementations/sql-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/sql-serializer/sql-serializer";

package/dist/types/serializer/implementations/sql-serializer/sql-serializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+/**
+ * @internal
+ */
+export declare class SqlSerializer implements ISerializer<string> {
+    private readonly serializer;
+    constructor(serializer: ISerializer<string>);
+    serialize<TValue>(value: TValue): Promise<string>;
+    deserialize<TValue>(value: string): Promise<TValue>;
+}

package/dist/types/serializer/implementations/super-json-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/super-json-serializer/super-json-serializer";

package/dist/types/serializer/implementations/super-json-serializer/super-json-serializer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import type { SuperJSON } from "superjson";
+/**
+ * @group Adapters
+ */
+export type SuperJsonSerializerSettings = {
+    dedupe?: boolean;
+    registerClass?: (registerClass: SuperJSON["registerClass"]) => void;
+    registerSymbol?: (registerClass: SuperJSON["registerSymbol"]) => void;
+    registerCustom?: (registerClass: SuperJSON["registerCustom"]) => void;
+};
+/**
+ * @group Adapters
+ */
+export declare class SuperJsonSerializer implements ISerializer<string> {
+    private superJson;
+    private dedupe;
+    private registerClass;
+    private registerSymbol;
+    private registerCustom;
+    constructor({ dedupe, registerClass, registerSymbol, registerCustom, }?: SuperJsonSerializerSettings);
+    private static registerBuffer;
+    private static registerUint8Array;
+    private static registerInt8Array;
+    private static registerUint16Array;
+    private static registerInt16Array;
+    private static registerUint32Array;
+    private static registerInt32Array;
+    private static registerFloat32Array;
+    private static registerFloat64Array;
+    private init;
+    serialize<TValue>(value: TValue): Promise<string>;
+    deserialize<TValue>(value: string): Promise<TValue>;
+}

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

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

@@ -0,0 +1,58 @@
+/**
+ * @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}
+ * @group Contracts
+ */
+export type IStorageAdapter<TType> = {
+    /**
+     * 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>>;
+    /**
+     * 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>>;
+    /**
+     * 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>>;
+    /**
+     * 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>>;
+    /**
+     * 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>>;
+    /**
+     * 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}
+     */
+    clear(prefix: string): PromiseLike<void>;
+};

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

@@ -0,0 +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> = IListenable<AllStorageEvents<TType>> & {
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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/_module.d.ts

@@ -0,0 +1,6 @@
+export * from "../../storage/implementations/storage/_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/_shared/test-utilities/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/_shared/test-utilities/storage-adapter.test-suite";

package/dist/types/storage/implementations/_shared/test-utilities/storage-adapter.test-suite.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module Storage
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type Promisable } from "../../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type StorageAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @group Utilities
+ */
+export declare function storageTestSuite(settings: StorageAdapterTestSuiteSettings): void;

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

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

package/dist/types/storage/implementations/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>);
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    clear(prefix: string): Promise<void>;
+}

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

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

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

@@ -0,0 +1,43 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import { type IInitizable } from "../../../_shared/types";
+import { type IStorageAdapter } from "../../../storage/contracts/_module";
+import { type Collection, ObjectId } from "mongodb";
+/**
+ * @group Adapters
+ */
+export type MongodbStorageDocument = {
+    _id: ObjectId;
+    key: string;
+    value: number | string;
+};
+/**
+ * @group Adapters
+ */
+export type MongodbStorageAdapterSettings = {
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class MongodbStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly collection;
+    private static isMongodbIncrementError;
+    private static isMongoDuplicateError;
+    private serializer;
+    constructor(collection: Collection<MongodbStorageDocument>, { serializer, }?: MongodbStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private updateOne;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private putOne;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private removeOne;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

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