@m2k-5f/pgtx 2.0.1 → 2.2.0

package/README.md

@@ -25,10 +25,12 @@ npm install @m2k-5f/pgtx
 
 | Tool | RPS | Avg Time | Connections |
 |------|-----|----------|-------------|
-| **Pgtx** | **1584** | **0.631ms** | **20 (used only one)** |
-| Native `pg` | 179 | 5.585ms | 20 |
+| **Pgtx** | **1584** | **0.631ms** | **20 pool connections (pipeline multiplexing)** |
+| Native `pg` | 179 | 5.585ms | 20 pool connections |
 
-**9x faster**
+**Up to 9x faster in concurrent pipeline workloads**
+
+**Pgtx achieves higher throughput by multiplexing concurrent queries over PostgreSQL connections using pipeline execution.**
 
 
 > Benchmark source available in the [repository](https://github.com/M2K-5F/pgtx).
@@ -43,7 +45,7 @@ npm install @m2k-5f/pgtx
 - **Bulk inserts** — Auto-extract columns from objects
 - **Dynamic updates** — Generate SET clauses from objects
 - **Recursive fragments** — Compose SQL like Lego
-- **Prepared statements** — Pre-parse any SQL with parameters
+- **Prepared statements** — Automatic prepared statement caching
 - **Connection pool** — Auto-management connections with support for pipeline queries via the pool itself.
 - **Zero dependencies** — Lightweight and blazing
 
@@ -111,6 +113,36 @@ await pool.begin(async (tx) => {
 })
 ```
 
+
+### Async Notifications (LISTEN / NOTIFY)
+
+Pgtx natively handles PostgreSQL `LISTEN/NOTIFY` protocol messages asynchronously without interrupting multiplexed query pipeline.
+
+```typescript
+// 1. Sending a notification
+await pool.notify('user_events', JSON.stringify({ id: 42, action: 'signup' }))
+
+// 2. Receiving notifications (Requires a dedicated connection from the pool)
+const conn = await pool.acquire()
+
+const onEvent = (payload: string) => {
+  console.log(`Received payload: ${payload}`)
+}
+
+// Multiplexes multiple callbacks onto a single LISTEN command seamlessly
+await conn.listen('user_events', onEvent)
+await conn.listen('user_events', (data) => logToFile(data))
+
+// Clean up callbacks (Sends UNLISTEN only when the channel has zero callbacks left)
+await conn.unlisten('user_events', onEvent)
+
+// Keep the connection active as long as you need notifications!
+// Do NOT release it back to the pool prematurely.
+```
+
+> ⚠️ **Architecture Note:** While `notify` is atomic and can be triggered directly from the `Pool` on any random socket, `listen` and `unlisten` are stateful commands tied to a specific PostgreSQL backend process. Therefore, subscription methods are **strictly available only on explicit `Connection` instances** fetched via `pool.acquire()`.
+
+
 ### Bulk Inserts
 
 ```typescript
@@ -250,6 +282,9 @@ class Connection {
 
     query<T>(strings: TemplateStringsArray, ...values: any[]): Promise<T[]>
     begin<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>
+    notify(channelName: string, payload?: string): Promise<[]>
+    listen(channelName: string, callback: (payload: string) => void): Promise<[]>
+    unlisten(channelName: string, callback: (payload: string) => void): Promise<[]>
 
     get isAlive(): boolean
     close(): void
@@ -273,6 +308,7 @@ class Pool {
 
     query<T>(strings: TemplateStringsArray, ...values: any[]): Promise<T[]>
     begin<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>
+    notify(channelName: string, payload?: string): Promise<[]>
     acquire(): Promise<Connection>
     release(conn: Connection): void
     close(): Promise<void>

package/dist/connection.d.ts

@@ -1,6 +1,5 @@
-import { ColumnDescription } from "./types";
+import { Branded, ColumnDescription } from "./types";
 import { Transaction } from "./transaction";
-import { Queue } from "./queue";
 type LogLevel = "none" | "error" | "notice" | "query";
 export type ConnectionParams = {
     user: string;
@@ -10,17 +9,26 @@ export type ConnectionParams = {
     database: string;
     logLevel?: LogLevel;
 };
-export type ConnectionQueryContext = {
-    columns: ColumnDescription[];
+export type ExecuteQueueUnit = {
     rows: (string | null)[][];
     resolve: (value: any) => void;
     reject: (err: Error) => void;
-    text: string;
-    statementName: string | null;
+    statementName: StatementName;
 };
-export declare class ConnectionQueryQueue extends Queue<ConnectionQueryContext> {
-    rejectAllNext(error: Error): void;
-}
+export type ParsingQueueUnit = {
+    resolve: (statementName: StatementName) => void;
+    reject: (error: Error) => void;
+    text: QueryText;
+    statementName: StatementName;
+};
+export type DescribeQueueUnit = {
+    resolve: (value: ColumnDescription[]) => void;
+    reject: (error: Error) => void;
+    statementName: StatementName;
+};
+export type StatementName = Branded<string, 'StatementName'>;
+export type QueryText = Branded<string, 'QueryText'>;
+export type ChannelName = Branded<string, "ChannelName">;
 /**
  * Represents a single dedicated connection to the PostgreSQL database.
  *
@@ -52,14 +60,18 @@ export declare class ConnectionQueryQueue extends Queue<ConnectionQueryContext>
  * ```
  */
 export declare class Connection {
+    private readonly params;
     private _isFlushing;
-    private _isAlive;
+    private _isOpened;
+    private _isReconnecting;
     private _socket;
     private _writer;
-    private _queue;
-    private _statementDescriptions;
-    private _statements;
-    private _parsePending;
+    private _pipelinesQueue;
+    private _described;
+    private _describingPending;
+    private _parsed;
+    private _parsingPending;
+    private _listeningCallbacks;
     private _stmtCounter;
     private _logLevel;
     private _nextStatement;
@@ -69,7 +81,7 @@ export declare class Connection {
      *
      * @param params - Connection parameters
      * @returns A new Connection instance
-     * @throws {Error} If authentication fails or connection cannot be established
+     * @throws {PostgresError} If authentication fails or connection cannot be established
      *
      * @example
      * ```ts
@@ -107,7 +119,7 @@ export declare class Connection {
      * const users = await conn.query<User>`SELECT * FROM users`
      * ```
      */
-    query<T extends Record<string, unknown>>(templates: TemplateStringsArray, ...args: any[]): Promise<T[]>;
+    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...params: any[]): Promise<T[]>;
     /**
      * Starts a managed transaction on this connection.
      *
@@ -130,15 +142,57 @@ export declare class Connection {
      * ```
      */
     begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Promise<T>;
+    /**
+     * 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 conn.notify('events', 'hello')
+     * ```
+     */
+    notify(channelName: string, payload?: string): Promise<[]>;
+    /**
+     * Subscribes a callback to a channel. Sends `LISTEN` on the first subscription.
+     *
+     * @param channelName - The channel identifier
+     * @param callback - Function invoked when a notification arrives
+     *
+     * @example
+     * ```ts
+     * await conn.listen('events', data => console.log(data))
+     * ```
+     */
+    listen(channelName: string, callback: (payload: string) => void): Promise<Record<string, any>[]>;
+    /**
+     * Unsubscribes a callback. Sends `UNLISTEN` if no callbacks remain for the channel.
+     *
+     * @param channelName - The channel identifier
+     * @param callback - The registered callback to remove
+     *
+     * @example
+     * ```ts
+     * await conn.unlisten('events', callback)
+     * ```
+     */
+    unlisten(channelName: string, callback: (payload: string) => void): Promise<void> | Promise<Record<string, any>[]>;
+    private _createQuery;
+    private _writeQuery;
     private _registerFlush;
     private _flush;
+    private _reconnect;
+    private _restoreSubscriptions;
+    private _getCurrentQuery;
+    private _rejectPipeline;
     private _handlePacket;
-    private _handleError;
     /**
      * Checks if the connection is still alive and usable.
      * Returns `false` if the socket is destroyed or connection is dead.
      */
-    get isAlive(): boolean;
+    get isOpened(): boolean;
+    private _destroyConnection;
     /**
      * Closes the connection immediately.
      * All pending queries will be rejected with an error.

package/dist/connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B,KAAK,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACtB,CAAA;AAKD,MAAM,MAAM,sBAAsB,GAAG;IACjC,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,CAAA;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IAC7B,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B,CAAA;AAGD,qBAAa,oBAAqB,SAAQ,KAAK,CAAC,sBAAsB,CAAC;IAEnE,aAAa,CAAC,KAAK,EAAE,KAAK;CAM7B;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,sBAAsB,CAAyC;IACvE,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,SAAS,CAAU;IAG3B,OAAO,CAAC,cAAc;IAItB,OAAO;IAcP;;;;;;;;;;;;;;;;;OAiBG;WACU,GAAG,CAAC,MAAM,EAAE,gBAAgB;IAQzC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IA0DvG;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAqBhF,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,MAAM;IAkBd,OAAO,CAAC,aAAa;IAoFrB,OAAO,CAAC,YAAY;IAQpB;;;OAGG;IACH,IAAI,OAAO,YAEV;IAGD;;;;;;;;;OASG;IACH,KAAK;CAIR"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAQ3C,KAAK,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACtB,CAAA;AAKD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,CAAA;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IAC7B,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC5B,aAAa,EAAE,aAAa,CAAA;CAC/B,CAAA;AAGD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,EAAE,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAA;IAC/C,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B,IAAI,EAAE,SAAS,CAAA;IACf,aAAa,EAAE,aAAa,CAAA;CAC/B,CAAA;AAGD,MAAM,MAAM,iBAAiB,GAAG;IAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAA;IAC7C,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B,aAAa,EAAE,aAAa,CAAA;CAC/B,CAAA;AAKD,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAE5D,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAEpD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,SAAS,CAAO;IACxB,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAyB;IAExC,OAAO,CAAC,eAAe,CAAwB;IAE/C,OAAO,CAAC,UAAU,CAAgD;IAClE,OAAO,CAAC,kBAAkB,CAA2B;IACrD,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,eAAe,CAAsC;IAE7D,OAAO,CAAC,mBAAmB,CAAyD;IACpF,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,SAAS,CAAU;IAG3B,OAAO,CAAC,cAAc;IAItB,OAAO;IAmBP;;;;;;;;;;;;;;;;;OAiBG;WACU,GAAG,CAAC,MAAM,EAAE,gBAAgB;IAQzC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAkBrG;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAqBhF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,OAAO,CAAC,EAAE,CAAC;IAIlF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAa/D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAkBjE,OAAO,CAAC,YAAY;IAuDpB,OAAO,CAAC,WAAW;IAwBnB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,MAAM;IAuBd,OAAO,CAAC,UAAU;IAiClB,OAAO,CAAC,qBAAqB;IAW7B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,aAAa;IAgJrB;;;OAGG;IACH,IAAI,QAAQ,YAEX;IAID,OAAO,CAAC,kBAAkB;IAU1B;;;;;;;;;OASG;IACH,KAAK;CAGR"}

package/dist/connection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = exports.ConnectionQueryQueue = void 0;
+exports.Connection = void 0;
 const process_1 = require("process");
 const connection_request_writer_1 = require("./protocol/connection-request-writer");
 const socket_authorization_1 = require("./protocol/socket-authorization");
@@ -10,16 +10,9 @@ const template_compiler_1 = require("./utils/template-compiler");
 const transaction_1 = require("./transaction");
 const socket_connector_1 = require("./protocol/socket-connector");
 const queue_1 = require("./queue");
+const query_1 = require("./query");
+const _1 = require(".");
 const ErrConnectionDead = new Error("Connection is Dead");
-class ConnectionQueryQueue extends queue_1.Queue {
-    rejectAllNext(error) {
-        while (!this.isFree) {
-            this.get().reject(error);
-            this.next();
-        }
-    }
-}
-exports.ConnectionQueryQueue = ConnectionQueryQueue;
 /**
  * Represents a single dedicated connection to the PostgreSQL database.
  *
@@ -54,16 +47,23 @@ class Connection {
     _nextStatement() {
         return `s-${this._stmtCounter++}`;
     }
-    constructor(socket, writer, logLevel) {
+    constructor(socket, writer, logLevel, params) {
         this._isFlushing = false;
-        this._isAlive = true;
-        this._queue = new ConnectionQueryQueue();
-        this._statementDescriptions = new Map();
-        this._statements = new Map();
-        this._parsePending = new Map();
+        this._isOpened = true;
+        this._isReconnecting = false;
+        this._pipelinesQueue = new queue_1.Queue();
+        this._described = new Map();
+        this._describingPending = new Set();
+        this._parsed = new Map();
+        this._parsingPending = new Map();
+        this._listeningCallbacks = new Map();
         this._stmtCounter = 0;
+        this.params = params;
         this._logLevel = logLevel;
-        this._socket = new socket_connector_1.SocketConnector(socket, (type, reader) => this._handlePacket(type, reader), error => this._handleError(error));
+        this._socket = new socket_connector_1.SocketConnector(socket, (type, reader) => this._handlePacket(type, reader), (err) => {
+            this._isReconnecting = true;
+            this._rejectPipeline(ErrConnectionDead);
+        });
         this._writer = writer;
     }
     /**
@@ -71,7 +71,7 @@ class Connection {
      *
      * @param params - Connection parameters
      * @returns A new Connection instance
-     * @throws {Error} If authentication fails or connection cannot be established
+     * @throws {PostgresError} If authentication fails or connection cannot be established
      *
      * @example
      * ```ts
@@ -87,7 +87,7 @@ class Connection {
     static async new(params) {
         const writer = connection_request_writer_1.ConnectionRequestWriter.new();
         const socket = await (0, socket_authorization_1.createAuthorizedSocket)(writer, params);
-        return new Connection(socket, writer, params.logLevel || 'error');
+        return new Connection(socket, writer, params.logLevel || 'error', params);
     }
     /**
      * Executes a query using tagged template literals.
@@ -113,47 +113,17 @@ class Connection {
      * const users = await conn.query<User>`SELECT * FROM users`
      * ```
      */
-    query(templates, ...args) {
-        if (!this._isAlive)
+    query(templates, ...params) {
+        this._registerFlush();
+        if (!this._isOpened)
             throw ErrConnectionDead;
-        const query = (0, template_compiler_1.compileSqlTemplate)({ templates, args });
+        const { text, args } = (0, template_compiler_1.compileSqlTemplate)({ templates, args: params });
         if (this._logLevel === 'query') {
-            console.log(`\nQUERY:     ${query.text}\n${query.args.length !== 0 ? `ARGUMENTS: [${query.args}]\n` : ""}`);
+            console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
-        return new Promise((resolve, reject) => {
-            this._registerFlush();
-            if (query.args.length === 0) {
-                this._writer.writeQuery(query.text);
-                this._queue.push({
-                    resolve, reject, columns: [], rows: [], statementName: null, text: query.text
-                });
-            }
-            else {
-                let rejectParsed = reject;
-                let statementName = '';
-                if (!this._statements.has(query.text) && !this._parsePending.has(query.text)) {
-                    statementName = this._nextStatement();
-                    this._parsePending.set(query.text, statementName);
-                    rejectParsed = (error) => {
-                        this._parsePending.delete(query.text);
-                        reject(error);
-                    };
-                    this._writer
-                        .writeParse(statementName, query.text);
-                    console.log('parsed once', statementName, query.text);
-                }
-                statementName = this._statements.get(query.text) || this._parsePending.get(query.text);
-                if (!this._statementDescriptions.has(statementName)) {
-                    this._writer.writeDescribe(statementName);
-                }
-                this._queue.push({
-                    resolve, reject: rejectParsed, columns: [], rows: [], statementName: statementName, text: query.text
-                });
-                this._writer
-                    .writeBind("", statementName, query.args)
-                    .writeExecute("");
-            }
-        });
+        const query = this._createQuery(text, args);
+        this._writeQuery(query);
+        return query.promise;
     }
     /**
      * Starts a managed transaction on this connection.
@@ -177,7 +147,7 @@ class Connection {
      * ```
      */
     async begin(txCallback) {
-        if (!this._isAlive)
+        if (!this._isOpened)
             throw ErrConnectionDead;
         const tx = new transaction_1.Transaction(this);
         try {
@@ -193,35 +163,192 @@ class Connection {
             throw err;
         }
     }
+    /**
+     * 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 conn.notify('events', 'hello')
+     * ```
+     */
+    notify(channelName, payload = "") {
+        return this.query `select pg_notify(${channelName}, ${payload})`;
+    }
+    /**
+     * Subscribes a callback to a channel. Sends `LISTEN` on the first subscription.
+     *
+     * @param channelName - The channel identifier
+     * @param callback - Function invoked when a notification arrives
+     *
+     * @example
+     * ```ts
+     * await conn.listen('events', data => console.log(data))
+     * ```
+     */
+    listen(channelName, callback) {
+        if (!this._listeningCallbacks.has(channelName)) {
+            this._listeningCallbacks.set(channelName, new Set());
+        }
+        const callbackSet = this._listeningCallbacks.get(channelName);
+        callbackSet.add(callback);
+        return this.query `listen ${_1.sql.ident(channelName)};`;
+    }
+    /**
+     * Unsubscribes a callback. Sends `UNLISTEN` if no callbacks remain for the channel.
+     *
+     * @param channelName - The channel identifier
+     * @param callback - The registered callback to remove
+     *
+     * @example
+     * ```ts
+     * await conn.unlisten('events', callback)
+     * ```
+     */
+    unlisten(channelName, callback) {
+        if (!this._listeningCallbacks.has(channelName)) {
+            return Promise.resolve();
+        }
+        const callbackSet = this._listeningCallbacks.get(channelName);
+        callbackSet.delete(callback);
+        if (callbackSet.size === 0) {
+            this._listeningCallbacks.delete(channelName);
+            return this.query `unlisten ${_1.sql.ident(channelName)};`;
+        }
+        return Promise.resolve();
+    }
+    _createQuery(text, args) {
+        if (this._parsed.has(text)) {
+            const statementName = this._parsed.get(text);
+            if (this._described.has(statementName)) {
+                const columns = this._described.get(statementName);
+                return new query_1.Query(text, args, query_1.QueryState.Executing, statementName, columns);
+            }
+            else {
+                if (this._describingPending.has(statementName)) {
+                    return new query_1.Query(text, args, query_1.QueryState.Executing, statementName);
+                }
+                else {
+                    this._describingPending.add(statementName);
+                    return new query_1.Query(text, args, query_1.QueryState.Describing, statementName);
+                }
+            }
+        }
+        else {
+            if (this._parsingPending.has(text)) {
+                const statementName = this._parsingPending.get(text);
+                return new query_1.Query(text, args, query_1.QueryState.Describing, statementName);
+            }
+            else {
+                const statementName = this._nextStatement();
+                this._parsingPending.set(text, statementName);
+                return new query_1.Query(text, args, query_1.QueryState.Parsing, statementName);
+            }
+        }
+    }
+    _writeQuery(query) {
+        if (query.state === query_1.QueryState.Parsing) {
+            this._writer
+                .writeParse(query.statementName, query.text)
+                .writeDescribe(query.statementName)
+                .writeBind("", query.statementName, query.args)
+                .writeExecute("");
+        }
+        if (query.state === query_1.QueryState.Describing) {
+            this._writer
+                .writeDescribe(query.statementName)
+                .writeBind("", query.statementName, query.args)
+                .writeExecute("");
+        }
+        if (query.state === query_1.QueryState.Executing) {
+            this._writer
+                .writeBind("", query.statementName, query.args)
+                .writeExecute("");
+        }
+        this._pipelinesQueue.get().push(query);
+    }
     _registerFlush() {
         if (!this._isFlushing) {
             this._isFlushing = true;
-            (0, process_1.nextTick)(() => this._flush());
+            this._pipelinesQueue.push(new queue_1.Queue());
+            (0, process_1.nextTick)(() => {
+                this._flush();
+            });
         }
     }
     _flush() {
-        if (!this._isAlive) {
-            this._queue.rejectAllNext(ErrConnectionDead);
+        if (!this._isOpened) {
+            this._rejectPipeline(ErrConnectionDead);
             return;
         }
-        try {
+        if (this._isReconnecting) {
+            this._reconnect().then(socket => {
+                this._isFlushing = false;
+                socket.write(this._writer.writeSync());
+                this._writer.clear();
+            });
+        }
+        else {
+            this._isFlushing = false;
             this._socket.write(this._writer.writeSync());
             this._writer.clear();
         }
-        catch (err) {
-            this._isAlive = false;
-            this._socket.destroy();
-            this._queue.rejectAllNext(ErrConnectionDead);
+    }
+    _reconnect() {
+        this._parsed.clear();
+        this._described.clear();
+        this._describingPending.clear();
+        this._parsingPending.clear();
+        this._writer.clear();
+        while (this._pipelinesQueue.hasMore) {
+            this._rejectPipeline(ErrConnectionDead);
+            this._pipelinesQueue.next();
+        }
+        this._pipelinesQueue = new queue_1.Queue();
+        this._pipelinesQueue.push(new queue_1.Queue());
+        return (0, socket_authorization_1.createAuthorizedSocket)(connection_request_writer_1.ConnectionRequestWriter.new(), this.params)
+            .then(socket => {
+            const connector = new socket_connector_1.SocketConnector(socket, (type, reader) => this._handlePacket(type, reader), (err) => {
+                this._isReconnecting = true;
+                this._rejectPipeline(ErrConnectionDead);
+            });
+            this._socket = connector;
+            this._restoreSubscriptions();
+            this._isReconnecting = false;
+            return connector;
+        });
+    }
+    _restoreSubscriptions() {
+        if (this._listeningCallbacks.size === 0)
+            return Promise.resolve();
+        const promises = Array.from(this._listeningCallbacks.keys()).map(channel => {
+            return this.query `LISTEN ${_1.sql.ident(channel)};`;
+        });
+        return Promise.all(promises);
+    }
+    _getCurrentQuery() {
+        return this._pipelinesQueue.get().get();
+    }
+    _rejectPipeline(error) {
+        if (this._pipelinesQueue.isFree)
+            return;
+        const queue = this._pipelinesQueue.get();
+        while (queue.hasMore) {
+            queue.get().reject(error);
+            queue.next();
         }
     }
     _handlePacket(type, reader) {
-        const context = this._queue.get();
         switch (type) {
             case constants_1.ResponseTypes.ParseComplete:
                 {
                     reader.readParseComplete();
-                    this._statements.set(context.text, context.statementName);
-                    this._parsePending.delete(context.text);
+                    const query = this._getCurrentQuery();
+                    this._parsingPending.delete(query.text);
+                    this._parsed.set(query.text, query.statementName);
+                    query.state = query_1.QueryState.Describing;
                 }
                 break;
             case constants_1.ResponseTypes.BindComplete:
@@ -242,50 +369,74 @@ class Connection {
             case constants_1.ResponseTypes.NoData:
                 {
                     reader.readNoData();
-                    if (context.statementName) {
-                        this._statementDescriptions.set(context.statementName, []);
-                    }
+                    const query = this._getCurrentQuery();
+                    this._describingPending.delete(query.statementName);
+                    this._described.set(query.statementName, []);
+                    query.state = query_1.QueryState.Executing;
                 }
                 break;
             case constants_1.ResponseTypes.RowDescription:
                 {
-                    if (context.statementName) {
-                        this._statementDescriptions.set(context.statementName, reader.readRowDescription());
-                    }
-                    else {
-                        context.columns = reader.readRowDescription();
-                    }
+                    const columns = reader.readRowDescription();
+                    const query = this._getCurrentQuery();
+                    this._describingPending.delete(query.statementName);
+                    this._described.set(query.statementName, columns);
+                    query.state = query_1.QueryState.Executing;
+                    query.columns = columns;
                 }
                 break;
             case constants_1.ResponseTypes.DataRow:
                 {
-                    context.rows.push(reader.readDataRow());
+                    const query = this._getCurrentQuery();
+                    query.rows.push(reader.readDataRow());
                 }
                 break;
             case constants_1.ResponseTypes.ComandComplete:
                 {
                     reader.readCommandComplete();
-                    if (context.statementName) {
-                        context.columns = this._statementDescriptions.get(context.statementName);
+                    if (this._pipelinesQueue.isFree) {
+                        this._destroyConnection();
+                        break;
                     }
-                    context.resolve((0, value_parser_1.parseRowValues)(context.columns, context.rows));
-                    this._queue.next();
+                    const query = this._getCurrentQuery();
+                    if (!query) {
+                        this._destroyConnection();
+                        break;
+                    }
+                    if (!query.columns) {
+                        query.columns = this._described.get(query.statementName);
+                    }
+                    query.state = query_1.QueryState.Completed;
+                    this._pipelinesQueue.get().next();
+                    query.resolve((0, value_parser_1.parseRowValues)(query.columns, query.rows));
                 }
                 break;
             case constants_1.ResponseTypes.ErrorResponse:
                 {
-                    const message = reader.readErrorResponse();
+                    const error = reader.readErrorResponse();
                     if (this._logLevel === 'error' || this._logLevel === 'notice' || this._logLevel === 'query') {
-                        console.log(`\nError:    ${message}\n`);
+                        console.log(`\nError:    ${error}\n`);
+                    }
+                    const query = this._getCurrentQuery();
+                    switch (query.state) {
+                        case query_1.QueryState.Parsing:
+                            this._parsingPending.delete(query.text);
+                            break;
+                        case query_1.QueryState.Describing:
+                            this._describingPending.delete(query.statementName);
+                            break;
                     }
-                    const error = new Error(message);
-                    this._queue.rejectAllNext(error);
+                    query.state = query_1.QueryState.Failed;
+                    this._rejectPipeline(error);
                 }
                 break;
             case constants_1.ResponseTypes.ReadyForQuery:
                 {
-                    this._isFlushing = false;
                     reader.readReadyForQuery();
+                    const pipeline = this._pipelinesQueue.get();
+                    if (!pipeline.hasMore) {
+                        this._pipelinesQueue.next();
+                    }
                 }
                 break;
             case constants_1.ResponseTypes.Notice:
@@ -296,20 +447,32 @@ class Connection {
                     }
                 }
                 break;
+            case constants_1.ResponseTypes.NotificationResponse:
+                {
+                    const { name, payload } = reader.readNotificationResponse();
+                    const callbackSet = this._listeningCallbacks.get(name);
+                    if (!callbackSet)
+                        break;
+                    callbackSet.forEach(cb => cb(payload));
+                }
+                break;
             default: console.warn('Undeclared response type: ', type);
         }
     }
-    _handleError(error) {
-        this._isAlive = false;
-        this._queue.rejectAllNext(error);
-        this._socket.destroy();
-    }
     /**
      * Checks if the connection is still alive and usable.
      * Returns `false` if the socket is destroyed or connection is dead.
      */
-    get isAlive() {
-        return this._isAlive && !this._socket.isDestroyed;
+    get isOpened() {
+        return this._isOpened;
+    }
+    _destroyConnection() {
+        this._isOpened = false;
+        this._socket.destroy();
+        while (this._pipelinesQueue.hasMore) {
+            this._rejectPipeline(ErrConnectionDead);
+            this._pipelinesQueue.next();
+        }
     }
     /**
      * Closes the connection immediately.
@@ -322,8 +485,7 @@ class Connection {
      * ```
      */
     close() {
-        this._isAlive = false;
-        this._socket.destroy();
+        this._destroyConnection();
     }
 }
 exports.Connection = Connection;

package/dist/error.d.ts

@@ -0,0 +1,18 @@
+export declare class PostgresError extends Error {
+    message: string;
+    code: string;
+    detail: string;
+    severity: string;
+    where: string;
+    hint: string;
+    position: string;
+    dataType: string;
+    constraint: string;
+    constructor(message: string, code: string, detail: string, severity: string, where: string, hint: string, position: string, dataType: string, constraint: string);
+    get isParseError(): boolean;
+    get isDeadlock(): boolean;
+    get isConstraintViolation(): boolean;
+    get isTimeout(): boolean;
+    get isConnectionFailure(): boolean;
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;IAEhB,OAAO,EAAE,MAAM;IACxB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;IACb,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE,MAAM;IAChB,UAAU,EAAE,MAAM;gBART,OAAO,EAAE,MAAM,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM;IAQ7B,IAAI,YAAY,IAAI,OAAO,CAE1B;IAID,IAAI,UAAU,IAAI,OAAO,CAExB;IAID,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAGD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGD,IAAI,mBAAmB,IAAI,OAAO,CAEjC;CACJ"}

package/dist/error.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresError = void 0;
+class PostgresError extends Error {
+    constructor(message, code, detail, severity, where, hint, position, dataType, constraint) {
+        super(message);
+        this.message = message;
+        this.code = code;
+        this.detail = detail;
+        this.severity = severity;
+        this.where = where;
+        this.hint = hint;
+        this.position = position;
+        this.dataType = dataType;
+        this.constraint = constraint;
+        this.name = "PostgresError";
+    }
+    // Parse error
+    get isParseError() {
+        return this.code.startsWith('42');
+    }
+    // Execute error
+    get isDeadlock() {
+        return this.code === '40P01';
+    }
+    // Execute error
+    get isConstraintViolation() {
+        return this.code.startsWith('23');
+    }
+    get isTimeout() {
+        return this.code === '57014';
+    }
+    get isConnectionFailure() {
+        return this.code.startsWith('08') || this.code.startsWith('57') && this.code !== '57014';
+    }
+}
+exports.PostgresError = PostgresError;

package/dist/index.d.ts

@@ -121,4 +121,5 @@ export { Connection as Connection };
 export { Transaction as Transaction };
 export { PgtxPool as Pool };
 export { setTypeParser as setTypeParser };
+export * from "./clauses";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EACH,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,mBAAmB,EAEnB,WAAW,EACX,aAAa,EACb,cAAc,EACjB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD;;;GAGG;AACH,eAAO,MAAM,GAAG;IACZ;;;;;;;;;;;OAWG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;KAWC;;IAGD;;;;;;;;;;OAUG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;CAEN,CAAA;AAGD;;;GAGG;AAEH,OAAO,EAAE,UAAU,IAAI,UAAU,EAAE,CAAA;AAEnC,OAAO,EAAE,WAAW,IAAI,WAAW,EAAE,CAAA;AAErC,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAA;AAE3B,OAAO,EAAE,aAAa,IAAI,aAAa,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EACH,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,mBAAmB,EAEnB,WAAW,EACX,aAAa,EACb,cAAc,EACjB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD;;;GAGG;AACH,eAAO,MAAM,GAAG;IACZ;;;;;;;;;;;OAWG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;KAWC;;IAGD;;;;;;;;;;OAUG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;CAEN,CAAA;AAGD;;;GAGG;AAEH,OAAO,EAAE,UAAU,IAAI,UAAU,EAAE,CAAA;AAEnC,OAAO,EAAE,WAAW,IAAI,WAAW,EAAE,CAAA;AAErC,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,CAAA;AAE3B,OAAO,EAAE,aAAa,IAAI,aAAa,EAAE,CAAA;AAEzC,cAAc,WAAW,CAAA"}

package/dist/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setTypeParser = exports.Pool = exports.Transaction = exports.Connection = exports.sql = void 0;
 const pool_1 = require("./pool");
@@ -120,3 +134,4 @@ exports.sql = {
      */
     array: clauses_1.ArrayClause.create,
 };
+__exportStar(require("./clauses"), exports);

package/dist/pool.d.ts

@@ -127,7 +127,19 @@ export declare class Pool {
      * const users = await pool.query<User>`SELECT * FROM users`
      * ```
      */
-    query<T extends Record<string, unknown>>(templates: TemplateStringsArray, ...args: any[]): Promise<T[]>;
+    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): Promise<T[]>;
+    /**
+     * 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')
+     * ```
+     */
+    notify(channelName: string, payload?: string): Promise<[]>;
     /**
      * 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;AAI3C,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IACG,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IA6BpC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYhF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAmCvG;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACG,KAAK;CAed"}
+{"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;AAK3C,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;IACG,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IA6BpC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYhF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAmCnG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,OAAO,CAAC,EAAE,CAAC;IAIlF;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACG,KAAK;CAed"}

package/dist/pool.js

@@ -71,10 +71,10 @@ class Pool {
      */
     async acquire() {
         this._checkClosed();
-        while (!this._available.isFree) {
+        while (this._available.hasMore) {
             const conn = this._available.get();
             this._available.next();
-            if (conn.isAlive) {
+            if (conn.isOpened) {
                 return conn;
             }
             this._total--;
@@ -113,11 +113,11 @@ class Pool {
      */
     release(conn) {
         this._checkClosed();
-        if (!conn.isAlive) {
+        if (!conn.isOpened) {
             this._total--;
             return;
         }
-        if (!this._waiting.isFree) {
+        if (this._waiting.hasMore) {
             const waiter = this._waiting.get();
             this._waiting.next();
             waiter.resolve(conn);
@@ -178,9 +178,9 @@ class Pool {
      */
     query(templates, ...args) {
         this._checkClosed();
-        while (!this._available.isFree) {
+        while (this._available.hasMore) {
             const conn = this._available.get();
-            if (conn.isAlive) {
+            if (conn.isOpened) {
                 return conn.query(templates, ...args);
             }
             this._available.next();
@@ -204,6 +204,20 @@ class Pool {
             return conn.query(templates, ...args);
         });
     }
+    /**
+     * 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')
+     * ```
+     */
+    notify(channelName, payload = "") {
+        return this.query `select pg_notify(${channelName}, ${payload})`;
+    }
     /**
      * Number of available (idle) connections in the pool.
      */
@@ -229,12 +243,12 @@ class Pool {
      * ```
      */
     async close() {
-        while (!this._available.isFree) {
+        while (this._available.hasMore) {
             const conn = this._available.get();
             this._available.next();
             conn.close();
         }
-        while (!this._waiting.isFree) {
+        while (this._waiting.hasMore) {
             const waiter = this._waiting.get();
             this._waiting.next();
             waiter.reject(new Error('Pool closed'));

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

@@ -1,5 +1,7 @@
 import { AuthenticationCode, ResponseType, TransactionStatus } from "./constants";
 import { ColumnDescription } from "../types";
+import { PostgresError } from "../error";
+import { ChannelName } from "../connection";
 export declare class ConnectionResponseBuffer {
     private buffer;
     private caret;
@@ -31,12 +33,16 @@ export declare class ConnectionResponseReader {
         PID: number;
         secret: number;
     };
-    readErrorResponse(): string;
+    readErrorResponse(): PostgresError;
     readReadyForQuery(): TransactionStatus;
     readSaslMechanisms(): string[];
     readSaslMessage(): string;
     readRowDescription(): ColumnDescription[];
     readDataRow(): (string | null)[];
+    readNotificationResponse(): {
+        name: ChannelName;
+        payload: string;
+    };
     readCommandComplete(): string;
     hasMore(): boolean;
     hasFullPacket(): boolean;

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,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C,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,aAAa,IAAI,OAAO;IAaxB,iBAAiB;CAGpB;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;IAgBjB,iBAAiB,IAEoB,iBAAiB;IAItD,kBAAkB,IAAI,MAAM,EAAE;IAa9B,eAAe,IAAI,MAAM;IAOzB,kBAAkB;IAuBlB,WAAW;IAmBX,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,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,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,aAAa,IAAI,OAAO;IAaxB,iBAAiB;CAGpB;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;IAmBX,wBAAwB;;;;IAUxB,mBAAmB,IAAI,MAAM;IAM7B,OAAO;IAKP,aAAa;IAKb,iBAAiB;IAKjB,iBAAiB;IAKjB,gBAAgB;IAKhB,wBAAwB;IAQxB,UAAU;CAGb"}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionResponseReader = exports.ConnectionResponseBuffer = void 0;
+const error_1 = require("../error");
 class ConnectionResponseBuffer {
     constructor(buffer) {
         this.buffer = buffer;
@@ -91,16 +92,51 @@ class ConnectionResponseReader {
     }
     readErrorResponse() {
         this.buffer.readInt32();
+        let severity = '';
+        let code = '';
         let message = '';
+        let detail = '';
+        let where = '';
+        let hint = '';
+        let position = '';
+        let dataType = '';
+        let constraint = '';
         while (true) {
             const marker = this.buffer.readChar();
             if (marker === '\0')
                 break;
             const text = this.buffer.readCString();
-            if (marker === 'M')
-                message += text;
+            switch (marker) {
+                case 'S':
+                    severity = text;
+                    break;
+                case 'C':
+                    code = text;
+                    break;
+                case 'M':
+                    message = text;
+                    break;
+                case 'D':
+                    detail = text;
+                    break;
+                case 'W':
+                    where = text;
+                    break;
+                case 'H':
+                    hint = text;
+                    break;
+                case 'P':
+                    position = text;
+                    break;
+                case 'd':
+                    dataType = text;
+                    break;
+                case 'n':
+                    constraint = text;
+                    break;
+            }
         }
-        return message;
+        return new error_1.PostgresError(message, code, detail, severity, where, hint, position, dataType, constraint);
     }
     readReadyForQuery() {
         this.buffer.readInt32();
@@ -152,6 +188,13 @@ class ConnectionResponseReader {
         }
         return rowValues;
     }
+    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();

package/dist/protocol/constants.d.ts

@@ -26,6 +26,7 @@ export declare const ResponseTypes: {
     readonly ParameterDescription: "t";
     readonly NoData: "n";
     readonly Notice: "N";
+    readonly NotificationResponse: "A";
 };
 export type ResponseType = ValueOF<typeof ResponseTypes>;
 export declare const AuthenticationCodes: {

package/dist/protocol/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/protocol/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAElC,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAA;AAGtD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAgBhB,CAAA;AAGV,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,aAAa,CAAC,CAAA;AAGxD,eAAO,MAAM,mBAAmB;;;;;;;CAOtB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAGpE,eAAO,MAAM,mBAAmB;;;;CAItB,CAAA;AAEV,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/protocol/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAElC,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAA;AAGtD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;CAiBhB,CAAA;AAGV,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,aAAa,CAAC,CAAA;AAGxD,eAAO,MAAM,mBAAmB;;;;;;;CAOtB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAGpE,eAAO,MAAM,mBAAmB;;;;CAItB,CAAA;AAEV,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/protocol/constants.js

@@ -26,7 +26,8 @@ exports.ResponseTypes = {
     CloseComplete: "3",
     ParameterDescription: "t",
     NoData: "n",
-    Notice: "N"
+    Notice: "N",
+    NotificationResponse: "A"
 };
 exports.AuthenticationCodes = {
     Ok: 0,

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;IA4B5C,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,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"}

package/dist/protocol/socket-connector.js

@@ -9,6 +9,7 @@ class SocketConnector {
         this._onError = _onError;
         this.residualBuffer = null;
         this._isDestroyed = false;
+        _socket.setKeepAlive(true, 10000);
         _socket.on('data', buffer => {
             const currentBuffer = this.residualBuffer
                 ? Buffer.concat([this.residualBuffer, buffer])

package/dist/query.d.ts

@@ -0,0 +1,24 @@
+import { QueryText, StatementName } from "./connection";
+import { ColumnDescription, ValueOF } from "./types";
+export declare const QueryState: {
+    readonly Parsing: 0;
+    readonly Describing: 1;
+    readonly Executing: 2;
+    readonly Completed: 3;
+    readonly Failed: 4;
+};
+export type State = ValueOF<typeof QueryState>;
+export declare class Query<T> {
+    text: QueryText;
+    args: (string | null)[];
+    state: State;
+    statementName: StatementName;
+    columns?: ColumnDescription[] | undefined;
+    promise: Promise<T[]>;
+    resolve: (value: T[]) => void;
+    reject: (error: Error) => void;
+    rows: (string | null)[][];
+    constructor(text: QueryText, args: (string | null)[], state: State, statementName: StatementName, columns?: ColumnDescription[] | undefined);
+    setState(state: State): void;
+}
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGrD,eAAO,MAAM,UAAU;;;;;;CAMb,CAAA;AAGV,MAAM,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,UAAU,CAAC,CAAA;AAG9C,qBAAa,KAAK,CAAC,CAAC;IAOL,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IACvB,KAAK,EAAE,KAAK;IACZ,aAAa,EAAE,aAAa;IAC5B,OAAO,CAAC,EAAE,iBAAiB,EAAE;IAVxC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAA;IACrB,OAAO,EAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAA;IAC9B,MAAM,EAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC/B,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,CAAK;gBAGnB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EACvB,KAAK,EAAE,KAAK,EACZ,aAAa,EAAE,aAAa,EAC5B,OAAO,CAAC,EAAE,iBAAiB,EAAE,YAAA;IAQxC,QAAQ,CAAC,KAAK,EAAE,KAAK;CAGxB"}

package/dist/query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = exports.QueryState = void 0;
+exports.QueryState = {
+    Parsing: 0,
+    Describing: 1,
+    Executing: 2,
+    Completed: 3,
+    Failed: 4
+};
+class Query {
+    constructor(text, args, state, statementName, columns) {
+        this.text = text;
+        this.args = args;
+        this.state = state;
+        this.statementName = statementName;
+        this.columns = columns;
+        this.rows = [];
+        this.promise = new Promise((a, b) => {
+            this.resolve = a;
+            this.reject = b;
+        });
+    }
+    setState(state) {
+        this.state = state;
+    }
+}
+exports.Query = Query;

package/dist/queue.d.ts

@@ -3,8 +3,10 @@ export declare class Queue<T> {
     private _pointer;
     next(): void;
     get(): T;
+    shift(): T;
     push(item: T): void;
     get size(): number;
+    get hasMore(): boolean;
     get isFree(): boolean;
 }
 //# sourceMappingURL=queue.d.ts.map

package/dist/queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK,CAAC,CAAC;IAChB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,QAAQ,CAAI;IAEpB,IAAI;IAQJ,GAAG;IAIH,IAAI,CAAC,IAAI,EAAE,CAAC;IAIZ,IAAI,IAAI,WAEP;IAED,IAAI,MAAM,YAAgD;CAC7D"}
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK,CAAC,CAAC;IAChB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,QAAQ,CAAI;IAEpB,IAAI;IASJ,GAAG;IAKH,KAAK;IAYL,IAAI,CAAC,IAAI,EAAE,CAAC;IAIZ,IAAI,IAAI,WAEP;IAGD,IAAI,OAAO,YAEV;IAGD,IAAI,MAAM,YAA+C;CAC5D"}

package/dist/queue.js

@@ -8,7 +8,7 @@ class Queue {
     }
     next() {
         this._pointer++;
-        if (this._pointer === this._queue.length) {
+        if (this._pointer >= this._queue.length) {
             this._queue = [];
             this._pointer = 0;
         }
@@ -16,12 +16,24 @@ class Queue {
     get() {
         return this._queue[this._pointer];
     }
+    shift() {
+        const item = this._queue[this._pointer];
+        this._pointer++;
+        if (this._pointer >= this._queue.length) {
+            this._queue = [];
+            this._pointer = 0;
+        }
+        return item;
+    }
     push(item) {
         this._queue.push(item);
     }
     get size() {
         return this._queue.length - this._pointer;
     }
-    get isFree() { return this._pointer === this._queue.length; }
+    get hasMore() {
+        return this._pointer < this._queue.length;
+    }
+    get isFree() { return this._pointer >= this._queue.length; }
 }
 exports.Queue = Queue;

package/dist/transaction.d.ts

@@ -23,7 +23,7 @@ export declare class Transaction {
     /**
      * Executes a query within the current transaction.
      */
-    query<T extends Record<string, unknown>>(strings: TemplateStringsArray, ...values: any[]): Promise<T[]>;
+    query<T extends Record<string, any>>(strings: TemplateStringsArray, ...values: any[]): Promise<T[]>;
     /**
      * Creates a sub-transaction using PostgreSQL SAVEPOINT.
      * If the callback throws, only the actions within this savepoint are rolled back.

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;GAGG;AACH,qBAAa,WAAW;IAIhB,QAAQ,CAAC,IAAI,EAAE,UAAU;IAH7B,OAAO,CAAC,UAAU,CAAiB;gBAGtB,IAAI,EAAE,UAAU;IAG7B;;OAEG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAED,OAAO,CAAC,WAAW;IAMnB;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAOpC;;OAEG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtC;;OAEG;IACU,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAKpH;;;;;;;;;OASG;IACU,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAe5G"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;GAGG;AACH,qBAAa,WAAW;IAIhB,QAAQ,CAAC,IAAI,EAAE,UAAU;IAH7B,OAAO,CAAC,UAAU,CAAiB;gBAGtB,IAAI,EAAE,UAAU;IAG7B;;OAEG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAED,OAAO,CAAC,WAAW;IAMnB;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAOpC;;OAEG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtC;;OAEG;IACU,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAKhH;;;;;;;;;OASG;IACU,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAe5G"}

package/dist/types.d.ts

@@ -19,5 +19,8 @@ export type ColumnDescription = {
     name: string;
     typeOID: number;
 };
+export type Branded<T, Brand> = T & {
+    __brand: Brand;
+};
 export type ValueOF<T extends Record<string, unknown>> = T[keyof T];
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,CAAC,OAAO,SAAS,GAAG,EAAE,OAAO,SAAS,GAAG,EAAE,IAAI;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;CACpD,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC3B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAC/B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,GAAG,EAAE,CAAC;CACf,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,SAAS,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,GAAG,EAAE,CAAC;CACf,CAAA;AAGD,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAGD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,CAAC,OAAO,SAAS,GAAG,EAAE,OAAO,SAAS,GAAG,EAAE,IAAI;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;CACpD,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC3B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAC/B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,GAAG,EAAE,CAAC;CACf,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,SAAS,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,GAAG,EAAE,CAAC;CACf,CAAA;AAGD,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,GAAG;IAAC,OAAO,EAAE,KAAK,CAAA;CAAC,CAAA;AAEpD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA"}

package/dist/utils/value-parser.d.ts

@@ -1,6 +1,6 @@
 import { ColumnDescription } from "../types";
 declare const Parsers: Record<number, (value: string) => unknown>;
-export declare function parseRowValues(columns: ColumnDescription[], rows: (string | null)[][]): Record<string, any>;
+export declare function parseRowValues(columns: ColumnDescription[], rows: (string | null)[][]): Record<string, any>[];
 export declare const setTypeParser: (typeOID: keyof typeof Parsers, parser: (value: string) => unknown) => void;
 export {};
 //# sourceMappingURL=value-parser.d.ts.map

package/dist/utils/value-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value-parser.d.ts","sourceRoot":"","sources":["../../src/utils/value-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AA+B5C,QAAA,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAkD9C,CAAA;AAMV,wBAAgB,cAAc,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CA8B3G;AAGD,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,OAAO,OAAO,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,SAE9F,CAAA"}
+{"version":3,"file":"value-parser.d.ts","sourceRoot":"","sources":["../../src/utils/value-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AA+B5C,QAAA,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAkD9C,CAAA;AAMV,wBAAgB,cAAc,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CA8B7G;AAGD,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,OAAO,OAAO,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,SAE9F,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m2k-5f/pgtx",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "Blazing-fast PostgreSQL driver with pipeline support.",
   "files": [
     "dist",
@@ -40,8 +40,9 @@
     }
   },
   "devDependencies": {
+    "@types/node": "^26.1.1",
+    "pg": "^8.22.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.0.0",
-    "@types/node": "^26.1.1"
+    "typescript": "^5.0.0"
   }
 }