@daiso-tech/core 0.11.0 → 0.12.0

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

@@ -1,182 +1,195 @@
 /**
- * @module Storage
+ * @module Cache
  */
 import type { IListenable } from "../../event-bus/contracts/_module";
 import type { OneOrMore } from "../../_shared/types";
 import { type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
-import type { AllStorageEvents } from "../../storage/contracts/_module";
-import type { LazyPromise } from "../../utilities/_module";
+import type { AllCacheEvents } from "../../cache/contracts/_module";
+import type { LazyPromise, TimeSpan } from "../../utilities/_module";
 /**
- * The <i>IStorageListenable</i> contract defines a way for listening <i>{@link IStorage}</i> crud operations.
+ * The <i>ICacheListenable</i> contract defines a way for listening <i>{@link ICache}</i> crud operations.
+ * @group Contracts
+ */
+export type ICacheListenable<TType = unknown> = IListenable<AllCacheEvents<TType>>;
+/**
+ * @group Contracts
  */
-export type IStorageListenable<TType = unknown> = IListenable<AllStorageEvents<TType>>;
+export type WithTtlValue<TType> = {
+    value: TType;
+    /**
+     * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
+     */
+    ttl?: TimeSpan | 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>.
+ * The <i>ICache</i> contract defines a way for storing data as key-value pairs independent of data storage.
+ * It commes with more convient methods compared to <i>ICacheAdapter</i>.
  * @group Contracts
  */
-export type IStorage<TType = unknown> = IStorageListenable & {
+export type ICache<TType = unknown> = ICacheListenable & {
     /**
      * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
+     * @throws {KeyNotFoundCacheError} {@link KeyNotFoundCacheError}
      */
     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}
+     * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
-    add(key: string, value: TType): LazyPromise<boolean>;
+    add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
     /**
      * 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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
-    addMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     update(key: string, value: TType): LazyPromise<boolean>;
     /**
      * 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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
-    put(key: string, value: TType): LazyPromise<boolean>;
+    put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
     /**
      * 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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
-    putMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     remove(key: string): LazyPromise<boolean>;
     /**
      * The <i>removeMany</i> method removes keys. Returns true for the keys that are removed otherwise false is returned.
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
-    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>): LazyPromise<TType>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, ttl?: TimeSpan | null): LazyPromise<TType>;
     /**
      * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
      * 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}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
+     * @throws {TypeCacheError} {@link TypeCacheError}
      */
     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.
      * An error will thrown if the key is not a number.
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
-     * @throws {TypeStorageError} {@link TypeStorageError}
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
+     * @throws {TypeCacheError} {@link TypeCacheError}
      * An error will thrown if the key is not a number.
      */
     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}
+     * The <i>clear</i> method removes all the keys in the cache.
+     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     clear(): LazyPromise<void>;
     /**
      * The <i>getNamespace</i> method returns the complete namespace.
      * @example
      * ```ts
-     * import type { IStorage } from "@daiso-tech/core";
+     * import type { ICache } from "@daiso-tech/core";
      *
-     * async function main(storage: IStorage) {
+     * async function main(cache: ICache) {
      *   // Will be "@root"
-     *   console.log(storage.getNamespace())
+     *   console.log(cache.getNamespace())
      *
-     *   const storageA = storage.withNamespace("a");
+     *   const cacheA = cache.withNamespace("a");
      *
      *   // Will be "@root/a"
-     *   console.log(storageA.getNamespace())
+     *   console.log(cacheA.getNamespace())
      * }
      * ```
      */
     getNamespace(): string;
 };
 /**
- * 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>.
+ * The <i>INamespacedCache</i> contract defines a way for storing data as key-value pairs independent of data storage.
+ * It commes with one extra method which is useful for multitennat applications compared to <i>ICache</i>.
  * @group Contracts
  */
-export type INamespacedStorage<TType = unknown> = IStorage<TType> & {
+export type INamespacedCache<TType = unknown> = ICache<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>.
+     * The <i>withNamespace</i> method returns new instance of <i>{@link ICache}</i> where all the keys will be prefixed with a given <i>namespace</i>.
      * This useful for multitennat applications.
      * @example
      * ```ts
-     * import { type IStorage } from "@daiso-tech/core";
+     * import { type ICache } from "@daiso-tech/core";
      *
-     * async function main(storage: IStorage): Promise<void> {
-     *   const storageA = storage.withNamespace("a");
-     *   await storageA.add("a", 1);
+     * async function main(cache: ICache): Promise<void> {
+     *   const cacheA = cache.withNamespace("a");
+     *   await cacheA.add("a", 1);
      *
-     *   const storageB = storage.withNamespace("b");
-     *   await storageB.add("b", 2);
+     *   const cacheB = cache.withNamespace("b");
+     *   await cacheB.add("b", 2);
      *
      *   // Will print { a: 1, b: null }
-     *   console.log(await storageA.getMany(["a", "b"]));
+     *   console.log(await cacheA.getMany(["a", "b"]));
      * }
      * ```
      */
-    withNamespace(namespace: OneOrMore<string>): IStorage<TType>;
+    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
 };

package/dist/types/{storage/contracts/storage.errors.d.ts → cache/contracts/cache.errors.d.ts}

@@ -1,27 +1,27 @@
 /**
- * @module Storage
+ * @module Cache
  */
 /**
  * @group Errors
  */
-export declare class StorageError extends Error {
+export declare class CacheError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class UnexpectedStorageError extends StorageError {
+export declare class UnexpectedCacheError extends CacheError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class TypeStorageError extends StorageError {
+export declare class TypeCacheError extends CacheError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class KeyNotFoundStorageError extends StorageError {
+export declare class KeyNotFoundCacheError extends CacheError {
     constructor(message: string, cause?: unknown);
 }

package/dist/types/cache/contracts/cache.events.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @module Cache
+ */
+import type { TimeSpan } from "../../utilities/_module";
+import type { ICacheAdapter } from "../../cache/contracts/cache-adapter.contract";
+/**
+ * Name of all the events of <i>{@link ICache}</i>.
+ * @group Events
+ */
+export declare const CACHE_EVENTS: {
+    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";
+};
+/**
+ * @group Events
+ */
+export type CacheEventNames = (typeof CACHE_EVENTS)[keyof typeof CACHE_EVENTS];
+/**
+ * @group Events
+ */
+export type CacheEvent = {
+    namespace: string;
+    adapter: ICacheAdapter<any>;
+};
+/**
+ * @group Events
+ */
+export type KeyFoundCacheEvent<TType = unknown> = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_FOUND"];
+    key: string;
+    value: TType;
+};
+/**
+ * @group Events
+ */
+export type KeyNotFoundCacheEvent = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_NOT_FOUND"];
+    key: string;
+};
+/**
+ * @group Events
+ */
+export type KeyAddedCacheEvent<TType = unknown> = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_ADDED"];
+    key: string;
+    value: TType;
+    ttl: TimeSpan | null;
+};
+/**
+ * @group Events
+ */
+export type KeyUpdatedCacheEvent<TType = unknown> = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_UPDATED"];
+    key: string;
+    value: TType;
+};
+/**
+ * @group Events
+ */
+export type KeyIncrementedCacheEvent = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_INCREMENTED"];
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export type KeyDecrementedCacheEvent = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_DECREMENTED"];
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export type KeyRemovedCacheEvent = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEY_REMOVED"];
+    key: string;
+};
+/**
+ * This event will be triggered when cache is cleared.
+ * @group Events
+ */
+export type KeysClearedCacheEvent = CacheEvent & {
+    type: (typeof CACHE_EVENTS)["KEYS_CLEARED"];
+};
+/**
+ * @group Events
+ */
+export type AllCacheEvents<TType> = KeyFoundCacheEvent<TType> | KeyNotFoundCacheEvent | KeyAddedCacheEvent<TType> | KeyUpdatedCacheEvent<TType> | KeyRemovedCacheEvent | KeysClearedCacheEvent | KeyIncrementedCacheEvent | KeyDecrementedCacheEvent;

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

