Added support for Observable/Listener of AfterDelete<T> events

Author: calvin-mbp-2019

Diff for: .vscode/launch.json

@@ -10,7 +10,7 @@
       "name": "Debug runner.ts",
       "skipFiles": ["<node_internals>/**"],
       "program": "${workspaceFolder}/src/runner.ts",
-      // "preLaunchTask": "tsc: build - tsconfig.json",
+      "preLaunchTask": "tsc: build - tsconfig.json",
       "outFiles": ["${workspaceFolder}/**/*.js"]
     }
   ]

Diff for: src/gang-of-four/observer.ts

@@ -17,6 +17,15 @@ export interface AfterSet<T> {
   createdAt: Date;
 }
 
+export interface BeforeDelete<T> {
+  existingValue: T | null;
+}
+
+export interface AfterDelete<T> {
+  existingValue: T;
+  deletedAt: Date;
+}
+
 /* this function returns an object with two members; i.e. two functions; namely
  * one to subscribe to events and one to publish an event that is observed by its
  * subscribed listeners. NOTE: that this function defines an inline type that could
@@ -55,12 +64,12 @@ export function createObserver<EventType>(): {
 }
 
 export interface ObservableDatabase<T extends Indexable> extends Database<T> {
-  set(value: T): T;
-  get(id: string): T | null;
-
   // The observable event hooks
   onBeforeSet(Listener: Listener<BeforeSet<T>>): () => void;
   onAfterSet(Listener: Listener<AfterSet<T>>): () => void;
+
+  onBeforeDelete(Listener: Listener<BeforeDelete<T>>): () => void;
+  onAfterDelete(Listener: Listener<AfterDelete<T>>): () => void;
 }
 
 export function createSingletonObservableDatabase<T extends Indexable>() {
@@ -106,6 +115,24 @@ export function createSingletonObservableDatabase<T extends Indexable>() {
       return this.dataStorage.get(id) ?? null;
     }
 
+    public delete(id: string): void {
+      // WARNING: race condition can occur between check and actual delete
+      const target = this.dataStorage.get(id);
+      if (target) {
+        this._beforeDeleteListeners.publish({
+          existingValue: target,
+        });
+      }
+
+      const deleted = this.dataStorage.delete(id);
+      if (target && deleted) {
+        this._afterDeleteListeners.publish({
+          existingValue: target,
+          deletedAt: new Date(),
+        });
+      }
+    }
+
     // The observable event hooks
     private _beforeAddListeners = createObserver<BeforeSet<T>>();
     private _afterAddListeners = createObserver<AfterSet<T>>();
@@ -116,6 +143,16 @@ export function createSingletonObservableDatabase<T extends Indexable>() {
     onAfterSet(listener: Listener<AfterSet<T>>): () => void {
       return this._afterAddListeners.subscribe(listener);
     }
+
+    private _beforeDeleteListeners = createObserver<BeforeDelete<T>>();
+    private _afterDeleteListeners = createObserver<AfterDelete<T>>();
+
+    onBeforeDelete(listener: Listener<BeforeDelete<T>>): () => void {
+      return this._beforeDeleteListeners.subscribe(listener);
+    }
+    onAfterDelete(listener: Listener<AfterDelete<T>>): () => void {
+      return this._afterDeleteListeners.subscribe(listener);
+    }
   }
 
   // NOTE: this may be odd but this does allow a class; rather than a function

Diff for: src/runner.ts

@@ -116,30 +116,22 @@ console.log(
   "Adding Observable Design Pattern on top of Factory and Singleton Database Intance rather than previous instances."
 );
 
-debugger;
 const RedisObservableDatabaseFromFactory =
   createSingletonObservableDatabase<Person>();
-// Add observer with a function that receives an instance that we destruture to just the value
-// RedisObservableDatabaseFromFactory.instance.onAfterSet(
-//   ({ existingValue, newValue, createdAt }) => {
-//     console.log(
-//       "Observable callback triggered from Observable Database AfterSet event triggered"
-//     );
-//     console.table({ createdAt, existingValue, newValue });
-//   }
-// );
-
-RedisObservableDatabaseFromFactory.instance.onAfterSet((event) => {
-  console.log(
-    "Observable callback triggered from Observable Database AfterSet event triggered"
-  );
-  console.table({
-    fromValue: event.existingValue,
-    to: event.newValue,
-    happenedAt: event.createdAt.toDateString(),
+
+// Add observer with a function that receives an instance of <T> log for visibility; can also destruture to just the value
+const terminateAfterSetSubscription =
+  RedisObservableDatabaseFromFactory.instance.onAfterSet((event) => {
+    console.log(
+      "Observable callback triggered from Observable Database AfterSet event triggered"
+    );
+    console.table({
+      fromValue: event.existingValue,
+      toValue: event.newValue,
+      happenedAt: event.createdAt.toDateString(),
+    });
+    // console.table({ ...event });
   });
-  // console.table({ ...event });
-});
 
 // Set it initially with no prior value
 RedisObservableDatabaseFromFactory.instance.set(<Engineer>{
@@ -158,3 +150,42 @@ RedisObservableDatabaseFromFactory.instance.set(<Engineer>{
   role: "director of FSD.V2",
   level: 46,
 });
+
+// Now terminate subscription and expect that no more events are dispatched for this AfterSet<T> listener
+terminateAfterSetSubscription();
+console.log(
+  'AfterSet listener has unsubscribed and will not receive the "V3" updates from Observable Database and has no readily available reference to re-subscribe once termianted.'
+);
+// Set it again to see the prior value
+RedisObservableDatabaseFromFactory.instance.set(<Engineer>{
+  id: karpathy,
+  name: "Andrei Karpathy.V3",
+  description: "ML/AI Engineer.V3",
+  role: "director of FSD.V3",
+  level: 46,
+});
+
+console.log("\n\r");
+console.log("AfterDelete listener subscribed to track deletes.");
+
+const terminateAfterDeleteSubscription =
+  RedisObservableDatabaseFromFactory.instance.onAfterDelete((event) => {
+    console.log(
+      "Observable AfterDelete event callback triggered from Observable Database "
+    );
+    console.table({
+      fromValue: event.existingValue,
+      happenedAt: event.deletedAt.toDateString(),
+    });
+  });
+
+// Delete the last modified record V3 instance of the reord
+RedisObservableDatabaseFromFactory.instance.delete(karpathy);
+
+console.log(
+  "Confirming the deleted record is no longer retrievable from Database."
+);
+const goner = RedisObservableDatabaseFromFactory.instance.get(karpathy);
+console.table({ goner });
+
+terminateAfterDeleteSubscription();

Diff for: tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "strict": true
-    // "sourceMap": true
+    "strict": true,
+    "sourceMap": true
   }
 }