Merge pull request #89 from malthe/event-cleanup

Event cleanup

Author: malthe

CHANGES.md

@@ -1,3 +1,12 @@
+In next release ...
+
+- The `Connect` and `End` events have been removed, in addition to the `Parameter`
+  event; the `connect` method now returns an object with information about the
+  established connection, namely whether the connection is encrypted and the
+  connection parameters sent by the server.
+
+- Fixed a regression where some symbols were not correctly exposed for importing.
+
 1.7.0 (2023-12-13)
 ------------------
 

README.md

@@ -244,14 +244,11 @@ The copy commands are not supported.
    const pool = createPool({
        create: async () => {
            const client = new Client();
-           return client.connect().then(() => {
-               client.on('error', console.log);
-               return client;
-           });
-       },
-       destroy: async (client: Client) => {
-           return client.end().then(() => { })
+           await client.connect();
+           client.on('error', console.log);
+           return client;
        },
+       destroy: async (client: Client) => client.end(),
        validate: (client: Client) => {
            return Promise.resolve(!client.closed);
        }
@@ -267,8 +264,20 @@ The copy commands are not supported.
    const result = client.query({text: ..., transform: camelcase})
    ```
 
-3. _How do I use LISTEN/NOTIFY?_ Send `LISTEN` as a regular query, then subscribe to notifications
-   using `on(event: 'notification', callback: Callback<Notification>)`.
+3. _How do I use LISTEN/NOTIFY?_ Send `LISTEN` as a regular query, then subscribe to
+   notifications, filtering out the relevant channels.
+
+   ```typescript
+   import { Notification } from 'ts-postgres';
+
+   const channel = 'test';
+   client.on('notification', (message: Notification) => {
+        if (message.channel === channel) {
+            // Do stuff
+        }
+   });
+   await client.query(`LISTEN ${channel}`);
+   ```
 
 ## Benchmarking
 

src/client.ts

@@ -41,13 +41,9 @@ import {
 
 import { md5 } from './utils';
 
-export type Connect = Error | null;
-
-export type End = void;
-
-export interface Parameter {
-    name: string;
-    value: string;
+export interface ConnectionInfo  {
+    encrypted: boolean;
+    parameters: ReadonlyMap<string, string>;
 }
 
 export interface ClientNotice extends DatabaseError {
@@ -108,13 +104,14 @@ type CallbackOf<U> = U extends any ? Callback<U> : never;
 
 type Event = (
     ClientNotice |
-    Connect |
     DatabaseError |
-    End |
-    Parameter |
     Notification
 );
 
+type Connect = Error | null;
+
+type End = NodeJS.ErrnoException | null;
+
 type CloseHandler = () => void;
 
 interface RowDataHandler {
@@ -164,7 +161,6 @@ export class Client {
     private readonly events = {
         connect: new TypedEvent<Connect>(),
         end: new TypedEvent<End>(),
-        parameter: new TypedEvent<Parameter>(),
         error: new TypedEvent<DatabaseError>(),
         notice: new TypedEvent<ClientNotice>(),
         notification: new TypedEvent<Notification>()
@@ -196,6 +192,7 @@ export class Client {
 
     private nextPreparedStatementId = 0;
     private activeDataHandlerInfo: RowDataHandlerInfo | null = null;
+    private readonly parameters: Map<string, string> = new Map();
 
     public closed = true;
     public processId: number | null = null;
@@ -213,7 +210,7 @@ export class Client {
 
         this.stream.on('close', () => {
             this.closed = true;
-            this.events.end.emit();
+            this.events.end.emit(null);
         });
 
         this.stream.on('connect', () => {
@@ -239,7 +236,7 @@ export class Client {
                 if (this.ending && error.errno ===
                     constants.errno.ECONNRESET) return;
 
-                this.events.end.emit();
+                this.events.end.emit(error);
             }
         });
 
@@ -408,9 +405,9 @@ export class Client {
      * @remarks
      * Don't forget to close the connection using {@link end} before exiting.
      *
-     * @returns The connection encryption status.
+     * @returns The connection information.
      */
-    connect(): Promise<boolean> {
+    connect(): Promise<ConnectionInfo> {
         if (this.connecting) {
             throw new Error('Already connecting');
         }
@@ -428,7 +425,10 @@ export class Client {
                 this.stream.destroy();
                 throw error;
             }
-            return this.stream instanceof TLSSocket;
+            return {
+                encrypted: this.stream instanceof TLSSocket,
+                parameters: this.parameters as ReadonlyMap<string, string>,
+            }
         });
 
         const port = this.config.port || defaults.port;
@@ -448,7 +448,7 @@ export class Client {
                         new Error(`Timeout after ${timeout} ms`)
                     ), timeout
                 )),
-            ]) as Promise<boolean>
+            ]) as Promise<ConnectionInfo>
         }
         return p;
     }
@@ -479,28 +479,21 @@ export class Client {
         } else {
             this.stream.destroy();
         }
-
-        return this.events.end.once();
+        return new Promise<void>((resolve, reject) =>
+            this.events.end.once().then(
+                value => {
+                    if (value === null) resolve();
+                    reject(value);
+                }
+            )
+        );
     }
 
-    on(event: 'connect', callback: Callback<Connect>): void;
-    on(event: 'end', callback: Callback<End>): void;
-    on(event: 'parameter', callback: Callback<Parameter>): void;
     on(event: 'notification', callback: Callback<Notification>): void;
     on(event: 'error', callback: Callback<DatabaseError>): void;
     on(event: 'notice', callback: Callback<ClientNotice>): void;
     on(event: string, callback: CallbackOf<Event>): void {
         switch (event) {
-            case 'connect': {
-                this.events.connect.on(
-                    callback as Callback<Connect>);
-                break;
-            }
-            case 'end': {
-                this.events.end.on(
-                    callback as Callback<End>);
-                break;
-            }
             case 'error': {
                 this.events.error.on(
                     callback as Callback<DatabaseError>);
@@ -516,11 +509,6 @@ export class Client {
                     callback as Callback<Notification>);
                 break
             }
-            case 'parameter': {
-                this.events.parameter.on(
-                    callback as Callback<Parameter>);
-                break
-            }
         }
     }
 
@@ -1109,10 +1097,7 @@ export class Client {
                     const reader = new Reader(buffer, start);
                     const name = reader.readCString(this.encoding);
                     const value = reader.readCString(this.encoding);
-                    this.events.parameter.emit({
-                        name: name,
-                        value: value
-                    });
+                    this.parameters.set(name, value);
                     break;
                 }
                 case Message.ReadyForQuery: {

src/index.ts

@@ -1,4 +1,13 @@
-export { Client, PreparedStatement } from './client';
+export {
+    Client,
+    ClientNotice,
+    Configuration,
+    DataTypeError,
+    Notification,
+    PreparedStatement,
+    SSL,
+    SSLMode
+} from './client';
 export {
     DataFormat,
     DataType,
@@ -14,6 +23,8 @@ export {
 } from './result';
 export { Environment } from './defaults';
 export {
+    ClientConnectionDefaults,
+    ClientConnectionOptions,
     DatabaseError,
     ErrorLevel,
     TransactionStatus,

test/client.test.ts

@@ -1,5 +1,5 @@
 import { createServer, AddressInfo, Socket } from 'net';
-import { describe, expect, jest, test } from '@jest/globals';
+import { describe, expect, test } from '@jest/globals';
 import { testWithClient } from './helper';
 import {
     Client,
@@ -136,37 +136,6 @@ function testSelect(
         });
 }
 
-describe('Events', () => {
-    testWithClient('End', async (client) => {
-        expect.assertions(1);
-        const f = jest.fn();
-        client.on('end', f);
-        /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-        const p = new Promise((resolve, _) => {
-            client.on('connect', async () => {
-                await client.end();
-                resolve(undefined);
-            });
-        });
-        await p;
-        expect(f).toBeCalled();
-    });
-
-    testWithClient('Connect', async (client) => {
-        /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-        const p = new Promise((resolve, _) => {
-            client.on('connect', () => {
-                setTimeout(() => {
-                    expect(true).toBeTruthy();
-                    resolve(undefined);
-                }, 125);
-            });
-        });
-        expect.assertions(1);
-        return p;
-    });
-});
-
 describe('Timeout', () => {
     test('Connection timeout', async () => {
         const server = createServer();

test/helper.ts

@@ -11,10 +11,7 @@ export function testWithClient(name: string, fn: Test, timeout?: number) {
     });
     client.on('notice', console.log);
     test(name, async () => {
-        let closed = true;
         let connected = false;
-        client.on('connect', () => { closed = false; });
-        client.on('end', () => { closed = true; });
         const p2 = client.connect();
         const p1 = fn(client);
         try {
@@ -25,9 +22,8 @@ export function testWithClient(name: string, fn: Test, timeout?: number) {
             if (!connected) {
                 await p2;
             }
-            if (!closed) {
+            if (!client.closed) {
                 await client.end();
-                if (!closed) throw new Error("Expected client close event");
                 if (!client.closed) throw new Error("Expected client to be closed");
             }
         }