@m2k-5f/pgtx 2.4.1 → 2.5.1

package/dist/pool.d.ts

@@ -67,7 +67,26 @@ export declare class Pool {
      * }
      * ```
      */
-    acquire(): Future<Connection, Error>;
+    acquire(): Future<Connection, PostgresError>;
+    /**
+     * Provides a safe execution context for performing low-level operations
+     * directly on a single, dedicated `Connection` instance.
+     *
+     * Automatically borrows a free socket from the pool, forwards it to the provided callback function,
+     * and guarantees that the connection is released back to the pool once the execution completes,
+     * even if errors or unexpected exceptions are thrown. Prevents connection descriptor leaks.
+     *
+     * @template T The return type of the provided callback function.
+     * @param {(conn: Connection) => Promise<T>} fn A callback function that operates on the allocated Connection.
+     * @returns {Future<T, PostgresError>} A `Future` that resolves with the return value of the callback.
+     *
+     * @example
+     * // Executing low-level engine commands on a single, pinned connection
+     * const status = await pool.withAcquire(async (conn) => {
+     *     return await conn.query`SELECT pg_is_in_recovery()`;
+     * });
+     */
+    withAcquire<T>(fn: (conn: Connection) => Promise<T>): Future<T, unknown>;
     /**
      * Releases the connection back to the pool.
      *
@@ -105,7 +124,7 @@ export declare class Pool {
      * })
      * ```
      */
-    begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Future<T, Error>;
+    begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Future<T, unknown>;
     /**
      * Executes a one-off query using pipeline.
      *
@@ -129,7 +148,33 @@ export declare class Pool {
      * const users = await pool.query<User>`SELECT * FROM users`
      * ```
      */
-    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): Future<T[], Error>;
+    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): Future<T[], PostgresError>;
+    /**
+     * Executes an SQL query in streaming mode.
+     *
+     * Data is streamed directly from the PostgreSQL binary network buffer into the Web Streams API
+     * (`ReadableStream`), bypassing any intermediate array allocation or row accumulation in the JS heap.
+     * This pattern provides a true Zero-Memory Footprint and is ideal for exporting massive tables
+     * or piping database payloads directly into HTTP responses (e.g., via `Bun.serve` or fetch `Response`).
+     *
+     * @template T The expected shape of a single row interface.
+     * @param {TemplateStringsArray} templates The SQL string parts from the tagged template literal.
+     * @param {...any} args The parameterized query arguments.
+     * @returns {ReadableStream<T>} Synchronously returns a native Web ReadableStream instance.
+     *
+     * @example
+     * // Streaming a giant table directly to an HTTP response (Bun.serve)
+     * const userStream = pool.stream<User>`SELECT id, name FROM users`;
+     * return new Response(userStream, { headers: { 'Content-Type': 'application/json' } });
+     *
+     * @example
+     * // Asynchronously iterating over rows as they arrive from the wire socket
+     * const stream = pool.stream<User>`SELECT * FROM orders WHERE status = ${'processed'}`;
+     * for await (const row of stream) {
+     *     console.log(row.id, row.amount); // Row object is eligible for GC immediately after iteration
+     * }
+     */
+    stream<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): ReadableStream<T>;
     /**
      * Sends an asynchronous notification to a channel via `pg_notify`.
      *
@@ -142,6 +187,31 @@ export declare class Pool {
      * ```
      */
     notify(channelName: string, payload?: string): Future<[], PostgresError>;
+    /**
+     * Asynchronously subscribes to pub/sub events on a specific PostgreSQL channel (LISTEN).
+     *
+     * This method automatically claims a dedicated connection from the pool, registers the callback
+     * to handle incoming asynchronous database notices (`NotificationResponse` packets), and returns
+     * a lazy unsubscribe function wrapped in a `Future`.
+     *
+     * Invoking the returned unsubscribe function will automatically issue the `UNLISTEN` command
+     * to the database backend, clean up the memory callback, and safely release the connection back to the pool.
+     *
+     * @param {string} channel The name of the PostgreSQL notification channel.
+     * @param {(payload: string) => void} callback The event handler invoked when a NOTIFY message arrives.
+     * @returns {Future<() => Promise<void>, PostgresError>} A `Future` resolving to an async unsubscribe function.
+     *
+     * @example
+     * // Subscribing to database events directly from the Pool
+     * const unlisten = await pool.listen('order_created', (payload) => {
+     *     const order = JSON.parse(payload);
+     *     console.log(`New order received: ${order.id}`);
+     * });
+     *
+     * // When the subscription is no longer needed (e.g., during teardown or server stop):
+     * await unlisten(); // The socket cleanly issues UNLISTEN and returns to the pool of free connections.
+     */
+    listen(channel: string, callback: (payload: string) => void): Future<() => Promise<void>, PostgresError>;
     /**
      * Number of available (idle) connections in the pool.
      */

