@decaf-ts/core
Version:
Core persistence module for the decaf framework
137 lines • 15.9 kB
JavaScript
import { InternalError, } from "@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);
* ```
*/
export 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 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 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}`);
});
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ObserverHandler.js","sourceRoot":"","sources":["../../../src/persistence/ObserverHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,aAAa,GAEd,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,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,aAAa,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,aAAa,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","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"]}