@daiso-tech/core 0.2.0 → 0.3.0

package/dist/types/serializer/_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 "../../../contracts/serializer/_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/mongodb-serializer/_module.d.ts

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

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

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../contracts/serializer/_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/redis-serializer/_module.d.ts

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

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

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../contracts/serializer/_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/sql-serializer/_module.d.ts

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

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

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../contracts/serializer/_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/super-json-serializer/_module.d.ts

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

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

@@ -0,0 +1,37 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../contracts/serializer/_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/_module.d.ts

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

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

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

package/dist/types/storage/_shared/test-utilities/storage-api.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 "../../../contracts/storage/_module";
+import { type Promisable } from "../../../_shared/types";
+/**
+ * @internal
+ */
+export type StorageApiTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @internal
+ */
+export declare function storageApiTestSuite(settings: StorageApiTestSuiteSettings): void;

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

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

package/dist/types/storage/_shared/test-utilities/storage-value.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 "../../../contracts/storage/_module";
+import { type Promisable } from "../../../_shared/types";
+/**
+ * @internal
+ */
+export type StorageValueTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @internal
+ */
+export declare function storageValueTestSuite(settings: StorageValueTestSuiteSettings): void;

package/dist/types/storage/_shared/test-utilities/storage.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 "../../../contracts/storage/_module";
+import { type Promisable } from "../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type StorageTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @group Utilities
+ */
+export declare function storageTestSuite(settings: StorageTestSuiteSettings): void;

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../contracts/storage/storage-adapter.contract";
+/**
+ * @group Adapters
+ */
+export declare class MemoryStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly map;
+    constructor(map?: Map<string, TType>);
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    clear(prefix: string): Promise<void>;
+}

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

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

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

@@ -0,0 +1,46 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../contracts/serializer/_module";
+import type { GetOrAddResult } from "../../_shared/types";
+import { type IInitizable } from "../../_shared/types";
+import { type IStorageAdapter } from "../../contracts/storage/_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<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    private updateOne;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    private putOne;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    private removeOne;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: TExtended): Promise<GetOrAddResult<TValue | TExtended>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/namespace-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import type { AsyncLazyable } from "../_shared/types";
+import { type IStorageAdapter } from "../contracts/storage/_module";
+import type { UsableStorageAdapter } from "../storage/usable-storage-adapter";
+/**
+ * @internal
+ */
+export declare class NamespaceStorageAdapter<TType> implements Required<Omit<IStorageAdapter<TType>, "clear" | "getOrAdd">> {
+    private readonly usableStorageAdapter;
+    private readonly namespace;
+    constructor(usableStorageAdapter: UsableStorageAdapter<TType>, namespace: string);
+    private withNamespace;
+    private withNamespaceArray;
+    private withNamespaceObject;
+    private withoutNamespace;
+    private withoutNamespaceObject;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: AsyncLazyable<TExtended>): Promise<TValue | TExtended>;
+    increment(key: string, value: number): Promise<boolean>;
+    decrement(key: string, value: number): Promise<boolean>;
+    clear(): Promise<void>;
+}

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

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

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

@@ -0,0 +1,41 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../contracts/serializer/_module";
+import { type IStorageAdapter } from "../../contracts/storage/_module";
+import type Redis from "ioredis";
+import { type Result } from "ioredis";
+import type { GetOrAddResult } from "../../_shared/types";
+declare module "ioredis" {
+    interface RedisCommander<Context> {
+        daiso_storage_increment(key: string, number: string): Result<number, Context>;
+        daiso_storage_put(key: string, value: string): Result<string, Context>;
+        daiso_storage_getOrAdd(key: string, valueToAdd: string): Result<string, Context>;
+    }
+}
+/**
+ * @group Adapters
+ */
+export type RedisStorageAdapterSettings = {
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class RedisStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly client;
+    private serializer;
+    constructor(client: Redis, { serializer, }?: RedisStorageAdapterSettings);
+    private initIncrementCommand;
+    private initPutCommand;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: TExtended): Promise<GetOrAddResult<TValue | TExtended>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export * from "../../storage/sqlite/sqlite-storage-adapter/_module";
+export * from "../../storage/sqlite/libsql-storage-adapter/_module";

package/dist/types/storage/sqlite/_shared/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../storage/sqlite/_shared/base-sqlite-storage-adapter";

package/dist/types/storage/sqlite/_shared/base-sqlite-storage-adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../contracts/storage/storage-adapter.contract";
+import { type Generated, type Kysely } from "kysely";
+import { type ISerializer } from "../../../contracts/serializer/_module";
+import type { GetOrAddResult } from "../../../_shared/types";
+import { type IInitizable } from "../../../_shared/types";
+/**
+ * @internal
+ */
+type BaseSqliteStorageTable = {
+    key: string;
+    value: string;
+    hasBeenUpdated: Generated<1 | 0>;
+};
+/**
+ * @internal
+ */
+type BaseSqliteTables = {
+    storage: BaseSqliteStorageTable;
+};
+/**
+ * @internal
+ */
+export declare class BaseSqliteStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly db;
+    private readonly serializer;
+    constructor(db: Kysely<BaseSqliteTables>, serializer: ISerializer<string>);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: TExtended): Promise<GetOrAddResult<TValue | TExtended>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}
+export {};

package/dist/types/storage/sqlite/libsql-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../storage/sqlite/libsql-storage-adapter/libsql-storage-adapter";