@@ -0,0 +1,3 @@
+export * from "../../cache/implementations/_shared/_module";
+export * from "../../cache/implementations/adapters/_module";
+export * from "../../cache/implementations/derivables/_module";

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

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

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

@@ -0,0 +1,51 @@
+/**
+ * @module Cache
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type ICacheAdapter } from "../../../cache/contracts/_module";
+import { type Promisable } from "../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type CacheAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<ICacheAdapter>;
+};
+/**
+ * The <i>cacheAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICacheAdapter}</i>.
+ * @group Utilities
+ * @example
+ * ```ts
+ * import { afterEach, beforeEach, describe, expect, test } from "vitest";
+ * import { cacheAdapterTestSuite, SqliteCacheAdapter } from "@daiso-tech/core";
+ * import Sqlite, { type Database } from "better-sqlite3";
+ *
+ * describe("class: SqliteCacheAdapter", () => {
+ *   let database: Database;
+ *   beforeEach(() => {
+ *       database = new Sqlite(":memory:");
+ *   });
+ *   afterEach(() => {
+ *       database.close();
+ *   });
+ *   cacheAdapterTestSuite({
+ *       createAdapter: async () => {
+ *         const cacheAdapter = new SqliteCacheAdapter(database, {
+ *           tableName: "custom_table",
+ *           enableTransactions: true,
+ *         });
+ *         await cacheAdapter.init();
+ *         return cacheAdapter;
+ *       },
+ *       test,
+ *       beforeEach,
+ *       expect,
+ *       describe,
+ *   });
+ * });
+ * ```
+ */
+export declare function cacheAdapterTestSuite(settings: CacheAdapterTestSuiteSettings): void;

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

