@decaf-ts/for-postgres
Version:
template for ts projects
183 lines • 20.7 kB
JavaScript
import { Dispatch } from "@decaf-ts/core";
import { InternalError, OperationKeys } from "@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
*/
export class PostgresDispatch extends 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 = OperationKeys.CREATE;
break;
case "update":
operationKey = OperationKeys.UPDATE;
break;
case "delete":
operationKey = 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 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 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;
}
}
}
//# 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"]}