feat: add notice event support

Author: gajus

README.md

@@ -40,6 +40,7 @@ Supported features:
 * `pool.connect`
 * `connection.query`
 * `connect` event
+* `notice` event
 
 Please submit PR if you require additional compatibility.
 

src/bridge.ts

@@ -37,20 +37,37 @@ type QueryResult = {
 };
 
 export const bridge = (postgres: typeof Postgres, poolConfiguration: PgPool) => {
-  const events = new EventEmitter();
+  const poolEvents = new EventEmitter();
 
-  const pool = genericPool.createPool<AnySql>({
+  const pool = genericPool.createPool<AnySql & {events: EventEmitter, }>({
     create: async () => {
-      return postgres({
+      const connectionEvents = new EventEmitter();
+
+      const connection = postgres({
         database: poolConfiguration.database,
         host: poolConfiguration.host ?? 'localhost',
         idle_timeout: poolConfiguration.idleTimeoutMillis ? poolConfiguration.idleTimeoutMillis / 1_000 : 0,
         max: 1,
+        onnotice: (notice) => {
+          connectionEvents.emit('notice', {
+            code: notice.code,
+            file: notice.file,
+            line: notice.line,
+            message: notice.message,
+            routine: notice.routine,
+            severity: notice.severity,
+            where: notice.where,
+          });
+        },
         password: poolConfiguration.password,
         port: poolConfiguration.port ?? 5_432,
         ssl: poolConfiguration.ssl,
         username: poolConfiguration.user,
-      });
+      }) as AnySql & {events: EventEmitter, };
+
+      connection.events = connectionEvents;
+
+      return connection;
     },
     destroy: (client: Sql<{}>) => {
       return client.end({
@@ -67,29 +84,31 @@ export const bridge = (postgres: typeof Postgres, poolConfiguration: PgPool) =>
       const connection = await pool.acquire();
 
       const compatibleConnection = {
+        off: connection.events.off.bind(connection.events),
+        on: connection.events.on.bind(connection.events),
         query: async (sql: string): Promise<QueryResult> => {
           // https://github.com/porsager/postgres#result-array
           const resultArray = await connection.unsafe(sql);
 
           return {
             command: resultArray.command as Command,
-            fields: resultArray.columns.map((column) => {
+            fields: resultArray.columns?.map((column) => {
               return {
                 dataTypeID: column.type,
                 name: column.name,
               };
-            }),
+            }) ?? [],
             rowCount: resultArray.count,
             rows: Array.from(resultArray),
           };
         },
       };
 
-      events.emit('connect', compatibleConnection);
+      poolEvents.emit('connect', compatibleConnection);
 
       return compatibleConnection;
     },
-    off: events.off.bind(events),
-    on: events.on.bind(events),
+    off: poolEvents.off.bind(poolEvents),
+    on: poolEvents.on.bind(poolEvents),
   };
 };

test/postgres-bridge/bridge.ts

@@ -24,7 +24,7 @@ const createPool = (clientName: string, poolConfiguration) => {
 };
 
 for (const client of clients) {
-  test(client + ': connect event is fired when a new connection is made', async (t) => {
+  test(client + ': "connect" event is fired when a new connection is made', async (t) => {
     const pool = createPool(client, {
       user: 'postgres',
     });
@@ -40,6 +40,45 @@ for (const client of clients) {
     t.is(spy.firstCall.args[0], connection);
   });
 
+  test(client + ': "notice event is fired when connection produces a notice"', async (t) => {
+    const pool = createPool(client, {
+      user: 'postgres',
+    });
+
+    const connection = await pool.connect();
+
+    const spy = sinon.spy();
+
+    connection.on('notice', spy);
+
+    await connection.query(`
+    CREATE OR REPLACE PROCEDURE raise_notice () AS $$
+    DECLARE
+      a INT:= 10;
+    BEGIN
+      RAISE NOTICE 'value of a: %', a; 
+    END;
+    $$
+    LANGUAGE plpgsql;
+    `);
+
+    await connection.query(`
+      CALL raise_notice();
+    `);
+
+    t.true(spy.called);
+
+    t.like(spy.firstCall.args[0], {
+      code: '00000',
+      file: 'pl_exec.c',
+      line: '3859',
+      message: 'value of a: 10',
+      routine: 'exec_stmt_raise',
+      severity: 'NOTICE',
+      where: 'PL/pgSQL function raise_notice() line 5 at RAISE',
+    });
+  });
+
   test(client + ': query method', async (t) => {
     const pool = createPool(client, {
       user: 'postgres',