@@ -0,0 +1,60 @@
+/**
+ * @module Cache
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type ICache } from "../../../cache/contracts/_module";
+import { type Promisable } from "../../../_shared/types";
+/**
+ * @group Utilities
+ * @example
+ * ```ts
+ * import { afterEach, beforeEach, describe, expect, test } from "vitest";
+ * import { cacheAdapterTestSuite, SqliteCacheAdapter } from "@daiso-tech/core";
+ * import Sqlite, { type Database } from "better-sqlite3";
+ *
+ * describe("class: Cache", () => {
+ *   let database: Database;
+ *   beforeEach(() => {
+ *       database = new Sqlite(":memory:");
+ *   });
+ *   afterEach(() => {
+ *       database.close();
+ *   });
+ *   cacheAdapterTestSuite({
+ *       createCacheA: async () => {
+ *         const cacheAdapterA = new SqliteCacheAdapter(database, {
+ *           tableName: "custom_table",
+ *           enableTransactions: true,
+ *         });
+ *         await cacheAdapterA.init();
+ *         return new Cache(cacheAdapterA, {
+ *           rootNamespace: "@a"
+ *         });
+ *       },
+ *       createCacheB: async () => {
+ *         const cacheAdapterB = new SqliteCacheAdapter(database, {
+ *           tableName: "custom_table",
+ *           enableTransactions: true,
+ *         });
+ *         await cacheAdapterB.init();
+ *         return new Cache(cacheAdapterB, {
+ *           rootNamespace: "@b"
+ *         });
+ *       },
+ *       test,
+ *       beforeEach,
+ *       expect,
+ *       describe,
+ *   });
+ * });
+ * ```
+ */
+export type CacheTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createCacheA: () => Promisable<ICache>;
+    createCacheB: () => Promisable<ICache>;
+};
+export declare function cacheTestSuite(settings: CacheTestSuiteSettings): void;

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

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

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

@@ -0,0 +1 @@
+export * from "../../../../cache/implementations/adapters/kysely-sqlite-cache-adapter/kysely-sqlite-cache-adapter";

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

@@ -0,0 +1,55 @@
+/**
+ * @module Cache
+ */
+import { type ICacheAdapter } from "../../../../cache/contracts/_module";
+import { type Kysely } from "kysely";
+import { type ISerializer } from "../../../../serializer/contracts/_module";
+import type { IDeinitizable, IInitizable } from "../../../../_shared/types";
+import { TimeSpan } from "../../../../utilities/_module";
+/**
+ * @internal
+ */
+type KyselySqliteCacheTable = {
+    key: string;
+    value: string;
+    expiresAt: number | null;
+};
+/**
+ * @internal
+ */
+type KyselySqliteTables = {
+    cache: KyselySqliteCacheTable;
+};
+/**
+ * @internal
+ */
+type KyselySqliteSettings = {
+    serializer: ISerializer<string>;
+    enableTransactions: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @internal
+ */
+export declare class KyselySqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly db;
+    private readonly serializer;
+    private readonly enableTransactions;
+    private readonly expiredKeysRemovalInterval;
+    private readonly shouldRemoveExpiredKeys;
+    private timeoutId;
+    constructor(db: Kysely<KyselySqliteTables>, settings: KyselySqliteSettings);
+    private withTransaction;
+    removeExpiredKeys(): Promise<void>;
+    init(): Promise<void>;
+    deInit(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}
+export {};

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * @module Cache
+ */
+import type { IDeinitizable, IInitizable } from "../../../../_shared/types";
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { TimeSpan } from "../../../../utilities/_module";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlCacheAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @group Adapters
+ */
+export declare class LibsqlCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly cacheAdapter;
+    constructor(client: Client, settings?: LibsqlCacheAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    deInit(): Promise<void>;
+    init(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

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

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

@@ -0,0 +1,20 @@
+/**
+ * @module Cache
+ */
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { TimeSpan } from "../../../../utilities/_module";
+/**
+ * @group Adapters
+ */
+export declare class MemoryCacheAdapter<TType> implements ICacheAdapter<TType> {
+    private readonly map;
+    constructor(map?: Map<string, TType>);
+    private readonly timeoutIdMap;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, _ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

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