feat(core-kernel): dispatch cache events

Author: faustbrian

__tests__/unit/core-kernel/services/cache/drivers/memory.test.ts

@@ -1,6 +1,10 @@
 import "jest-extended";
+
+import { Application } from "@packages/core-kernel/src/application";
+import { Container, Identifiers } from "@packages/core-kernel/src/ioc";
 import { MemoryCacheStore } from "@packages/core-kernel/src/services/cache/drivers/memory";
 import { NotImplemented } from "@packages/core-kernel/src/exceptions/runtime";
+import { MemoryEventDispatcher } from "@packages/core-kernel/src/services/events/drivers/memory";
 
 const items: Record<string, number> = {
     "1": 1,
@@ -14,8 +18,17 @@ const itemsBool: boolean[] = new Array(5).fill(true);
 const itemsTruthy: boolean[] = new Array(5).fill(true);
 const itemsFalsey: boolean[] = new Array(5).fill(false);
 
+let app: Application;
 let store: MemoryCacheStore<string, number>;
-beforeEach(() => (store = new MemoryCacheStore<string, number>()));
+beforeEach(() => {
+    app = new Application(new Container());
+
+    app.bind(Identifiers.EventDispatcherService)
+        .to(MemoryEventDispatcher)
+        .inSingletonScope();
+
+    store = app.resolve(MemoryCacheStore);
+});
 
 describe("MemoryCacheStore", () => {
     it("should make a new instance", async () => {

__tests__/unit/core-kernel/services/cache/service-provider.test.ts

@@ -4,10 +4,16 @@ import { Application } from "@packages/core-kernel/src/application";
 import { Container, Identifiers } from "@packages/core-kernel/src/ioc";
 import { ServiceProvider } from "@packages/core-kernel/src/services/cache";
 import { MemoryCacheStore } from "@packages/core-kernel/src/services/cache/drivers/memory";
+import { MemoryEventDispatcher } from "@packages/core-kernel/src/services/events/drivers/memory";
 
 let app: Application;
+beforeEach(() => {
+    app = new Application(new Container());
 
-beforeEach(() => (app = new Application(new Container())));
+    app.bind(Identifiers.EventDispatcherService)
+        .to(MemoryEventDispatcher)
+        .inSingletonScope();
+});
 
 describe("CacheServiceProvider", () => {
     it(".register", async () => {

packages/core-kernel/src/enums/events.ts

@@ -12,6 +12,18 @@ export enum KernelEvent {
     ServiceProviderRegistered = "kernel.serviceProvider.registered",
 }
 
+/**
+ * @export
+ * @enum {number}
+ */
+export enum CacheEvent {
+    Flushed = "cache.flushed",
+    Forgotten = "cache.forgotten",
+    Hit = "cache.hit",
+    Missed = "cache.missed",
+    Written = "cache.written",
+}
+
 /**
  * @export
  * @enum {number}

packages/core-kernel/src/services/cache/drivers/memory.ts

@@ -1,6 +1,8 @@
+import { EventDispatcher } from "../../../contracts/kernel";
 import { CacheStore } from "../../../contracts/kernel/cache";
+import { CacheEvent } from "../../../enums";
 import { NotImplemented } from "../../../exceptions/runtime";
-import { injectable } from "../../../ioc";
+import { Identifiers, inject, injectable } from "../../../ioc";
 
 /**
  * @export
@@ -9,6 +11,14 @@ import { injectable } from "../../../ioc";
  */
 @injectable()
 export class MemoryCacheStore<K, T> implements CacheStore<K, T> {
+    /**
+     * @private
+     * @type {EventDispatcher}
+     * @memberof BlockJob
+     */
+    @inject(Identifiers.EventDispatcherService)
+    private readonly eventDispatcher!: EventDispatcher;
+
     /**
      * @private
      * @type {Map<K, T>}
@@ -65,7 +75,13 @@ export class MemoryCacheStore<K, T> implements CacheStore<K, T> {
      * @memberof MemoryCacheStore
      */
     public async get(key: K): Promise<T | undefined> {
-        return this.store.get(key);
+        const value: T | undefined = this.store.get(key);
+
+        value
+            ? this.eventDispatcher.dispatch(CacheEvent.Hit, { key, value })
+            : this.eventDispatcher.dispatch(CacheEvent.Missed, { key });
+
+        return value;
     }
 
     /**
@@ -91,6 +107,10 @@ export class MemoryCacheStore<K, T> implements CacheStore<K, T> {
     public async put(key: K, value: T, seconds?: number): Promise<boolean> {
         this.store.set(key, value);
 
+        if (this.has(key)) {
+            this.eventDispatcher.dispatch(CacheEvent.Written, { key, value, seconds });
+        }
+
         return this.has(key);
     }
 
@@ -183,6 +203,10 @@ export class MemoryCacheStore<K, T> implements CacheStore<K, T> {
     public async forget(key: K): Promise<boolean> {
         this.store.delete(key);
 
+        if (this.missing(key)) {
+            this.eventDispatcher.dispatch(CacheEvent.Forgotten, { key });
+        }
+
         return this.missing(key);
     }
 
@@ -206,6 +230,8 @@ export class MemoryCacheStore<K, T> implements CacheStore<K, T> {
     public async flush(): Promise<boolean> {
         this.store.clear();
 
+        this.eventDispatcher.dispatch(CacheEvent.Flushed);
+
         return this.store.size === 0;
     }