@daiso-tech/core 0.41.1 → 0.43.2

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

@@ -1,15 +1,14 @@
 /**
  * @module Cache
  */
-import type { CacheEventMap, IDatabaseCacheAdapter } from "../../../../cache/contracts/_module-exports.js";
-import { type ICache, type ICacheAdapter } from "../../../../cache/contracts/_module-exports.js";
-import type { AsyncLazyable } from "../../../../utilities/_module-exports.js";
-import { type NoneFunc } from "../../../../utilities/_module-exports.js";
-import { Task } from "../../../../task/_module-exports.js";
-import type { IEventBus, Unsubscribe, EventListener } from "../../../../event-bus/contracts/_module-exports.js";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ITimeSpan } from "../../../../time-span/contracts/_module-exports.js";
-import { Namespace } from "../../../../namespace/_module-exports.js";
+import { type StandardSchemaV1 } from "@standard-schema/spec";
+import { type ICache, type CacheEventMap, type CacheWriteSettings } from "../../../../cache/contracts/_module.js";
+import { type CacheAdapterVariants } from "../../../../cache/contracts/types.js";
+import { type IEventBus, type Unsubscribe, type EventListener } from "../../../../event-bus/contracts/_module.js";
+import { Namespace } from "../../../../namespace/_module.js";
+import { type ITask } from "../../../../task/contracts/_module.js";
+import { type ITimeSpan } from "../../../../time-span/contracts/_module.js";
+import { type AsyncLazyable, type NoneFunc } from "../../../../utilities/_module.js";
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/cache"`
@@ -38,10 +37,10 @@ export type CacheSettingsBase<TType = unknown> = {
      * @default
      * ```ts
      * import { EventBus } from "@daiso-tech/core/event-bus";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { NoOpEventBusAdapter } from "@daiso-tech/core/event-bus/no-op-event-bus-adapter";
      *
      * new EventBus({
-     *   adapter: new MemoryEventBusAdapter()
+     *   adapter: new NoOpEventBusAdapter()
      * })
      * ```
      */
@@ -51,13 +50,13 @@ export type CacheSettingsBase<TType = unknown> = {
      * @default null
      */
     defaultTtl?: ITimeSpan | null;
+    /**
+     * You can pass jitter value to ensure the backoff will not execute at the same time.
+     * If you pas null you can disable the jitrter.
+     * @default 0.2
+     */
+    defaultJitter?: number | null;
 };
-/**
- *
- * IMPORT_PATH: `"@daiso-tech/core/cache"`
- * @group Derivables
- */
-export type CacheAdapterVariants<TType> = ICacheAdapter<TType> | IDatabaseCacheAdapter<TType>;
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/cache"`
@@ -84,21 +83,26 @@ export declare class Cache<TType = unknown> implements ICache<TType> {
     private readonly namespace;
     private readonly schema;
     private readonly shouldValidateOutput;
+    private readonly defaultJitter;
     /**
      *
      * @example
      * ```ts
-     * import { SqliteCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KyselyCacheAdapter } from "@daiso-tech/core/cache/kysely-cache-adapter";
      * import { Serde } from "@daiso-tech/core/serde";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter"
      * import Sqlite from "better-sqlite3";
      * import { Cache } from "@daiso-tech/core/cache";
-     * import { Namespace } from "@daiso-tech/core/namespace";
+     * import { Kysely, SqliteDialect } from "kysely";
      *
      * const database = new Sqlite("local.db");
      * const serde = new Serde(new SuperJsonSerdeAdapter());
-     * const cacheAdapter = new SqliteCacheAdapter({
-     *   database,
+     * const cacheAdapter = new KyselyCacheAdapter({
+     *   kysely: new Kysely({
+     *     dialect: new SqliteDialect({
+     *       database,
+     *     }),
+     *   }),
      *   serde,
      * });
      * // You need initialize the adapter once before using it.
@@ -114,45 +118,51 @@ export declare class Cache<TType = unknown> implements ICache<TType> {
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    addListener<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): Task<void>;
+    addListener<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): ITask<void>;
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    removeListener<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): Task<void>;
+    removeListener<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): ITask<void>;
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    listenOnce<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): Task<void>;
+    listenOnce<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): ITask<void>;
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    asPromise<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName): Task<CacheEventMap<TType>[TEventName]>;
+    asTask<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName): ITask<CacheEventMap<TType>[TEventName]>;
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    subscribeOnce<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): Task<Unsubscribe>;
+    subscribeOnce<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): ITask<Unsubscribe>;
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    subscribe<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): Task<Unsubscribe>;
-    exists(key: string): Task<boolean>;
-    missing(key: string): Task<boolean>;
-    get(key: string): Task<TType | null>;
-    getOrFail(key: string): Task<TType>;
-    getAndRemove(key: string): Task<TType | null>;
-    getOr(key: string, defaultValue: AsyncLazyable<NoneFunc<TType>>): Task<TType>;
-    getOrAdd(key: string, valueToAdd: AsyncLazyable<NoneFunc<TType>>, ttl?: ITimeSpan | null): Task<TType>;
-    add(key: string, value: TType, ttl?: ITimeSpan | null): Task<boolean>;
-    put(key: string, value: TType, ttl?: ITimeSpan | null): Task<boolean>;
-    update(key: string, value: TType): Task<boolean>;
-    increment(key: string, value?: Extract<TType, number>): Task<boolean>;
-    decrement(key: string, value?: Extract<TType, number>): Task<boolean>;
-    remove(key: string): Task<boolean>;
-    removeMany(keys: Iterable<string>): Task<boolean>;
-    clear(): Task<void>;
+    subscribe<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): ITask<Unsubscribe>;
+    exists(key: string): ITask<boolean>;
+    missing(key: string): ITask<boolean>;
+    get(key: string): ITask<TType | null>;
+    getOrFail(key: string): ITask<TType>;
+    getAndRemove(key: string): ITask<TType | null>;
+    getOr(key: string, defaultValue: AsyncLazyable<NoneFunc<TType>>): ITask<TType>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<NoneFunc<TType>>, settings?: CacheWriteSettings): ITask<TType>;
+    private resolveCacheWriteSettings;
+    add(key: string, value: TType, settings?: CacheWriteSettings): ITask<boolean>;
+    addOrFail(key: string, value: TType, settings?: CacheWriteSettings): ITask<void>;
+    put(key: string, value: TType, settings?: CacheWriteSettings): ITask<boolean>;
+    update(key: string, value: TType): ITask<boolean>;
+    updateOrFail(key: string, value: TType): ITask<void>;
+    increment(key: string, value?: Extract<TType, number>): ITask<boolean>;
+    incrementOrFail(key: string, value?: Extract<TType, number>): ITask<void>;
+    decrement(key: string, value?: Extract<TType, number>): ITask<boolean>;
+    decrementOrFail(key: string, value?: Extract<TType, number>): ITask<void>;
+    remove(key: string): ITask<boolean>;
+    removeOrFail(key: string): ITask<void>;
+    removeMany(keys: Iterable<string>): ITask<boolean>;
+    clear(): ITask<void>;
 }

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

@@ -2,17 +2,19 @@
 /**
  * @module Cache
  */
-import { CACHE_EVENTS, } from "../../../../cache/contracts/_module-exports.js";
-import { KeyNotFoundCacheError } from "../../../../cache/contracts/_module-exports.js";
-import { resolveAsyncLazyable, validate } from "../../../../utilities/_module-exports.js";
-import {} from "../../../../utilities/_module-exports.js";
-import { Task } from "../../../../task/_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";
-import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
-import { Namespace } from "../../../../namespace/_module-exports.js";
+import {} from "@standard-schema/spec";
+import { CACHE_EVENTS, KeyNotFoundCacheError, KeyExistsCacheError, } from "../../../../cache/contracts/_module.js";
+import {} from "../../../../cache/contracts/types.js";
+import { resolveCacheAdapter } from "../../../../cache/implementations/derivables/cache/resolve-cache-adapter.js";
+import {} from "../../../../event-bus/contracts/_module.js";
+import { NoOpEventBusAdapter } from "../../../../event-bus/implementations/adapters/_module.js";
+import { EventBus } from "../../../../event-bus/implementations/derivables/_module.js";
+import { Namespace } from "../../../../namespace/_module.js";
+import {} from "../../../../task/contracts/_module.js";
+import { Task } from "../../../../task/implementations/_module.js";
+import {} from "../../../../time-span/contracts/_module.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module.js";
+import { resolveAsyncLazyable, validate, withJitter, } from "../../../../utilities/_module.js";
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/cache"`
@@ -31,21 +33,26 @@ export class Cache {
     namespace;
     schema;
     shouldValidateOutput;
+    defaultJitter;
     /**
      *
      * @example
      * ```ts
-     * import { SqliteCacheAdapter } from "@daiso-tech/core/cache/adapters";
+     * import { KyselyCacheAdapter } from "@daiso-tech/core/cache/kysely-cache-adapter";
      * import { Serde } from "@daiso-tech/core/serde";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters"
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter"
      * import Sqlite from "better-sqlite3";
      * import { Cache } from "@daiso-tech/core/cache";
-     * import { Namespace } from "@daiso-tech/core/namespace";
+     * import { Kysely, SqliteDialect } from "kysely";
      *
      * const database = new Sqlite("local.db");
      * const serde = new Serde(new SuperJsonSerdeAdapter());
-     * const cacheAdapter = new SqliteCacheAdapter({
-     *   database,
+     * const cacheAdapter = new KyselyCacheAdapter({
+     *   kysely: new Kysely({
+     *     dialect: new SqliteDialect({
+     *       database,
+     *     }),
+     *   }),
      *   serde,
      * });
      * // You need initialize the adapter once before using it.
@@ -58,20 +65,16 @@ export class Cache {
      */
     constructor(settings) {
         const { shouldValidateOutput = true, schema, namespace = DEFAULT_CACHE_NAMESPACE, adapter, eventBus = new EventBus({
-            adapter: new MemoryEventBusAdapter(),
-        }), defaultTtl = null, } = settings;
+            adapter: new NoOpEventBusAdapter(),
+        }), defaultTtl = null, defaultJitter = 0.2, } = settings;
         this.shouldValidateOutput = shouldValidateOutput;
         this.schema = schema;
         this.namespace = namespace;
         this.defaultTtl =
             defaultTtl === null ? null : TimeSpan.fromTimeSpan(defaultTtl);
         this.eventBus = eventBus;
-        if (isDatabaseCacheAdapter(adapter)) {
-            this.adapter = new DatabaseCacheAdapter(adapter);
-        }
-        else {
-            this.adapter = adapter;
-        }
+        this.adapter = resolveCacheAdapter(adapter);
+        this.defaultJitter = defaultJitter;
     }
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
@@ -98,8 +101,8 @@ export class Cache {
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
      * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
      */
-    asPromise(eventName) {
-        return this.eventBus.asPromise(eventName);
+    asTask(eventName) {
+        return this.eventBus.asTask(eventName);
     }
     /**
      * You can listen to the following {@link CacheEventMap | `CacheEventMap`} of the {@link ICache | `ICache`} instance.
@@ -138,14 +141,14 @@ export class Cache {
                 if (value === null) {
                     this.eventBus
                         .dispatch(CACHE_EVENTS.NOT_FOUND, {
-                        key: keyObj.get(),
+                        key: keyObj,
                     })
                         .detach();
                 }
                 else {
                     this.eventBus
                         .dispatch(CACHE_EVENTS.FOUND, {
-                        key: keyObj.get(),
+                        key: keyObj,
                         value,
                     })
                         .detach();
@@ -168,7 +171,7 @@ export class Cache {
         return new Task(async () => {
             const value = await this.get(key);
             if (value === null) {
-                throw new KeyNotFoundCacheError(`Key "${this.namespace.create(key).get()}" is not found`);
+                throw KeyNotFoundCacheError.create(this.namespace.create(key));
             }
             return value;
         });
@@ -184,21 +187,14 @@ export class Cache {
                 if (value === null) {
                     this.eventBus
                         .dispatch(CACHE_EVENTS.NOT_FOUND, {
-                        key: keyObj.get(),
+                        key: keyObj,
                     })
                         .detach();
                 }
                 else {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.FOUND, {
-                        key: keyObj.get(),
-                        value,
-                    })
-                        .detach();
-                    this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "removed",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.REMOVED, {
+                        key: keyObj,
                     })
                         .detach();
                 }
@@ -226,31 +222,68 @@ export class Cache {
             return value;
         });
     }
-    getOrAdd(key, valueToAdd, ttl) {
+    getOrAdd(key, valueToAdd, settings) {
         return new Task(async () => {
-            const value = await this.get(key);
+            const ttl = this.resolveCacheWriteSettings(settings);
+            const keyObj = this.namespace.create(key);
+            const value = await this.adapter.get(keyObj.toString());
+            if (this.shouldValidateOutput && value !== null) {
+                await validate(this.schema, value);
+            }
             if (value === null) {
-                const simplifiedValueToAdd = await resolveAsyncLazyable(valueToAdd);
-                await this.add(key, simplifiedValueToAdd, ttl);
-                return simplifiedValueToAdd;
+                const resolvedValueToAdd = await resolveAsyncLazyable(valueToAdd);
+                await validate(this.schema, resolvedValueToAdd);
+                const hasAdded = await this.adapter.add(keyObj.toString(), resolvedValueToAdd, ttl);
+                if (hasAdded) {
+                    this.eventBus
+                        .dispatch(CACHE_EVENTS.ADDED, {
+                        key: keyObj,
+                        value: resolvedValueToAdd,
+                        ttl,
+                    })
+                        .detach();
+                }
+                return resolvedValueToAdd;
+            }
+            else {
+                this.eventBus
+                    .dispatch(CACHE_EVENTS.FOUND, {
+                    key: keyObj,
+                    value,
+                })
+                    .detach();
             }
             return value;
         });
     }
-    add(key, value, ttl = this.defaultTtl) {
+    resolveCacheWriteSettings(settings = {}) {
+        const { ttl = this.defaultTtl, jitter = this.defaultJitter, _mathRandom = Math.random, } = settings;
+        if (ttl === null) {
+            return null;
+        }
+        const ttlAsTimeSpan = TimeSpan.fromTimeSpan(ttl);
+        if (jitter === null) {
+            return ttlAsTimeSpan;
+        }
+        return TimeSpan.fromMilliseconds(withJitter({
+            jitter,
+            randomValue: _mathRandom(),
+            value: ttlAsTimeSpan.toMilliseconds(),
+        }));
+    }
+    add(key, value, settings) {
         return new Task(async () => {
-            const ttlAsTimeSpan = ttl === null ? null : TimeSpan.fromTimeSpan(ttl);
+            const ttl = this.resolveCacheWriteSettings(settings);
             const keyObj = this.namespace.create(key);
             try {
                 await validate(this.schema, value);
-                const hasAdded = await this.adapter.add(keyObj.toString(), value, ttlAsTimeSpan);
+                const hasAdded = await this.adapter.add(keyObj.toString(), value, ttl);
                 if (hasAdded) {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "added",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.ADDED, {
+                        key: keyObj,
                         value,
-                        ttl: ttlAsTimeSpan,
+                        ttl,
                     })
                         .detach();
                 }
@@ -269,29 +302,35 @@ export class Cache {
             }
         });
     }
-    put(key, value, ttl = this.defaultTtl) {
+    addOrFail(key, value, settings) {
+        return new Task(async () => {
+            const isNotFound = await this.add(key, value, settings);
+            if (!isNotFound) {
+                throw KeyExistsCacheError.create(this.namespace.create(key));
+            }
+        });
+    }
+    put(key, value, settings) {
         return new Task(async () => {
-            const ttlAsTimeSpan = ttl === null ? null : TimeSpan.fromTimeSpan(ttl);
+            const ttl = this.resolveCacheWriteSettings(settings);
             const keyObj = this.namespace.create(key);
             try {
                 await validate(this.schema, value);
-                const hasUpdated = await this.adapter.put(keyObj.toString(), value, ttlAsTimeSpan);
+                const hasUpdated = await this.adapter.put(keyObj.toString(), value, ttl);
                 if (hasUpdated) {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "updated",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.UPDATED, {
+                        key: keyObj,
                         value,
                     })
                         .detach();
                 }
                 else {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "added",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.ADDED, {
+                        key: keyObj,
                         value,
-                        ttl: ttlAsTimeSpan,
+                        ttl,
                     })
                         .detach();
                 }
@@ -318,9 +357,8 @@ export class Cache {
                 const hasUpdated = await this.adapter.update(keyObj.toString(), value);
                 if (hasUpdated) {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "updated",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.UPDATED, {
+                        key: keyObj,
                         value,
                     })
                         .detach();
@@ -328,7 +366,7 @@ export class Cache {
                 else {
                     this.eventBus
                         .dispatch(CACHE_EVENTS.NOT_FOUND, {
-                        key: keyObj.get(),
+                        key: keyObj,
                     })
                         .detach();
                 }
@@ -347,25 +385,31 @@ export class Cache {
             }
         });
     }
-    increment(key, value = 0) {
+    updateOrFail(key, value) {
+        return new Task(async () => {
+            const isFound = await this.update(key, value);
+            if (!isFound) {
+                throw KeyNotFoundCacheError.create(this.namespace.create(key));
+            }
+        });
+    }
+    increment(key, value = 1) {
         return new Task(async () => {
             const keyObj = this.namespace.create(key);
             try {
                 const hasUpdated = await this.adapter.increment(keyObj.toString(), value);
                 if (hasUpdated && value > 0) {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "incremented",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.INCREMENTED, {
+                        key: keyObj,
                         value,
                     })
                         .detach();
                 }
                 if (hasUpdated && value < 0) {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "decremented",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.DECREMENTED, {
+                        key: keyObj,
                         value: -value,
                     })
                         .detach();
@@ -373,7 +417,7 @@ export class Cache {
                 if (!hasUpdated) {
                     this.eventBus
                         .dispatch(CACHE_EVENTS.NOT_FOUND, {
-                        key: keyObj.get(),
+                        key: keyObj,
                     })
                         .detach();
                 }
@@ -392,11 +436,27 @@ export class Cache {
             }
         });
     }
-    decrement(key, value = 0) {
+    incrementOrFail(key, value) {
+        return new Task(async () => {
+            const isFound = await this.increment(key, value);
+            if (!isFound) {
+                throw KeyNotFoundCacheError.create(this.namespace.create(key));
+            }
+        });
+    }
+    decrement(key, value = 1) {
         return new Task(async () => {
             return await this.increment(key, -value);
         });
     }
+    decrementOrFail(key, value) {
+        return new Task(async () => {
+            const isFound = await this.decrement(key, value);
+            if (!isFound) {
+                throw KeyNotFoundCacheError.create(this.namespace.create(key));
+            }
+        });
+    }
     remove(key) {
         return new Task(async () => {
             const keyObj = this.namespace.create(key);
@@ -406,16 +466,15 @@ export class Cache {
                 ]);
                 if (hasRemoved) {
                     this.eventBus
-                        .dispatch(CACHE_EVENTS.WRITTEN, {
-                        type: "removed",
-                        key: keyObj.get(),
+                        .dispatch(CACHE_EVENTS.REMOVED, {
+                        key: keyObj,
                     })
                         .detach();
                 }
                 else {
                     this.eventBus
                         .dispatch(CACHE_EVENTS.NOT_FOUND, {
-                        key: keyObj.get(),
+                        key: keyObj,
                     })
                         .detach();
                 }
@@ -433,6 +492,14 @@ export class Cache {
             }
         });
     }
+    removeOrFail(key) {
+        return new Task(async () => {
+            const isFound = await this.remove(key);
+            if (!isFound) {
+                throw KeyNotFoundCacheError.create(this.namespace.create(key));
+            }
+        });
+    }
     removeMany(keys) {
         return new Task(async () => {
             const keysArr = [...keys];
@@ -444,10 +511,9 @@ export class Cache {
                 const hasRemovedAtLeastOne = await this.adapter.removeMany(keyObjArr.map((keyObj) => keyObj.toString()));
                 if (hasRemovedAtLeastOne) {
                     const events = keyObjArr.map((keyObj) => [
-                        CACHE_EVENTS.WRITTEN,
+                        CACHE_EVENTS.REMOVED,
                         {
-                            type: "removed",
-                            key: keyObj.get(),
+                            key: keyObj,
                         },
                     ]);
                     for (const [eventName, event] of events) {
@@ -458,7 +524,7 @@ export class Cache {
                     const events = keyObjArr.map((keyObj) => [
                         CACHE_EVENTS.NOT_FOUND,
                         {
-                            key: keyObj.get(),
+                            key: keyObj,
                         },
                     ]);
                     for (const [eventName, event] of events) {