package/dist/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,OAAO,EAAE,MAAM,EAAW,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAQ;IAEzB,OAAO,CAAC,YAAY;gBAIR,MAAM,EAAE,UAAU;IAM9B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO;IAyBP;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAiBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAW7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IAIhG;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAWR"}
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAQ;IAEzB,OAAO,CAAC,YAAY;gBAIR,MAAM,EAAE,UAAU;IAM9B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO;IA2BP;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAiBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAY7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IAIhG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAWR"}

package/dist/pool.js

@@ -1,6 +1,8 @@
 import { Connection } from "./connection";
 import { Queue } from "./queue";
-import { Future, Resolve } from "fluent-future";
+import { Begin, Future, Ok } from "fluent-future";
+import { PostgresError } from "./error";
+const ErrPoolClosed = new PostgresError('Pool closed');
 /**
  * The main entry point for Pgtx.
  * Manages a connection pool and provides high-level API for queries and transactions.
@@ -72,18 +74,42 @@ export class Pool {
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (conn.isOpened) {
-                return Resolve(conn);
+                return Ok(conn);
             }
             this._total--;
         }
         if (this._total < this._max) {
             this._total++;
-            return Future.of(Connection.new(this._config))
+            return Connection.new(this._config)
                 .tapErr(() => this._total--);
         }
-        return Future.of(new Promise((resolve, reject) => {
-            this._waiting.push({ resolve, reject });
-        }));
+        const { future, reject, resolve } = Future.withResolvers();
+        this._waiting.push({ resolve, reject });
+        return future;
+    }
+    /**
+     * Provides a safe execution context for performing low-level operations
+     * directly on a single, dedicated `Connection` instance.
+     *
+     * Automatically borrows a free socket from the pool, forwards it to the provided callback function,
+     * and guarantees that the connection is released back to the pool once the execution completes,
+     * even if errors or unexpected exceptions are thrown. Prevents connection descriptor leaks.
+     *
+     * @template T The return type of the provided callback function.
+     * @param {(conn: Connection) => Promise<T>} fn A callback function that operates on the allocated Connection.
+     * @returns {Future<T, PostgresError>} A `Future` that resolves with the return value of the callback.
+     *
+     * @example
+     * // Executing low-level engine commands on a single, pinned connection
+     * const status = await pool.withAcquire(async (conn) => {
+     *     return await conn.query`SELECT pg_is_in_recovery()`;
+     * });
+     */
+    withAcquire(fn) {
+        return Begin()
+            .andThen(() => this.acquire())
+            .andThen(conn => Future.of(fn(conn))
+            .finally(() => this.release(conn)));
     }
     /**
      * Releases the connection back to the pool.
@@ -135,7 +161,8 @@ export class Pool {
      */
     begin(txCallback) {
         this._checkClosed();
-        return this.acquire()
+        return Begin()
+            .andThen(() => this.acquire())
             .andThen(conn => conn.begin(txCallback)
             .finally(() => this.release(conn)));
     }
@@ -179,6 +206,58 @@ export class Pool {
             return conn.query(templates, ...args);
         });
     }
