fix: expose _clients as a property

Author: gajus

src/bridge.ts

@@ -5,9 +5,6 @@ import genericPool, {
   type Pool as GenericPool,
 } from 'generic-pool';
 import type Postgres from 'postgres';
-import {
-  type Sql,
-} from 'postgres';
 
 type PgPool = {
   database?: string,
@@ -21,8 +18,6 @@ type PgPool = {
   user?: string,
 };
 
-type AnySql = Sql<{}>;
-
 type Command = 'DELETE' | 'INSERT' | 'SELECT' | 'UPDATE';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,18 +33,22 @@ type QueryResult = {
   rows: Row[],
 };
 
-type Client = AnySql & {events: EventEmitter, };
+export type BridgetClient = {
+  end: () => void,
+  off: (eventName: string, listener: (...args: any[]) => void) => void,
+  on: (eventName: string, listener: (...args: any[]) => void) => void,
+};
 
 export const createBridge = (postgres: typeof Postgres) => {
   return class PostgresBridge {
     private readonly poolEvents: EventEmitter;
 
-    private readonly pool: GenericPool<Client>;
+    private readonly pool: GenericPool<BridgetClient>;
 
     public constructor (poolConfiguration: PgPool) {
       this.poolEvents = new EventEmitter();
 
-      this.pool = genericPool.createPool<Client>({
+      this.pool = genericPool.createPool<BridgetClient>({
         create: async () => {
           const connectionEvents = new EventEmitter();
 
@@ -73,16 +72,39 @@ export const createBridge = (postgres: typeof Postgres) => {
             port: poolConfiguration.port ?? 5_432,
             ssl: poolConfiguration.ssl,
             username: poolConfiguration.user,
-          }) as Client;
+          });
+
+          const compatibleConnection = {
+            end: async () => {
+              await connection.end();
+            },
+            off: connectionEvents.off.bind(connectionEvents),
+            on: connectionEvents.on.bind(connectionEvents),
+            query: async (sql: string, parameters): Promise<QueryResult> => {
+              // https://github.com/porsager/postgres#result-array
+              const resultArray = await connection.unsafe(sql, parameters);
 
-          connection.events = connectionEvents;
+              return {
+                command: resultArray.command as Command,
+                fields: resultArray.columns?.map((column) => {
+                  return {
+                    dataTypeID: column.type,
+                    name: column.name,
+                  };
+                }) ?? [],
+                rowCount: resultArray.count,
+                rows: Array.from(resultArray),
+              };
+            },
+            release: async () => {
+              await this.pool.release(compatibleConnection);
+            },
+          };
 
-          return connection;
+          return compatibleConnection;
         },
-        destroy: (client: Sql<{}>) => {
-          return client.end({
-            timeout: 5,
-          });
+        destroy: async (client: BridgetClient) => {
+          client.end();
         },
       }, {
         max: poolConfiguration.max ?? 10,
@@ -93,36 +115,9 @@ export const createBridge = (postgres: typeof Postgres) => {
     public async connect () {
       const connection = await this.pool.acquire();
 
-      const compatibleConnection = {
-        end: async () => {
-          await this.pool.destroy(connection);
-        },
-        off: connection.events.off.bind(connection.events),
-        on: connection.events.on.bind(connection.events),
-        query: async (sql: string, parameters): Promise<QueryResult> => {
-          // https://github.com/porsager/postgres#result-array
-          const resultArray = await connection.unsafe(sql, parameters);
-
-          return {
-            command: resultArray.command as Command,
-            fields: resultArray.columns?.map((column) => {
-              return {
-                dataTypeID: column.type,
-                name: column.name,
-              };
-            }) ?? [],
-            rowCount: resultArray.count,
-            rows: Array.from(resultArray),
-          };
-        },
-        release: async () => {
-          await this.pool.release(connection);
-        },
-      };
-
-      this.poolEvents.emit('connect', compatibleConnection);
+      this.poolEvents.emit('connect', connection);
 
-      return compatibleConnection;
+      return connection;
     }
 
     public _pulseQueue () {
@@ -133,9 +128,11 @@ export const createBridge = (postgres: typeof Postgres) => {
       await client.end();
     }
 
-    public _clients () {
+    public get _clients () {
       // @ts-expect-error accessing private method
-      return Array.from(this.pool._allObjects);
+      return Array.from<{obj: BridgetClient, }>(this.pool._allObjects, (member) => {
+        return member.obj;
+      });
     }
 
     public get idleCount () {

test/postgres-bridge/bridge.ts

@@ -156,4 +156,14 @@ for (const client of clients) {
         name: '?column?',
       });
   });
+
+  test(client + ': _clients returns all active connections', async (t) => {
+    const pool = createPool(client, {
+      user: 'postgres',
+    });
+
+    const connection = await pool.connect();
+
+    t.is(pool._clients[0], connection);
+  });
 }