@daiso-tech/core 0.23.0 → 0.25.0

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

@@ -0,0 +1,1109 @@
+/**
+ * @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 {} from "../../../../cache/contracts/_module-exports.js";
+import { isObjectEmpty, resolveAsyncLazyable, resolveOneOrMoreStr, } 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";
+/**
+ * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/cache/implementations/derivables"```
+ * @group Derivables
+ */
+export class Cache {
+    static defaultRetryPolicy = (error) => {
+        return !(error instanceof TypeCacheError ||
+            error instanceof KeyNotFoundCacheError);
+    };
+    groupdEventBus;
+    eventBus;
+    adapter;
+    defaultTtl;
+    retryAttempts;
+    backoffPolicy;
+    retryPolicy;
+    timeout;
+    /**
+     * @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) {
+        const { adapter, eventBus: groupdEventBus = new EventBus({
+            adapter: new MemoryEventBusAdapter({
+                rootGroup: "@global",
+            }),
+        }), defaultTtl = null, retryAttempts = null, backoffPolicy = null, retryPolicy = Cache.defaultRetryPolicy, timeout = null, } = settings;
+        this.groupdEventBus = groupdEventBus;
+        this.eventBus = groupdEventBus.withGroup(adapter.getGroup());
+        this.adapter = adapter;
+        this.defaultTtl = defaultTtl;
+        this.retryAttempts = retryAttempts;
+        this.backoffPolicy = backoffPolicy;
+        this.retryPolicy = retryPolicy;
+        this.timeout = timeout;
+    }
+    createLayPromise(asyncFn) {
+        return new LazyPromise(asyncFn)
+            .setRetryAttempts(this.retryAttempts)
+            .setBackoffPolicy(this.backoffPolicy)
+            .setRetryPolicy(this.retryPolicy)
+            .setTimeout(this.timeout);
+    }
+    /**
+     * 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 { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.addListener(KeyAddedCacheEvent, listener);
+     * await cache.add("a", 1);
+     * ```
+     */
+    addListener(eventName, listener) {
+        return this.eventBus.addListener(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.
+     * @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 { EventListener} from "@daiso-tech/core/event-bus/contracts";
+     * import type { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
+     * await cache.add("a", 1);
+     * ```
+     */
+    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.
+     * @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 { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.addListener(KeyAddedCacheEvent, listener);
+     * await cache.removeListener(KeyAddedCacheEvent, listener);
+     * await cache.add("a", 1);
+     * ```
+     */
+    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.
+     * @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 { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
+     * await cache.removeListenerMany(KeyAddedCacheEvent, listener);
+     * await cache.add("a", 1);
+     * ```
+     */
+    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.
+     * @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 { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.listenOnce(KeyAddedCacheEvent, listener);
+     * await cache.add("a", 1);
+     * ```
+     */
+    listenOnce(eventName, listener) {
+        return this.eventBus.listenOnce(eventName, listener);
+    }
+    asPromise(event) {
+        return this.eventBus.asPromise(event);
+    }
+    /**
+     * 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 { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, listener);
+     * await cache.add("a", 1);
+     * await unsubscribe();
+     * ```
+     */
+    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.
+     * @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 { EventListener} 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: EventListener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * const unsubscribe = await cache.subscribeMany([KeyAddedCacheEvent], listener);
+     * await cache.add("a", 1);
+     * await unsubscribe();
+     * ```
+     */
+    subscribeMany(eventNames, listener) {
+        return this.eventBus.subscribeMany(eventNames, listener);
+    }
+    /**
+     * @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());
+     * ```
+     */
+    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,
+        });
+    }
+    /**
+     * @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());
+     * ```
+     */
+    getGroup() {
+        return this.adapter.getGroup();
+    }
+    get(key) {
+        return this.createLayPromise(async () => {
+            try {
+                const value = await this.adapter.get(key);
+                if (value === null) {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                    }))
+                        .defer();
+                }
+                else {
+                    this.eventBus
+                        .dispatch(new KeyFoundCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value,
+                    }))
+                        .defer();
+                }
+                return value;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    key,
+                    method: this.get.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    add(key, value, 
+    /**
+     * @default null
+     */
+    ttl = this.defaultTtl) {
+        return this.createLayPromise(async () => {
+            try {
+                const hasAdded = await this.adapter.add(key, value, ttl);
+                if (hasAdded) {
+                    this.eventBus
+                        .dispatch(new KeyAddedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value,
+                        ttl,
+                    }))
+                        .defer();
+                }
+                return hasAdded;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    key,
+                    value,
+                    method: this.add.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    update(key, value) {
+        return this.createLayPromise(async () => {
+            try {
+                const hasUpdated = await this.adapter.update(key, value);
+                if (hasUpdated) {
+                    this.eventBus
+                        .dispatch(new KeyUpdatedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value,
+                    }))
+                        .defer();
+                }
+                else {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                    }))
+                        .defer();
+                }
+                return hasUpdated;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    key,
+                    value,
+                    method: this.update.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    put(key, value, 
+    /**
+     * @default null
+     */
+    ttl = this.defaultTtl) {
+        return this.createLayPromise(async () => {
+            try {
+                const hasUpdated = await this.adapter.put(key, value, ttl);
+                if (hasUpdated) {
+                    this.eventBus
+                        .dispatch(new KeyUpdatedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value,
+                    }))
+                        .defer();
+                }
+                else {
+                    this.eventBus
+                        .dispatch(new KeyAddedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value,
+                        ttl,
+                    }))
+                        .defer();
+                }
+                return hasUpdated;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    key,
+                    value,
+                    method: this.put.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    remove(key) {
+        return this.createLayPromise(async () => {
+            try {
+                const hasRemoved = await this.adapter.remove(key);
+                if (hasRemoved) {
+                    this.eventBus
+                        .dispatch(new KeyRemovedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                    }))
+                        .defer();
+                }
+                else {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                    }))
+                        .defer();
+                }
+                return hasRemoved;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    key,
+                    method: this.remove.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    increment(key, value = 1) {
+        return this.createLayPromise(async () => {
+            try {
+                const hasUpdated = await this.adapter.increment(key, value);
+                if (hasUpdated && value > 0) {
+                    this.eventBus
+                        .dispatch(new KeyIncrementedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value,
+                    }))
+                        .defer();
+                }
+                if (hasUpdated && value < 0) {
+                    this.eventBus
+                        .dispatch(new KeyDecrementedCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                        value: -value,
+                    }))
+                        .defer();
+                }
+                if (!hasUpdated) {
+                    this.eventBus
+                        .dispatch(new KeyNotFoundCacheEvent({
+                        group: this.getGroup(),
+                        key,
+                    }))
+                        .defer();
+                }
+                return hasUpdated;
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    key,
+                    value,
+                    method: this.increment.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    clear() {
+        return this.createLayPromise(async () => {
+            try {
+                await this.adapter.clear();
+                this.eventBus
+                    .dispatch(new KeysClearedCacheEvent({
+                    group: this.getGroup(),
+                }))
+                    .defer();
+            }
+            catch (error) {
+                this.eventBus
+                    .dispatch(new UnexpectedCacheErrorEvent({
+                    group: this.getGroup(),
+                    method: this.clear.name,
+                    error,
+                }))
+                    .defer();
+                throw error;
+            }
+        });
+    }
+    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";
+     *
+     * 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 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)
+     *
+     * const result2 = await cache.getAndRemove("a");
+     * // Will print 2
+     * console.log(result2);
+     *
+     * const result3 = await cache.get("a");
+     * // Will print null
+     * console.log(result3);
+     * ```
+     */
+    getAndRemove(key) {
+        return this.createLayPromise(async () => {
+            const value = await this.get(key);
+            if (value === null) {
+                return null;
+            }
+            await this.remove(key);
+            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.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";
+     *
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     * });
+     *
+     * 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);
+     * ```
+     */
+    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);
+        });
+    }
+}
+//# sourceMappingURL=cache.js.map