+    /**
+     * Executes an SQL query in streaming mode.
+     *
+     * Data is streamed directly from the PostgreSQL binary network buffer into the Web Streams API
+     * (`ReadableStream`), bypassing any intermediate array allocation or row accumulation in the JS heap.
+     * This pattern provides a true Zero-Memory Footprint and is ideal for exporting massive tables
+     * or piping database payloads directly into HTTP responses (e.g., via `Bun.serve` or fetch `Response`).
+     *
+     * @template T The expected shape of a single row interface.
+     * @param {TemplateStringsArray} templates The SQL string parts from the tagged template literal.
+     * @param {...any} args The parameterized query arguments.
+     * @returns {ReadableStream<T>} Synchronously returns a native Web ReadableStream instance.
+     *
+     * @example
+     * // Streaming a giant table directly to an HTTP response (Bun.serve)
+     * const userStream = pool.stream<User>`SELECT id, name FROM users`;
+     * return new Response(userStream, { headers: { 'Content-Type': 'application/json' } });
+     *
+     * @example
+     * // Asynchronously iterating over rows as they arrive from the wire socket
+     * const stream = pool.stream<User>`SELECT * FROM orders WHERE status = ${'processed'}`;
+     * for await (const row of stream) {
+     *     console.log(row.id, row.amount); // Row object is eligible for GC immediately after iteration
+     * }
+     */
+    stream(templates, ...args) {
+        this._checkClosed();
+        while (this._available.hasMore) {
+            const conn = this._available.shift;
+            if (!conn.isOpened) {
+                this._total--;
+                continue;
+            }
+            this._available.push(conn);
+            return conn.stream(templates, ...args);
+        }
+        let controller;
+        const stream = new ReadableStream({
+            start: c => {
+                controller = c;
+            }
+        });
+        this.acquire()
+            .tap(conn => {
+            this.release(conn);
+            conn['_streamWithController'](templates, args, controller);
+        })
+            .catch(err => {
+            controller.error(err);
+        });
+        return stream;
+    }
     /**
      * Sends an asynchronous notification to a channel via `pg_notify`.
      *
@@ -193,6 +272,38 @@ export class Pool {
     notify(channelName, payload = "") {
         return this.query `select pg_notify(${channelName}, ${payload})`;
     }
+    /**
+     * Asynchronously subscribes to pub/sub events on a specific PostgreSQL channel (LISTEN).
+     *
+     * This method automatically claims a dedicated connection from the pool, registers the callback
+     * to handle incoming asynchronous database notices (`NotificationResponse` packets), and returns
+     * a lazy unsubscribe function wrapped in a `Future`.
+     *
+     * Invoking the returned unsubscribe function will automatically issue the `UNLISTEN` command
+     * to the database backend, clean up the memory callback, and safely release the connection back to the pool.
+     *
+     * @param {string} channel The name of the PostgreSQL notification channel.
+     * @param {(payload: string) => void} callback The event handler invoked when a NOTIFY message arrives.
+     * @returns {Future<() => Promise<void>, PostgresError>} A `Future` resolving to an async unsubscribe function.
+     *
+     * @example
+     * // Subscribing to database events directly from the Pool
+     * const unlisten = await pool.listen('order_created', (payload) => {
+     *     const order = JSON.parse(payload);
+     *     console.log(`New order received: ${order.id}`);
+     * });
+     *
+     * // When the subscription is no longer needed (e.g., during teardown or server stop):
+     * await unlisten(); // The socket cleanly issues UNLISTEN and returns to the pool of free connections.
+     */
+    listen(channel, callback) {
+        return this.acquire()
+            .andThen(conn => conn.listen(channel, callback)
+            .map(() => async () => {
+            await conn.unlisten(channel, callback);
+            this.release(conn);
+        }));
+    }
     /**
      * Number of available (idle) connections in the pool.
      */
@@ -222,7 +333,7 @@ export class Pool {
             this._available.shift.close();
         }
         while (this._waiting.hasMore) {
-            this._waiting.shift.reject(new Error('Pool closed'));
+            this._waiting.shift.reject(ErrPoolClosed);
         }
         this._total = 0;
     }

package/dist/protocol/connection-response-reader.d.ts

