@daiso-tech/core 0.26.1 → 0.28.0

package/dist/cache/implementations/derivables/cache/cache.js

@@ -2,369 +2,520 @@
  * @module Cache
  */
 import { KeyFoundCacheEvent, KeyNotFoundCacheEvent, KeyAddedCacheEvent, KeyUpdatedCacheEvent, KeyRemovedCacheEvent, KeyIncrementedCacheEvent, KeyDecrementedCacheEvent, KeysClearedCacheEvent, UnexpectedCacheErrorEvent, } from "../../../../cache/contracts/_module-exports.js";
-import { KeyNotFoundCacheError, TypeCacheError, UnexpectedCacheError, } from "../../../../cache/contracts/_module-exports.js";
+import { KeyNotFoundCacheError, TypeCacheError, } from "../../../../cache/contracts/_module-exports.js";
 import {} from "../../../../cache/contracts/_module-exports.js";
-import { isObjectEmpty, resolveAsyncLazyable, resolveOneOrMoreStr, } from "../../../../utilities/_module-exports.js";
+import { isFactory, resolveAsyncLazyable, resolveFactoryable, } from "../../../../utilities/_module-exports.js";
+import {} from "../../../../utilities/_module-exports.js";
+import { KeyPrefixer, } from "../../../../utilities/_module-exports.js";
 import { LazyPromise } from "../../../../async/_module-exports.js";
 import { EventBus } from "../../../../event-bus/implementations/derivables/_module-exports.js";
 import { MemoryEventBusAdapter } from "../../../../event-bus/implementations/adapters/_module-exports.js";
+import { isDatabaseCacheAdapter } from "../../../../cache/implementations/derivables/cache/is-database-cache-adapter.js";
+import { DatabaseCacheAdapter } from "../../../../cache/implementations/derivables/cache/database-cache-adapter.js";
 /**
- * <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 class Cache {
+    static resolveCacheAdapter(adapter) {
+        if (isDatabaseCacheAdapter(adapter)) {
+            return new DatabaseCacheAdapter(adapter);
+        }
+        return adapter;
+    }
+    static async resolveCacheAdapterFactoryable(factoryable, rootPrefix) {
+        const adapter = await resolveFactoryable(factoryable, rootPrefix);
+        return Cache.resolveCacheAdapter(adapter);
+    }
     static defaultRetryPolicy = (error) => {
         return !(error instanceof TypeCacheError ||
             error instanceof KeyNotFoundCacheError);
     };
     groupdEventBus;
     eventBus;
-    adapter;
+    adapterFactoryable;
+    adapterPromise;
     defaultTtl;
     retryAttempts;
     backoffPolicy;
     retryPolicy;
-    timeout;
+    retryTimeout;
+    totalTimeout;
+    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";
+     * 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 cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   keyPrefixer: new KeyPrefixer("cache"),
+     *   adapter: cacheAdapter,
+     * });
+     * ```
+     *
+     * You can pass factory function that will create an adapter for every group.
+     * @example
+     * ```ts
+     * 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),
+     * });
+     * ```
+     *
+     * You can also pass factory object that implements <i>{@link IFactoryObject}</i> contract. This useful for depedency injection libraries.
+     * @example
+     * ```ts
+     * 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),
      * });
      * ```
      */
     constructor(settings) {
-        const { adapter, eventBus: groupdEventBus = new EventBus({
-            adapter: new MemoryEventBusAdapter({
-                rootGroup: "@global",
-            }),
-        }), defaultTtl = null, retryAttempts = null, backoffPolicy = null, retryPolicy = Cache.defaultRetryPolicy, timeout = null, } = settings;
+        const { keyPrefixer, adapter, eventBus: groupdEventBus = new EventBus({
+            keyPrefixer: new KeyPrefixer("event-bus"),
+            adapter: new MemoryEventBusAdapter(),
+        }), defaultTtl = null, retryAttempts = null, backoffPolicy = null, retryPolicy = Cache.defaultRetryPolicy, retryTimeout = null, totalTimeout = null, } = settings;
+        this.keyPrefixer = keyPrefixer;
         this.groupdEventBus = groupdEventBus;
-        this.eventBus = groupdEventBus.withGroup(adapter.getGroup());
-        this.adapter = adapter;
+        this.adapterFactoryable = adapter;
         this.defaultTtl = defaultTtl;
         this.retryAttempts = retryAttempts;
         this.backoffPolicy = backoffPolicy;
         this.retryPolicy = retryPolicy;
-        this.timeout = timeout;
+        this.retryTimeout = retryTimeout;
+        this.totalTimeout = totalTimeout;
+        this.eventBus = this.groupdEventBus.withGroup(this.keyPrefixer.resolvedRootPrefix);
+        if (this.keyPrefixer.resolvedGroup) {
+            this.eventBus = this.groupdEventBus.withGroup([
+                this.keyPrefixer.resolvedRootPrefix,
+                this.keyPrefixer.resolvedGroup,
+            ]);
+        }
+        this.adapterPromise = new LazyPromise(() => Cache.resolveCacheAdapterFactoryable(this.adapterFactoryable, this.keyPrefixer.keyPrefix));
+    }
+    /**
+     * 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>.
+     */
+    addListener(event, listener) {
+        return this.eventBus.addListener(event, listener);
     }
