@daiso-tech/core 0.33.0 → 0.35.0

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

@@ -6,7 +6,7 @@ import { type TimeSpan, type IInitizable, type IDeinitizable, type IPrunable, ty
 import type { ISerde } from "../../../../serde/contracts/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache/adapters"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache/adapters"`
  * @group Adapters
  */
 export type SqliteCacheAdapterSettings = {
@@ -17,9 +17,9 @@ export type SqliteCacheAdapterSettings = {
     shouldRemoveExpiredKeys?: boolean;
 };
 /**
- * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, with adapter like <i>{@link SuperJsonSerdeAdapter}</i>.
+ * To utilize the `SqliteCacheAdapter`, you must install the `"better-sqlite3"` package and supply a {@link ISerde | `ISerde<string>`}, with adapter like {@link SuperJsonSerdeAdapter | `SuperJsonSerdeAdapter `}.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache/adapters"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache/adapters"`
  * @group Adapters
  */
 export declare class SqliteCacheAdapter<TType = unknown> implements IDatabaseCacheAdapter<TType>, IInitizable, IDeinitizable, IPrunable {

package/dist/cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter.js

@@ -8,9 +8,9 @@ import { KyselyTableNameTransformerPlugin, } from "../../../../utilities/_module
 import { Kysely, SqliteDialect } from "kysely";
 import { KyselyCacheAdapter } from "../../../../cache/implementations/adapters/kysely-cache-adapter/_module.js";
 /**
- * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, with adapter like <i>{@link SuperJsonSerdeAdapter}</i>.
+ * To utilize the `SqliteCacheAdapter`, you must install the `"better-sqlite3"` package and supply a {@link ISerde | `ISerde<string>`}, with adapter like {@link SuperJsonSerdeAdapter | `SuperJsonSerdeAdapter `}.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache/adapters"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache/adapters"`
  * @group Adapters
  */
 export class SqliteCacheAdapter {

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

@@ -1,22 +1,22 @@
 /**
  * @module Cache
  */
-import type { CacheEvents, IDatabaseCacheAdapter } from "../../../../cache/contracts/_module-exports.js";
+import type { CacheEventMap, IDatabaseCacheAdapter } from "../../../../cache/contracts/_module-exports.js";
 import { type ICache, type ICacheAdapter } from "../../../../cache/contracts/_module-exports.js";
 import { type AsyncLazyable, type OneOrMore } from "../../../../utilities/_module-exports.js";
 import { type NoneFunc, type TimeSpan, KeyPrefixer } from "../../../../utilities/_module-exports.js";
 import { LazyPromise } from "../../../../async/_module-exports.js";
-import type { IEventBus, Unsubscribe, EventClass, EventInstance, EventListener } from "../../../../event-bus/contracts/_module-exports.js";
+import type { IEventBus, Unsubscribe, EventListener } from "../../../../event-bus/contracts/_module-exports.js";
 import type { AsyncLazy, Factory } from "../../../../utilities/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache"`
  * @group Derivables
  */
 export type CacheSettingsBase = {
     keyPrefixer: KeyPrefixer;
     /**
-     * You can pass a <i>{@link Factory}</i> of <i>{@link LazyPromise}</i> to configure default settings for all <i>{@link LazyPromise}</i> instances used in the <i>Cache</i> class.
+     * You can pass a {@link Factory | `Factory`} of {@link LazyPromise| `LazyPromise`} to configure default settings for all {@link LazyPromise| `LazyPromise`} instances used in the `Cache` class.
      * @default
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core/async";
@@ -38,7 +38,7 @@ export type CacheSettingsBase = {
      * })
      * ```
      */
-    eventBus?: IEventBus<any>;
+    eventBus?: IEventBus;
     /**
      * You can decide the default ttl value. If null is passed then no ttl will be used by default.
      * @default {null}
@@ -47,13 +47,13 @@ export type CacheSettingsBase = {
 };
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache"`
  * @group Derivables
  */
 export type CacheAdapter<TType> = ICacheAdapter<TType> | IDatabaseCacheAdapter<TType>;
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache"`
  * @group Derivables
  */
 export type CacheSettings = CacheSettingsBase & {
@@ -61,11 +61,10 @@ export type CacheSettings = CacheSettingsBase & {
 };
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache"`
  * @group Derivables
  */
 export declare class Cache<TType = unknown> implements ICache<TType> {
-    private static defaultRetryPolicy;
     private readonly eventBus;
     private readonly adapterFactoryable;
     private readonly adapter;
@@ -100,35 +99,35 @@ export declare class Cache<TType = unknown> implements ICache<TType> {
      */
     constructor(settings: CacheSettings);
     /**
-     * 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>.
+     * 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<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListener<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): LazyPromise<void>;
     /**
-     * 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>.
+     * 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<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): LazyPromise<void>;
     /**
-     * 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>.
+     * 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<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): LazyPromise<void>;
     /**
-     * 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>.
+     * 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<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
+    asPromise<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName): LazyPromise<CacheEventMap<TType>[TEventName]>;
     /**
-     * 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>.
+     * 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<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeOnce<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): LazyPromise<Unsubscribe>;
     /**
-     * You can listen to the following <i>{@link CacheEvents}</i> of the <i>{@link ICache}</i> instance.
-     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     * 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<TEventClass extends EventClass<CacheEvents<TType>>>(event: TEventClass, listener: EventListener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribe<TEventName extends keyof CacheEventMap<TType>>(eventName: TEventName, listener: EventListener<CacheEventMap<TType>[TEventName]>): LazyPromise<Unsubscribe>;
     private createLazyPromise;
     exists(key: OneOrMore<string>): LazyPromise<boolean>;
     missing(key: OneOrMore<string>): LazyPromise<boolean>;

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

@@ -2,7 +2,7 @@
 /**
  * @module Cache
  */
-import { KeyFoundCacheEvent, KeyNotFoundCacheEvent, KeyAddedCacheEvent, KeyUpdatedCacheEvent, KeyRemovedCacheEvent, KeyIncrementedCacheEvent, KeyDecrementedCacheEvent, KeysClearedCacheEvent, UnexpectedErrorCacheEvent, } from "../../../../cache/contracts/_module-exports.js";
+import { CACHE_EVENTS, } from "../../../../cache/contracts/_module-exports.js";
 import { KeyNotFoundCacheError, TypeCacheError, } from "../../../../cache/contracts/_module-exports.js";
 import { isAsyncFactory, resolveAsyncLazyable, resolveFactory, } from "../../../../utilities/_module-exports.js";
 import {} from "../../../../utilities/_module-exports.js";
@@ -14,14 +14,10 @@ import { isDatabaseCacheAdapter } from "../../../../cache/implementations/deriva
 import { DatabaseCacheAdapter } from "../../../../cache/implementations/derivables/cache/database-cache-adapter.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache"`
  * @group Derivables
  */
 export class Cache {
-    static defaultRetryPolicy = (error) => {
-        return !(error instanceof TypeCacheError ||
-            error instanceof KeyNotFoundCacheError);
-    };
     eventBus;
     adapterFactoryable;
     adapter;
@@ -72,49 +68,49 @@ export class Cache {
         }
     }
     /**
-     * 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>.
+     * 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(event, listener) {
-        return this.eventBus.addListener(event, listener);
+    addListener(eventName, listener) {
+        return this.eventBus.addListener(eventName, 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>.
+     * 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(event, listener) {
-        return this.eventBus.removeListener(event, listener);
+    removeListener(eventName, listener) {
+        return this.eventBus.removeListener(eventName, 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>.
+     * 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(event, listener) {
-        return this.eventBus.listenOnce(event, listener);
+    listenOnce(eventName, listener) {
+        return this.eventBus.listenOnce(eventName, 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>.
+     * 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(event) {
-        return this.eventBus.asPromise(event);
+    asPromise(eventName) {
+        return this.eventBus.asPromise(eventName);
     }
     /**
-     * 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>.
+     * 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(event, listener) {
-        return this.eventBus.subscribeOnce(event, listener);
+    subscribeOnce(eventName, listener) {
+        return this.eventBus.subscribeOnce(eventName, 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>.
+     * 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(event, listener) {
-        return this.eventBus.subscribe(event, listener);
+    subscribe(eventName, listener) {
+        return this.eventBus.subscribe(eventName, listener);
     }
     createLazyPromise(asyncFn) {
-        return this.lazyPromiseFactory(asyncFn).setRetryPolicy(Cache.defaultRetryPolicy);
+        return this.lazyPromiseFactory(asyncFn);
     }
     exists(key) {
         return new LazyPromise(async () => {
@@ -135,28 +131,28 @@ export class Cache {
                 const value = await this.adapter.get(keyObj.prefixed);
                 if (value === null) {
                     this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.NOT_FOUND, {
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 else {
                     this.eventBus
-                        .dispatch(new KeyFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.FOUND, {
                         key: keyObj.resolved,
                         value,
-                    }))
+                    })
                         .defer();
                 }
                 return value;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     method: this.get.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -178,33 +174,34 @@ export class Cache {
                 const value = await this.adapter.getAndRemove(keyObj.prefixed);
                 if (value === null) {
                     this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.NOT_FOUND, {
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 else {
                     this.eventBus
-                        .dispatch(new KeyFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.FOUND, {
                         key: keyObj.resolved,
                         value,
-                    }))
+                    })
                         .defer();
                     this.eventBus
-                        .dispatch(new KeyRemovedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "removed",
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 return value;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     method: this.get.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -238,23 +235,24 @@ export class Cache {
                 const hasAdded = await this.adapter.add(keyObj.prefixed, value, ttl);
                 if (hasAdded) {
                     this.eventBus
-                        .dispatch(new KeyAddedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "added",
                         key: keyObj.resolved,
                         value,
                         ttl,
-                    }))
+                    })
                         .defer();
                 }
                 return hasAdded;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     value,
                     method: this.add.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -267,31 +265,33 @@ export class Cache {
                 const hasUpdated = await this.adapter.put(keyObj.prefixed, value, ttl);
                 if (hasUpdated) {
                     this.eventBus
-                        .dispatch(new KeyUpdatedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "updated",
                         key: keyObj.resolved,
                         value,
-                    }))
+                    })
                         .defer();
                 }
                 else {
                     this.eventBus
-                        .dispatch(new KeyAddedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "added",
                         key: keyObj.resolved,
                         value,
                         ttl,
-                    }))
+                    })
                         .defer();
                 }
                 return hasUpdated;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     value,
                     method: this.put.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -304,29 +304,30 @@ export class Cache {
                 const hasUpdated = await this.adapter.update(keyObj.prefixed, value);
                 if (hasUpdated) {
                     this.eventBus
-                        .dispatch(new KeyUpdatedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "updated",
                         key: keyObj.resolved,
                         value,
-                    }))
+                    })
                         .defer();
                 }
                 else {
                     this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.NOT_FOUND, {
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 return hasUpdated;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     value,
                     method: this.update.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -339,39 +340,41 @@ export class Cache {
                 const hasUpdated = await this.adapter.increment(keyObj.prefixed, value);
                 if (hasUpdated && value > 0) {
                     this.eventBus
-                        .dispatch(new KeyIncrementedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "incremented",
                         key: keyObj.resolved,
                         value,
-                    }))
+                    })
                         .defer();
                 }
                 if (hasUpdated && value < 0) {
                     this.eventBus
-                        .dispatch(new KeyDecrementedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "decremented",
                         key: keyObj.resolved,
                         value: -value,
-                    }))
+                    })
                         .defer();
                 }
                 if (!hasUpdated) {
                     this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.NOT_FOUND, {
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 return hasUpdated;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     value,
                     method: this.increment.name,
                     error,
-                }))
+                })
                     .defer();
-                throw error;
+                throw new TypeCacheError(`Unable to increment or decrement none number type key "${keyObj.resolved}"`, error);
             }
         });
     }
@@ -389,27 +392,28 @@ export class Cache {
                 ]);
                 if (hasRemoved) {
                     this.eventBus
-                        .dispatch(new KeyRemovedCacheEvent({
+                        .dispatch(CACHE_EVENTS.WRITTEN, {
+                        type: "removed",
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 else {
                     this.eventBus
-                        .dispatch(new KeyNotFoundCacheEvent({
+                        .dispatch(CACHE_EVENTS.NOT_FOUND, {
                         key: keyObj.resolved,
-                    }))
+                    })
                         .defer();
                 }
                 return hasRemoved;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: [keyObj.resolved],
                     method: this.remove.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -425,30 +429,37 @@ export class Cache {
             try {
                 const hasRemovedAtLeastOne = await this.adapter.removeMany(keyObjArr.map((keyObj) => keyObj.prefixed));
                 if (hasRemovedAtLeastOne) {
-                    const events = keyObjArr.map((keyObj) => new KeyRemovedCacheEvent({
-                        key: keyObj.resolved,
-                    }));
-                    for (const event of events) {
-                        this.eventBus.dispatch(event).defer();
+                    const events = keyObjArr.map((keyObj) => [
+                        CACHE_EVENTS.WRITTEN,
+                        {
+                            type: "removed",
+                            key: keyObj.resolved,
+                        },
+                    ]);
+                    for (const [eventName, event] of events) {
+                        this.eventBus.dispatch(eventName, event).defer();
                     }
                 }
                 else {
-                    const events = keyObjArr.map((keyObj) => new KeyNotFoundCacheEvent({
-                        key: keyObj.resolved,
-                    }));
-                    for (const event of events) {
-                        this.eventBus.dispatch(event).defer();
+                    const events = keyObjArr.map((keyObj) => [
+                        CACHE_EVENTS.NOT_FOUND,
+                        {
+                            key: keyObj.resolved,
+                        },
+                    ]);
+                    for (const [eventName, event] of events) {
+                        this.eventBus.dispatch(eventName, event).defer();
                     }
                 }
                 return hasRemovedAtLeastOne;
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     keys: keyObjArr.map((keyObj) => keyObj.resolved),
                     method: this.remove.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }
@@ -457,7 +468,7 @@ export class Cache {
     clear() {
         return this.createLazyPromise(async () => {
             try {
-                const promise = this.eventBus.dispatch(new KeysClearedCacheEvent({}));
+                const promise = this.eventBus.dispatch(CACHE_EVENTS.CLEARED, {});
                 if (isAsyncFactory(this.adapterFactoryable)) {
                     await this.adapter.removeAll();
                     promise.defer();
@@ -468,10 +479,10 @@ export class Cache {
             }
             catch (error) {
                 this.eventBus
-                    .dispatch(new UnexpectedErrorCacheEvent({
+                    .dispatch(CACHE_EVENTS.UNEXPECTED_ERROR, {
                     method: this.clear.name,
                     error,
-                }))
+                })
                     .defer();
                 throw error;
             }