@decaf-ts/core 0.5.0 → 0.5.2

package/lib/persistence/Dispatch.cjs

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatch = void 0;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const Adapter_1 = require("./Adapter.cjs");
+const errors_1 = require("./errors.cjs");
+const logging_1 = require("@decaf-ts/logging");
+/**
+ * @description Dispatches database operation events to observers
+ * @summary The Dispatch class implements the Observable interface and is responsible for intercepting
+ * database operations from an Adapter and notifying observers when changes occur. It uses proxies to
+ * wrap the adapter's CRUD methods and automatically trigger observer updates after operations complete.
+ * @template Y - The native database driver type
+ * @param {void} - No constructor parameters
+ * @class Dispatch
+ * @example
+ * ```typescript
+ * // Creating and using a Dispatch instance
+ * const dispatch = new Dispatch<PostgresDriver>();
+ *
+ * // Connect it to an adapter
+ * const adapter = new PostgresAdapter(connection);
+ * dispatch.observe(adapter);
+ *
+ * // Now any CRUD operations on the adapter will automatically
+ * // trigger observer notifications
+ * await adapter.create('users', 123, userModel);
+ * // Observers will be notified about the creation
+ *
+ * // When done, you can disconnect
+ * dispatch.unObserve(adapter);
+ * ```
+ */
+class Dispatch {
+    /**
+     * @description Accessor for the logger
+     * @summary Gets or initializes the logger for this dispatch instance
+     * @return {Logger} The logger instance
+     */
+    get log() {
+        if (!this.logger)
+            this.logger = logging_1.Logging.for(this).for(this.adapter);
+        return this.logger;
+    }
+    /**
+     * @description Creates a new Dispatch instance
+     * @summary Initializes a new Dispatch instance without any adapter
+     */
+    constructor() { }
+    /**
+     * @description Initializes the dispatch by proxying adapter methods
+     * @summary Sets up proxies on the adapter's CRUD methods to intercept operations and notify observers.
+     * This method is called automatically when an adapter is observed.
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     * @mermaid
+     * sequenceDiagram
+     *   participant Dispatch
+     *   participant Adapter
+     *   participant Proxy
+     *
+     *   Dispatch->>Dispatch: initialize()
+     *   Dispatch->>Dispatch: Check if adapter exists
+     *   alt No adapter
+     *     Dispatch-->>Dispatch: Throw InternalError
+     *   end
+     *
+     *   loop For each CRUD method
+     *     Dispatch->>Adapter: Check if method exists
+     *     alt Method doesn't exist
+     *       Dispatch-->>Dispatch: Throw InternalError
+     *     end
+     *
+     *     Dispatch->>Adapter: Get property descriptor
+     *     loop While descriptor not found
+     *       Dispatch->>Adapter: Check prototype chain
+     *     end
+     *
+     *     alt Descriptor not found or not writable
+     *       Dispatch->>Dispatch: Log error and continue
+     *     else Descriptor found and writable
+     *       Dispatch->>Proxy: Create proxy for method
+     *       Dispatch->>Adapter: Replace method with proxy
+     *     end
+     *   end
+     */
+    async initialize() {
+        if (!this.adapter)
+            throw new db_decorators_1.InternalError(`No adapter observed for dispatch`);
+        const adapter = this.adapter;
+        [
+            db_decorators_1.OperationKeys.CREATE,
+            db_decorators_1.OperationKeys.UPDATE,
+            db_decorators_1.OperationKeys.DELETE,
+            db_decorators_1.BulkCrudOperationKeys.CREATE_ALL,
+            db_decorators_1.BulkCrudOperationKeys.UPDATE_ALL,
+            db_decorators_1.BulkCrudOperationKeys.DELETE_ALL,
+        ].forEach((method) => {
+            if (!adapter[method])
+                throw new db_decorators_1.InternalError(`Method ${method} not found in ${adapter.alias} adapter to bind Observables Dispatch`);
+            let descriptor = Object.getOwnPropertyDescriptor(adapter, method);
+            let proto = adapter;
+            while (!descriptor && proto !== Object.prototype) {
+                proto = Object.getPrototypeOf(proto);
+                descriptor = Object.getOwnPropertyDescriptor(proto, method);
+            }
+            if (!descriptor || !descriptor.writable) {
+                this.log.error(`Could not find method ${method} to bind Observables Dispatch`);
+                return;
+            }
+            function bulkToSingle(method) {
+                switch (method) {
+                    case db_decorators_1.BulkCrudOperationKeys.CREATE_ALL:
+                        return db_decorators_1.OperationKeys.CREATE;
+                    case db_decorators_1.BulkCrudOperationKeys.UPDATE_ALL:
+                        return db_decorators_1.OperationKeys.UPDATE;
+                    case db_decorators_1.BulkCrudOperationKeys.DELETE_ALL:
+                        return db_decorators_1.OperationKeys.DELETE;
+                    default:
+                        return method;
+                }
+            }
+            // @ts-expect-error because there are read only properties
+            adapter[method] = new Proxy(adapter[method], {
+                apply: async (target, thisArg, argArray) => {
+                    const [tableName, ids] = argArray;
+                    const result = await target.apply(thisArg, argArray);
+                    this.updateObservers(tableName, bulkToSingle(method), ids)
+                        .then(() => {
+                        this.log.verbose(`Observer refresh dispatched by ${method} for ${tableName}`);
+                        this.log.debug(`pks: ${ids}`);
+                    })
+                        .catch((e) => this.log.error(`Failed to dispatch observer refresh for ${method} on ${tableName}: ${e}`));
+                    return result;
+                },
+            });
+        });
+    }
+    /**
+     * @description Closes the dispatch
+     * @summary Performs any necessary cleanup when the dispatch is no longer needed
+     * @return {Promise<void>} A promise that resolves when closing is complete
+     */
+    async close() {
+        // to nothing in this instance but may be required for closing connections
+    }
+    /**
+     * @description Starts observing an adapter
+     * @summary Connects this dispatch to an adapter to monitor its operations
+     * @param {Adapter<Y, any, any, any>} observer - The adapter to observe
+     * @return {void}
+     */
+    observe(observer) {
+        if (!(observer instanceof Adapter_1.Adapter))
+            throw new errors_1.UnsupportedError("Only Adapters can be observed by dispatch");
+        this.adapter = observer;
+        this.native = observer.native;
+        this.models = Adapter_1.Adapter.models(this.adapter.alias);
+        this.initialize().then(() => this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`));
+    }
+    /**
+     * @description Stops observing an adapter
+     * @summary Disconnects this dispatch from an adapter
+     * @param {Observer} observer - The adapter to stop observing
+     * @return {void}
+     */
+    unObserve(observer) {
+        if (this.adapter !== observer)
+            throw new errors_1.UnsupportedError("Only the adapter that was used to observe can be unobserved");
+        this.adapter = undefined;
+    }
+    /**
+     * @description Updates observers about a database event
+     * @summary Notifies observers about a change in the database
+     * @param {string} table - The name of the table where the change occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     */
+    async updateObservers(table, event, id) {
+        if (!this.adapter)
+            throw new db_decorators_1.InternalError(`No adapter observed for dispatch`);
+        try {
+            await this.adapter.refresh(table, event, id);
+        }
+        catch (e) {
+            throw new db_decorators_1.InternalError(`Failed to refresh dispatch: ${e}`);
+        }
+    }
+}
+exports.Dispatch = Dispatch;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Dispatch.js","sourceRoot":"","sources":["../../src/persistence/Dispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  InternalError,\n  OperationKeys,\n  BulkCrudOperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Observable, Observer } from \"../interfaces\";\nimport { Adapter } from \"./Adapter\";\nimport { UnsupportedError } from \"./errors\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { EventIds } from \"./types\";\n\n/**\n * @description Dispatches database operation events to observers\n * @summary The Dispatch class implements the Observable interface and is responsible for intercepting\n * database operations from an Adapter and notifying observers when changes occur. It uses proxies to\n * wrap the adapter's CRUD methods and automatically trigger observer updates after operations complete.\n * @template Y - The native database driver type\n * @param {void} - No constructor parameters\n * @class Dispatch\n * @example\n * ```typescript\n * // Creating and using a Dispatch instance\n * const dispatch = new Dispatch<PostgresDriver>();\n *\n * // Connect it to an adapter\n * const adapter = new PostgresAdapter(connection);\n * dispatch.observe(adapter);\n *\n * // Now any CRUD operations on the adapter will automatically\n * // trigger observer notifications\n * await adapter.create('users', 123, userModel);\n * // Observers will be notified about the creation\n *\n * // When done, you can disconnect\n * dispatch.unObserve(adapter);\n * ```\n */\nexport class Dispatch<Y> implements Observable {\n  /**\n   * @description The adapter being observed\n   * @summary Reference to the database adapter whose operations are being monitored\n   */\n  protected adapter?: Adapter<Y, any, any, any>;\n\n  /**\n   * @description The native database driver\n   * @summary Reference to the underlying database driver from the adapter\n   */\n  protected native?: Y;\n\n  /**\n   * @description List of model constructors\n   * @summary Array of model constructors that are registered with the adapter\n   */\n  protected models!: ModelConstructor<any>[];\n\n  /**\n   * @description Logger instance\n   * @summary Logger for recording dispatch activities\n   */\n  private logger!: Logger;\n\n  /**\n   * @description Accessor for the logger\n   * @summary Gets or initializes the logger for this dispatch instance\n   * @return {Logger} The logger instance\n   */\n  protected get log() {\n    if (!this.logger)\n      this.logger = Logging.for(this as any).for(this.adapter as any);\n    return this.logger;\n  }\n\n  /**\n   * @description Creates a new Dispatch instance\n   * @summary Initializes a new Dispatch instance without any adapter\n   */\n  constructor() {}\n\n  /**\n   * @description Initializes the dispatch by proxying adapter methods\n   * @summary Sets up proxies on the adapter's CRUD methods to intercept operations and notify observers.\n   * This method is called automatically when an adapter is observed.\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   * @mermaid\n   * sequenceDiagram\n   *   participant Dispatch\n   *   participant Adapter\n   *   participant Proxy\n   *\n   *   Dispatch->>Dispatch: initialize()\n   *   Dispatch->>Dispatch: Check if adapter exists\n   *   alt No adapter\n   *     Dispatch-->>Dispatch: Throw InternalError\n   *   end\n   *\n   *   loop For each CRUD method\n   *     Dispatch->>Adapter: Check if method exists\n   *     alt Method doesn't exist\n   *       Dispatch-->>Dispatch: Throw InternalError\n   *     end\n   *\n   *     Dispatch->>Adapter: Get property descriptor\n   *     loop While descriptor not found\n   *       Dispatch->>Adapter: Check prototype chain\n   *     end\n   *\n   *     alt Descriptor not found or not writable\n   *       Dispatch->>Dispatch: Log error and continue\n   *     else Descriptor found and writable\n   *       Dispatch->>Proxy: Create proxy for method\n   *       Dispatch->>Adapter: Replace method with proxy\n   *     end\n   *   end\n   */\n  protected async initialize(): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    const adapter = this.adapter as Adapter<Y, any, any, any>;\n    (\n      [\n        OperationKeys.CREATE,\n        OperationKeys.UPDATE,\n        OperationKeys.DELETE,\n        BulkCrudOperationKeys.CREATE_ALL,\n        BulkCrudOperationKeys.UPDATE_ALL,\n        BulkCrudOperationKeys.DELETE_ALL,\n      ] as (keyof Adapter<Y, any, any, any>)[]\n    ).forEach((method) => {\n      if (!adapter[method])\n        throw new InternalError(\n          `Method ${method} not found in ${adapter.alias} adapter to bind Observables Dispatch`\n        );\n\n      let descriptor = Object.getOwnPropertyDescriptor(adapter, method);\n      let proto: any = adapter;\n      while (!descriptor && proto !== Object.prototype) {\n        proto = Object.getPrototypeOf(proto);\n        descriptor = Object.getOwnPropertyDescriptor(proto, method);\n      }\n\n      if (!descriptor || !descriptor.writable) {\n        this.log.error(\n          `Could not find method ${method} to bind Observables Dispatch`\n        );\n        return;\n      }\n      function bulkToSingle(method: string) {\n        switch (method) {\n          case BulkCrudOperationKeys.CREATE_ALL:\n            return OperationKeys.CREATE;\n          case BulkCrudOperationKeys.UPDATE_ALL:\n            return OperationKeys.UPDATE;\n          case BulkCrudOperationKeys.DELETE_ALL:\n            return OperationKeys.DELETE;\n          default:\n            return method;\n        }\n      }\n      // @ts-expect-error because there are read only properties\n      adapter[method] = new Proxy(adapter[method], {\n        apply: async (target: any, thisArg, argArray: any[]) => {\n          const [tableName, ids] = argArray;\n          const result = await target.apply(thisArg, argArray);\n          this.updateObservers(tableName, bulkToSingle(method), ids as EventIds)\n            .then(() => {\n              this.log.verbose(\n                `Observer refresh dispatched by ${method} for ${tableName}`\n              );\n              this.log.debug(`pks: ${ids}`);\n            })\n            .catch((e: unknown) =>\n              this.log.error(\n                `Failed to dispatch observer refresh for ${method} on ${tableName}: ${e}`\n              )\n            );\n          return result;\n        },\n      });\n    });\n  }\n\n  /**\n   * @description Closes the dispatch\n   * @summary Performs any necessary cleanup when the dispatch is no longer needed\n   * @return {Promise<void>} A promise that resolves when closing is complete\n   */\n  async close() {\n    // to nothing in this instance but may be required for closing connections\n  }\n\n  /**\n   * @description Starts observing an adapter\n   * @summary Connects this dispatch to an adapter to monitor its operations\n   * @param {Adapter<Y, any, any, any>} observer - The adapter to observe\n   * @return {void}\n   */\n  observe(observer: Adapter<Y, any, any, any>): void {\n    if (!(observer instanceof Adapter))\n      throw new UnsupportedError(\"Only Adapters can be observed by dispatch\");\n    this.adapter = observer;\n    this.native = observer.native;\n    this.models = Adapter.models(this.adapter.alias);\n    this.initialize().then(() =>\n      this.log.verbose(\n        `Dispatch initialized for ${this.adapter!.alias} adapter`\n      )\n    );\n  }\n\n  /**\n   * @description Stops observing an adapter\n   * @summary Disconnects this dispatch from an adapter\n   * @param {Observer} observer - The adapter to stop observing\n   * @return {void}\n   */\n  unObserve(observer: Observer): void {\n    if (this.adapter !== observer)\n      throw new UnsupportedError(\n        \"Only the adapter that was used to observe can be unobserved\"\n      );\n    this.adapter = undefined;\n  }\n\n  /**\n   * @description Updates observers about a database event\n   * @summary Notifies observers about a change in the database\n   * @param {string} table - The name of the table where the change occurred\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred\n   * @param {EventIds} id - The identifier(s) of the affected record(s)\n   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   */\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds\n  ): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    try {\n      await this.adapter.refresh(table, event, id);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n}\n"]}

package/lib/persistence/Dispatch.d.ts

@@ -0,0 +1,131 @@
+import { OperationKeys, BulkCrudOperationKeys } from "@decaf-ts/db-decorators";
+import { ModelConstructor } from "@decaf-ts/decorator-validation";
+import { Observable, Observer } from "../interfaces";
+import { Adapter } from "./Adapter";
+import { Logger } from "@decaf-ts/logging";
+import { EventIds } from "./types";
+/**
+ * @description Dispatches database operation events to observers
+ * @summary The Dispatch class implements the Observable interface and is responsible for intercepting
+ * database operations from an Adapter and notifying observers when changes occur. It uses proxies to
+ * wrap the adapter's CRUD methods and automatically trigger observer updates after operations complete.
+ * @template Y - The native database driver type
+ * @param {void} - No constructor parameters
+ * @class Dispatch
+ * @example
+ * ```typescript
+ * // Creating and using a Dispatch instance
+ * const dispatch = new Dispatch<PostgresDriver>();
+ *
+ * // Connect it to an adapter
+ * const adapter = new PostgresAdapter(connection);
+ * dispatch.observe(adapter);
+ *
+ * // Now any CRUD operations on the adapter will automatically
+ * // trigger observer notifications
+ * await adapter.create('users', 123, userModel);
+ * // Observers will be notified about the creation
+ *
+ * // When done, you can disconnect
+ * dispatch.unObserve(adapter);
+ * ```
+ */
+export declare class Dispatch<Y> implements Observable {
+    /**
+     * @description The adapter being observed
+     * @summary Reference to the database adapter whose operations are being monitored
+     */
+    protected adapter?: Adapter<Y, any, any, any>;
+    /**
+     * @description The native database driver
+     * @summary Reference to the underlying database driver from the adapter
+     */
+    protected native?: Y;
+    /**
+     * @description List of model constructors
+     * @summary Array of model constructors that are registered with the adapter
+     */
+    protected models: ModelConstructor<any>[];
+    /**
+     * @description Logger instance
+     * @summary Logger for recording dispatch activities
+     */
+    private logger;
+    /**
+     * @description Accessor for the logger
+     * @summary Gets or initializes the logger for this dispatch instance
+     * @return {Logger} The logger instance
+     */
+    protected get log(): Logger;
+    /**
+     * @description Creates a new Dispatch instance
+     * @summary Initializes a new Dispatch instance without any adapter
+     */
+    constructor();
+    /**
+     * @description Initializes the dispatch by proxying adapter methods
+     * @summary Sets up proxies on the adapter's CRUD methods to intercept operations and notify observers.
+     * This method is called automatically when an adapter is observed.
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     * @mermaid
+     * sequenceDiagram
+     *   participant Dispatch
+     *   participant Adapter
+     *   participant Proxy
+     *
+     *   Dispatch->>Dispatch: initialize()
+     *   Dispatch->>Dispatch: Check if adapter exists
+     *   alt No adapter
+     *     Dispatch-->>Dispatch: Throw InternalError
+     *   end
+     *
+     *   loop For each CRUD method
+     *     Dispatch->>Adapter: Check if method exists
+     *     alt Method doesn't exist
+     *       Dispatch-->>Dispatch: Throw InternalError
+     *     end
+     *
+     *     Dispatch->>Adapter: Get property descriptor
+     *     loop While descriptor not found
+     *       Dispatch->>Adapter: Check prototype chain
+     *     end
+     *
+     *     alt Descriptor not found or not writable
+     *       Dispatch->>Dispatch: Log error and continue
+     *     else Descriptor found and writable
+     *       Dispatch->>Proxy: Create proxy for method
+     *       Dispatch->>Adapter: Replace method with proxy
+     *     end
+     *   end
+     */
+    protected initialize(): Promise<void>;
+    /**
+     * @description Closes the dispatch
+     * @summary Performs any necessary cleanup when the dispatch is no longer needed
+     * @return {Promise<void>} A promise that resolves when closing is complete
+     */
+    close(): Promise<void>;
+    /**
+     * @description Starts observing an adapter
+     * @summary Connects this dispatch to an adapter to monitor its operations
+     * @param {Adapter<Y, any, any, any>} observer - The adapter to observe
+     * @return {void}
+     */
+    observe(observer: Adapter<Y, any, any, any>): void;
+    /**
+     * @description Stops observing an adapter
+     * @summary Disconnects this dispatch from an adapter
+     * @param {Observer} observer - The adapter to stop observing
+     * @return {void}
+     */
+    unObserve(observer: Observer): void;
+    /**
+     * @description Updates observers about a database event
+     * @summary Notifies observers about a change in the database
+     * @param {string} table - The name of the table where the change occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     */
+    updateObservers(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds): Promise<void>;
+}

package/lib/persistence/ObserverHandler.cjs

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObserverHandler = void 0;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+/**
+ * @description Manages a collection of observers for database events
+ * @summary The ObserverHandler class implements the Observable interface and provides a centralized
+ * way to manage multiple observers. It allows registering observers with optional filters to control
+ * which events they receive notifications for, and handles the process of notifying all relevant
+ * observers when database events occur.
+ * @class ObserverHandler
+ * @example
+ * ```typescript
+ * // Create an observer handler
+ * const handler = new ObserverHandler();
+ *
+ * // Register an observer
+ * const myObserver = {
+ *   refresh: async (table, event, id) => {
+ *     console.log(`Change in ${table}: ${event} for ID ${id}`);
+ *   }
+ * };
+ *
+ * // Add observer with a filter for only user table events
+ * handler.observe(myObserver, (table, event, id) => table === 'users');
+ *
+ * // Notify observers about an event
+ * await handler.updateObservers(logger, 'users', 'CREATE', 123);
+ *
+ * // Remove an observer when no longer needed
+ * handler.unObserve(myObserver);
+ * ```
+ */
+class ObserverHandler {
+    constructor() {
+        /**
+         * @description Collection of registered observers
+         * @summary Array of observer objects along with their optional filters
+         */
+        this.observers = [];
+    }
+    /**
+     * @description Gets the number of registered observers
+     * @summary Returns the count of observers currently registered with this handler
+     * @return {number} The number of registered observers
+     */
+    count() {
+        return this.observers.length;
+    }
+    /**
+     * @description Registers a new observer
+     * @summary Adds an observer to the collection with an optional filter function
+     * @param {Observer} observer - The observer to register
+     * @param {ObserverFilter} [filter] - Optional filter function to determine which events the observer receives
+     * @return {void}
+     */
+    observe(observer, filter) {
+        const index = this.observers.map((o) => o.observer).indexOf(observer);
+        if (index !== -1)
+            throw new db_decorators_1.InternalError("Observer already registered");
+        this.observers.push({ observer: observer, filter: filter });
+    }
+    /**
+     * @description Unregisters an observer
+     * @summary Removes an observer from the collection
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
+     */
+    unObserve(observer) {
+        const index = this.observers.map((o) => o.observer).indexOf(observer);
+        if (index === -1)
+            throw new db_decorators_1.InternalError("Failed to find Observer");
+        this.observers.splice(index, 1);
+    }
+    /**
+     * @description Notifies all relevant observers about a database event
+     * @summary Filters observers based on their filter functions and calls refresh on each matching observer
+     * @param {Logger} log - Logger for recording notification activities
+     * @param {string} table - The name of the table where the event occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @param {...any[]} args - Additional arguments to pass to the observers
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant ObserverHandler
+     *   participant Observer
+     *
+     *   Client->>ObserverHandler: updateObservers(log, table, event, id, ...args)
+     *
+     *   ObserverHandler->>ObserverHandler: Filter observers
+     *
+     *   loop For each observer with matching filter
+     *     alt Observer has filter
+     *       ObserverHandler->>Observer: Apply filter(table, event, id)
+     *       alt Filter throws error
+     *         ObserverHandler->>Logger: Log error
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       else Filter returns true
+     *         ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *       else Filter returns false
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       end
+     *     else No filter
+     *       ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *     end
+     *   end
+     *
+     *   ObserverHandler->>ObserverHandler: Process results
+     *   loop For each result
+     *     alt Result is rejected
+     *       ObserverHandler->>Logger: Log error
+     *     end
+     *   end
+     *
+     *   ObserverHandler-->>Client: Return
+     */
+    async updateObservers(log, table, event, id, ...args) {
+        const results = await Promise.allSettled(this.observers
+            .filter((o) => {
+            const { filter } = o;
+            if (!filter)
+                return true;
+            try {
+                return filter(table, event, id);
+            }
+            catch (e) {
+                log.error(`Failed to filter observer ${o.observer.toString()}: ${e}`);
+                return false;
+            }
+        })
+            .map((o) => o.observer.refresh(table, event, id, ...args)));
+        results.forEach((result, i) => {
+            if (result.status === "rejected")
+                log.error(`Failed to update observable ${this.observers[i].toString()}: ${result.reason}`);
+        });
+    }
+}
+exports.ObserverHandler = ObserverHandler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ObserverHandler.js","sourceRoot":"","sources":["../../src/persistence/ObserverHandler.ts"],"names":[],"mappings":";;;AAEA,2DAIiC;AAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,eAAe;IAA5B;QACE;;;WAGG;QACgB,cAAS,GAGtB,EAAE,CAAC;IA8GX,CAAC;IA5GC;;;;OAIG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,QAAkB,EAAE,MAAuB;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtE,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,IAAI,6BAAa,CAAC,6BAA6B,CAAC,CAAC;QACzE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,QAAkB;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtE,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,IAAI,6BAAa,CAAC,yBAAyB,CAAC,CAAC;QACrE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,KAAK,CAAC,eAAe,CACnB,GAAW,EACX,KAAa,EACb,KAAqD,EACrD,EAAY,EACZ,GAAG,IAAW;QAEd,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CACtC,IAAI,CAAC,SAAS;aACX,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;YACZ,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;YACrB,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC;YACzB,IAAI,CAAC;gBACH,OAAO,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YAClC,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,GAAG,CAAC,KAAK,CACP,6BAA6B,CAAC,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAC3D,CAAC;gBACF,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC,CAAC;aACD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,CAC7D,CAAC;QACF,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5B,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAC9B,GAAG,CAAC,KAAK,CACP,+BAA+B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,MAAM,CAAC,MAAM,EAAE,CAChF,CAAC;QACN,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAtHD,0CAsHC","sourcesContent":["import { Observable, Observer } from \"../interfaces\";\nimport { EventIds, ObserverFilter } from \"./types\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Logger } from \"@decaf-ts/logging\";\n\n/**\n * @description Manages a collection of observers for database events\n * @summary The ObserverHandler class implements the Observable interface and provides a centralized\n * way to manage multiple observers. It allows registering observers with optional filters to control\n * which events they receive notifications for, and handles the process of notifying all relevant\n * observers when database events occur.\n * @class ObserverHandler\n * @example\n * ```typescript\n * // Create an observer handler\n * const handler = new ObserverHandler();\n * \n * // Register an observer\n * const myObserver = {\n *   refresh: async (table, event, id) => {\n *     console.log(`Change in ${table}: ${event} for ID ${id}`);\n *   }\n * };\n * \n * // Add observer with a filter for only user table events\n * handler.observe(myObserver, (table, event, id) => table === 'users');\n * \n * // Notify observers about an event\n * await handler.updateObservers(logger, 'users', 'CREATE', 123);\n * \n * // Remove an observer when no longer needed\n * handler.unObserve(myObserver);\n * ```\n */\nexport class ObserverHandler implements Observable {\n  /**\n   * @description Collection of registered observers\n   * @summary Array of observer objects along with their optional filters\n   */\n  protected readonly observers: {\n    observer: Observer;\n    filter?: ObserverFilter;\n  }[] = [];\n\n  /**\n   * @description Gets the number of registered observers\n   * @summary Returns the count of observers currently registered with this handler\n   * @return {number} The number of registered observers\n   */\n  count() {\n    return this.observers.length;\n  }\n\n  /**\n   * @description Registers a new observer\n   * @summary Adds an observer to the collection with an optional filter function\n   * @param {Observer} observer - The observer to register\n   * @param {ObserverFilter} [filter] - Optional filter function to determine which events the observer receives\n   * @return {void}\n   */\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    const index = this.observers.map((o) => o.observer).indexOf(observer);\n    if (index !== -1) throw new InternalError(\"Observer already registered\");\n    this.observers.push({ observer: observer, filter: filter });\n  }\n\n  /**\n   * @description Unregisters an observer\n   * @summary Removes an observer from the collection\n   * @param {Observer} observer - The observer to unregister\n   * @return {void}\n   */\n  unObserve(observer: Observer): void {\n    const index = this.observers.map((o) => o.observer).indexOf(observer);\n    if (index === -1) throw new InternalError(\"Failed to find Observer\");\n    this.observers.splice(index, 1);\n  }\n\n  /**\n   * @description Notifies all relevant observers about a database event\n   * @summary Filters observers based on their filter functions and calls refresh on each matching observer\n   * @param {Logger} log - Logger for recording notification activities\n   * @param {string} table - The name of the table where the event occurred\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred\n   * @param {EventIds} id - The identifier(s) of the affected record(s)\n   * @param {...any[]} args - Additional arguments to pass to the observers\n   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant ObserverHandler\n   *   participant Observer\n   *   \n   *   Client->>ObserverHandler: updateObservers(log, table, event, id, ...args)\n   *   \n   *   ObserverHandler->>ObserverHandler: Filter observers\n   *   \n   *   loop For each observer with matching filter\n   *     alt Observer has filter\n   *       ObserverHandler->>Observer: Apply filter(table, event, id)\n   *       alt Filter throws error\n   *         ObserverHandler->>Logger: Log error\n   *         ObserverHandler-->>ObserverHandler: Skip observer\n   *       else Filter returns true\n   *         ObserverHandler->>Observer: refresh(table, event, id, ...args)\n   *       else Filter returns false\n   *         ObserverHandler-->>ObserverHandler: Skip observer\n   *       end\n   *     else No filter\n   *       ObserverHandler->>Observer: refresh(table, event, id, ...args)\n   *     end\n   *   end\n   *   \n   *   ObserverHandler->>ObserverHandler: Process results\n   *   loop For each result\n   *     alt Result is rejected\n   *       ObserverHandler->>Logger: Log error\n   *     end\n   *   end\n   *   \n   *   ObserverHandler-->>Client: Return\n   */\n  async updateObservers(\n    log: Logger,\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    const results = await Promise.allSettled(\n      this.observers\n        .filter((o) => {\n          const { filter } = o;\n          if (!filter) return true;\n          try {\n            return filter(table, event, id);\n          } catch (e: unknown) {\n            log.error(\n              `Failed to filter observer ${o.observer.toString()}: ${e}`\n            );\n            return false;\n          }\n        })\n        .map((o) => o.observer.refresh(table, event, id, ...args))\n    );\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\")\n        log.error(\n          `Failed to update observable ${this.observers[i].toString()}: ${result.reason}`\n        );\n    });\n  }\n}\n"]}

package/lib/persistence/ObserverHandler.d.ts

@@ -0,0 +1,109 @@
+import { Observable, Observer } from "../interfaces";
+import { EventIds, ObserverFilter } from "./types";
+import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
+import { Logger } from "@decaf-ts/logging";
+/**
+ * @description Manages a collection of observers for database events
+ * @summary The ObserverHandler class implements the Observable interface and provides a centralized
+ * way to manage multiple observers. It allows registering observers with optional filters to control
+ * which events they receive notifications for, and handles the process of notifying all relevant
+ * observers when database events occur.
+ * @class ObserverHandler
+ * @example
+ * ```typescript
+ * // Create an observer handler
+ * const handler = new ObserverHandler();
+ *
+ * // Register an observer
+ * const myObserver = {
+ *   refresh: async (table, event, id) => {
+ *     console.log(`Change in ${table}: ${event} for ID ${id}`);
+ *   }
+ * };
+ *
+ * // Add observer with a filter for only user table events
+ * handler.observe(myObserver, (table, event, id) => table === 'users');
+ *
+ * // Notify observers about an event
+ * await handler.updateObservers(logger, 'users', 'CREATE', 123);
+ *
+ * // Remove an observer when no longer needed
+ * handler.unObserve(myObserver);
+ * ```
+ */
+export declare class ObserverHandler implements Observable {
+    /**
+     * @description Collection of registered observers
+     * @summary Array of observer objects along with their optional filters
+     */
+    protected readonly observers: {
+        observer: Observer;
+        filter?: ObserverFilter;
+    }[];
+    /**
+     * @description Gets the number of registered observers
+     * @summary Returns the count of observers currently registered with this handler
+     * @return {number} The number of registered observers
+     */
+    count(): number;
+    /**
+     * @description Registers a new observer
+     * @summary Adds an observer to the collection with an optional filter function
+     * @param {Observer} observer - The observer to register
+     * @param {ObserverFilter} [filter] - Optional filter function to determine which events the observer receives
+     * @return {void}
+     */
+    observe(observer: Observer, filter?: ObserverFilter): void;
+    /**
+     * @description Unregisters an observer
+     * @summary Removes an observer from the collection
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
+     */
+    unObserve(observer: Observer): void;
+    /**
+     * @description Notifies all relevant observers about a database event
+     * @summary Filters observers based on their filter functions and calls refresh on each matching observer
+     * @param {Logger} log - Logger for recording notification activities
+     * @param {string} table - The name of the table where the event occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @param {...any[]} args - Additional arguments to pass to the observers
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant ObserverHandler
+     *   participant Observer
+     *
+     *   Client->>ObserverHandler: updateObservers(log, table, event, id, ...args)
+     *
+     *   ObserverHandler->>ObserverHandler: Filter observers
+     *
+     *   loop For each observer with matching filter
+     *     alt Observer has filter
+     *       ObserverHandler->>Observer: Apply filter(table, event, id)
+     *       alt Filter throws error
+     *         ObserverHandler->>Logger: Log error
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       else Filter returns true
+     *         ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *       else Filter returns false
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       end
+     *     else No filter
+     *       ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *     end
+     *   end
+     *
+     *   ObserverHandler->>ObserverHandler: Process results
+     *   loop For each result
+     *     alt Result is rejected
+     *       ObserverHandler->>Logger: Log error
+     *     end
+     *   end
+     *
+     *   ObserverHandler-->>Client: Return
+     */
+    updateObservers(log: Logger, table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
+}