-    createLayPromise(asyncFn) {
-        return new LazyPromise(asyncFn)
-            .setRetryAttempts(this.retryAttempts)
-            .setBackoffPolicy(this.backoffPolicy)
-            .setRetryPolicy(this.retryPolicy)
-            .setTimeout(this.timeout);
+    /**
+     * 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>.
+     */
+    addListenerMany(events, listener) {
+        return this.eventBus.addListenerMany(events, listener);
     }
     /**
-     * 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.addListener(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>.
      */
-    addListener(eventName, listener) {
-        return this.eventBus.addListener(eventName, listener);
+    removeListener(event, listener) {
+        return this.eventBus.removeListener(event, listener);
+    }
+    /**
+     * 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(events, listener) {
+        return this.eventBus.removeListenerMany(events, listener);
+    }
+    /**
+     * 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(event, listener) {
+        return this.eventBus.listenOnce(event, listener);
+    }
+    /**
+     * 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>.
+     */
+    asPromise(event) {
+        return this.eventBus.asPromise(event);
+    }
+    /**
+     * 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(event, listener) {
+        return this.eventBus.subscribe(event, listener);
+    }
+    /**
+     * 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(events, listener) {
+        return this.eventBus.subscribeMany(events, listener);
+    }
+    createLazyPromise(asyncFn) {
+        return new LazyPromise(asyncFn, {
+            retryAttempts: this.retryAttempts,
+            backoffPolicy: this.backoffPolicy,
+            retryPolicy: this.retryPolicy,
+            retryTimeout: this.retryTimeout,
+            totalTimeout: this.totalTimeout,
+        });
+    }
+    exists(key) {
+        return new LazyPromise(async () => {
+            const value = await this.get(key);
+            return value !== null;
+        });
+    }
+    missing(key) {
+        return this.createLazyPromise(async () => {
+            const hasKey = await this.exists(key);
+            return !hasKey;
+        });
+    }
+    get(key) {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
+            try {
+                const adapter = await this.adapterPromise;
+                const value = await adapter.get(keyObj.prefixed);
+                if (value === null) {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
+                    }))
+                        .defer();
+                }
+                else {
+                    this.eventBus
+                        .dispatch(new KeyFoundCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
+                        value,
+                    }))
+                        .defer();
+                }
+                return value;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    keys: [keyObj.resolved],
+                    method: this.get.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    getOrFail(key) {
+        return this.createLazyPromise(async () => {
+            const value = await this.get(key);
+            if (value === null) {
+                throw new KeyNotFoundCacheError(`Key "${this.keyPrefixer.create(key).resolved}" is not found`);
+            }
+            return value;
+        });
+    }
+    getAndRemove(key) {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
+            try {
+                const adapter = await this.adapterPromise;
+                const value = await adapter.getAndRemove(keyObj.prefixed);
+                if (value === null) {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
+                    }))
+                        .defer();
+                }
+                else {
+                    this.eventBus
+                        .dispatch(new KeyFoundCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
+                        value,
+                    }))
+                        .defer();
+                    this.eventBus
+                        .dispatch(new KeyRemovedCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
+                    }))
+                        .defer();
+                }
+                return value;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    keys: [keyObj.resolved],
+                    method: this.get.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
     }
     /**
-     * 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 type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
-     * await cache.add("a", 1);
+     * const value = await cache.getOr("a", 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
-     */
-    addListenerMany(eventNames, listener) {
-        return this.eventBus.addListenerMany(eventNames, listener);
-    }
-    /**
-     * 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 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";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListener(KeyAddedCacheEvent, listener);
-     * await cache.removeListener(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
+     * const value = await cache.getOr("a", () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
-     */
-    removeListener(eventName, listener) {
-        return this.eventBus.removeListener(eventName, listener);
-    }
-    /**
-     * 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 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";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
-     * await cache.removeListenerMany(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
+     * const value = await cache.getOr("a", async () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
-     */
-    removeListenerMany(eventNames, listener) {
-        return this.eventBus.removeListenerMany(eventNames, listener);
-    }
-    /**
-     * 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 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";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     * 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: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * await cache.listenOnce(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
+     * const value = await cache.getOr("a", new LazyPromise(async () => 1));
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      */
-    listenOnce(eventName, listener) {
-        return this.eventBus.listenOnce(eventName, listener);
-    }
-    asPromise(event) {
-        return this.eventBus.asPromise(event);
+    getOr(key, defaultValue) {
+        return this.createLazyPromise(async () => {
+            const value = await this.get(key);
+            if (value === null) {
+                const simplifiedValueToAdd = await resolveAsyncLazyable(defaultValue);
+                return simplifiedValueToAdd;
+            }
+            return value;
+        });
     }
     /**
-     * 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";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, listener);
-     * await cache.add("a", 1);
-     * await unsubscribe();
+     * const value = await cache.getOrAdd("a", 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
-     */
-    subscribe(eventName, listener) {
-        return this.eventBus.subscribe(eventName, listener);
-    }
-    /**
-     * 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 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";
-     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
-     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * const listener: Invokable<CacheEvents> = event => {
-     *   console.log(event);
-     * };
-     * const unsubscribe = await cache.subscribeMany([KeyAddedCacheEvent], listener);
-     * await cache.add("a", 1);
-     * await unsubscribe();
+     * const value = await cache.getOrAdd("a", () => 1);
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
-     */
-    subscribeMany(eventNames, listener) {
-        return this.eventBus.subscribeMany(eventNames, listener);
-    }
-    /**
+     *
+     * 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, 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";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * // Will print "@global"
-     * console.log(cache.getGroup());
+     * const value = await cache.getOrAdd("a", async () => 1);
      *
-     * const groupedCache: ICache = cache.withGroup("company-1");
-     *
-     * // Will print "@global/company-1"
-     * console.log(groupedCache.getGroup());
+     * // Will be 1
+     * console.log(value);
      * ```
-     */
-    withGroup(group) {
-        return new Cache({
-            adapter: this.adapter.withGroup(resolveOneOrMoreStr(group)),
-            defaultTtl: this.defaultTtl,
-            eventBus: this.groupdEventBus,
-            retryAttempts: this.retryAttempts,
-            backoffPolicy: this.backoffPolicy,
-            retryPolicy: this.retryPolicy,
-            timeout: this.timeout,
-        });
-    }
-    /**
+     *
+     * 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";
+     * 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: IGroupableCache = new Cache({
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter(),
+     *   keyPrefixer: new KeyPrefixer("cache")
      * });
      *
-     * // Will print "@global"
-     * console.log(cache.getGroup());
+     * const value = await cache.getOrAdd("a", new LazyPromise(async () => 1));
+     *
+     * // Will be 1
+     * console.log(value);
      * ```
      */
-    getGroup() {
-        return this.adapter.getGroup();
+    getOrAdd(key, valueToAdd, ttl) {
+        return this.createLazyPromise(async () => {
+            const value = await this.get(key);
+            if (value === null) {
+                const simplifiedValueToAdd = await resolveAsyncLazyable(valueToAdd);
+                await this.add(key, simplifiedValueToAdd, ttl);
+                return simplifiedValueToAdd;
+            }
+            return value;
+        });
     }
-    get(key) {
-        return this.createLayPromise(async () => {
+    add(key, value, ttl = this.defaultTtl) {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
             try {
-                const value = await this.adapter.get(key);
-                if (value === null) {
-                    this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
-                        group: this.getGroup(),
-                        key,
-                    }))
-                        .defer();
-                }
-                else {
+                const adapter = await this.adapterPromise;
+                const hasAdded = await adapter.add(keyObj.prefixed, value, ttl);
+                if (hasAdded) {
                     this.eventBus
-                        .dispatch(new KeyFoundCacheEvent({
+                        .dispatch(new KeyAddedCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                         value,
+                        ttl,
                     }))
                         .defer();
                 }
-                return value;
+                return hasAdded;
             }
             catch (error) {
                 this.eventBus
                     .dispatch(new UnexpectedCacheErrorEvent({
                     group: this.getGroup(),
-                    key,
-                    method: this.get.name,
+                    keys: [keyObj.resolved],
+                    value,
+                    method: this.add.name,
                     error,
                 }))
                     .defer();
@@ -372,33 +523,40 @@ export class Cache {
             }
         });
     }
-    add(key, value, 
-    /**
-     * @default null
-     */
-    ttl = this.defaultTtl) {
-        return this.createLayPromise(async () => {
+    put(key, value, ttl = this.defaultTtl) {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
             try {
-                const hasAdded = await this.adapter.add(key, value, ttl);
-                if (hasAdded) {
+                const adapter = await this.adapterPromise;
+                const hasUpdated = await adapter.put(keyObj.prefixed, value, ttl);
+                if (hasUpdated) {
+                    this.eventBus
+                        .dispatch(new KeyUpdatedCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
+                        value,
+                    }))
+                        .defer();
+                }
+                else {
                     this.eventBus
                         .dispatch(new KeyAddedCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                         value,
                         ttl,
                     }))
                         .defer();
                 }
-                return hasAdded;
+                return hasUpdated;
             }
             catch (error) {
                 this.eventBus
                     .dispatch(new UnexpectedCacheErrorEvent({
                     group: this.getGroup(),
-                    key,
+                    keys: [keyObj.resolved],
                     value,
-                    method: this.add.name,
+                    method: this.put.name,
                     error,
                 }))
                     .defer();
@@ -407,14 +565,16 @@ export class Cache {
         });
     }
     update(key, value) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
             try {
-                const hasUpdated = await this.adapter.update(key, value);
+                const adapter = await this.adapterPromise;
+                const hasUpdated = await adapter.update(keyObj.prefixed, value);
                 if (hasUpdated) {
                     this.eventBus
                         .dispatch(new KeyUpdatedCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                         value,
                     }))
                         .defer();
@@ -423,7 +583,7 @@ export class Cache {
                     this.eventBus
                         .dispatch(new KeyNotFoundCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                     }))
                         .defer();
                 }
@@ -433,7 +593,7 @@ export class Cache {
                 this.eventBus
                     .dispatch(new UnexpectedCacheErrorEvent({
                     group: this.getGroup(),
-                    key,
+                    keys: [keyObj.resolved],
                     value,
                     method: this.update.name,
                     error,
@@ -443,30 +603,35 @@ export class Cache {
             }
         });
     }
-    put(key, value, 
-    /**
-     * @default null
-     */
-    ttl = this.defaultTtl) {
-        return this.createLayPromise(async () => {
+    increment(key, value = 0) {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
             try {
-                const hasUpdated = await this.adapter.put(key, value, ttl);
-                if (hasUpdated) {
+                const adapter = await this.adapterPromise;
+                const hasUpdated = await adapter.increment(keyObj.prefixed, value);
+                if (hasUpdated && value > 0) {
                     this.eventBus
-                        .dispatch(new KeyUpdatedCacheEvent({
+                        .dispatch(new KeyIncrementedCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                         value,
                     }))
                         .defer();
                 }
-                else {
+                if (hasUpdated && value < 0) {
                     this.eventBus
-                        .dispatch(new KeyAddedCacheEvent({
+                        .dispatch(new KeyDecrementedCacheEvent({
                         group: this.getGroup(),
-                        key,
-                        value,
-                        ttl,
+                        key: keyObj.resolved,
+                        value: -value,
+                    }))
+                        .defer();
+                }
+                if (!hasUpdated) {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key: keyObj.resolved,
                     }))
                         .defer();
                 }
@@ -476,9 +641,9 @@ export class Cache {
                 this.eventBus
                     .dispatch(new UnexpectedCacheErrorEvent({
                     group: this.getGroup(),
-                    key,
+                    keys: [keyObj.resolved],
                     value,
-                    method: this.put.name,
+                    method: this.increment.name,
                     error,
                 }))
                     .defer();
@@ -486,15 +651,22 @@ export class Cache {
             }
         });
     }
+    decrement(key, value = 0) {
+        return this.createLazyPromise(async () => {
+            return await this.increment(key, -value);
+        });
+    }
     remove(key) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
+            const keyObj = this.keyPrefixer.create(key);
             try {
-                const hasRemoved = await this.adapter.remove(key);
+                const adapter = await this.adapterPromise;
+                const hasRemoved = await adapter.removeMany([keyObj.prefixed]);
                 if (hasRemoved) {
                     this.eventBus
                         .dispatch(new KeyRemovedCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                     }))
                         .defer();
                 }
@@ -502,7 +674,7 @@ export class Cache {
                     this.eventBus
                         .dispatch(new KeyNotFoundCacheEvent({
                         group: this.getGroup(),
-                        key,
+                        key: keyObj.resolved,
                     }))
                         .defer();
                 }
@@ -512,7 +684,7 @@ export class Cache {
                 this.eventBus
                     .dispatch(new UnexpectedCacheErrorEvent({
                     group: this.getGroup(),
-                    key,
+                    keys: [keyObj.resolved],
                     method: this.remove.name,
                     error,
                 }))
@@ -521,45 +693,38 @@ export class Cache {
             }
         });
     }
-    increment(key, value = 1) {
-        return this.createLayPromise(async () => {
+    removeMany(keys) {
+        return this.createLazyPromise(async () => {
+            const keysArr = [...keys];
+            if (keysArr.length === 0) {
+                return true;
+            }
+            const keyObjArr = keysArr.map((key) => this.keyPrefixer.create(key));
             try {
-                const hasUpdated = await this.adapter.increment(key, value);
-                if (hasUpdated && value > 0) {
-                    this.eventBus
-                        .dispatch(new KeyIncrementedCacheEvent({
+                const adapter = await this.adapterPromise;
+                const hasRemovedAtLeastOne = await adapter.removeMany(keyObjArr.map((keyObj) => keyObj.prefixed));
+                if (hasRemovedAtLeastOne) {
+                    const events = keyObjArr.map((keyObj) => new KeyRemovedCacheEvent({
                         group: this.getGroup(),
-                        key,
-                        value,
-                    }))
-                        .defer();
+                        key: keyObj.resolved,
+                    }));
+                    this.eventBus.dispatchMany(events).defer();
                 }
-                if (hasUpdated && value < 0) {
-                    this.eventBus
-                        .dispatch(new KeyDecrementedCacheEvent({
-                        group: this.getGroup(),
-                        key,
-                        value: -value,
-                    }))
-                        .defer();
-                }
-                if (!hasUpdated) {
-                    this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
+                else {
+                    const events = keyObjArr.map((keyObj) => new KeyNotFoundCacheEvent({
                         group: this.getGroup(),
-                        key,
-                    }))
-                        .defer();
+                        key: keyObj.resolved,
+                    }));
+                    this.eventBus.dispatchMany(events).defer();
                 }
-                return hasUpdated;
+                return hasRemovedAtLeastOne;
             }
             catch (error) {
                 this.eventBus
                     .dispatch(new UnexpectedCacheErrorEvent({
                     group: this.getGroup(),
-                    key,
-                    value,
-                    method: this.increment.name,
+                    keys: keyObjArr.map((keyObj) => keyObj.resolved),
+                    method: this.remove.name,
                     error,
                 }))
                     .defer();
@@ -568,14 +733,19 @@ export class Cache {
         });
     }
     clear() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
-                await this.adapter.clear();
-                this.eventBus
-                    .dispatch(new KeysClearedCacheEvent({
+                const adapter = await this.adapterPromise;
+                const promise = this.eventBus.dispatch(new KeysClearedCacheEvent({
                     group: this.getGroup(),
-                }))
-                    .defer();
+                }));
+                if (isFactory(this.adapterFactoryable)) {
+                    await adapter.removeAll();
+                    promise.defer();
+                    return;
+                }
+                await adapter.removeByKeyPrefix(this.keyPrefixer.keyPrefix);
+                promise.defer();
             }
             catch (error) {
                 this.eventBus
@@ -589,521 +759,67 @@ export class Cache {
             }
         });
     }
-    exists(key) {
-        return this.createLayPromise(async () => {
-            const value = await this.get(key);
-            return value !== null;
-        });
-    }
-    existsMany(keys) {
-        return this.createLayPromise(async () => {
-            if (keys.length === 0) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key of keys) {
-                valuePromises.push(this.exists(key));
-            }
-            const values = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of keys.entries()) {
-                const value = values[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    missing(key) {
-        return this.createLayPromise(async () => {
-            const value = await this.get(key);
-            return value === null;
-        });
-    }
-    missingMany(keys) {
-        return this.createLayPromise(async () => {
-            if (keys.length === 0) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key of keys) {
-                valuePromises.push(this.missing(key));
-            }
-            const values = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of keys.entries()) {
-                const value = values[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    getMany(keys) {
-        return this.createLayPromise(async () => {
-            if (keys.length === 0) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key of keys) {
-                valuePromises.push(this.get(key));
-            }
-            const values = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of keys.entries()) {
-                const value = values[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    /**
-     * @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.getOr("a", -1);
-     * // -1
-     * console.log(result);
-     * ```
-     *
-     * 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 result = await cache.getOr("a", () => -1);
-     * // -1
-     * console.log(result);
-     * ```
-     *
-     * 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"
-     *   }),
-     * });
-     *
-     * const result = await cache.getOr("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.getOr("a", new LazyPromise(async () => -1));
-     * // -1
-     * console.log(result);
-     * ```
-     */
-    getOr(key, defaultValue) {
-        return this.createLayPromise(async () => {
-            const value = await this.get(key);
-            if (value === null) {
-                return await resolveAsyncLazyable(defaultValue);
-            }
-            return 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.getOrMany({ a: -1 });
-     * // { a: -1 }
-     * console.log(result);
-     * ```
-     *
-     * 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";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * 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.getOrMany({ a: () => -1 });
-     * // { a: -1 }
-     * console.log(result);
-     * ```
-     *
-     * 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"
-     *   }),
-     * });
-     *
-     * const result = await cache.getOrMany({ a: async () => -1 });
-     * // { a: -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.getOrMany({ a: new LazyPromise(async () => - 1) });
-     * // { a: -1 }
-     * console.log(result);
-     * ```
-     */
-    getOrMany(keysWithDefaults) {
-        return this.createLayPromise(async () => {
-            const keys = Object.keys(keysWithDefaults);
-            if (keys.length === 0) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key of keys) {
-                const defaultValue = keysWithDefaults[key];
-                valuePromises.push(this.getOr(key, defaultValue));
-            }
-            const values = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of keys.entries()) {
-                const value = values[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    /**
-     * @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"
-     *   }),
-     * });
-     *
-     * await cache.add("a", 1);
-     *
-     * const result1 = await cache.getOrFail("a");
-     * // Will print 1
-     * console.log(result1);
-     *
-     * await cache.remove("a");
-     *
-     * // Will throw an error
-     * await cache.getOrFail("a");
-     * ```
-     */
-    getOrFail(key) {
-        return this.createLayPromise(async () => {
-            const value = await this.get(key);
-            if (value === null) {
-                throw new KeyNotFoundCacheError(`Key "${key}" is not found`);
-            }
-            return value;
-        });
-    }
-    addMany(values) {
-        return this.createLayPromise(async () => {
-            if (isObjectEmpty(values)) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key in values) {
-                const { value, ttl } = values[key];
-                valuePromises.push(this.add(key, value, ttl));
-            }
-            const returnValues = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of Object.keys(values).entries()) {
-                const value = returnValues[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    updateMany(values) {
-        return this.createLayPromise(async () => {
-            if (isObjectEmpty(values)) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key in values) {
-                const value = values[key];
-                valuePromises.push(this.update(key, value));
-            }
-            const returnValues = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of Object.keys(values).entries()) {
-                const value = returnValues[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    putMany(values) {
-        return this.createLayPromise(async () => {
-            if (isObjectEmpty(values)) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key in values) {
-                const { value, ttl } = values[key];
-                valuePromises.push(this.put(key, value, ttl));
-            }
-            const returnValues = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of Object.keys(values).entries()) {
-                const value = returnValues[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    removeMany(keys) {
-        return this.createLayPromise(async () => {
-            if (keys.length === 0) {
-                return {};
-            }
-            const valuePromises = [];
-            for (const key of keys) {
-                valuePromises.push(this.remove(key));
-            }
-            const values = await Promise.all(valuePromises);
-            const result = {};
-            for (const [index, key] of keys.entries()) {
-                const value = values[index];
-                if (value === undefined) {
-                    throw new UnexpectedCacheError(`Item "values[${String(index)}]" is undefined`);
-                }
-                result[key] = value;
-            }
-            return result;
-        });
-    }
-    /**
-     * @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 result1 = await cache.getAndRemove("a");
-     * // Will print null
-     * console.log(result1);
-     *
-     * 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) {
-        return this.createLayPromise(async () => {
-            const value = await this.get(key);
-            if (value === null) {
-                return null;
-            }
-            await this.remove(key);
-            return value;
-        });
+    getGroup() {
+        if (this.keyPrefixer.resolvedGroup) {
+            return this.keyPrefixer.resolvedGroup;
+        }
+        return 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);
-     * ```
-     *
-     * 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 result = await cache.getOrAdd("a", () => -1);
-     * // -1
-     * console.log(result);
-     * ```
-     *
-     * 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";
+     * import { Cache } from "@daiso-tech/core/cache";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * 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", async () => -1);
-     * // -1
-     * console.log(result);
-     * ```
+     * const groupedCache = cache.withGroup("group-a");
+     * await groupedCache.add("a", 1);
      *
-     * 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"
-     *   }),
-     * });
+     * // Will log "a".
+     * console.log(await groupedCache.get("a"));
      *
-     * 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, valueToAdd, 
-    /**
-     * @default {null}
-     */
-    ttl) {
-        return this.createLayPromise(async () => {
-            const value = await this.get(key);
-            if (value === null) {
-                const simplifiedValueToAdd = await resolveAsyncLazyable(valueToAdd);
-                await this.add(key, simplifiedValueToAdd, ttl);
-                return simplifiedValueToAdd;
-            }
-            return value;
-        });
-    }
-    decrement(key, value = 1) {
-        return this.createLayPromise(async () => {
-            return await this.increment(key, -value);
+    withGroup(group) {
+        const cache = new Cache({
+            keyPrefixer: this.keyPrefixer.withGroup(group),
+            adapter: this.adapterFactoryable,
+            eventBus: this.groupdEventBus,
+            defaultTtl: this.defaultTtl,
+            retryAttempts: this.retryAttempts,
+            backoffPolicy: this.backoffPolicy,
+            retryPolicy: this.retryPolicy,
+            retryTimeout: this.retryTimeout,
         });
+        return cache;
     }
 }
 //# sourceMappingURL=cache.js.map