@daiso-tech/core 0.26.1 → 0.28.0

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

@@ -1,28 +1,32 @@
 /**
  * @module Cache
  */
-import type { CacheEvents, WithTtlValue } from "../../../../cache/contracts/_module-exports.js";
+import type { CacheEvents, IDatabaseCacheAdapter } from "../../../../cache/contracts/_module-exports.js";
 import { type ICache, type ICacheAdapter } from "../../../../cache/contracts/_module-exports.js";
 import { type IGroupableCache } from "../../../../cache/contracts/_module-exports.js";
-import type { AsyncLazyable, GetOrAddValue, Invokable, OneOrMore } from "../../../../utilities/_module-exports.js";
-import type { TimeSpan } from "../../../../utilities/_module-exports.js";
-import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
+import { type AsyncLazyable, type Invokable, type OneOrMore } from "../../../../utilities/_module-exports.js";
+import { type NoneFunction, type TimeSpan, type Factoryable } from "../../../../utilities/_module-exports.js";
+import type { LazyPromiseSettingsBase } from "../../../../async/_module-exports.js";
 import { LazyPromise } from "../../../../async/_module-exports.js";
 import type { IGroupableEventBus, Unsubscribe, EventClass, EventInstance } from "../../../../event-bus/contracts/_module-exports.js";
+import type { IKeyPrefixer, Items } from "../../../../utilities/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/cache"```
  * @group Derivables
  */
-export type CacheSettings = {
-    adapter: ICacheAdapter<any>;
+export type CacheSettingsBase = LazyPromiseSettingsBase & {
+    keyPrefixer: IKeyPrefixer;
     /**
      * @default
      * ```ts
