@daiso-tech/core 0.13.0 → 0.15.0

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

@@ -3,24 +3,6 @@
  */
 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
  */
@@ -28,69 +10,38 @@ 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"];
+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 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
  */
@@ -15,35 +15,37 @@ export type CacheAdapterTestSuiteSettings = {
     createAdapter: () => 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 { SuperJsonSerializer, 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 serializer = new SuperJsonSerializer();
+ *   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,
+ *     createAdapter: () =>
+ *       new RedisCacheAdapter(client, {
+ *         serializer,
+ *       }),
+ *     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 { SuperJsonSerializer, 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 serializer = new SuperJsonSerializer();
+ *   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, {
+ *           serializer,
+ *         }),
+ *         {
+ *           rootNamespace: "@a",
+ *           eventBus,
+ *         }
+ *       ),
+ *     createCacheB: () =>
+ *       new Cache(
+ *         new RedisCacheAdapter(client, {
+ *           serializer,
+ *         }),
+ *         {
+ *           rootNamespace: "@b",
+ *           eventBus,
+ *         }
+ *       ),
+ *     test,
+ *     beforeEach,
+ *     expect,
+ *     describe,
+ *   });
+ * });
+ * ```
+ */
 export declare function cacheTestSuite(settings: CacheTestSuiteSettings): void;

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

@@ -1,5 +1,6 @@
 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/no-op-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/kysely-sqlite-cache-adapter.d.ts

@@ -4,7 +4,7 @@
 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 { IDeinitizable, IInitizable } from "../../../../utilities/_module";
 import { TimeSpan } from "../../../../utilities/_module";
 /**
  * @internal

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

@@ -1,27 +1,46 @@
 /**
  * @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 { TimeSpan, IDeinitizable, IInitizable } from "../../../../utilities/_module";
 import type { Client } from "@libsql/client";
 /**
  * @group Adapters
  */
 export type LibsqlCacheAdapterSettings = {
     tableName?: string;
-    serializer?: ISerializer<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 {
     private readonly cacheAdapter;
-    constructor(client: Client, settings?: LibsqlCacheAdapterSettings);
+    constructor(client: Client, settings: LibsqlCacheAdapterSettings);
     removeExpiredKeys(): Promise<void>;
     deInit(): Promise<void>;
     init(): Promise<void>;

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

@@ -4,7 +4,22 @@
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import type { TimeSpan } from "../../../../utilities/_module";
 /**
+ * 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> {
     private readonly map;

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

@@ -2,8 +2,7 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan } from "../../../../utilities/_module";
-import type { IInitizable } from "../../../../_shared/types";
+import type { TimeSpan, IInitizable } from "../../../../utilities/_module";
 import type { ObjectId } from "mongodb";
 import { type Collection } from "mongodb";
 import type { ISerializer } from "../../../../serializer/contracts/_module";
@@ -20,16 +19,33 @@ export type MongodbCacheDocument = {
  * @group Adapters
  */
 export type MongodbCacheAdapterSettings = {
-    serializer?: ISerializer<string>;
+    serializer: ISerializer<string>;
 };
 /**
+ * To utilize the <i>MongodbCacheAdapter</i>, you must install the <i>"mongodb"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
  * @group Adapters
+ * @example
+ * ```ts
+ * import { MongodbCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
+ * import { MongoClient } from "mongodb";
+ *
+ * const client = new MongoClient("YOUR_MONGODB_CONNECTION_STRING");
+ * const database = client.db("database");
+ * const cacheCollection = database.collection("cache");
+ * const serializer = new SuperJsonSerializer();
+ * const cacheAdapter = new MongodbCacheAdapter(cacheCollection, {
+ *   serializer,
+ * });
+ *   // You only need to call it once before using the adapter.
+ *   await cacheAdapter.init();
+ *   await cacheAdapter.add("a", 1);
+ * ```
  */
 export declare class MongodbCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable {
     private readonly collection;
     private static isMongodbIncrementError;
     private serializer;
-    constructor(collection: Collection<MongodbCacheDocument>, { serializer, }?: MongodbCacheAdapterSettings);
+    constructor(collection: Collection<MongodbCacheDocument>, { serializer }: MongodbCacheAdapterSettings);
     init(): Promise<void>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * @module Cache
+ */
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { TimeSpan } from "../../../../utilities/_module";
+/**
+ * This <i>NoOpCacheAdapter</i> will do nothing and is used for easily mocking {@link ICacheAdapter} for testing.
+ * @group Adapters
+ */
+export declare class NoOpCacheAdapter<TType> implements ICacheAdapter<TType> {
+    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/redis-cache-adapter/redis-cache-adapter.d.ts

@@ -16,16 +16,28 @@ declare module "ioredis" {
  * @group Adapters
  */
 export type RedisCacheAdapterSettings = {
-    serializer?: ISerializer<string>;
+    serializer: ISerializer<string>;
 };
 /**
+ * To utilize the <i>RedisCacheAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
  * @group Adapters
+ * @example
+ * ```ts
+ * import { RedisCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
+ * import Redis from "ioredis";
+ *
+ * const client = new Redis("YOUR_REDIS_CONNECTION_STRING");
+ * const serializer = new SuperJsonSerializer();
+ * const cacheAdapter = new RedisCacheAdapter(client, {
+ *   serializer,
+ * });
+ * ```
  */
 export declare class RedisCacheAdapter<TType> implements ICacheAdapter<TType> {
     private readonly client;
     private static isRedisTypeError;
     private serializer;
-    constructor(client: Redis, { serializer, }?: RedisCacheAdapterSettings);
+    constructor(client: Redis, { serializer }: RedisCacheAdapterSettings);
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -1,23 +1,40 @@
 /**
  * @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 { TimeSpan, IInitizable, IDeinitizable } from "../../../../utilities/_module";
 import { type Database } from "better-sqlite3";
 /**
  * @group Adapters
  */
 export type SqliteStorageAdapterSettings = {
     tableName?: string;
-    serializer?: ISerializer<string>;
+    serializer: ISerializer<string>;
     enableTransactions?: boolean;
     expiredKeysRemovalInterval?: TimeSpan;
     shouldRemoveExpiredKeys?: boolean;
 };
 /**
+ * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
  * @group Adapters
+ * @example
+ * ```ts
+ * import { SqliteCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
+ * import Sqlite from "better-sqlite3";
+ *
+ * const client = new Sqlite("local.db");
+ * const serializer = new SuperJsonSerializer();
+ * const cacheAdapter = new SqliteCacheAdapter(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 SqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly cacheAdapter;

package/dist/types/cache/implementations/derivables/base-cache.d.ts

@@ -1,35 +1,36 @@
 /**
  * @module Cache
  */
-import type { CacheEventNames, WithTtlValue } from "../../../cache/contracts/_module";
+import type { WithTtlValue } from "../../../cache/contracts/_module";
 import { type ICache } from "../../../cache/contracts/_module";
-import { type INamespacedCache, type AllCacheEvents } from "../../../cache/contracts/_module";
-import type { OneOrMore } from "../../../_shared/types";
-import { type AsyncLazyable, type GetOrAddValue } from "../../../_shared/types";
+import { type INamespacedCache, type CacheEvents } from "../../../cache/contracts/_module";
+import type { OneOrMore } from "../../../utilities/_module";
+import { type AsyncLazyable, type GetOrAddValue } from "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
-import { LazyPromise } from "../../../utilities/_module";
-import type { Listener, SelectEvent, Unsubscribe, INamespacedEventBus } from "../../../event-bus/contracts/_module";
+import { LazyPromise } from "../../../async/_module";
+import type { Listener, Unsubscribe, INamespacedEventBus, SelectEvent } from "../../../event-bus/contracts/_module";
 /**
  * @group Derivables
  */
 export type BaseCacheSettings<TType> = {
     namespace: string;
-    eventBus: INamespacedEventBus<AllCacheEvents<TType>>;
+    eventBus: INamespacedEventBus<CacheEvents<TType>>;
 };
 /**
  * The BaseCache class serves as an abstract base class that provides implementations for redundant methods.
  * It simplifies implementing the {@link INamespacedCache} interface without using an {@link ICacheAdapter}.
  * @group Derivables
  */
-export declare abstract class BaseCache<TType = unknown> implements INamespacedCache<TType> {
+export declare abstract class BaseCache<TType> implements INamespacedCache<TType> {
+    protected static createLayPromise<TValue = void>(asyncFn: () => PromiseLike<TValue>): LazyPromise<TValue>;
     private readonly listenable;
     constructor(settings: BaseCacheSettings<TType>);
-    addListener<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
-    addListenerMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
-    removeListener<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
-    removeListenerMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
-    subscribe<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
-    subscribeMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    addListener<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    addListenerMany<TEventName extends keyof CacheEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    removeListener<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    removeListenerMany<TEventName extends keyof CacheEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<void>;
+    subscribe<TEventName extends keyof CacheEvents>(eventName: TEventName, listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventName extends keyof CacheEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<CacheEvents, TEventName>>): LazyPromise<Unsubscribe>;
     abstract withNamespace(namespace: OneOrMore<string>): ICache<TType>;
     abstract getNamespace(): string;
     exists(key: string): LazyPromise<boolean>;

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

@@ -1,11 +1,13 @@
 /**
  * @module Cache
  */
+import type { CacheEvents } from "../../../cache/contracts/_module";
 import { type ICache, type ICacheAdapter } from "../../../cache/contracts/_module";
-import { type INamespacedCache, type AllCacheEvents } from "../../../cache/contracts/_module";
-import type { OneOrMore } from "../../../_shared/types";
+import { type INamespacedCache } from "../../../cache/contracts/_module";
+import type { OneOrMore } from "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
-import { LazyPromise } from "../../../utilities/_module";
+import type { LazyPromiseSettings } from "../../../async/_module";
+import type { LazyPromise } from "../../../async/_module";
 import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
 import { BaseCache } from "../../../cache/implementations/derivables/base-cache";
 /**
@@ -43,11 +45,12 @@ export type CacheSettings<TType> = {
     /**
      * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
      */
-    eventBus?: INamespacedEventBus<AllCacheEvents<TType>>;
+    eventBus?: INamespacedEventBus<CacheEvents<TType>>;
     /**
      * You can decide the default ttl value. If null is passed then no ttl will be used by default.
      */
     defaultTtl?: TimeSpan | null;
+    lazyPromiseSettings?: LazyPromiseSettings;
 };
 /**
  * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.