@decaf-ts/for-postgres/lib/PostgresDispatch.cjs

template for ts projects

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PostgresDispatch = void 0;
const core_1 = require("@decaf-ts/core");
const db_decorators_1 = require("@decaf-ts/db-decorators");
/**
 * @description Dispatcher for PostgreSQL database change events
 * @summary Handles the subscription to and processing of database change events from a PostgreSQL database,
 * notifying observers when records are created, updated, or deleted
 * @template Pool - The pg Pool type
 * @param {number} [timeout=5000] - Timeout in milliseconds for notification requests
 * @class PostgresDispatch
 * @example
 * ```typescript
 * // Create a dispatcher for a PostgreSQL database
 * const pool = new Pool({
 *   user: 'postgres',
 *   password: 'password',
 *   host: 'localhost',
 *   port: 5432,
 *   database: 'mydb'
 * });
 * const adapter = new PostgreSQLAdapterImpl(pool);
 * const dispatch = new PostgreSQLDispatch();
 *
 * // The dispatcher will automatically subscribe to notifications
 * // and notify observers when records change
 * ```
 * @mermaid
 * classDiagram
 *   class Dispatch {
 *     +initialize()
 *     +updateObservers()
 *   }
 *   class PostgreSQLDispatch {
 *     -observerLastUpdate?: string
 *     -attemptCounter: number
 *     -timeout: number
 *     -client?: PoolClient
 *     +constructor(timeout)
 *     #notificationHandler()
 *     #initialize()
 *   }
 *   Dispatch <|-- PostgreSQLDispatch
 */
