@daiso-tech/core 0.14.0 → 0.16.0

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

@@ -2,15 +2,16 @@
  * @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 { AllCacheEvents } from "../../cache/contracts/_module";
-import type { LazyPromise, TimeSpan } from "../../utilities/_module";
+import type { OneOrMore } from "../../utilities/_module";
+import { type AsyncLazyable, type GetOrAddValue } from "../../utilities/_module";
+import type { CacheEvents } from "../../cache/contracts/_module";
+import type { TimeSpan } from "../../utilities/_module";
+import type { LazyPromise } from "../../async/_module";
 /**
  * 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>>;
+export type ICacheListenable<TType = unknown> = IListenable<CacheEvents<TType>>;
 /**
  * @group Contracts
  */
@@ -29,107 +30,89 @@ export type WithTtlValue<TType> = {
 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 {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 {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 {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 {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 {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 {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 {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 {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 {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.
      * 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, 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 {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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 {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 {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.
-     * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
+     * The <i>put</i> method replaces a <i>key</i> if the <i>key</i> exists including the ttl value or adds <i>key</i> that do not exists with a given <i>ttl</i>.
+     * Returns true if the <i>key</i> where replaced otherwise false is returned.
+     * You must provide a <i>ttl</i> value. If null is passed, the item will not expire.
      */
     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. Returns true for all the keys that where updated otherwise false is returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
+     * The <i>putMany</i> method replaces the keys that exists including their ttl values or adds keys that do not exists.
+     * Returns true for all the keys that where replaced otherwise false is returned.
      */
     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 {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 {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 {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 {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     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 {UnexpectedCacheError} {@link UnexpectedCacheError}
      * @throws {TypeCacheError} {@link TypeCacheError}
      */
     increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
@@ -137,53 +120,52 @@ export type ICache<TType = unknown> = ICacheListenable & {
      * 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 {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 cache.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     clear(): LazyPromise<void>;
     /**
-     * The <i>getNamespace</i> method returns the complete namespace.
+     * The <i>getGroup</i> method returns the group name.
      * @example
      * ```ts
      * import type { ICache } from "@daiso-tech/core";
      *
      * async function main(cache: ICache) {
-     *   // Will be "@root"
-     *   console.log(cache.getNamespace())
+     *   // Will be "@global"
+     *   console.log(cache.getGroup())
      *
-     *   const cacheA = cache.withNamespace("a");
+     *   const cacheA = cache.withGroup("a");
      *
-     *   // Will be "@root/a"
-     *   console.log(cacheA.getNamespace())
+     *   // Will be "@global/a"
+     *   console.log(cacheA.getGroup())
      * }
      * ```
      */
-    getNamespace(): string;
+    getGroup(): string;
 };
 /**
- * The <i>INamespacedCache</i> contract defines a way for storing data as key-value pairs independent of data storage.
+ * The <i>IGroupableCache</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 INamespacedCache<TType = unknown> = ICache<TType> & {
+export type IGroupableCache<TType = unknown> = ICache<TType> & {
     /**
-     * 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>.
+     * The <i>withGroup</i> method returns a new <i>{@link ICache}</i> instance that groups keys together.
+     * Only keys in the group can be updated, removed, or retrieved, leaving keys outside the group unaffected.
      * This useful for multitennat applications.
      * @example
      * ```ts
      * import { type ICache } from "@daiso-tech/core";
      *
      * async function main(cache: ICache): Promise<void> {
-     *   const cacheA = cache.withNamespace("a");
+     *   const cacheA = cache.withGroup("a");
      *   await cacheA.add("a", 1);
      *
-     *   const cacheB = cache.withNamespace("b");
+     *   const cacheB = cache.withGroup("b");
      *   await cacheB.add("b", 2);
      *
      *   // Will print { a: 1, b: null }
@@ -191,5 +173,5 @@ export type INamespacedCache<TType = unknown> = ICache<TType> & {
      * }
      * ```
      */
-    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
+    withGroup(group: OneOrMore<string>): ICache<TType>;
 };

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

@@ -2,95 +2,42 @@
  * @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";
+export type CacheEvents<TType = unknown> = {
+    key_found: {
+        group: string;
+        key: string;
+        value: TType;
+    };
+    key_not_found: {
+        group: string;
+        key: string;
+    };
+    key_added: {
+        group: string;
+        key: string;
+        value: TType;
+        ttl: TimeSpan | null;
+    };
+    key_updated: {
+        group: string;
+        key: string;
+        value: TType;
+    };
+    key_removed: {
+        group: string;
+        key: string;
+    };
+    key_incremented: {
+        group: string;
+        key: string;
+        value: number;
+    };
+    key_decremented: {
+        group: string;
+        key: string;
+        value: number;
+    };
+    keys_cleared: {
+        group: string;
+    };
 };
-/**
- * @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/_shared/cache-adapter.test-suite.d.ts

@@ -3,7 +3,7 @@
  */
 import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
 import { type ICacheAdapter } from "../../../cache/contracts/_module";
-import { type Promisable } from "../../../_shared/types";
+import { type Promisable } from "../../../utilities/_module";
 /**
  * @group Utilities
  */
@@ -12,38 +12,47 @@ export type CacheAdapterTestSuiteSettings = {
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createAdapter: () => Promisable<ICacheAdapter>;
+    createAdapterA: () => Promisable<ICacheAdapter>;
+    createAdapterB: () => Promisable<ICacheAdapter>;
 };
 /**
- * The <i>cacheAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICacheAdapter}</i>.
+ * The <i>cacheAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICacheAdapter}</i> with <i>vitest</i>.
  * @group Utilities
  * @example
  * ```ts
+ * import Redis from "ioredis";
  * import { afterEach, beforeEach, describe, expect, test } from "vitest";
- * import { cacheAdapterTestSuite, SqliteCacheAdapter } from "@daiso-tech/core";
- * import Sqlite, { type Database } from "better-sqlite3";
+ * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheAdapterTestSuite } from "@daiso-tech/core";
  *
- * describe("class: SqliteCacheAdapter", () => {
- *   let database: Database;
- *   beforeEach(() => {
- *       database = new Sqlite(":memory:");
- *   });
- *   afterEach(() => {
- *       database.close();
- *   });
+ * const timeout = TimeSpan.fromMinutes(2);
+ * describe("class: RedisCacheAdapter", () => {
+ *   let client: Redis;
+ *   let startedContainer: StartedRedisContainer;
+ *   const serde = new SuperJsonSerde();
+ *   beforeEach(async () => {
+ *     startedContainer = await new RedisContainer("redis:7.4.2").start();
+ *     client = new Redis(startedContainer.getConnectionUrl());
+ *   }, timeout.toMilliseconds());
+ *   afterEach(async () => {
+ *     await client.quit();
+ *     await startedContainer.stop();
+ *   }, timeout.toMilliseconds());
  *   cacheAdapterTestSuite({
- *       createAdapter: async () => {
- *         const cacheAdapter = new SqliteCacheAdapter(database, {
- *           tableName: "custom_table",
- *           enableTransactions: true,
- *         });
- *         await cacheAdapter.init();
- *         return cacheAdapter;
- *       },
- *       test,
- *       beforeEach,
- *       expect,
- *       describe,
+ *     createAdapterA: () =>
+ *       new RedisCacheAdapter(client, {
+ *         serde,
+ *         rootGroup: "@a"
+ *       }),
+ *     createAdapterB: () =>
+ *       new RedisCacheAdapter(client, {
+ *         serde,
+ *         rootGroup: "@b"
+ *       }),
+ *     test,
+ *     beforeEach,
+ *     expect,
+ *     describe,
  *   });
  * });
  * ```

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

@@ -3,51 +3,9 @@
  */
 import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
 import { type ICache } from "../../../cache/contracts/_module";
-import { type Promisable } from "../../../_shared/types";
+import { type Promisable } from "../../../utilities/_module";
 /**
  * @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;
@@ -57,4 +15,57 @@ export type CacheTestSuiteSettings = {
     createCacheA: () => Promisable<ICache>;
     createCacheB: () => Promisable<ICache>;
 };
+/**
+ * The <i>cacheTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICache}</i> with <i>vitest</i>.
+ * @group Utilities
+ * @example
+ * ```ts
+ * import Redis from "ioredis";
+ * import { afterEach, beforeEach, describe, expect, test } from "vitest";
+ * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
+ *
+ * const timeout = TimeSpan.fromMinutes(2);
+ * describe("class: Cache", () => {
+ *   let client: Redis;
+ *   let startedContainer: StartedRedisContainer;
+ *   const eventBus = new EventBus(new MemoryEventBusAdapter()):
+ *   const serde = new SuperJsonSerde();
+ *   beforeEach(async () => {
+ *     startedContainer = await new RedisContainer("redis:7.4.2").start();
+ *     client = new Redis(startedContainer.getConnectionUrl());
+ *   }, timeout.toMilliseconds());
+ *   afterEach(async () => {
+ *     await client.quit();
+ *     await startedContainer.stop();
+ *   }, timeout.toMilliseconds());
+ *   cacheTestSuite({
+ *     createCacheA: () =>
+ *       new Cache(
+ *         new RedisCacheAdapter(client, {
+ *           serde,
+ *         }),
+ *         {
+ *           rootGroup: "@a",
+ *           eventBus,
+ *         }
+ *       ),
+ *     createCacheB: () =>
+ *       new Cache(
+ *         new RedisCacheAdapter(client, {
+ *           serde,
+ *         }),
+ *         {
+ *           rootGroup: "@b",
+ *           eventBus,
+ *         }
+ *       ),
+ *     test,
+ *     beforeEach,
+ *     expect,
+ *     describe,
+ *   });
+ * });
+ * ```
+ */
 export declare function cacheTestSuite(settings: CacheTestSuiteSettings): void;

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

@@ -3,13 +3,14 @@
  */
 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 { type ISerde } from "../../../../serde/contracts/_module";
+import type { IDeinitizable, IInitizable, OneOrMore } from "../../../../utilities/_module";
 import { TimeSpan } from "../../../../utilities/_module";
 /**
  * @internal
  */
 type KyselySqliteCacheTable = {
+    group: string;
     key: string;
     value: string;
     expiresAt: number | null;
@@ -24,32 +25,37 @@ type KyselySqliteTables = {
  * @internal
  */
 type KyselySqliteSettings = {
-    serializer: ISerializer<string>;
+    serde: ISerde<string>;
     enableTransactions: boolean;
     expiredKeysRemovalInterval?: TimeSpan;
     shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
 };
 /**
  * @internal
  */
 export declare class KyselySqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly db;
-    private readonly serializer;
+    private readonly group;
+    private readonly serde;
     private readonly enableTransactions;
     private readonly expiredKeysRemovalInterval;
     private readonly shouldRemoveExpiredKeys;
     private timeoutId;
     constructor(db: Kysely<KyselySqliteTables>, settings: KyselySqliteSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     private withTransaction;
     removeExpiredKeys(): Promise<void>;
     init(): Promise<void>;
     deInit(): Promise<void>;
+    exists(key: string): Promise<boolean>;
     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>;
+    clear(): Promise<void>;
 }
 export {};

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

@@ -1,47 +1,60 @@
 /**
  * @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 { ISerde } from "../../../../serde/contracts/_module";
+import type { TimeSpan, IDeinitizable, IInitizable, OneOrMore } from "../../../../utilities/_module";
 import type { Client } from "@libsql/client";
 /**
  * @group Adapters
  */
 export type LibsqlCacheAdapterSettings = {
     tableName?: string;
-    serializer: ISerializer<string>;
+    serde: ISerde<string>;
     enableTransactions?: boolean;
     expiredKeysRemovalInterval?: TimeSpan;
     shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
 };
 /**
- * To utilize the <i>LibsqlCacheAdapter</i>, you must install the <i>"@libsql/client"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
+ * To utilize the <i>LibsqlCacheAdapter</i>, you must install the <i>"@libsql/client"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  * @example
  * ```ts
- * import { LibsqlCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
+ * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
  * import { createClient } from "@libsql/client";
  *
  * const client = createClient({ url: "file:local.db" });
- * const serializer = new SuperJsonSerializer();
+ * const serde = new SuperJsonSerde();
  * const cacheAdapter = new LibsqlCacheAdapter(client, {
- *   serializer,
+ *   serde,
+ *   rootGroup: "@global"
  * });
+ *
+ * (async () => {
+ *   // You only need to call it once before using the adapter.
+ *   await cacheAdapter.init();
+ *   await cacheAdapter.add("a", 1);
+ *
+ *   // Will remove the cache
+ *   await cacheAdapter.deInit();
+ * })();
  * ```
  */
 export declare class LibsqlCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly cacheAdapter;
     constructor(client: Client, settings: LibsqlCacheAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     removeExpiredKeys(): Promise<void>;
     deInit(): Promise<void>;
     init(): Promise<void>;
+    exists(key: string): Promise<boolean>;
     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>;
+    clear(): Promise<void>;
 }