@@ -32,7 +32,10 @@ export declare class ConnectionResponseReader {
     private currentPacketLength;
     private constructor();
     static from(buffer: Buffer): ConnectionResponseReader;
-    readType(): ResponseType;
+    readType(): {
+        type: ResponseType;
+        length: number;
+    };
     readAuthentication(): AuthenticationCode;
     readMD5Salt(): Buffer<ArrayBufferLike>;
     readParameterStatus(): {
@@ -46,7 +49,7 @@ export declare class ConnectionResponseReader {
     readErrorResponse(): PostgresError;
     readReadyForQuery(): TransactionStatus;
     readSaslMechanisms(): string[];
-    readSaslMessage(): string;
+    readSaslMessage(length: number): string;
     readRowDescription(): ColumnDescription[];
     readDataRow(descriptions: ColumnDescription[], int8toBigint?: boolean): Record<string, any>;
     readNotificationResponse(): {

package/dist/protocol/connection-response-reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-response-reader.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-response-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAA6B,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC5G,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAM3C,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,KAAK,CAAI;IAEjB,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ,IAAI,MAAM;IAOlB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,WAAW,IAAI,MAAM;IAQrB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOrC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOjC,OAAO,IAAI,OAAO;IAKlB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAO3C,cAAc,IAAI,IAAI;IAOtB,mBAAmB,IAAI,IAAI;IAO3B,cAAc,IAAI,MAAM;IAaxB,SAAS,CAAC,SAAS,EAAE,MAAM;IAK3B,aAAa,IAAI,OAAO;IAaxB,iBAAiB;IAIjB,QAAQ;IAMR,YAAY,IAAI,MAAM;IAOtB,SAAS;IAST,WAAW,IAAI,MAAM;IAMrB,aAAa,CAAC,MAAM,EAAE,MAAM;CAW/B;AAGD,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,mBAAmB,CAAK;IAEhC,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ,IAC6B,YAAY;IAIjD,kBAAkB,IAGoB,kBAAkB;IAIxD,WAAW;IAKX,mBAAmB;;;;IAUnB,kBAAkB;;;;IAUlB,iBAAiB,IAAI,aAAa;IA8ClC,iBAAiB,IAEoB,iBAAiB;IAItD,kBAAkB,IAAI,MAAM,EAAE;IAa9B,eAAe,IAAI,MAAM;IAOzB,kBAAkB;IAuBlB,WAAW,CAAC,YAAY,EAAE,iBAAiB,EAAE,EAAE,YAAY,GAAE,OAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IA8FlG,wBAAwB;;;;IAUxB,mBAAmB,IAAI,MAAM;IAM7B,OAAO;IAKP,aAAa;IAKb,iBAAiB;IAKjB,iBAAiB;IAKjB,gBAAgB;IAKhB,wBAAwB;IAQxB,UAAU;CAGb"}
+{"version":3,"file":"connection-response-reader.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-response-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAA6B,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC5G,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAM3C,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,KAAK,CAAI;IAEjB,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ,IAAI,MAAM;IAOlB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,WAAW,IAAI,MAAM;IAQrB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOrC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOjC,OAAO,IAAI,OAAO;IAKlB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAO3C,cAAc,IAAI,IAAI;IAOtB,mBAAmB,IAAI,IAAI;IAO3B,cAAc,IAAI,MAAM;IAaxB,SAAS,CAAC,SAAS,EAAE,MAAM;IAK3B,aAAa,IAAI,OAAO;IAaxB,iBAAiB;IAIjB,QAAQ;IAMR,YAAY,IAAI,MAAM;IAOtB,SAAS;IAST,WAAW,IAAI,MAAM;IAMrB,aAAa,CAAC,MAAM,EAAE,MAAM;CAW/B;AAGD,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,mBAAmB,CAAK;IAEhC,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ;cACoC,YAAY;;;IAIxD,kBAAkB,IACoB,kBAAkB;IAIxD,WAAW;IAKX,mBAAmB;;;;IAQnB,kBAAkB;;;;IAQlB,iBAAiB,IAAI,aAAa;IA4ClC,iBAAiB,IACoB,iBAAiB;IAItD,kBAAkB,IAAI,MAAM,EAAE;IAa9B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAKvC,kBAAkB;IAsBlB,WAAW,CAAC,YAAY,EAAE,iBAAiB,EAAE,EAAE,YAAY,GAAE,OAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IA6FlG,wBAAwB;;;;IASxB,mBAAmB,IAAI,MAAM;IAK7B,OAAO;IAKP,aAAa;IAKb,iBAAiB;IAKjB,iBAAiB;IAGjB,gBAAgB;IAGhB,wBAAwB;IAOxB,UAAU;CACb"}

package/dist/protocol/connection-response-reader.js

@@ -123,31 +123,27 @@ export class ConnectionResponseReader {
         return new ConnectionResponseReader(ConnectionResponseBuffer.from(buffer));
     }
     readType() {
-        return this.buffer.readChar();
+        return { type: this.buffer.readChar(), length: this.buffer.readInt32() };
     }
     readAuthentication() {
-        this.currentPacketLength = this.buffer.readInt32();
         return this.buffer.readInt32();
     }
     readMD5Salt() {
         return this.buffer.readBytes(4);
     }
     readParameterStatus() {
-        this.buffer.readInt32();
         return {
             name: this.buffer.readCString(),
             value: this.buffer.readCString()
         };
     }
     readBackendKeyData() {
-        this.buffer.readInt32();
         return {
             PID: this.buffer.readInt32(),
             secret: this.buffer.readInt32()
         };
     }
     readErrorResponse() {
-        this.buffer.readInt32();
         let severity = '';
         let code = '';
         let message = '';
@@ -195,7 +191,6 @@ export class ConnectionResponseReader {
         return new PostgresError(message, code, detail, severity, where, hint, position, dataType, constraint);
     }
     readReadyForQuery() {
-        this.buffer.readInt32();
         return this.buffer.readChar();
     }
     readSaslMechanisms() {
@@ -208,12 +203,10 @@ export class ConnectionResponseReader {
         }
         return mechanisms;
     }
-    readSaslMessage() {
-        const dataLength = this.currentPacketLength - 4 - 4;
-        return this.buffer.readRawString(dataLength);
+    readSaslMessage(length) {
+        return this.buffer.readRawString(length - 4 - 4);
     }
     readRowDescription() {
-        this.buffer.skipBytes(4);
         const columnsCount = this.buffer.readInt16();
         const columns = new Array(columnsCount);
         for (let i = 0; i < columnsCount; i++) {
@@ -230,7 +223,6 @@ export class ConnectionResponseReader {
         return columns;
     }
     readDataRow(descriptions, int8toBigint = false) {
-        this.buffer.skipBytes(4);
         const fieldsCount = this.buffer.readInt16();
         const row = {};
         for (let i = 0; i < fieldsCount; i++) {
@@ -311,14 +303,12 @@ export class ConnectionResponseReader {
         return row;
     }
     readNotificationResponse() {
-        this.buffer.readInt32();
         this.buffer.readInt32();
         const name = this.buffer.readCString();
         const payload = this.buffer.readCString();
         return { name, payload };
     }
     readCommandComplete() {
-        this.buffer.readInt32();
         return this.buffer.readCString();
     }
     hasMore() {
@@ -330,20 +320,13 @@ export class ConnectionResponseReader {
     getResidualBuffer() {
         return this.buffer.getResidualBuffer();
     }
-    readParseComplete() {
-        this.buffer.readInt32();
-    }
-    readBindComplete() {
-        this.buffer.readInt32();
-    }
+    readParseComplete() { }
+    readBindComplete() { }
     readParameterDescription() {
-        this.buffer.readInt32();
         const count = this.buffer.readInt16();
         for (let i = 0; i < count; i++) {
             this.buffer.readInt32();
         }
     }
-    readNoData() {
-        this.buffer.readInt32();
-    }
+    readNoData() { }
 }

package/dist/protocol/socket-authorization.d.ts

@@ -11,5 +11,6 @@ export type AuthorizationParams = {
 };
 export declare const ErrNonceMismatch: PostgresError;
 export declare const ErrPasswordRequired: PostgresError;
+export declare const ErrSocketFailedDuringAuth: PostgresError;
 export declare const createAuthorizedSocket: (writer: ConnectionRequestWriter, params: AuthorizationParams) => Future<Socket, PostgresError>;
 //# sourceMappingURL=socket-authorization.d.ts.map

package/dist/protocol/socket-authorization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket-authorization.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAKrE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAGtC,MAAM,MAAM,mBAAmB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAGD,eAAO,MAAM,gBAAgB,eAAmF,CAAA;AAChH,eAAO,MAAM,mBAAmB,eAAqE,CAAA;AAIrG,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,QAAQ,mBAAmB,kCAwHlG,CAAA"}
+{"version":3,"file":"socket-authorization.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAKrE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAGtC,MAAM,MAAM,mBAAmB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAGD,eAAO,MAAM,gBAAgB,eAAmF,CAAA;AAChH,eAAO,MAAM,mBAAmB,eAAqE,CAAA;AACrG,eAAO,MAAM,yBAAyB,eAAiD,CAAA;AAIvF,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,QAAQ,mBAAmB,kCAoHlG,CAAA"}

package/dist/protocol/socket-authorization.js

@@ -7,93 +7,90 @@ import { PostgresError } from "../error";
 import { Future } from "fluent-future";
 export const ErrNonceMismatch = new PostgresError("Protocol violation: server nonce doesn't match client nonce");
 export const ErrPasswordRequired = new PostgresError('The authorization method requires a password.');
+export const ErrSocketFailedDuringAuth = new PostgresError("Socket failed during auth");
 export const createAuthorizedSocket = (writer, params) => {
-    return Future.of(new Promise((resolve, reject) => {
-        const nonce = generateNonce();
-        let clientMessage = '';
-        let serverMessage = '';
-        const socket = createConnection({ host: params.host, port: params.port });
-        const connector = new SocketConnector(socket, (type, reader) => {
-            writer.clear();
-            switch (type) {
-                case ResponseTypes.Authentication: {
-                    switch (reader.readAuthentication()) {
-                        case AuthenticationCodes.Ok: break;
-                        case AuthenticationCodes.CleartextPassword: {
-                            if (!params.password)
-                                throw ErrPasswordRequired;
-                            connector.write(writer.writePassword(params.password));
-                            break;
-                        }
-                        case AuthenticationCodes.MD5Password: {
-                            const salt = reader.readMD5Salt();
-                            if (!params.password)
-                                throw ErrPasswordRequired;
-                            const password = encryptMd5(params.password, params.user, salt);
-                            connector.write(writer.writePassword(password));
-                            break;
-                        }
-                        case AuthenticationCodes.SASL: {
-                            reader.readSaslMechanisms();
-                            if (!params.password)
-                                throw ErrPasswordRequired;
-                            clientMessage = `n=${params.user},r=${nonce}`;
-                            connector.write(writer.writeSaslInitial('SCRAM-SHA-256', `n,,${clientMessage}`));
-                            break;
-                        }
-                        case AuthenticationCodes.SASLContinue: {
-                            serverMessage = reader.readSaslMessage();
-                            if (!params.password)
-                                throw ErrPasswordRequired;
-                            const parts = Object.fromEntries(serverMessage.split(',').map(x => x.split('=')));
-                            const serverNonce = parts.r;
-                            const saltBase64 = parts.s;
-                            const iterations = parseInt(parts.i, 10);
-                            if (!serverNonce.startsWith(nonce)) {
-                                connector.destroy();
-                                return reject(ErrNonceMismatch);
-                            }
-                            const clientFinalMessageWithoutProof = `c=biws,r=${serverNonce}`;
-                            const authMessage = `${clientMessage},${serverMessage},${clientFinalMessageWithoutProof}`;
-                            const { clientProof } = calculateScramAuth(params.password, saltBase64, iterations, authMessage);
-                            const clientFinalMessage = `${clientFinalMessageWithoutProof},p=${clientProof}`;
-                            connector.write(writer.writeSaslResponse(clientFinalMessage));
-                            break;
-                        }
-                        case AuthenticationCodes.SASLFinal: {
-                            reader.readSaslMessage();
-                            break;
+    const { future, reject, resolve } = Future.withResolvers();
+    const nonce = generateNonce();
+    let clientMessage = '';
+    let serverMessage = '';
+    const socket = createConnection({ host: params.host, port: params.port });
+    const connector = new SocketConnector(socket, (type, length, reader) => {
+        writer.clear();
+        switch (type) {
+            case ResponseTypes.Authentication: {
+                switch (reader.readAuthentication()) {
+                    case AuthenticationCodes.Ok: break;
+                    case AuthenticationCodes.CleartextPassword: {
+                        if (!params.password)
+                            throw ErrPasswordRequired;
+                        connector.write(writer.writePassword(params.password));
+                        break;
+                    }
+                    case AuthenticationCodes.MD5Password: {
+                        const salt = reader.readMD5Salt();
+                        if (!params.password)
+                            throw ErrPasswordRequired;
+                        const password = encryptMd5(params.password, params.user, salt);
+                        connector.write(writer.writePassword(password));
+                        break;
+                    }
+                    case AuthenticationCodes.SASL: {
+                        reader.readSaslMechanisms();
+                        if (!params.password)
+                            throw ErrPasswordRequired;
+                        clientMessage = `n=${params.user},r=${nonce}`;
+                        connector.write(writer.writeSaslInitial('SCRAM-SHA-256', `n,,${clientMessage}`));
+                        break;
+                    }
+                    case AuthenticationCodes.SASLContinue: {
+                        serverMessage = reader.readSaslMessage(length);
+                        if (!params.password)
+                            throw ErrPasswordRequired;
+                        const parts = Object.fromEntries(serverMessage.split(',').map(x => x.split('=')));
+                        const serverNonce = parts.r;
+                        const saltBase64 = parts.s;
+                        const iterations = parseInt(parts.i, 10);
+                        if (!serverNonce.startsWith(nonce)) {
+                            connector.destroy();
+                            return reject(ErrNonceMismatch);
                         }
+                        const clientFinalMessageWithoutProof = `c=biws,r=${serverNonce}`;
+                        const authMessage = `${clientMessage},${serverMessage},${clientFinalMessageWithoutProof}`;
+                        const { clientProof } = calculateScramAuth(params.password, saltBase64, iterations, authMessage);
+                        const clientFinalMessage = `${clientFinalMessageWithoutProof},p=${clientProof}`;
+                        connector.write(writer.writeSaslResponse(clientFinalMessage));
+                        break;
+                    }
+                    case AuthenticationCodes.SASLFinal: {
+                        reader.readSaslMessage(length);
+                        break;
                     }
-                    break;
-                }
-                case ResponseTypes.ParamaterStatus: {
-                    reader.readParameterStatus();
-                    break;
-                }
-                case ResponseTypes.ErrorResponse: {
-                    const error = reader.readErrorResponse();
-                    connector.destroy();
-                    reject(error);
-                    return;
-                }
-                case ResponseTypes.BackendKeyData: {
-                    reader.readBackendKeyData();
-                }
-                case ResponseTypes.ReadyForQuery: {
-                    reader.readReadyForQuery();
-                    resolve(connector.unwrapSocket());
-                    return;
                 }
+                break;
             }
-        }, error => {
-            reject(error);
-        });
-        connector.write(writer.writeStartup(params.user, params.database));
-        writer.clear();
-    }), error => {
-        if (error instanceof PostgresError)
-            return error;
-        return new PostgresError(error.message);
+            case ResponseTypes.ParamaterStatus: {
+                reader.readParameterStatus();
+                break;
+            }
+            case ResponseTypes.ErrorResponse: {
+                const error = reader.readErrorResponse();
+                connector.destroy();
+                reject(error);
+                return;
+            }
+            case ResponseTypes.BackendKeyData: {
+                reader.readBackendKeyData();
+            }
+            case ResponseTypes.ReadyForQuery: {
+                reader.readReadyForQuery();
+                resolve(connector.unwrapSocket());
+                return;
+            }
+        }
+    }, error => {
+        reject(ErrSocketFailedDuringAuth);
     });
+    connector.write(writer.writeStartup(params.user, params.database));
+    writer.clear();
+    return future;
 };

package/dist/protocol/socket-connector.d.ts

@@ -8,7 +8,7 @@ export declare class SocketConnector {
     private _onError;
     private residualBuffer;
     private _isDestroyed;
-    constructor(_socket: Socket, _onData: (type: ResponseType, reader: ConnectionResponseReader) => void, _onError: (error: Error) => void);
+    constructor(_socket: Socket, _onData: (type: ResponseType, length: number, reader: ConnectionResponseReader) => void, _onError: (error: Error) => void);
     write(writer: ConnectionRequestWriter): void;
     unwrapSocket(): Socket;
     destroy(): void;

package/dist/protocol/socket-connector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket-connector.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAA;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAA;AAE/E,qBAAa,eAAe;IAKpB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IANpB,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,YAAY,CAAQ;gBAGhB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,wBAAwB,KAAK,IAAI,EACvE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;IA6B5C,KAAK,CAAC,MAAM,EAAE,uBAAuB;IAOrC,YAAY;IAQZ,OAAO;IAMP,IAAI,WAAW,YAA6B;CAC/C"}
+{"version":3,"file":"socket-connector.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAA;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAA;AAE/E,qBAAa,eAAe;IAKpB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IANpB,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,YAAY,CAAQ;gBAGhB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,KAAK,IAAI,EACvF,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;IA8B5C,KAAK,CAAC,MAAM,EAAE,uBAAuB;IAOrC,YAAY;IAQZ,OAAO;IAMP,IAAI,WAAW,YAA6B;CAC/C"}

package/dist/protocol/socket-connector.js

@@ -18,7 +18,8 @@ export class SocketConnector {
                     this.residualBuffer = reader.getResidualBuffer();
                     return;
                 }
-                this._onData(reader.readType(), reader);
+                const { type, length } = reader.readType();
+                this._onData(type, length, reader);
             }
         });
         _socket.on('error', error => {