+     * import { EventBus } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
      * new EventBus({
-     *   adapter: new MemoryEventBusAdapter({
-     *     rootGroup: "@global"
-     *   })
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
+     *   adapter: new MemoryEventBusAdapter()
      * })
      * ```
      */
@@ -32,619 +36,377 @@ export type CacheSettings = {
      * @default {null}
      */
     defaultTtl?: TimeSpan | null;
-    /**
-     * The default retry attempt to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    retryAttempts?: number | null;
-    /**
-     * The default backof policy to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    backoffPolicy?: BackoffPolicy | null;
-    /**
-     * The default retry policy to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    retryPolicy?: RetryPolicy | null;
-    /**
-     * The default timeout to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    timeout?: TimeSpan | null;
 };
 /**
- * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * @group Derivables
+ */
+export type CacheAdapterFactoryable<TType> = Factoryable<string, ICacheAdapter<TType> | IDatabaseCacheAdapter<TType>>;
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * @group Derivables
+ */
+export type CacheSettings = CacheSettingsBase & {
+    adapter: CacheAdapterFactoryable<any>;
+};
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/cache"```
  * @group Derivables
  */
 export declare class Cache<TType = unknown> implements IGroupableCache<TType> {
+    private static resolveCacheAdapter;
+    private static resolveCacheAdapterFactoryable;
     private static defaultRetryPolicy;
     private readonly groupdEventBus;
     private readonly eventBus;
-    private readonly adapter;
+    private readonly adapterFactoryable;
+    private readonly adapterPromise;
     private readonly defaultTtl;
     private readonly retryAttempts;
     private readonly backoffPolicy;
     private readonly retryPolicy;
-    private readonly timeout;
+    private readonly retryTimeout;
+    private readonly totalTimeout;
+    private readonly keyPrefixer;
     /**
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     * ```
-     */
-    constructor(settings: CacheSettings);
-    private createLayPromise;
-    /**
-     * You can listen to different events of <i>Cache</i> class instance.
      *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { SqliteCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
+     * import Sqlite from "better-sqlite3";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const cacheAdapter = new SqliteCacheAdapter({
+     *   database,
+     *   serde,
      * });
+     * // You need initialize the adapter once before using it.
+     * await cacheAdapter.init();
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListener(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
+     * const cache = new Cache({
+     *   keyPrefixer: new KeyPrefixer("cache"),
+     *   adapter: cacheAdapter,
+     * });
      * ```
-     */
-    addListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of <i>Cache</i> class instance.
      *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
+     * You can pass factory function that will create an adapter for every group.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { SqliteCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import type { ICacheAdapter } from "@daiso-tech/core/cache/contracts";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import type { ISerde } from "@daiso-tech/core/serde/contracts";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
+     * import Sqlite from "better-sqlite3";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { KeyPrefixer, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
+     *
+     * function cahceAdapterFactory(database: ISqliteDatabase, serde: ISerde<string>): FactoryFn<string, ICacheAdapter> {
+     *   return async (prefix) => {
+     *     const cacheAdapter = new SqliteCacheAdapter({
+     *       database,
+     *       serde,
+     *       tableName: `cache_${prefix}`
+     *     });
+     *     await cacheAdapter.init();
+     *     return cacheAdapter;
+     *   }
+     * }
+     *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const cache = new Cache({
+     *   keyPrefixer: new KeyPrefixer("cache"),
+     *   adapter: cahceAdapterFactory(database, serde),
      * });
-     *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
-     * await cache.add("a", 1);
      * ```
-     */
-    addListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of <i>Cache</i> class instance.
      *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
+     * You can also pass factory object that implements <i>{@link IFactoryObject}</i> contract. This useful for depedency injection libraries.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { SqliteCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import type { ICacheAdapter } from "@daiso-tech/core/cache/contracts";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import type { ISerde } from "@daiso-tech/core/serde/contracts";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
+     * import Sqlite from "better-sqlite3";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { KeyPrefixer, type ISqliteDatabase, type IFactoryObject, type Promiseable } from "@daiso-tech/core/utilities";
+     *
+     * class CahceAdapterFactory implements IFactoryObject<string, ICacheAdapter> {
+     *   constructor(private readonly database: ISqliteDatabase, private readonly serde: ISerde<string>) {}
+     *
+     *   async use(prefix: string): Promiseable<ICacheAdapter> {
+     *     const cacheAdapter = new SqliteCacheAdapter({
+     *       database: this.database,
+     *       serde: this.serde,
+     *       tableName: `cache_${prefix}`
+     *     });
+     *     await cacheAdapter.init();
+     *     return cacheAdapter;
+     *   }
+     * }
+     *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const cache = new Cache({
+     *   keyPrefixer: new KeyPrefixer("cache"),
+     *   adapter: new CahceAdapterFactory(database, serde),
      * });
-     *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListener(KeyAddedCacheEvent, listener);
-     * await cache.removeListener(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
      * ```
      */
-    removeListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    constructor(settings: CacheSettings);
     /**
-     * You can listen to different events of <i>Cache</i> class instance.
-     *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
-     * await cache.removeListenerMany(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
-     * ```
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    removeListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListener<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * You can listen to different events of <i>Cache</i> class instance.
-     *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.listenOnce(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
-     * ```
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    listenOnce<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    asPromise<TEventClass extends EventClass<CacheEvents>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
+    addListenerMany<TEventClassArr extends EventClass<CacheEvents<TType>>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
     /**
-     * You can listen to different events of <i>Cache</i> class instance.
-     *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
-     * await unsubscribe();
-     * ```
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    subscribe<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    removeListener<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * You can listen to different events of <i>Cache</i> class instance.
-     *
-     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * const unsubscribe = await cache.subscribeMany([KeyAddedCacheEvent], listener);
-     * await cache.add("a", 1);
-     * await unsubscribe();
-     * ```
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    subscribeMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    removeListenerMany<TEventClassArr extends EventClass<CacheEvents<TType>>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
     /**
-     * @example
-     * ```ts
-     * import type { IGroupableCache, ICache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * // Will print "@global"
-     * console.log(cache.getGroup());
-     *
-     * const groupedCache: ICache = cache.withGroup("company-1");
-     *
-     * // Will print "@global/company-1"
-     * console.log(groupedCache.getGroup());
-     * ```
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    withGroup(group: OneOrMore<string>): ICache<TType>;
+    listenOnce<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * // Will print "@global"
-     * console.log(cache.getGroup());
-     * ```
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    getGroup(): string;
-    get(key: string): LazyPromise<TType | null>;
-    add(key: string, value: TType, 
+    asPromise<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
     /**
-     * @default null
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    ttl?: TimeSpan | null): LazyPromise<boolean>;
-    update(key: string, value: TType): LazyPromise<boolean>;
-    put(key: string, value: TType, 
+    subscribe<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
     /**
-     * @default null
+     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    ttl?: TimeSpan | null): LazyPromise<boolean>;
-    remove(key: string): LazyPromise<boolean>;
-    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
-    clear(): LazyPromise<void>;
-    exists(key: string): LazyPromise<boolean>;
-    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
-    missing(key: string): LazyPromise<boolean>;
-    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
-    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
+    subscribeMany<TEventClassArr extends EventClass<CacheEvents<TType>>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<Unsubscribe>;
+    private createLazyPromise;
+    exists(key: OneOrMore<string>): LazyPromise<boolean>;
+    missing(key: OneOrMore<string>): LazyPromise<boolean>;
+    get(key: OneOrMore<string>): LazyPromise<TType | null>;
+    getOrFail(key: OneOrMore<string>): LazyPromise<TType>;
+    getAndRemove(key: OneOrMore<string>): LazyPromise<TType | null>;
     /**
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOr("a", -1);
-     * // -1
-     * console.log(result);
+     * const value = await cache.getOr("a", 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      *
-     * You can pass function as default value.
+     * You can also pass in a function
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOr("a", () => -1);
-     * // -1
-     * console.log(result);
+     * const value = await cache.getOr("a", () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      *
-     * You can pass async function as default value.
+     * You can also pass in a async function. This is useful because it allows for retrieval of external data if the key doesnt't.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOr("a", async () => -1);
-     * // -1
-     * console.log(result);
+     * const value = await cache.getOr("a", async () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      *
-     * You can pass <i>{@link LazyPromise}</i> as default value.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer, LazyPromise } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOr("a", new LazyPromise(async () => -1));
-     * // -1
-     * console.log(result);
+     * const value = await cache.getOr("a", new LazyPromise(async () => 1));
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      */
-    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
+    getOr(key: OneOrMore<string>, defaultValue: AsyncLazyable<NoneFunction<TType>>): LazyPromise<TType>;
     /**
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOrMany({ a: -1 });
-     * // { a: -1 }
-     * console.log(result);
+     * const value = await cache.getOrAdd("a", 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      *
-     * You can pass function as default value.
+     * You can also pass in a function
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOrMany({ a: () => -1 });
-     * // { a: -1 }
-     * console.log(result);
+     * const value = await cache.getOrAdd("a", () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      *
-     * You can pass async function as default value.
+     * You can also pass in a async function. This is useful because it allows for retrieval of external data if the key doesnt't.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOrMany({ a: async () => -1 });
-     * // { a: -1 }
-     * console.log(result);
+     * const value = await cache.getOrAdd("a", async () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      *
-     * You can pass <i>{@link LazyPromise}</i> as default value.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer, LazyPromise } from "@daiso-tech/core/utilities";
      *
-     * const result = await cache.getOrMany({ a: new LazyPromise(async () => - 1) });
-     * // { a: -1 }
-     * console.log(result);
-     * ```
-     */
-    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
-    /**
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * await cache.add("a", 1);
-     *
-     * const result1 = await cache.getOrFail("a");
-     * // Will print 1
-     * console.log(result1);
+     * const value = await cache.getOrAdd("a", new LazyPromise(async () => 1));
      *
-     * await cache.remove("a");
-     *
-     * // Will throw an error
-     * await cache.getOrFail("a");
+     * // Will be 1
+     * console.log(value);
      * ```
      */
-    getOrFail(key: string): LazyPromise<TType>;
-    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
-    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
-    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
-    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    getOrAdd(key: OneOrMore<string>, valueToAdd: AsyncLazyable<NoneFunction<TType>>, ttl?: TimeSpan | null): LazyPromise<TType>;
+    add(key: OneOrMore<string>, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    put(key: OneOrMore<string>, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    update(key: OneOrMore<string>, value: TType): LazyPromise<boolean>;
+    increment(key: OneOrMore<string>, value?: Extract<TType, number>): LazyPromise<boolean>;
+    decrement(key: OneOrMore<string>, value?: Extract<TType, number>): LazyPromise<boolean>;
+    remove(key: OneOrMore<string>): LazyPromise<boolean>;
+    removeMany(keys: Iterable<OneOrMore<string>>): LazyPromise<boolean>;
+    clear(): LazyPromise<void>;
     /**
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const result1 = await cache.getAndRemove("a");
-     * // Will print null
-     * console.log(result1);
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
+     * });
      *
-     * await cache.add("a", 2)
+     * // Will log null because the cache is not in a group
+     * console.log(cache.getGroup());
      *
-     * const result2 = await cache.getAndRemove("a");
-     * // Will print 2
-     * console.log(result2);
+     * const groupedCache = cache.withGroup("group-a");
      *
-     * const result3 = await cache.get("a");
-     * // Will print null
-     * console.log(result3);
+     * // Will log "group-a" because the groupedCache is in a group
+     * console.log(groupedCache.getGroup());
      * ```
      */
-    getAndRemove(key: string): LazyPromise<TType | null>;
+    getGroup(): string | null;
     /**
      * @example
      * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * const result = await cache.getOrAdd("a", -1);
-     * // -1
-     * console.log(result);
-     * ```
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * You can pass function as default value.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const result = await cache.getOrAdd("a", () => -1);
-     * // -1
-     * console.log(result);
-     * ```
+     * const groupedCache = cache.withGroup("group-a");
+     * await groupedCache.add("a", 1);
      *
-     * You can pass async function as default value.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
+     * // Will log "a".
+     * console.log(await groupedCache.get("a"));
      *
-     * const result = await cache.getOrAdd("a", async () => -1);
-     * // -1
-     * console.log(result);
-     * ```
-     *
-     * You can pass <i>{@link LazyPromise}</i> as default value.
-     * @example
-     * ```ts
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     * });
-     *
-     * const result = await cache.getOrAdd("a", new LazyPromise(async () => -1));
-     * // -1
-     * console.log(result);
+     * // Will log null because the caches are in different groups.
+     * console.log(await cache.get("a"));
      * ```
      */
-    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, 
-    /**
-     * @default {null}
-     */
-    ttl?: TimeSpan): LazyPromise<TType>;
-    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    withGroup(group: OneOrMore<string>): ICache<TType>;
 }