package/dist/types/storage/sqlite/libsql-storage-adapter/libsql-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../../_module";
+import { type IStorageAdapter } from "../../../contracts/storage/_module";
+import { type IInitizable } from "../../../_shared/types";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class LibsqlStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly storageAdapter;
+    constructor(client: Client, { tableName, serializer, }?: LibsqlStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    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/sqlite/sqlite-storage-adapter/_module.d.ts

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

package/dist/types/storage/sqlite/sqlite-storage-adapter/sqlite-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../../_module";
+import { type IStorageAdapter } from "../../../contracts/storage/_module";
+import { type Database } from "better-sqlite3";
+import { type IInitizable } from "../../../_shared/types";
+/**
+ * @group Adapters
+ */
+export type SqliteStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class SqliteStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly storageAdapter;
+    constructor(database: Database, { tableName, serializer, }?: SqliteStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    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/storage.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../contracts/storage/_module";
+import { type StorageValue, type IStorage } from "../contracts/storage/_module";
+import { type AsyncLazyable, type GetOrAddValue } from "../_shared/types";
+export type StorageSettings = {
+    namespace?: string;
+};
+export declare class Storage<TType> implements IStorage<TType> {
+    private readonly storageAdapter;
+    constructor(storageAdapter: IStorageAdapter<TType>, { namespace }?: StorageSettings);
+    [Symbol.asyncDispose](): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    missing(key: string): Promise<boolean>;
+    missingMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    get<TValue extends TType>(key: string): Promise<TValue | null>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    getOr<TValue extends TType, TExtended extends TType>(key: string, defaultValue: AsyncLazyable<TExtended>): Promise<TValue | TExtended>;
+    getOrMany<TValues extends TType, TExtended extends TType, TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TExtended>>): Promise<Record<TKeys, TValues | TExtended>>;
+    getOrFail<TValue extends TType>(key: string): Promise<TValue>;
+    add<TValue extends TType>(key: string, value: StorageValue<TValue>): Promise<boolean>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, StorageValue<TValues>>): Promise<Record<TKeys, boolean>>;
+    update<TValue extends TType>(key: string, value: TValue): Promise<boolean>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    put<TValue extends TType>(key: string, value: StorageValue<TValue>): Promise<boolean>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, StorageValue<TValues>>): Promise<Record<TKeys, boolean>>;
+    remove(key: string): Promise<boolean>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TExtended>>>): Promise<TValue | TExtended>;
+    increment(key: string, value?: number): Promise<boolean>;
+    decrement(key: string, value?: number): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/types/storage/usable-storage-adapter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module Storage
+ */
+import type { AsyncLazyable, GetOrAddResult } from "../_shared/types";
+import { type IStorageAdapter } from "../contracts/storage/_module";
+/**
+ * @internal
+ */
+export declare class UsableStorageAdapter<TType> implements Required<Omit<IStorageAdapter<TType>, "getOrAdd">> {
+    private readonly storageAdapter;
+    constructor(storageAdapter: IStorageAdapter<TType>);
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TValues extends TType, TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TValues | null>>;
+    addMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    updateMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    putMany<TValues extends TType, TKeys extends string>(values: Record<TKeys, TValues>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    getAndRemove<TValue extends TType>(key: string): Promise<TValue | null>;
+    getOrAdd<TValue extends TType, TExtended extends TType>(key: string, valueToAdd: AsyncLazyable<TExtended>): Promise<GetOrAddResult<TValue | TExtended>>;
+    clear(prefix: string): Promise<void>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.2.0",
+    "version": "0.3.0",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",
@@ -13,12 +13,13 @@
         "url": "https://github.com/yousif-khalil-abdulkarim/daiso-core.git"
     },
     "keywords": [
-        "Collections",
-        "Arrays",
-        "Iterables",
+        "Collection",
+        "Array",
         "Iterable",
-        "Async iterables",
-        "AsyncIterable"
+        "AsyncIterable",
+        "Cache",
+        "Mongodb",
+        "Redis"
     ],
     "files": [
         "./dist"
@@ -38,9 +39,14 @@
     },
     "devDependencies": {
         "@changesets/cli": "^2.27.7",
+        "@libsql/client": "^0.14.0",
+        "@testcontainers/mongodb": "^10.13.2",
+        "@testcontainers/redis": "^10.13.2",
+        "@types/better-sqlite3": "^7.6.11",
         "@typescript-eslint/eslint-plugin": "^8.1.0",
         "@typescript-eslint/parser": "^8.1.0",
         "@vitest/eslint-plugin": "^1.0.3",
+        "better-sqlite3": "^11.5.0",
         "eslint": "^8.57.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-no-relative-import-paths": "^1.5.5",
@@ -49,6 +55,8 @@
         "eslint-plugin-tsdoc": "^0.3.0",
         "eslint-plugin-typescript-enum": "^2.1.0",
         "eslint-plugin-vitest": "^0.5.4",
+        "ioredis": "^5.4.1",
+        "mongodb": "^6.10.0",
         "rimraf": "^6.0.1",
         "tsc-alias": "^1.8.10",
         "typedoc": "^0.26.5",
@@ -57,5 +65,32 @@
         "typescript": "^5.5.4",
         "vite-tsconfig-paths": "^4.3.2",
         "vitest": "^2.0.5"
+    },
+    "peerDependencies": {
+        "@libsql/client": "^0.4.1",
+        "better-sqlite3": "^11.5.0",
+        "ioredis": "^5.4.1",
+        "mongodb": "^6.10.0"
+    },
+    "peerDependenciesMeta": {
+        "mongodb": {
+            "optional": true
+        },
+        "ioredis": {
+            "optional": true
+        },
+        "better-sqlite3": {
+            "optional": true
+        },
+        "@libsql/client": {
+            "optional": true
+        }
+    },
+    "dependencies": {
+        "@libsql/kysely-libsql": "^0.4.1",
+        "escape-string-regexp": "^5.0.0",
+        "kysely": "^0.27.4",
+        "superjson": "^2.2.1",
+        "uuid": "^11.0.2"
     }
 }