class PostgresDispatch extends core_1.Dispatch {
    constructor(timeout = 5000) {
        super();
        this.timeout = timeout;
        this.attemptCounter = 0;
    }
    /**
     * @description Processes database notification events
     * @summary Handles the notifications from PostgreSQL LISTEN/NOTIFY mechanism,
     * and notifies observers about record changes
     * @param {Notification} notification - The notification from PostgreSQL
     * @return {Promise<void>} A promise that resolves when all notifications have been processed
     * @mermaid
     * sequenceDiagram
     *   participant D as PostgreSQLDispatch
     *   participant L as Logger
     *   participant O as Observers
     *   Note over D: Receive notification from PostgreSQL
     *   D->>D: Parse notification payload
     *   D->>D: Extract table, operation, and ids
     *   D->>O: updateObservers(table, operation, ids)
     *   D->>D: Update observerLastUpdate
     *   D->>L: Log successful dispatch
     */
    async notificationHandler(notification) {
        const log = this.log.for(this.notificationHandler);
        try {
            // Parse the notification payload (expected format: table:operation:id1,id2,...)
            const payload = notification.payload;
            const [table, operation, idsString] = payload.split(":");
            const ids = idsString.split(",");
            if (!table || !operation || !ids.length) {
                return log.error(`Invalid notification format: ${payload}`);
            }
            // Map operation string to OperationKeys
            let operationKey;
            switch (operation.toLowerCase()) {
                case "insert":
                    operationKey = db_decorators_1.OperationKeys.CREATE;
                    break;
                case "update":
                    operationKey = db_decorators_1.OperationKeys.UPDATE;
                    break;
                case "delete":
                    operationKey = db_decorators_1.OperationKeys.DELETE;
                    break;
                default:
                    return log.error(`Unknown operation: ${operation}`);
            }
            // Notify observers
            await this.updateObservers(table, operationKey, ids);
            this.observerLastUpdate = new Date().toISOString();
            log.verbose(`Observer refresh dispatched by ${operation} for ${table}`);
            log.debug(`pks: ${ids}`);
        }
        catch (e) {
            log.error(`Failed to process notification: ${e}`);
        }
    }
    /**
     * @description Initializes the dispatcher and subscribes to database notifications
     * @summary Sets up the LISTEN mechanism to subscribe to PostgreSQL notifications
     * and handles reconnection attempts if the connection fails
     * @return {Promise<void>} A promise that resolves when the subscription is established
     * @mermaid
     * sequenceDiagram
     *   participant D as PostgreSQLDispatch
     *   participant S as subscribeToPostgreSQL
     *   participant DB as PostgreSQL Database
     *   participant L as Logger
     *   D->>S: Call subscribeToPostgreSQL
     *   S->>S: Check adapter and native
     *   alt No adapter or native
     *     S-->>S: throw InternalError
     *   end
     *   S->>DB: Connect client from pool
     *   S->>DB: LISTEN table_changes
     *   alt Success
     *     DB-->>S: Subscription established
     *     S-->>D: Promise resolves
     *     D->>L: Log successful subscription
     *   else Error
     *     DB-->>S: Error
     *     S->>S: Increment attemptCounter
     *     alt attemptCounter > 3
     *       S->>L: Log error
     *       S-->>D: Promise rejects
     *     else attemptCounter <= 3
     *       S->>L: Log retry
     *       S->>S: Wait timeout
     *       S->>S: Recursive call to subscribeToPostgreSQL
     *     end
     *   end
     */
    async initialize() {
        const log = this.log.for(this.initialize);
        async function subscribeToPostgres() {
            if (!this.adapter || !this.native) {
                throw new db_decorators_1.InternalError(`No adapter/native observed for dispatch`);
            }
            try {
                this.client = await this.native.connect();
                this.client.on("notification", this.notificationHandler.bind(this));
                // Listen for table change notifications
                // This assumes you have set up triggers in PostgreSQL to NOTIFY on table changes
                const res = await this.client.query("LISTEN user_table_changes");
                this.attemptCounter = 0;
            }
            catch (e) {
                if (this.client) {
                    this.client.release();
                    this.client = undefined;
                }
                if (++this.attemptCounter > 3) {
                    return log.error(`Failed to subscribe to Postgres notifications: ${e}`);
                }
                log.info(`Failed to subscribe to Postgres notifications: ${e}. Retrying in ${this.timeout}ms...`);
                await new Promise((resolve) => setTimeout(resolve, this.timeout));
                return subscribeToPostgres.call(this);
            }
        }
        subscribeToPostgres
            .call(this)
            .then(() => {
            this.log.info(`Subscribed to Postgres notifications`);
        })
            .catch((e) => {
            throw new db_decorators_1.InternalError(`Failed to subscribe to Postgres notifications: ${e}`);
        });
    }
    /**
     * Cleanup method to release resources when the dispatcher is no longer needed
     */
    cleanup() {
        if (this.client) {
            this.client.release();
            this.client = undefined;
        }
    }
}
exports.PostgresDispatch = PostgresDispatch;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PostgresDispatch.js","sourceRoot":"","sources":["../src/PostgresDispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import { Dispatch } from \"@decaf-ts/core\";\nimport { Pool, PoolClient, Notification } from \"pg\";\nimport { InternalError, OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Dispatcher for PostgreSQL database change events\n * @summary Handles the subscription to and processing of database change events from a PostgreSQL database,\n * notifying observers when records are created, updated, or deleted\n * @template Pool - The pg Pool type\n * @param {number} [timeout=5000] - Timeout in milliseconds for notification requests\n * @class PostgresDispatch\n * @example\n * ```typescript\n * // Create a dispatcher for a PostgreSQL database\n * const pool = new Pool({\n *   user: 'postgres',\n *   password: 'password',\n *   host: 'localhost',\n *   port: 5432,\n *   database: 'mydb'\n * });\n * const adapter = new PostgreSQLAdapterImpl(pool);\n * const dispatch = new PostgreSQLDispatch();\n *\n * // The dispatcher will automatically subscribe to notifications\n * // and notify observers when records change\n * ```\n * @mermaid\n * classDiagram\n *   class Dispatch {\n *     +initialize()\n *     +updateObservers()\n *   }\n *   class PostgreSQLDispatch {\n *     -observerLastUpdate?: string\n *     -attemptCounter: number\n *     -timeout: number\n *     -client?: PoolClient\n *     +constructor(timeout)\n *     #notificationHandler()\n *     #initialize()\n *   }\n *   Dispatch <|-- PostgreSQLDispatch\n */\nexport class PostgresDispatch extends Dispatch<Pool> {\n  private observerLastUpdate?: string;\n  private attemptCounter: number = 0;\n  private client?: PoolClient;\n\n  constructor(private timeout = 5000) {\n    super();\n  }\n\n  /**\n   * @description Processes database notification events\n   * @summary Handles the notifications from PostgreSQL LISTEN/NOTIFY mechanism,\n   * and notifies observers about record changes\n   * @param {Notification} notification - The notification from PostgreSQL\n   * @return {Promise<void>} A promise that resolves when all notifications have been processed\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as PostgreSQLDispatch\n   *   participant L as Logger\n   *   participant O as Observers\n   *   Note over D: Receive notification from PostgreSQL\n   *   D->>D: Parse notification payload\n   *   D->>D: Extract table, operation, and ids\n   *   D->>O: updateObservers(table, operation, ids)\n   *   D->>D: Update observerLastUpdate\n   *   D->>L: Log successful dispatch\n   */\n  protected async notificationHandler(\n    notification: Notification\n  ): Promise<void> {\n    const log = this.log.for(this.notificationHandler);\n\n    try {\n      // Parse the notification payload (expected format: table:operation:id1,id2,...)\n      const payload = notification.payload as string;\n      const [table, operation, idsString] = payload.split(\":\");\n      const ids = idsString.split(\",\");\n\n      if (!table || !operation || !ids.length) {\n        return log.error(`Invalid notification format: ${payload}`);\n      }\n\n      // Map operation string to OperationKeys\n      let operationKey: OperationKeys;\n      switch (operation.toLowerCase()) {\n        case \"insert\":\n          operationKey = OperationKeys.CREATE;\n          break;\n        case \"update\":\n          operationKey = OperationKeys.UPDATE;\n          break;\n        case \"delete\":\n          operationKey = OperationKeys.DELETE;\n          break;\n        default:\n          return log.error(`Unknown operation: ${operation}`);\n      }\n\n      // Notify observers\n      await this.updateObservers(table, operationKey, ids);\n      this.observerLastUpdate = new Date().toISOString();\n      log.verbose(`Observer refresh dispatched by ${operation} for ${table}`);\n      log.debug(`pks: ${ids}`);\n    } catch (e: unknown) {\n      log.error(`Failed to process notification: ${e}`);\n    }\n  }\n\n  /**\n   * @description Initializes the dispatcher and subscribes to database notifications\n   * @summary Sets up the LISTEN mechanism to subscribe to PostgreSQL notifications\n   * and handles reconnection attempts if the connection fails\n   * @return {Promise<void>} A promise that resolves when the subscription is established\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as PostgreSQLDispatch\n   *   participant S as subscribeToPostgreSQL\n   *   participant DB as PostgreSQL Database\n   *   participant L as Logger\n   *   D->>S: Call subscribeToPostgreSQL\n   *   S->>S: Check adapter and native\n   *   alt No adapter or native\n   *     S-->>S: throw InternalError\n   *   end\n   *   S->>DB: Connect client from pool\n   *   S->>DB: LISTEN table_changes\n   *   alt Success\n   *     DB-->>S: Subscription established\n   *     S-->>D: Promise resolves\n   *     D->>L: Log successful subscription\n   *   else Error\n   *     DB-->>S: Error\n   *     S->>S: Increment attemptCounter\n   *     alt attemptCounter > 3\n   *       S->>L: Log error\n   *       S-->>D: Promise rejects\n   *     else attemptCounter <= 3\n   *       S->>L: Log retry\n   *       S->>S: Wait timeout\n   *       S->>S: Recursive call to subscribeToPostgreSQL\n   *     end\n   *   end\n   */\n  protected override async initialize(): Promise<void> {\n    const log = this.log.for(this.initialize);\n\n    async function subscribeToPostgres(this: PostgresDispatch): Promise<void> {\n      if (!this.adapter || !this.native) {\n        throw new InternalError(`No adapter/native observed for dispatch`);\n      }\n\n      try {\n        this.client = await this.native.connect();\n\n        this.client.on(\"notification\", this.notificationHandler.bind(this));\n\n        // Listen for table change notifications\n        // This assumes you have set up triggers in PostgreSQL to NOTIFY on table changes\n        const res = await this.client.query(\"LISTEN user_table_changes\");\n\n        this.attemptCounter = 0;\n      } catch (e: unknown) {\n        if (this.client) {\n          this.client.release();\n          this.client = undefined;\n        }\n\n        if (++this.attemptCounter > 3) {\n          return log.error(\n            `Failed to subscribe to Postgres notifications: ${e}`\n          );\n        }\n\n        log.info(\n          `Failed to subscribe to Postgres notifications: ${e}. Retrying in ${this.timeout}ms...`\n        );\n\n        await new Promise((resolve) => setTimeout(resolve, this.timeout));\n        return subscribeToPostgres.call(this);\n      }\n    }\n\n    subscribeToPostgres\n      .call(this)\n      .then(() => {\n        this.log.info(`Subscribed to Postgres notifications`);\n      })\n      .catch((e: unknown) => {\n        throw new InternalError(\n          `Failed to subscribe to Postgres notifications: ${e}`\n        );\n      });\n  }\n\n  /**\n   * Cleanup method to release resources when the dispatcher is no longer needed\n   */\n  public cleanup(): void {\n    if (this.client) {\n      this.client.release();\n      this.client = undefined;\n    }\n  }\n}\n"]}