@daiso-tech/core 0.15.0 → 0.17.4

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

@@ -1,47 +1,161 @@
 /**
  * @module Cache
  */
+import { BaseEvent } from "../../event-bus/contracts/_module";
+import type { IFlexibleSerde } from "../../serde/contracts/_module";
 import type { TimeSpan } from "../../utilities/_module";
-import type { ICacheAdapter } from "../../cache/contracts/cache-adapter.contract";
-/**
- * @group Events
- */
-export type CacheEvent = {
-    namespace: string;
-    adapter: ICacheAdapter<any>;
-};
-/**
- * This event will be triggered when cache is cleared.
- * @group Events
- */
-export type KeysClearedCacheEvent = CacheEvent & {};
-export type CacheEvents<TType = unknown> = {
-    key_found: CacheEvent & {
-        key: string;
-        value: TType;
-    };
-    key_not_found: CacheEvent & {
-        key: string;
-    };
-    key_added: CacheEvent & {
-        key: string;
-        value: TType;
-        ttl: TimeSpan | null;
-    };
-    key_updated: CacheEvent & {
-        key: string;
-        value: TType;
-    };
-    key_removed: CacheEvent & {
-        key: string;
-    };
-    key_incremented: CacheEvent & {
-        key: string;
-        value: number;
-    };
-    key_decremented: CacheEvent & {
-        key: string;
-        value: number;
-    };
-    keys_cleared: CacheEvent;
+/**
+ * @group Events
+ */
+export type KeyFoundCacheEventFields<TType> = {
+    group: string;
+    key: string;
+    value: TType;
+};
+/**
+ * @group Events
+ */
+export declare class KeyFoundCacheEvent<TType = unknown> extends BaseEvent<KeyFoundCacheEventFields<TType>> {
+    group: string;
+    key: string;
+    value: TType;
+    static deserialize<TType>(serializedEvent: KeyFoundCacheEventFields<TType>): KeyFoundCacheEvent<TType>;
+    constructor(fields: KeyFoundCacheEventFields<TType>);
+    serialize(): KeyFoundCacheEventFields<TType>;
+}
+/**
+ * @group Events
+ */
+export type KeyNotFoundCacheEventFields = {
+    group: string;
+    key: string;
+};
+/**
+ * @group Events
+ */
+export declare class KeyNotFoundCacheEvent extends BaseEvent<KeyNotFoundCacheEventFields> {
+    group: string;
+    key: string;
+    static deserialize(serializedEvent: KeyNotFoundCacheEventFields): KeyNotFoundCacheEvent;
+    constructor(fields: KeyNotFoundCacheEventFields);
+    serialize(): KeyNotFoundCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeyAddedCacheEventFields<TType = unknown> = {
+    group: string;
+    key: string;
+    value: TType;
+    ttl: TimeSpan | null;
+};
+/**
+ * @group Events
+ */
+export declare class KeyAddedCacheEvent<TType = unknown> extends BaseEvent<KeyAddedCacheEventFields<TType>> {
+    group: string;
+    key: string;
+    value: TType;
+    ttl: TimeSpan | null;
+    static deserialize<TType>(serializedEvent: KeyAddedCacheEventFields<TType>): KeyAddedCacheEvent<TType>;
+    constructor(fields: KeyAddedCacheEventFields<TType>);
+    serialize(): KeyAddedCacheEventFields<TType>;
+}
+/**
+ * @group Events
+ */
+export type KeyUpdatedCacheEventFields<TType = unknown> = {
+    group: string;
+    key: string;
+    value: TType;
+};
+/**
+ * @group Events
+ */
+export declare class KeyUpdatedCacheEvent<TType = unknown> extends BaseEvent<KeyUpdatedCacheEventFields<TType>> {
+    group: string;
+    key: string;
+    value: TType;
+    static deserialize<TType>(serializedEvent: KeyUpdatedCacheEventFields<TType>): KeyUpdatedCacheEvent<TType>;
+    constructor(fields: KeyUpdatedCacheEventFields<TType>);
+    serialize(): KeyUpdatedCacheEventFields<TType>;
+}
+/**
+ * @group Events
+ */
+export type KeyRemovedCacheEventFields = {
+    group: string;
+    key: string;
 };
+/**
+ * @group Events
+ */
+export declare class KeyRemovedCacheEvent extends BaseEvent<KeyRemovedCacheEventFields> {
+    group: string;
+    key: string;
+    static deserialize(serializedEvent: KeyRemovedCacheEventFields): KeyRemovedCacheEvent;
+    constructor(fields: KeyRemovedCacheEventFields);
+    serialize(): KeyRemovedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeyIncrementedCacheEventFields = {
+    group: string;
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export declare class KeyIncrementedCacheEvent extends BaseEvent<KeyIncrementedCacheEventFields> {
+    group: string;
+    key: string;
+    value: number;
+    static deserialize(serializedEvent: KeyIncrementedCacheEventFields): KeyIncrementedCacheEvent;
+    constructor(fields: KeyIncrementedCacheEventFields);
+    serialize(): KeyIncrementedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeyDecrementedCacheEventFields = {
+    group: string;
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export declare class KeyDecrementedCacheEvent extends BaseEvent<KeyDecrementedCacheEventFields> {
+    group: string;
+    key: string;
+    value: number;
+    static deserialize(serializedEvent: KeyDecrementedCacheEventFields): KeyDecrementedCacheEvent;
+    constructor(fields: KeyDecrementedCacheEventFields);
+    serialize(): KeyDecrementedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeysClearedCacheEventFields = {
+    group: string;
+};
+/**
+ * @group Events
+ */
+export declare class KeysClearedCacheEvent extends BaseEvent<KeysClearedCacheEventFields> {
+    group: string;
+    static deserialize(serializedEvent: KeysClearedCacheEventFields): KeysClearedCacheEvent;
+    constructor(fields: KeysClearedCacheEventFields);
+    serialize(): KeysClearedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type CacheEvents<TType = unknown> = KeyFoundCacheEvent<TType> | KeyNotFoundCacheEvent | KeyAddedCacheEvent<TType> | KeyUpdatedCacheEvent<TType> | KeyRemovedCacheEvent | KeyIncrementedCacheEvent | KeyDecrementedCacheEvent | KeysClearedCacheEvent;
+/**
+ * The <i>registerCacheEvents</i> function is used to register all cache events with a <i>{@link IFlexibleSerde}</i>.
+ * @group Events
+ */
+export declare function registerCacheEvents<TSerializedValue>(serde: IFlexibleSerde<TSerializedValue>): void;

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

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

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

@@ -12,7 +12,8 @@ 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> with <i>vitest</i>.
@@ -22,25 +23,33 @@ export type CacheAdapterTestSuiteSettings = {
  * import Redis from "ioredis";
  * import { afterEach, beforeEach, describe, expect, test } from "vitest";
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
- * import { SuperJsonSerializer, TimeSpan, RedisCacheAdapter, cacheAdapterTestSuite } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheAdapterTestSuite } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: RedisCacheAdapter", () => {
- *   let client: Redis;
+ *   let database: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const serializer = new SuperJsonSerializer();
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer("redis:7.4.2").start();
- *     client = new Redis(startedContainer.getConnectionUrl());
- *   }, timeout.toMilliseconds());
+ *     database = new Redis(startedContainer.getConnectionUrl());
+ *   }, TIMEOUT.toMilliseconds());
  *   afterEach(async () => {
- *     await client.quit();
+ *     await database.quit();
  *     await startedContainer.stop();
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *   cacheAdapterTestSuite({
- *     createAdapter: () =>
- *       new RedisCacheAdapter(client, {
- *         serializer,
+ *     createAdapterA: () =>
+ *       new RedisCacheAdapter({
+ *         database,
+ *         serde,
+ *         rootGroup: "@a"
+ *       }),
+ *     createAdapterB: () =>
+ *       new RedisCacheAdapter({
+ *         database,
+ *         serde,
+ *         rootGroup: "@b"
  *       }),
  *     test,
  *     beforeEach,

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

@@ -23,40 +23,46 @@ export type CacheTestSuiteSettings = {
  * import Redis from "ioredis";
  * import { afterEach, beforeEach, describe, expect, test } from "vitest";
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
- * import { SuperJsonSerializer, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: Cache", () => {
- *   let client: Redis;
+ *   let database: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const eventBus = new EventBus(new MemoryEventBusAdapter()):
- *   const serializer = new SuperJsonSerializer();
+ *   const eventBus = new EventBus({
+ *     adapter: new MemoryEventBusAdapter({
+ *       rootGroup: "@global"
+ *     })
+ *   }):
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer("redis:7.4.2").start();
- *     client = new Redis(startedContainer.getConnectionUrl());
- *   }, timeout.toMilliseconds());
+ *     database = new Redis(startedContainer.getConnectionUrl());
+ *   }, TIMEOUT.toMilliseconds());
  *   afterEach(async () => {
- *     await client.quit();
+ *     await database.quit();
  *     await startedContainer.stop();
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *   cacheTestSuite({
  *     createCacheA: () =>
  *       new Cache(
- *         new RedisCacheAdapter(client, {
- *           serializer,
+ *         new RedisCacheAdapter({
+ *           database,
+ *           serde,
  *         }),
  *         {
- *           rootNamespace: "@a",
+ *           rootGroup: "@a",
  *           eventBus,
  *         }
  *       ),
  *     createCacheB: () =>
  *       new Cache(
- *         new RedisCacheAdapter(client, {
- *           serializer,
+ *         new RedisCacheAdapter({
+ *           database,
+ *           serde,
  *         }),
  *         {
- *           rootNamespace: "@b",
+ *           rootGroup: "@b",
  *           eventBus,
  *         }
  *       ),

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 "../../../../utilities/_module";
+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,38 @@ type KyselySqliteTables = {
  * @internal
  */
 type KyselySqliteSettings = {
-    serializer: ISerializer<string>;
+    db: Kysely<KyselySqliteTables>;
+    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;
+export declare class KyselySqliteCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly group;
+    private readonly serde;
     private readonly enableTransactions;
     private readonly expiredKeysRemovalInterval;
     private readonly shouldRemoveExpiredKeys;
     private timeoutId;
-    constructor(db: Kysely<KyselySqliteTables>, settings: KyselySqliteSettings);
+    private readonly db;
+    constructor(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/_module.d.ts

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

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

@@ -0,0 +1,48 @@
+/**
+ * @module Cache
+ */
+import type { ISerde } from "../../../../serde/contracts/_module";
+import type { TimeSpan, OneOrMore, IBuildable } from "../../../../utilities/_module";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlCacheAdapterSettings = {
+    database: Client;
+    tableName?: string;
+    serde: ISerde<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
+};
+/**
+ * The <i>LibsqlCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class LibsqlCacheAdapterSettingsBuilder<TSettings extends Partial<LibsqlCacheAdapterSettings>> implements IBuildable<LibsqlCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setDatabase(database: Client): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        database: Client;
+    }>;
+    setTableName(name: string): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        tableName: string;
+    }>;
+    setSerde(serde: ISerde<string>): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        serde: ISerde<string>;
+    }>;
+    setEnableTransactions(enable: boolean): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        enableTransactions: boolean;
+    }>;
+    setExpiredKeysRemovalInterval(interval: TimeSpan): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        expiredKeysRemovalInterval: TimeSpan;
+    }>;
+    setShouldRemoveExpiredKeys(shouldRemove: boolean): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        shouldRemoveExpiredKeys: boolean;
+    }>;
+    setRootGroup(group: OneOrMore<string>): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: LibsqlCacheAdapterSettingsBuilder<LibsqlCacheAdapterSettings>): LibsqlCacheAdapterSettings;
+}

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

@@ -2,53 +2,71 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
-import type { TimeSpan, IDeinitizable, IInitizable } from "../../../../utilities/_module";
-import type { Client } from "@libsql/client";
+import type { TimeSpan, IDeinitizable, IInitizable, OneOrMore } from "../../../../utilities/_module";
+import type { LibsqlCacheAdapterSettings } from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
+import { LibsqlCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
 /**
+ * To utilize the <i>LibsqlCacheAdapter</i>, you must install the <i>"@libsql/client"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
-export type LibsqlCacheAdapterSettings = {
-    tableName?: string;
-    serializer: ISerializer<string>;
-    enableTransactions?: boolean;
-    expiredKeysRemovalInterval?: TimeSpan;
-    shouldRemoveExpiredKeys?: boolean;
-};
-/**
- * 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>.
- * @group Adapters
- * @example
- * ```ts
- * import { LibsqlCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
- * import { createClient } from "@libsql/client";
- *
- * (async () => {
- *   const client = createClient({ url: "file:local.db" });
- *   const serializer = new SuperJsonSerializer();
- *   const cacheAdapter = new LibsqlCacheAdapter(client, {
- *     serializer,
- *   });
- *   // 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 {
+export declare class LibsqlCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    /**
+     * @example
+     * ```ts
+     * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { createClient } from "@libsql/client";
+     *
+     * const cacheAdapter = new LibsqlCacheAdapter(
+     *   LibsqlCacheAdapter
+     *     .settings()
+     *     .setDatabase(createClient({ url: "file:local.db" }))
+     *     .setSerde(new SuperJsonSerde())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<LibsqlCacheAdapterSettings>>(): LibsqlCacheAdapterSettingsBuilder<TSettings>;
     private readonly cacheAdapter;
-    constructor(client: Client, settings: LibsqlCacheAdapterSettings);
+    /***
+     * @example
+     * ```ts
+     * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { createClient } from "@libsql/client";
+     *
+     * const database = createClient({ url: "file:local.db" });
+     * const serde = new SuperJsonSerde();
+     * const cacheAdapter = new LibsqlCacheAdapter({
+     *   database,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     *
+     * (async () => {
+     *   await cacheAdapter.init();
+     *   await cacheAdapter.add("a", 1);
+     *   await cacheAdapter.deInit();
+     * })();
+     * ```
+     */
+    constructor(settings: LibsqlCacheAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     removeExpiredKeys(): Promise<void>;
+    /**
+     * Removes the table where the cache values are stored and removes the table indexes.
+     */
     deInit(): Promise<void>;
+    /**
+     * Creates the table where the cache values are stored and it's related indexes.
+     */
     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>;
 }

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

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

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

@@ -0,0 +1,27 @@
+/**
+ * @module Cache
+ */
+import type { IBuildable } from "../../../../utilities/_module";
+import { type OneOrMore } from "../../../../utilities/_module";
+/**
+ * @group Adapters
+ */
+export type MemoryCacheAdapterSettings = {
+    rootGroup: OneOrMore<string>;
+    map?: Map<string, unknown>;
+};
+/**
+ * The <i>MemoryCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class MemoryCacheAdapterSettingsBuilder<TSettings extends Partial<MemoryCacheAdapterSettings>> implements IBuildable<MemoryCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setMap(map: Map<string, unknown>): MemoryCacheAdapterSettingsBuilder<TSettings & {
+        map: Map<string, unknown>;
+    }>;
+    setRootGroup(group: OneOrMore<string>): MemoryCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: MemoryCacheAdapterSettingsBuilder<MemoryCacheAdapterSettings>): MemoryCacheAdapterSettings;
+}

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

@@ -2,34 +2,64 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan } from "../../../../utilities/_module";
+import { type OneOrMore, type TimeSpan } from "../../../../utilities/_module";
+import type { MemoryCacheAdapterSettings } from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
+import { MemoryCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
 /**
  * To utilize the <i>MemoryCacheAdapter</i>, you must create instance of it.
  * @group Adapters
- * @example
- * ```ts
- * import { MemoryCacheAdapter } from "@daiso-tech/core";
- *
- * const cacheAdapter = new MemoryCacheAdapter(client);
- * ```
- * You can also provide an <i>Map</i>.
- * @example
- * ```ts
- * import { MemoryCacheAdapter } from "@daiso-tech/core";
- *
- * const map = new Map<any, any>();
- * const cacheAdapter = new MemoryCacheAdapter(map);
- * ```
  */
-export declare class MemoryCacheAdapter<TType> implements ICacheAdapter<TType> {
+export declare class MemoryCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
+    /**
+     * @example
+     * ```ts
+     * import { MemoryCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     *
+     * const cacheAdapter = new MemoryCacheAdapter(
+     *   MemoryCacheAdapter
+     *     .settings()
+     *     .setMap(new Map())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<MemoryCacheAdapterSettings>>(): MemoryCacheAdapterSettingsBuilder<TSettings>;
+    private readonly group;
+    private readonly timeoutMap;
     private readonly map;
-    constructor(map?: Map<string, TType>);
-    private readonly timeoutIdMap;
+    /**
+     *  @example
+     * ```ts
+     * import { MemoryCacheAdapter } from "@daiso-tech/core";
+     *
+     * const cacheAdapter = new MemoryCacheAdapter({
+     *   rootGroup: "@cache"
+     * });
+     * ```
+     * You can also provide an <i>Map</i>.
+     * @example
+     * ```ts
+     * import { MemoryCacheAdapter } from "@daiso-tech/core";
+     *
+     * const map = new Map<any, any>();
+     * const cacheAdapter = new MemoryCacheAdapter({
+     *   rootGroup: "@cache",
+     *   map
+     * });
+     * ```
+     */
+    constructor(settings: MemoryCacheAdapterSettings);
+    private getGroupName;
+    private withPrefix;
+    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>;
+    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>;
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
 }