@m2k-5f/pgtx 2.6.0 → 2.6.2

package/dist/pool.js

@@ -1,76 +1,32 @@
 import { Connection } from "./connection";
 import { Queue, RingQueue } from "./queue";
 import { Begin, Future, Ok } from "fluent-future";
-import { PostgresError } from "./error";
-const ErrPoolClosed = new PostgresError('Pool closed');
+import { ErrPoolClosed } from "./error";
 /**
- * The main entry point for Pgtx.
- * Manages a connection pool and provides high-level API for queries and transactions.
+ * Connection pool and the main entry point for Pgtx.
  *
  * @example
- * ```ts
- * const pool = new Pool({
- *   host: 'localhost',
- *   user: 'postgres',
- *   password: 'postgres',
- *   database: 'test',
- *   max: 10
- * })
- *
- * // Simple query
+ * const pool = new Pool({ host: 'localhost', user: 'postgres', password: 'postgres', database: 'test', max: 10 })
  * const users = await pool.query`SELECT * FROM users WHERE id = ${1}`
- *
- * // Transaction
- * const result = await pool.begin(async tx => {
- *   await tx.query`INSERT INTO users ...`
- *   return 'success'
- * })
- *
- * // Manual acquire/release
- * const conn = await pool.acquire()
- * try {
- *   await conn.query`SELECT 1`
- * } finally {
- *   pool.release(conn)
- * }
- *
- * // Clean up
- *  pool.close()
- * ```
+ * await pool.begin(async tx => tx.query`INSERT INTO users ...`)
+ * await pool.close()
  */
 export class Pool {
-    _checkClosed() {
-        if (this._isClosed)
-            throw new Error('Pool closed');
-    }
-    constructor(params) {
+    constructor(config) {
         this._total = 0;
         this._waiting = new Queue();
-        this._isClosed = false;
-        this._config = params;
-        this._max = params.max || 20;
-        this._available = new RingQueue(this._max);
+        this._isOpened = true;
+        const conf = { ...config, max: config.max || 20 };
+        this.config = conf;
+        this._available = new RingQueue(this.config.max);
     }
     /**
-     * Acquires a dedicated connection from the pool.
-     *
-     * **Note:** You must call `pool.release(conn)` manually when finished.
-     * For most cases, prefer using `pool.query()` or `pool.begin()` which handle this automatically.
-     *
-     * @returns A connection from the pool or a new one if available.
-     *
-     * @example
-     * ```ts
-     * const conn = await pool.acquire()
-     * try {
-     *   await conn.query`SELECT 1`
-     * } finally {
-     *   pool.release(conn)
-     * }
-     * ```
+     * Acquires a dedicated connection. Call `pool.release(conn)` when done —
+     * prefer `pool.query()`/`pool.begin()` where possible, they release automatically.
      */
     acquire() {
-        this._checkClosed();
+        if (!this._isOpened)
+            return Future.reject(ErrPoolClosed);
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (conn.isOpened) {
@@ -78,9 +34,9 @@ export class Pool {
             }
             this._total--;
         }
-        if (this._total < this._max) {
+        if (this._total < this.config.max) {
             this._total++;
-            return Connection.new(this._config)
+            return Connection.new(this.config)
                 .tapErr(() => this._total--);
         }
         const { future, reject, resolve } = Future.withResolvers();
@@ -88,22 +44,10 @@ export class Pool {
         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.
+     * Runs `fn` with a borrowed connection and releases it afterward, even on error.
      *
      * @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()`;
-     * });
+     * const status = await pool.withAcquire(conn => conn.query`SELECT pg_is_in_recovery()`)
      */
     withAcquire(fn) {
         return Begin()
@@ -111,26 +55,12 @@ export class Pool {
             .andThen(conn => Future.of(fn(conn))
             .finally(() => this.release(conn)));
     }
-    /**
-     * Releases the connection back to the pool.
-     *
-     * If there are pending `acquire()` calls, the connection is passed directly to the next waiter.
-     * Otherwise, it's added to the available connections queue.
-     *
-     * @param conn - The connection to release.
-     *
-     * @example
-     * ```ts
-     * const conn = await pool.acquire()
-     * try {
-     *   await conn.query`SELECT 1`
-     * } finally {
-     *   pool.release(conn)
-     * }
-     * ```
-     */
+    /** Returns `conn` to the pool, or hands it directly to the next waiting `acquire()`. */
     release(conn) {
-        this._checkClosed();
+        if (!this._isOpened) {
+            void conn.close();
+            throw ErrPoolClosed;
+        }
         if (!conn.isOpened) {
             this._total--;
             return;
@@ -142,55 +72,28 @@ export class Pool {
         this._available.push(conn);
     }
     /**
-     * Starts a managed transaction.
-     *
-     * Automatically acquires a connection and handles `BEGIN`, `COMMIT`, and `ROLLBACK`.
-     * If the callback throws an error, the transaction is rolled back.
-     *
-     * @param txCallback - Async function that receives a `Transaction` instance.
-     * @returns The value returned from the callback.
+     * Runs `txCallback` inside a transaction on a borrowed connection, releasing it afterward.
      *
      * @example
-     * ```ts
-     * const result = await pool.begin(async tx => {
-     *   await tx.query`INSERT INTO accounts (id, balance) VALUES (1, 100)`
+     * await pool.begin(async tx => {
      *   await tx.query`UPDATE accounts SET balance = balance - 10 WHERE id = 1`
-     *   return { success: true }
      * })
-     * ```
      */
     begin(txCallback) {
-        this._checkClosed();
         return Begin()
             .andThen(() => this.acquire())
             .andThen(conn => conn.begin(txCallback)
             .finally(() => this.release(conn)));
     }
     /**
-     * Executes a one-off query using pipeline.
-     *
-     * Automatically acquires and releases a connection from the pool.
-     * For optimal performance, multiple queries can be pipelined through the same connection.
-     *
-     * @param templates - Tagged template string with SQL.
-     * @param args - Query parameters.
-     * @returns Array of rows with proper typing.
+     * Runs a one-off query on a borrowed connection.
      *
      * @example
-     * ```ts
-     * // Simple query
-     * const users = await pool.query`SELECT * FROM users`
-     *
-     * // With parameters
-     * const user = await pool.query`SELECT * FROM users WHERE id = ${1}`
-     *
-     * // With typed result
-     * type User = { id: number, name: string }
-     * const users = await pool.query<User>`SELECT * FROM users`
-     * ```
+     * const users = await pool.query<User>`SELECT * FROM users WHERE id = ${1}`
      */
     query(templates, ...args) {
-        this._checkClosed();
+        if (!this._isOpened)
+            return Future.reject(ErrPoolClosed);
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (!conn.isOpened) {
@@ -206,33 +109,34 @@ export class Pool {
             return conn.query(templates, ...args);
         });
     }
+    /** Like {@link query}, but for statements that don't return rows. */
+    execute(templates, ...params) {
+        if (!this._isOpened)
+            return Future.reject(ErrPoolClosed);
+        while (this._available.hasMore) {
+            const conn = this._available.shift;
+            if (conn.isClosed) {
+                this._total--;
+                continue;
+            }
+            this._available.push(conn);
+            return conn.execute(templates, ...params);
+        }
+        return this.acquire()
+            .andThen(conn => {
+            this.release(conn);
+            return conn.execute(templates, ...params);
+        });
+    }
     /**
-     * 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.
+     * Streams query results as a `ReadableStream`, without buffering rows in memory.
      *
      * @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
-     * }
+     * for await (const row of pool.stream<User>`SELECT * FROM orders`) { ... }
      */
     stream(templates, ...args) {
-        this._checkClosed();
+        if (!this._isOpened)
+            throw ErrPoolClosed;
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (!conn.isOpened) {
@@ -251,90 +155,54 @@ export class Pool {
         this.acquire()
             .tap(conn => {
             this.release(conn);
-            conn['_streamWithController'](templates, args, controller);
+            conn['_performStream'](templates, args, controller);
         })
             .catch(err => {
             controller.error(err);
         });
         return stream;
     }
-    /**
-     * Sends an asynchronous notification to a channel via `pg_notify`.
-     *
-     * @param channelName - The channel identifier
-     * @param payload - Optional string data (max 8000 bytes)
-     *
-     * @example
-     * ```ts
-     * await pool.notify('events', 'hello')
-     * ```
-     */
+    /** Sends a `pg_notify` message on `channelName` (payload ≤ 8000 bytes). */
     notify(channelName, payload = "") {
-        return this.query `select pg_notify(${channelName}, ${payload})`;
+        return this.acquire()
+            .andThen(conn => conn.notify(channelName, payload)
+            .finally(() => this.release(conn)));
     }
     /**
-     * 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.
+     * Subscribes `callback` to `channel` on a dedicated connection.
+     * Returns an unsubscribe function that issues `UNLISTEN` and releases the connection.
      *
      * @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.
+     * const unlisten = await pool.listen('order_created', payload => console.log(payload))
+     * await unlisten()
      */
     listen(channel, callback) {
         return this.acquire()
             .andThen(conn => conn.listen(channel, callback)
-            .map(() => async () => {
-            await conn.unlisten(channel, callback);
-            this.release(conn);
-        }));
+            .map(() => () => conn.unlisten(channel, callback)
+            .tap(() => this.release(conn))));
     }
-    /**
-     * Number of available (idle) connections in the pool.
-     */
+    /** Number of idle connections. */
     get size() {
         return this._available.size;
     }
-    /**
-     * Total number of connections currently managed by the pool
-     * (available + in use).
-     */
+    /** Total connections managed (idle + in use). */
     get total() {
         return this._total;
     }
     /**
-     * Shuts down the pool and closes all active connections.
-     *
-     * All pending `acquire()` calls will be rejected with an error.
-     * The pool cannot be used after calling `close()`.
-     *
-     * @example
-     * ```ts
-     *  pool.close()
-     * ```
+     * Closes idle connections and rejects pending `acquire()` calls. Not usable afterward.
      */
     close() {
+        this._isOpened = false;
+        const futures = [];
         while (this._available.hasMore) {
-            this._available.shift.close();
+            futures.push(this._available.shift.close());
         }
         while (this._waiting.hasMore) {
             this._waiting.shift.reject(ErrPoolClosed);
         }
         this._total = 0;
+        return Future.all(futures).map(() => { });
     }
 }

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

@@ -1,7 +1,6 @@
 import { AuthenticationCode, ResponseType, TransactionStatus } from "./constants";
-import { ColumnDescription } from "../types";
+import { ChannelName, ColumnDescription } from "../types";
 import { PostgresError } from "../error";
-import { ChannelName } from "../connection";
 export declare class ConnectionResponseBuffer {
     private buffer;
     private caret;
@@ -31,7 +30,6 @@ export declare class ConnectionResponseBuffer {
 }
 export declare class ConnectionResponseReader {
     private buffer;
-    private currentPacketLength;
     private constructor();
     static from(buffer: Buffer): ConnectionResponseReader;
     readType(): {
@@ -53,7 +51,7 @@ export declare class ConnectionResponseReader {
     readSaslMechanisms(): string[];
     readSaslMessage(length: number): string;
     readRowDescription(): ColumnDescription[];
-    readDataRow(descriptions: ColumnDescription[], int8toBigint?: boolean): Record<string, any>;
+    readDataRow(descriptions: ColumnDescription[], int8toBigint: boolean): Record<string, any>;
     readNotificationResponse(): {
         name: ChannelName;
         payload: string;
@@ -66,5 +64,6 @@ export declare class ConnectionResponseReader {
     readBindComplete(): void;
     readParameterDescription(): void;
     readNoData(): void;
+    skip(count: number): void;
 }
 //# sourceMappingURL=connection-response-reader.d.ts.map

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,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;IAOX,WAAW,IAAI,MAAM;IAMrB,QAAQ;IAWR,SAAS,CAAC,MAAM,EAAE,MAAM;IAQxB,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;IA0GlG,wBAAwB;;;;IASxB,mBAAmB,IAAI,MAAM;IAK7B,OAAO;IAKP,aAAa;IAKb,iBAAiB;IAKjB,iBAAiB;IAGjB,gBAAgB;IAGhB,wBAAwB;IAOxB,UAAU;CACb"}
+{"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,WAAW,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAQxC,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,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;IAOX,WAAW,IAAI,MAAM;IAMrB,QAAQ;IAWR,SAAS,CAAC,MAAM,EAAE,MAAM;IAQxB,aAAa,CAAC,MAAM,EAAE,MAAM;CAW/B;AAGD,qBAAa,wBAAwB;IAG7B,OAAO,CAAC,MAAM;IADlB,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,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IA0G1F,wBAAwB;;;;IASxB,mBAAmB,IAAI,MAAM;IAK7B,OAAO;IAKP,aAAa;IAKb,iBAAiB;IAKjB,iBAAiB;IAGjB,gBAAgB;IAGhB,wBAAwB;IAOxB,UAAU;IAEV,IAAI,CAAC,KAAK,EAAE,MAAM;CAGrB"}

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

@@ -131,7 +131,6 @@ export class ConnectionResponseBuffer {
 export class ConnectionResponseReader {
     constructor(buffer) {
         this.buffer = buffer;
-        this.currentPacketLength = 0;
     }
     static from(buffer) {
         return new ConnectionResponseReader(ConnectionResponseBuffer.from(buffer));
@@ -236,7 +235,7 @@ export class ConnectionResponseReader {
         }
         return columns;
     }
-    readDataRow(descriptions, int8toBigint = false) {
+    readDataRow(descriptions, int8toBigint) {
         const fieldsCount = this.buffer.readInt16();
         const row = {};
         for (let i = 0; i < fieldsCount; i++) {
@@ -377,4 +376,7 @@ export class ConnectionResponseReader {
         }
     }
     readNoData() { }
+    skip(count) {
+        this.buffer.skipBytes(count);
+    }
 }

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

@@ -2,15 +2,6 @@ import { Socket } from "node:net";
 import { ConnectionRequestWriter } from "./connection-request-writer";
 import { PostgresError } from "../error";
 import { Future } from "fluent-future";
-export type AuthorizationParams = {
-    host: string;
-    port: number;
-    user: string;
-    database: string;
-    password?: string;
-};
-export declare const ErrNonceMismatch: PostgresError;
-export declare const ErrPasswordRequired: PostgresError;
-export declare const ErrSocketFailedDuringAuth: PostgresError;
+import { AuthorizationParams } from "../types";
 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;AACrG,eAAO,MAAM,yBAAyB,eAAiD,CAAA;AAIvF,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,QAAQ,mBAAmB,kCAoHlG,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,EAAoE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC1G,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAG9C,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,QAAQ,mBAAmB,kCAoHlG,CAAA"}

package/dist/protocol/socket-authorization.js

@@ -3,11 +3,8 @@ import { calculateScramAuth, generateNonce } from "../security/sasl";
 import { SocketConnector } from "./socket-connector";
 import { AuthenticationCodes, ResponseTypes } from "./constants";
 import { encryptMd5 } from "../security/md5";
-import { PostgresError } from "../error";
+import { ErrNonceMismatch, ErrPasswordRequired, ErrSocketFailedDuringAuth } 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) => {
     const { future, reject, resolve } = Future.withResolvers();
     const nonce = generateNonce();

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

@@ -4,14 +4,14 @@ import { ConnectionResponseReader } from '../protocol/connection-response-reader
 import { ConnectionRequestWriter } from '../protocol/connection-request-writer';
 export declare class SocketConnector {
     private _socket;
-    private _onData;
-    private _onError;
     private residualBuffer;
-    private _isDestroyed;
-    constructor(_socket: Socket, _onData: (type: ResponseType, length: number, reader: ConnectionResponseReader) => void, _onError: (error: Error) => void);
+    private _onError;
+    private _onClose;
+    private _onData;
+    private _destroyed;
+    constructor(_socket: Socket, onData: (type: ResponseType, length: number, reader: ConnectionResponseReader) => void, onError: (error: unknown) => void);
     write(writer: ConnectionRequestWriter): void;
     unwrapSocket(): Socket;
     destroy(): void;
-    get isDestroyed(): boolean;
 }
 //# sourceMappingURL=socket-connector.d.ts.map

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,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"}
+{"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;IAQpB,OAAO,CAAC,OAAO;IAPnB,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAAQ;gBAGd,OAAO,EAAE,MAAM,EACvB,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,KAAK,IAAI,EACtF,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI;IA4CrC,KAAK,CAAC,MAAM,EAAE,uBAAuB;IAKrC,YAAY;IASZ,OAAO;CAGV"}

package/dist/protocol/socket-connector.js

@@ -1,13 +1,24 @@
 import { ConnectionResponseReader } from '../protocol/connection-response-reader';
 export class SocketConnector {
-    constructor(_socket, _onData, _onError) {
+    constructor(_socket, onData, onError) {
         this._socket = _socket;
-        this._onData = _onData;
-        this._onError = _onError;
         this.residualBuffer = null;
-        this._isDestroyed = false;
-        _socket.setKeepAlive(true, 10000);
-        _socket.on('data', buffer => {
+        this._destroyed = false;
+        this._onError = (err) => {
+            if (this._destroyed)
+                return;
+            this._destroyed = true;
+            onError(err);
+            this.destroy();
+        };
+        this._onClose = () => {
+            if (this._destroyed)
+                return;
+            this._destroyed = true;
+            onError(new Error("Socket closed"));
+            this.destroy();
+        };
+        this._onData = buffer => {
             const currentBuffer = this.residualBuffer
                 ? Buffer.concat([this.residualBuffer, buffer])
                 : buffer;
@@ -19,28 +30,24 @@ export class SocketConnector {
                     return;
                 }
                 const { type, length } = reader.readType();
-                this._onData(type, length, reader);
+                onData(type, length, reader);
             }
-        });
-        _socket.on('error', error => {
-            this._onError(error);
-            this._socket.destroy();
-            this._isDestroyed = true;
-        });
+        };
+        _socket.setKeepAlive(true, 10000);
+        _socket.on('data', this._onData);
+        _socket.on('error', this._onError);
+        _socket.on('close', this._onClose);
     }
     write(writer) {
-        if (this._isDestroyed)
-            throw new Error("SocketConnector is destroyed");
         this._socket.write(writer.asBuffer());
     }
     unwrapSocket() {
         this._socket.off('error', this._onError);
         this._socket.off("data", this._onData);
+        this._socket.off('close', this._onClose);
         return this._socket;
     }
     destroy() {
-        this._isDestroyed = true;
         this._socket.destroy();
     }
-    get isDestroyed() { return this._isDestroyed; }
 }

package/dist/query.d.ts

@@ -1,53 +1,44 @@
 import { Future } from "fluent-future";
-import { QueryMeta, QueryText, StatementName } from "./connection";
-import { ColumnDescription, ValueOF } from "./types";
+import { ColumnDescription, QueryText, Row, StatementName } from "./types";
 import { PostgresError } from "./error";
-export declare const QueryState: {
-    readonly Parsing: 0;
-    readonly Executing: 1;
-    readonly Completed: 2;
-    readonly Failed: 3;
-};
-export type State = ValueOF<typeof QueryState>;
 export declare abstract class Query {
     statement: StatementName;
+    text: QueryText;
+    args: (string | null)[];
     protected _timer?: NodeJS.Timeout;
-    constructor(statement: StatementName);
-    startTimeout(timeout: number): void;
+    constructor(statement: StatementName, text: QueryText, args: (string | null)[], timeout: number);
     abstract reject(cause: PostgresError): void;
     abstract resolve(...args: any[]): void;
+    abstract push(...args: any[]): void;
 }
-export declare class SimpleQuery<T> extends Query {
-    text: QueryText;
-    args: (string | null)[];
-    columns: ColumnDescription[];
+export declare class CollectQuery<T extends Row> extends Query {
+    columns: ColumnDescription[] | null;
     future: Future<T[], PostgresError>;
     private _resolve;
     private _reject;
     private _rows;
-    constructor(statement: StatementName, text: QueryText, args: (string | null)[], columns: ColumnDescription[]);
+    constructor(statement: StatementName, text: QueryText, args: (string | null)[], columns: ColumnDescription[] | null, timeout: number);
     push(value: T): void;
     reject(cause: PostgresError): void;
     resolve(): void;
 }
-export declare class ParseQuery extends Query {
-    text: QueryText;
-    future: Future<QueryMeta, PostgresError>;
+export declare class ExecuteQuery extends Query {
+    columns: ColumnDescription[] | null;
+    future: Future<void, PostgresError>;
     private _resolve;
     private _reject;
-    constructor(statement: StatementName, text: QueryText);
+    constructor(statement: StatementName, text: QueryText, args: (string | null)[], columns: ColumnDescription[] | null, timeout: number);
     reject(cause: PostgresError): void;
-    resolve(meta: QueryMeta): void;
+    resolve(): void;
+    push(): void;
 }
 export declare class StreamQuery<T> extends Query {
-    text: QueryText;
-    args: (string | null)[];
     controller: ReadableStreamDefaultController<T>;
-    columns: ColumnDescription[];
-    constructor(statement: StatementName, text: QueryText, args: (string | null)[], controller: ReadableStreamDefaultController<T>, columns: ColumnDescription[]);
+    columns: ColumnDescription[] | null;
+    constructor(statement: StatementName, text: QueryText, args: (string | null)[], controller: ReadableStreamDefaultController<T>, columns: ColumnDescription[] | null, timeout: number);
     push(value: T): void;
     reject(cause: PostgresError): void;
     resolve(): void;
 }
-export type PostgresQuery = SimpleQuery<any> | ParseQuery | StreamQuery<any>;
+export type PostgresQuery = CollectQuery<any> | StreamQuery<any> | ExecuteQuery;
 //# sourceMappingURL=query.d.ts.map