@m2k-5f/pgtx 2.6.0 → 2.6.1

package/README.md

@@ -64,83 +64,65 @@
   - **Connection pool** — Auto-management connections with support for pipeline queries via the pool itself.
   - **Zero dependencies** — Lightweight and blazing
 
----
+  ---
 
-## ⚡ Performance
+  ## ⚡ Performance
 
-All benchmarks are executed on **GitHub Actions** (Ubuntu, 2 vCPUs) and are fully reproducible. Benchmark sources are included in this repository.
+  All benchmarks are executed on **GitHub Actions** (Ubuntu, 2 vCPUs) and are fully reproducible. Benchmark sources are included in this repository.
 
-### 1. PostgreSQL Pipeline Stress Test
+  ### 1. PostgreSQL Pipeline Stress Test
 
-**3000 concurrent parameterized `SELECT` queries**
+  **3000 concurrent parameterized `SELECT` queries**
 
-* Connection pool: **10 connections**
-* Measured with **mitata**
+  * Connection pool: **10 connections**
+  * Measured with **mitata**
 
-| Driver                 |     Avg Time |       Relative Speed | Memory (p75) |
-| :--------------------- | -----------: | -------------------: | -----------: |
-| **Pgtx (Pipeline)**    | **24.18 ms** | **Baseline (1.00×)** |  **≈2.5 MB** |
-| Postgres.js (Pipeline) |     83.36 ms |     **3.45× slower** |      ≈7.6 MB |
-| node-postgres (`pg`)   |    377.95 ms |    **15.63× slower** |     ≈11.4 MB |
+  | Driver                 |     Avg Time |       Relative Speed | Memory (p75) |
+  | :--------------------- | -----------: | -------------------: | -----------: |
+  | **Pgtx (Pipeline)**    | **24.18 ms** | **Baseline (1.00×)** |  **≈2.5 MB** |
+  | Postgres.js (Pipeline) |     83.36 ms |     **3.45× slower** |      ≈7.6 MB |
+  | node-postgres (`pg`)   |    377.95 ms |    **15.63× slower** |     ≈11.4 MB |
 
-### 2. Real-World HTTP Throughput
+  ### 2. Real-World HTTP Throughput
 
-Simple `node:http` server serving a PostgreSQL-backed endpoint.
+  Simple `node:http` server serving a PostgreSQL-backed endpoint.
 
-Measured with:
+  Measured with:
 
-```bash
-wrk -t2 -c<N> -d10s http://localhost:3000/users
-```
+  ```bash
+  wrk -t2 -c<N> -d10s http://localhost:3000/users
+  ```
 
-| Concurrent Connections |             Pgtx |  Postgres.js |   Speedup |
-| ---------------------: | ---------------: | -----------: | --------: |
-|                     50 |      5,272 req/s |  5,691 req/s |     0.93× |
-|                    200 | **12,918 req/s** |  6,724 req/s | **1.92×** |
-|                   1000 | **21,429 req/s** |  8,423 req/s | **2.54×** |
-|                  10000 | **22,486 req/s** | 12,764 req/s | **1.76×** |
+  | Concurrent Connections |             Pgtx |  Postgres.js |   Speedup |
+  | ---------------------: | ---------------: | -----------: | --------: |
+  |                     50 |      5,272 req/s |  5,691 req/s |     0.93× |
+  |                    200 | **12,918 req/s** |  6,724 req/s | **1.92×** |
+  |                   1000 | **21,429 req/s** |  8,423 req/s | **2.54×** |
+  |                  10000 | **22,486 req/s** | 12,764 req/s | **1.76×** |
 
-### Why is Pgtx fast?
+  ### Why is Pgtx fast?
 
-Pgtx is engineered for **throughput**, not for minimizing the latency of individual queries.
+  Pgtx is engineered for **throughput**, not for minimizing the latency of individual queries.
 
-Instead of optimizing a single request in isolation, Pgtx minimizes per-query overhead under sustained concurrent load by combining:
+  Instead of optimizing a single request in isolation, Pgtx minimizes per-query overhead under sustained concurrent load by combining:
 
-* Pipeline query multiplexing
-* Synchronous PostgreSQL wire protocol encoding
-* Batched socket writes
-* Automatic prepared statement caching
-* Prepared statement deduplication
-* Row description caching
-* Binary protocol support
-* Zero-dependency implementation
+  * Pipeline query multiplexing
+  * Synchronous PostgreSQL wire protocol encoding
+  * Batched socket writes
+  * Automatic prepared statement caching
+  * Prepared statement deduplication
+  * Row description caching
+  * Binary protocol support
+  * Zero-dependency implementation
 
-As concurrency increases, these optimizations significantly reduce protocol overhead, allowing Pgtx to scale more efficiently than traditional PostgreSQL drivers.
+  As concurrency increases, these optimizations significantly reduce protocol overhead, allowing Pgtx to scale more efficiently than traditional PostgreSQL drivers.
 
-In the `mitata` benchmark, Pgtx also demonstrated approximately **3× lower memory usage** than Postgres.js while processing the same workload, reducing allocation pressure and improving sustained throughput under heavy load.
+  In the `mitata` benchmark, Pgtx also demonstrated approximately **2× lower memory usage** than Postgres.js while processing the same workload, reducing allocation pressure and improving sustained throughput under heavy load.
 
-> **Blazing** isn't just a tagline — it's backed by reproducible benchmarks.
+  > **Blazing** isn't just a tagline — it's backed by reproducible benchmarks.
 
 ---
 
-  ## 🔥 Why Pgtx?
-
-  | Capability                          | **Pgtx** | **Postgres.js** | **pg** |
-  | -------------------------------- | :------: | :-------------: | :----: |
-  | Pipeline queries                 |     ✅    |        ✅        |    ❌   |
-  | Pipeline multiplexing in pool    |     ✅    |        ❌        |    ❌   |
-  | Tagged template SQL              |     ✅    |        ✅        |    ❌   |
-  | Automatic prepared statements    |     ✅    |        ✅        |    ✅   |
-  | Prepared statement deduplication |     ✅    |        ❌        |    ❌   |
-  | Transactions                     |     ✅    |        ✅        |    ✅   |
-  | Savepoints                       |     ✅    |        ✅        |    ❌   |
-  | LISTEN / NOTIFY                  |     ✅    |        ✅        |    ✅   |
-  | Connection pool                  |     ✅    |        ✅        |    ✅   |
-  | Zero dependencies                |     ✅    |        ✅        |    ❌   |
-
-  ---
-
-
   ## 📖 Features
 
   ### 🎯 Typed Error Handling
@@ -167,9 +149,9 @@ In the `mitata` benchmark, Pgtx also demonstrated approximately **3× lower memo
   ```typescript
   // 5 queries, only 2 network round-trips
   const {user, posts, ...data} = await Bind({
-    user: () => pool.query<User>`...`,
-    config: () => pool.query<Config>`...`,
-    announcements: () => pool.query<Announcement>`...`
+    user: pool.query<User>`...`,
+    config: pool.query<Config>`...`,
+    announcements: pool.query<Announcement>`...`
   })
   .bind({
     posts: ({ user }) => pool.query<Post>`...`,
@@ -452,26 +434,28 @@ In the `mitata` benchmark, Pgtx also demonstrated approximately **3× lower memo
   ###  Connection 
   ```typescript
   class Connection {
-      static new(params: ConnectionParams): Promise<Connection>
+      static new(params: ConnectionPartialParams): Promise<Connection>
 
       query<T>(strings: TemplateStringsArray, ...values: any[]): Future<T[], PostgresError>
-      begin<T>(callback: (tx: Transaction) => Promise<T>): Future<T, Error>
-      notify(channelName: string, payload?: string): Future<[], PostgresError>
-      listen(channelName: string, callback: (payload: string) => void): Future<[], PostgresError>
-      unlisten(channelName: string, callback: (payload: string) => void): Future<[], PostgresError>
+      begin<T>(callback: (tx: Transaction) => Promise<T>): Future<T, unknown>
+      notify(channelName: string, payload?: string): Future<void, PostgresError>
+      listen(channelName: string, callback: (payload: string) => void): Future<void, PostgresError>
+      unlisten(channelName: string, callback: (payload: string) => void): Future<void, PostgresError>
       stream<T extends Record<string, any>>(templates: TemplateStringsArray, ...params: any[]): ReadableStream<T>
       get isAlive(): boolean
       close(): void
   }
 
-  interface ConnectionParams {
-      user: string
-      password?: string
-      host: string
-      port: number
-      database: string
-      queryTimeout?: number // default: 30 srconds
-      logLevel?: 'none' | 'error' | 'notice' | 'query' // default: "error"
+  interface ConnectionPartialParams {
+    user: string
+    password?: string
+    host: string
+    port: number
+    database: string
+    logLevel?: LogLevel, // default "error"
+    int8toBigint?: boolean, // default false
+    queryTimeout?: number // default 30000 (30 seconds)
+    syncShedule?: "Tick" | "Immediate" // default "Immediate"
   }
   ```
 
@@ -479,14 +463,14 @@ In the `mitata` benchmark, Pgtx also demonstrated approximately **3× lower memo
 
   ```typescript
   class Pool {
-      constructor(config: PoolConfig)
+      constructor(config: PoolPartialConfig)
 
       query<T>(strings: TemplateStringsArray, ...values: any[]): Future<T[], PostgresError>
-      begin<T>(callback: (tx: Transaction) => Promise<T>): Future<T, Error>
-      notify(channelName: string, payload?: string): Future<[], PostgresError>
-      listen(channel: string, callback: (payload: string) => void): Future<() => Promise<void>, PostgresError>
+      begin<T>(callback: (tx: Transaction) => Promise<T>): Future<T, unknown>
+      notify(channelName: string, payload?: string): Future<void, PostgresError>
+      listen(channel: string, callback: (payload: string) => void): Future<() => Future<void, PostgresError>, PostgresError>
       stream<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): ReadableStream<T>
-      withAcquire<T>(fn: (conn: Connection) => Promise<T>): Future<T, Error>
+      withAcquire<T>(fn: (conn: Connection) => Promise<T>): Future<T, unknown>
       acquire(): Future<Connection, PostgresError>
       release(conn: Connection): void
       close(): void
@@ -495,7 +479,7 @@ In the `mitata` benchmark, Pgtx also demonstrated approximately **3× lower memo
       get total(): number
   }
 
-  interface PoolConfig extends ConnectionParams {
+  interface PoolPartialConfig extends ConnectionPartialConfig {
       max?: number
   }
   ```
@@ -505,9 +489,9 @@ In the `mitata` benchmark, Pgtx also demonstrated approximately **3× lower memo
   ```typescript
   class Transaction {
     query<T>(strings: TemplateStringsArray, ...values: any[]): Future<T[], PostgresError>
-    commit(): Future<[], PostgresError>
-    rollback(): Future<[], PostgresError>
-    savepoint<T>(name: string, callback: (tx: Transaction) => Promise<T>): Future<T, Error>
+    commit(): Future<void, PostgresError>
+    rollback(): Future<void, PostgresError>
+    savepoint<T>(name: string, callback: (tx: Transaction) => Promise<T>): Future<T, unknown>
 
     get isActive(): boolean
   }

package/dist/batch.d.ts

@@ -5,7 +5,7 @@ export declare class Batch {
     private _queryQueue;
     private _buffer;
     constructor(buffer: ConnectionRequestWriter);
-    registerQuery(query: PostgresQuery, timeout: number): void;
+    registerQuery(query: PostgresQuery): void;
     end(): ConnectionRequestWriter;
     get current(): PostgresQuery;
     next(): void;

package/dist/batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../src/batch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAc,aAAa,EAAsB,MAAM,SAAS,CAAC;AAGxE,qBAAa,KAAK;IACd,OAAO,CAAC,WAAW,CAAsB;IACzC,OAAO,CAAC,OAAO,CAAyB;gBAE5B,MAAM,EAAE,uBAAuB;IAK3C,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM;IAgBnD,GAAG;IAIH,IAAI,OAAO,kBAEV;IAED,IAAI;IAIJ,MAAM,CAAC,KAAK,EAAE,aAAa;CAK9B"}
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../src/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAc,aAAa,EAAE,MAAM,SAAS,CAAC;AAGpD,qBAAa,KAAK;IACd,OAAO,CAAC,WAAW,CAAsB;IACzC,OAAO,CAAC,OAAO,CAAyB;gBAE5B,MAAM,EAAE,uBAAuB;IAK3C,aAAa,CAAC,KAAK,EAAE,aAAa;IAelC,GAAG;IAIH,IAAI,OAAO,kBAEV;IAED,IAAI;IAIJ,MAAM,CAAC,KAAK,EAAE,aAAa;CAK9B"}

package/dist/batch.js

@@ -5,9 +5,8 @@ export class Batch {
         this._queryQueue = new Queue();
         this._buffer = buffer;
     }
-    registerQuery(query, timeout) {
+    registerQuery(query) {
         this._queryQueue.push(query);
-        query.startTimeout(timeout);
         if (query instanceof ParseQuery) {
             this._buffer
                 .writeParse(query.statement, query.text)

package/dist/clauses/abstract.clause.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstract.clause.d.ts","sourceRoot":"","sources":["../../src/clauses/abstract.clause.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAsC,MAAM,UAAU,CAAC;AAEpF,8BAAsB,MAAM;IACxB,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI;CAC5D"}
+{"version":3,"file":"abstract.clause.d.ts","sourceRoot":"","sources":["../../src/clauses/abstract.clause.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,8BAAsB,MAAM;IACxB,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI;CAC5D"}

package/dist/connection.d.ts

@@ -1,27 +1,7 @@
-import { Branded, ColumnDescription } from "./types";
+import { ConnectionPartialConfig } from "./types";
 import { Transaction } from "./transaction";
 import { Future } from 'fluent-future';
 import { PostgresError } from "./error";
-type LogLevel = "none" | "error" | "notice" | "query";
-export type ConnectionParams = {
-    user: string;
-    password?: string;
-    host: string;
-    port: number;
-    database: string;
-    logLevel?: LogLevel;
-    int8toBigint?: boolean;
-    queryTimeout?: number;
-    batchCapacity?: number;
-    flushShedule?: "nextTick" | "Immediate";
-};
-export type StatementName = Branded<string, 'StatementName'>;
-export type QueryText = Branded<string, 'QueryText'>;
-export type ChannelName = Branded<string, "ChannelName">;
-export type QueryMeta = {
-    statement: StatementName;
-    columns: ColumnDescription[];
-};
 /**
  * Represents a single dedicated connection to the PostgreSQL database.
  *
@@ -53,7 +33,7 @@ export type QueryMeta = {
  * ```
  */
 export declare class Connection {
-    private readonly params;
+    private readonly config;
     private _activeBatch;
     private _isOpened;
     private _isReconnecting;
@@ -64,7 +44,6 @@ export declare class Connection {
     private _parsing;
     private _listeningCallbacks;
     private _stmtCounter;
-    private _logLevel;
     private _nextStatement;
     private constructor();
     /**
@@ -85,7 +64,7 @@ export declare class Connection {
      * })
      * ```
      */
-    static new(params: ConnectionParams): Future<Connection, PostgresError>;
+    static new(config: ConnectionPartialConfig): Future<Connection, PostgresError>;
     private _registerBatch;
     private _sync;
     /**
@@ -146,7 +125,7 @@ export declare class Connection {
      * await conn.notify('events', 'hello')
      * ```
      */
-    notify(channelName: string, payload?: string): Future<Record<string, any>[], PostgresError>;
+    notify(channelName: string, payload?: string): Future<void, PostgresError>;
     /**
      * Subscribes a callback to a channel. Sends `LISTEN` on the first subscription.
      *
@@ -222,5 +201,4 @@ export declare class Connection {
      */
     close(): void;
 }
-export {};
 //# sourceMappingURL=connection.d.ts.map

package/dist/connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAMA,OAAO,EAA6D,uBAAuB,EAAuC,MAAM,SAAS,CAAA;AACjJ,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAK3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAA;AACjD,OAAO,EAAkD,aAAa,EAAE,MAAM,SAAS,CAAA;AAKvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IAEzC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,SAAS,CAAO;IACxB,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,aAAa,CAAgC;IAErD,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAA4B;IAE/C,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,QAAQ,CAAyD;IAEzE,OAAO,CAAC,mBAAmB,CAAyD;IACpF,OAAO,CAAC,YAAY,CAAI;IAGxB,OAAO,CAAC,cAAc;IAKtB,OAAO;IAYP;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB;IAe1C,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,KAAK;IA4Bb;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC;IA2CnH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAoB7D;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAQhD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAgB/D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC;IAqB/F;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAqDvF,OAAO,CAAC,qBAAqB;IAoD7B,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,qBAAqB;YASf,UAAU;IAgBxB,OAAO,CAAC,qBAAqB;IAW7B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,aAAa;IAqHrB;;;OAGG;IACH,IAAI,QAAQ,YAEX;IAGD;;;;;;;;;OASG;IACH,KAAK;CAKR"}

package/dist/connection.js

@@ -10,6 +10,7 @@ import { sql } from ".";
 import { Begin, Future, Ok } from 'fluent-future';
 import { ErrConnectionClosed, ErrConnectionReconnecting } from "./error";
 import { Batch } from "./batch";
+import { nextTick } from "process";
 /**
  * Represents a single dedicated connection to the PostgreSQL database.
  *
@@ -44,7 +45,7 @@ export class Connection {
     _nextStatement() {
         return `s-${this._stmtCounter++}`;
     }
-    constructor(socket, logLevel, params) {
+    constructor(config, socket) {
         this._activeBatch = null;
         this._isOpened = true;
         this._isReconnecting = false;
@@ -54,8 +55,7 @@ export class Connection {
         this._parsing = new Map();
         this._listeningCallbacks = new Map();
         this._stmtCounter = 0;
-        this.params = params;
-        this._logLevel = logLevel;
+        this.config = config;
         this._socket = new SocketConnector(socket, (type, _, reader) => this._handlePacket(type, reader), () => this._registerReconnect());
     }
     /**
@@ -76,16 +76,23 @@ export class Connection {
      * })
      * ```
      */
-    static new(params) {
+    static new(config) {
+        const conf = {
+            ...config,
+            logLevel: config.logLevel || 'error',
+            int8toBigint: config.int8toBigint || false,
+            queryTimeout: config.queryTimeout || 30000,
+            syncShedule: config.syncShedule || 'Immediate'
+        };
         const writer = ConnectionRequestWriter.new();
-        return createAuthorizedSocket(writer, params)
-            .andThen(socket => Ok(new Connection(socket, params.logLevel || 'error', params)));
+        return createAuthorizedSocket(writer, conf)
+            .andThen(socket => Ok(new Connection(conf, socket)));
     }
     _registerBatch() {
         if (!this._activeBatch) {
             const batch = new Batch(this._cachedBuffer.clear());
             this._activeBatch = batch;
-            setImmediate(() => {
+            (this.config.syncShedule === 'Immediate' ? setImmediate : nextTick)(() => {
                 this._sync(batch);
             });
             return batch;
@@ -143,25 +150,24 @@ export class Connection {
         if (this._isReconnecting)
             return Future.reject(ErrConnectionReconnecting);
         const { text, args } = compileSqlTemplate(templates, params);
-        if (this._logLevel === 'query') {
+        if (this.config.logLevel === 'query') {
             console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
-        const batch = this._registerBatch();
         if (this._parsed.has(text)) {
             const meta = this._parsed.get(text);
-            const query = new SimpleQuery(meta.statement, text, args, meta.columns);
-            batch.registerQuery(query, this.params.queryTimeout || 30000);
+            const query = new SimpleQuery(meta.statement, text, args, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
             return query.future;
         }
         if (!this._parsing.has(text)) {
-            const parseQuery = new ParseQuery(this._nextStatement(), text);
+            const parseQuery = new ParseQuery(this._nextStatement(), text, this.config.queryTimeout);
             this._parsing.set(text, parseQuery.future);
-            batch.registerQuery(parseQuery, this.params.queryTimeout || 30000);
+            this._registerBatch().registerQuery(parseQuery);
         }
         const future = this._parsing.get(text);
         return future.andThen(meta => {
-            const query = new SimpleQuery(meta.statement, text, args, meta.columns);
-            this._registerBatch().registerQuery(query, this.params.queryTimeout || 30000);
+            const query = new SimpleQuery(meta.statement, text, args, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
             return query.future;
         });
     }
@@ -220,7 +226,7 @@ export class Connection {
             return Future.reject(ErrConnectionClosed);
         if (this._isReconnecting)
             return Future.reject(ErrConnectionReconnecting);
-        return this.query `select pg_notify(${channelName}, ${payload})`;
+        return this.query `select pg_notify(${channelName}, ${payload})`.map(() => { });
     }
     /**
      * Subscribes a callback to a channel. Sends `LISTEN` on the first subscription.
@@ -303,7 +309,7 @@ export class Connection {
         if (this._isReconnecting)
             throw ErrConnectionReconnecting;
         const { text, args } = compileSqlTemplate(templates, params);
-        if (this._logLevel === 'query') {
+        if (this.config.logLevel === 'query') {
             console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
         let controller;
@@ -312,23 +318,22 @@ export class Connection {
                 controller = c;
             }
         });
-        const batch = this._registerBatch();
         if (this._parsed.has(text)) {
             const meta = this._parsed.get(text);
-            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns);
-            batch.registerQuery(query, this.params.queryTimeout || 30000);
+            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
             return stream;
         }
         if (!this._parsing.has(text)) {
-            const parseQuery = new ParseQuery(this._nextStatement(), text);
+            const parseQuery = new ParseQuery(this._nextStatement(), text, this.config.queryTimeout);
             this._parsing.set(text, parseQuery.future);
-            batch.registerQuery(parseQuery, this.params.queryTimeout || 30000);
+            this._registerBatch().registerQuery(parseQuery);
         }
         const future = this._parsing.get(text);
         future
             .tap(meta => {
-            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns);
-            this._registerBatch().registerQuery(query, this.params.queryTimeout || 30000);
+            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
         })
             .catch(err => controller.error(err));
         return stream;
@@ -339,25 +344,24 @@ export class Connection {
         if (this._isReconnecting)
             throw ErrConnectionReconnecting;
         const { text, args } = compileSqlTemplate(templates, params);
-        if (this._logLevel === 'query') {
+        if (this.config.logLevel === 'query') {
             console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
-        const batch = this._registerBatch();
         if (this._parsed.has(text)) {
             const meta = this._parsed.get(text);
-            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns);
-            batch.registerQuery(query, this.params.queryTimeout || 30000);
+            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
         }
         if (!this._parsing.has(text)) {
-            const parseQuery = new ParseQuery(this._nextStatement(), text);
+            const parseQuery = new ParseQuery(this._nextStatement(), text, this.config.queryTimeout);
             this._parsing.set(text, parseQuery.future);
-            batch.registerQuery(parseQuery, this.params.queryTimeout || 30000);
+            this._registerBatch().registerQuery(parseQuery);
         }
         const future = this._parsing.get(text);
         future
             .tap(meta => {
-            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns);
-            this._registerBatch().registerQuery(query, this.params.queryTimeout || 30000);
+            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
         })
             .catch(err => controller.error(err));
     }
@@ -373,7 +377,7 @@ export class Connection {
         this._rejectAllBatches(cause);
     }
     async _reconnect() {
-        const socket = await createAuthorizedSocket(ConnectionRequestWriter.new(), this.params);
+        const socket = await createAuthorizedSocket(ConnectionRequestWriter.new(), this.config);
         const connector = new SocketConnector(socket, (type, _, reader) => this._handlePacket(type, reader), (err) => this._registerReconnect());
         this._socket = connector;
         this._resetConnectionState(ErrConnectionReconnecting);
@@ -441,7 +445,7 @@ export class Connection {
             case ResponseTypes.DataRow:
                 {
                     let query = this._getCurrentQuery();
-                    query.push(reader.readDataRow(query.columns, this.params.int8toBigint));
+                    query.push(reader.readDataRow(query.columns, this.config.int8toBigint));
                 }
                 break;
             case ResponseTypes.ComandComplete:
@@ -455,7 +459,7 @@ export class Connection {
             case ResponseTypes.ErrorResponse:
                 {
                     const error = reader.readErrorResponse();
-                    if (this._logLevel === 'error' || this._logLevel === 'notice' || this._logLevel === 'query') {
+                    if (this.config.logLevel === 'error' || this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
                         console.log(`\nError:    ${error}\n`);
                     }
                     const query = this._getCurrentQuery();
@@ -472,7 +476,7 @@ export class Connection {
             case ResponseTypes.Notice:
                 {
                     const message = reader.readErrorResponse();
-                    if (this._logLevel === 'notice' || this._logLevel === 'query') {
+                    if (this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
                         console.log(`\nError:    ${message}\n`);
                     }
                 }

package/dist/error.d.ts

@@ -15,7 +15,12 @@ export declare class PostgresError extends Error {
     get isTimeout(): boolean;
     get isConnectionFailure(): boolean;
 }
+export declare const ErrNonceMismatch: PostgresError;
+export declare const ErrPasswordRequired: PostgresError;
+export declare const ErrSocketFailedDuringAuth: PostgresError;
 export declare const ErrQueryTimeout: PostgresError;
+export declare const ErrPoolClosed: PostgresError;
+export declare const ErrTransactionClosed: PostgresError;
 export declare const ErrConnectionClosed: PostgresError;
 export declare const ErrConnectionReconnecting: PostgresError;
 //# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -1 +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,GAAE,MAAqB,EAC3B,MAAM,GAAE,MAAW,EACnB,QAAQ,GAAE,MAAW,EACrB,KAAK,GAAE,MAAW,EAClB,IAAI,GAAE,MAAW,EACjB,QAAQ,GAAE,MAAW,EACrB,QAAQ,GAAE,MAAW,EACrB,UAAU,GAAE,MAAW;IAQlC,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;AAED,eAAO,MAAM,eAAe,eAA8C,CAAA;AAE1E,eAAO,MAAM,mBAAmB,eAA8E,CAAA;AAC9G,eAAO,MAAM,yBAAyB,eAA2F,CAAA"}
+{"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,GAAE,MAAqB,EAC3B,MAAM,GAAE,MAAW,EACnB,QAAQ,GAAE,MAAW,EACrB,KAAK,GAAE,MAAW,EAClB,IAAI,GAAE,MAAW,EACjB,QAAQ,GAAE,MAAW,EACrB,QAAQ,GAAE,MAAW,EACrB,UAAU,GAAE,MAAW;IAQlC,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;AAED,eAAO,MAAM,gBAAgB,eAAmF,CAAA;AAChH,eAAO,MAAM,mBAAmB,eAAqE,CAAA;AACrG,eAAO,MAAM,yBAAyB,eAAiD,CAAA;AAEvF,eAAO,MAAM,eAAe,eAA8C,CAAA;AAE1E,eAAO,MAAM,aAAa,eAAkE,CAAA;AAE5F,eAAO,MAAM,oBAAoB,eAA6E,CAAA;AAE9G,eAAO,MAAM,mBAAmB,eAA8E,CAAA;AAC9G,eAAO,MAAM,yBAAyB,eAA2F,CAAA"}

package/dist/error.js

@@ -31,6 +31,11 @@ export class PostgresError extends Error {
         return this.code.startsWith('08') || this.code.startsWith('57') && this.code !== '57014';
     }
 }
+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 ErrQueryTimeout = new PostgresError('Query timeout', '57014');
+export const ErrPoolClosed = new PostgresError("Pool is closed", 'pool_closed', '', "ERROR");
+export const ErrTransactionClosed = new PostgresError("Transaction closed", "transaction_closed", '', "ERROR");
 export const ErrConnectionClosed = new PostgresError("Connection is closed", 'connection_closed', "", "ERROR");
 export const ErrConnectionReconnecting = new PostgresError("Connection are reconnecting", "connection_reconnecting", "", "ERROR");

package/dist/index.d.ts

@@ -120,4 +120,5 @@ export { Connection as Connection };
 export { Transaction as Transaction };
 export { PgtxPool as Pool };
 export * from "./clauses";
+export * from './error';
 //# 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;;;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;AAG3B,cAAc,WAAW,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;;;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;AAG3B,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA"}

package/dist/index.js

@@ -120,3 +120,4 @@ export { Connection as Connection };
 export { Transaction as Transaction };
 export { PgtxPool as Pool };
 export * from "./clauses";
+export * from './error';

package/dist/pool.d.ts

@@ -1,10 +1,8 @@
-import { Connection, ConnectionParams } from "./connection";
+import { Connection } from "./connection";
 import { Transaction } from "./transaction";
 import { Future } from "fluent-future";
 import { PostgresError } from "./error";
-type PoolParams = ConnectionParams & {
-    max?: number;
-};
+import { PoolPartialConfig } from "./types";
 /**
  * The main entry point for Pgtx.
  * Manages a connection pool and provides high-level API for queries and transactions.
@@ -42,13 +40,11 @@ type PoolParams = ConnectionParams & {
  */
 export declare class Pool {
     private _available;
-    private _config;
-    private _max;
+    private config;
     private _total;
     private _waiting;
-    private _isClosed;
-    private _checkClosed;
-    constructor(params: PoolParams);
+    private _isOpened;
+    constructor(config: PoolPartialConfig);
     /**
      * Acquires a dedicated connection from the pool.
      *
@@ -186,7 +182,7 @@ export declare class Pool {
      * await pool.notify('events', 'hello')
      * ```
      */
-    notify(channelName: string, payload?: string): Future<[], PostgresError>;
+    notify(channelName: string, payload?: string): Future<void, PostgresError>;
     /**
      * Asynchronously subscribes to pub/sub events on a specific PostgreSQL channel (LISTEN).
      *
@@ -211,7 +207,7 @@ export declare class Pool {
      * // When the subscription is no longer needed (e.g., during teardown or server stop):
      * await unlisten(); // The socket cleanly issues UNLISTEN and returns to the pool of free connections.
      */
-    listen(channel: string, callback: (payload: string) => void): Future<() => Promise<void>, PostgresError>;
+    listen(channel: string, callback: (payload: string) => void): Future<() => Future<void, PostgresError>, PostgresError>;
     /**
      * Number of available (idle) connections in the pool.
      */
@@ -234,5 +230,4 @@ export declare class Pool {
      */
     close(): void;
 }
-export {};
 //# sourceMappingURL=pool.d.ts.map

package/dist/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAAuB;IACzC,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;IAO9B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO;IA2BP;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAiBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAY7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IAIhG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAWR"}
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAC;AAClD,OAAO,EAAiB,aAAa,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAc,iBAAiB,EAAU,MAAM,SAAS,CAAC;AAGhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,IAAI;IACb,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAO;gBAEZ,MAAM,EAAE,iBAAiB;IAOrC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO;IA2BP;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAiBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAU7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAQhD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAaR"}

package/dist/pool.js

@@ -1,8 +1,7 @@
 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.
@@ -39,17 +38,13 @@ const ErrPoolClosed = new PostgresError('Pool closed');
  * ```
  */
 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.
@@ -70,7 +65,8 @@ export class Pool {
      * ```
      */
     acquire() {
-        this._checkClosed();
+        if (!this._isOpened)
+            return Future.reject(ErrPoolClosed);
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (conn.isOpened) {
@@ -78,9 +74,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();
@@ -130,7 +126,8 @@ export class Pool {
      * ```
      */
     release(conn) {
-        this._checkClosed();
+        if (!this._isOpened)
+            throw ErrPoolClosed;
         if (!conn.isOpened) {
             this._total--;
             return;
@@ -160,7 +157,6 @@ export class Pool {
      * ```
      */
     begin(txCallback) {
-        this._checkClosed();
         return Begin()
             .andThen(() => this.acquire())
             .andThen(conn => conn.begin(txCallback)
@@ -190,7 +186,8 @@ export class Pool {
      * ```
      */
     query(templates, ...args) {
-        this._checkClosed();
+        if (!this._isOpened)
+            return Future.reject(ErrPoolClosed);
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (!conn.isOpened) {
@@ -232,7 +229,8 @@ export class Pool {
      * }
      */
     stream(templates, ...args) {
-        this._checkClosed();
+        if (!this._isOpened)
+            throw ErrPoolClosed;
         while (this._available.hasMore) {
             const conn = this._available.shift;
             if (!conn.isOpened) {
@@ -270,7 +268,9 @@ export class Pool {
      * ```
      */
     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).
@@ -299,10 +299,8 @@ export class Pool {
     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.
@@ -329,6 +327,7 @@ export class Pool {
      * ```
      */
     close() {
+        this._isOpened = false;
         while (this._available.hasMore) {
             this._available.shift.close();
         }

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;

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

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++) {

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.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;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;IAMrC,YAAY;IAQZ,OAAO;IAMP,IAAI,WAAW,YAA6B;CAC/C"}

package/dist/protocol/socket-connector.js

@@ -29,8 +29,6 @@ export class SocketConnector {
         });
     }
     write(writer) {
-        if (this._isDestroyed)
-            throw new Error("SocketConnector is destroyed");
         this._socket.write(writer.asBuffer());
     }
     unwrapSocket() {

package/dist/query.d.ts

@@ -1,19 +1,10 @@
 import { Future } from "fluent-future";
-import { QueryMeta, QueryText, StatementName } from "./connection";
-import { ColumnDescription, ValueOF } from "./types";
+import { ColumnDescription, QueryMeta, QueryText, 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;
     protected _timer?: NodeJS.Timeout;
-    constructor(statement: StatementName);
-    startTimeout(timeout: number): void;
+    constructor(statement: StatementName, timeout: number);
     abstract reject(cause: PostgresError): void;
     abstract resolve(...args: any[]): void;
 }
@@ -25,7 +16,7 @@ export declare class SimpleQuery<T> extends Query {
     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[], timeout: number);
     push(value: T): void;
     reject(cause: PostgresError): void;
     resolve(): void;
@@ -35,7 +26,7 @@ export declare class ParseQuery extends Query {
     future: Future<QueryMeta, PostgresError>;
     private _resolve;
     private _reject;
-    constructor(statement: StatementName, text: QueryText);
+    constructor(statement: StatementName, text: QueryText, timeout: number);
     reject(cause: PostgresError): void;
     resolve(meta: QueryMeta): void;
 }
@@ -44,7 +35,7 @@ export declare class StreamQuery<T> extends Query {
     args: (string | null)[];
     controller: ReadableStreamDefaultController<T>;
     columns: ColumnDescription[];
-    constructor(statement: StatementName, text: QueryText, args: (string | null)[], controller: ReadableStreamDefaultController<T>, columns: ColumnDescription[]);
+    constructor(statement: StatementName, text: QueryText, args: (string | null)[], controller: ReadableStreamDefaultController<T>, columns: ColumnDescription[], timeout: number);
     push(value: T): void;
     reject(cause: PostgresError): void;
     resolve(): void;

package/dist/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,EAAmB,aAAa,EAAE,MAAM,SAAS,CAAC;AAGzD,eAAO,MAAM,UAAU;;;;;CAKb,CAAA;AAGV,MAAM,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9C,8BAAsB,KAAK;IAIZ,SAAS,EAAE,aAAa;IAHnC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,CAAA;gBAGtB,SAAS,EAAE,aAAa;IAGnC,YAAY,CAAC,OAAO,EAAE,MAAM;IAM5B,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAE3C,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CACzC;AAGD,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,KAAK;IAQ1B,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IACvB,OAAO,EAAE,iBAAiB,EAAE;IAThC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC,CAAA;IACzC,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,KAAK,CAAU;gBAGnB,SAAS,EAAE,aAAa,EACjB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EACvB,OAAO,EAAE,iBAAiB,EAAE;IAWvC,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,MAAM,CAAC,KAAK,EAAE,aAAa;IAM3B,OAAO;CAIV;AAGD,qBAAa,UAAW,SAAQ,KAAK;IAOtB,IAAI,EAAE,SAAS;IANnB,MAAM,EAAE,MAAM,CAAC,SAAS,EAAG,aAAa,CAAC,CAAA;IAChD,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,OAAO,CAAiC;gBAG5C,SAAS,EAAE,aAAa,EACjB,IAAI,EAAE,SAAS;IAW1B,MAAM,CAAC,KAAK,EAAE,aAAa;IAM3B,OAAO,CAAC,IAAI,EAAE,SAAS;CAI1B;AAGD,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,KAAK;IAG1B,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IACvB,UAAU,EAAE,+BAA+B,CAAC,CAAC,CAAC;IAC9C,OAAO,EAAE,iBAAiB,EAAE;gBAJnC,SAAS,EAAE,aAAa,EACjB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EACvB,UAAU,EAAE,+BAA+B,CAAC,CAAC,CAAC,EAC9C,OAAO,EAAE,iBAAiB,EAAE;IAMvC,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,MAAM,CAAC,KAAK,EAAE,aAAa;IAM3B,OAAO;CAIV;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAA"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACjF,OAAO,EAAmB,aAAa,EAAE,MAAM,SAAS,CAAC;AAGzD,8BAAsB,KAAK;IAIZ,SAAS,EAAE,aAAa;IAHnC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,CAAA;gBAGtB,SAAS,EAAE,aAAa,EAC/B,OAAO,EAAE,MAAM;IAQnB,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAE3C,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CACzC;AAGD,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,KAAK;IAQ1B,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IACvB,OAAO,EAAE,iBAAiB,EAAE;IAThC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC,CAAA;IACzC,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,KAAK,CAAU;gBAGnB,SAAS,EAAE,aAAa,EACjB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EACvB,OAAO,EAAE,iBAAiB,EAAE,EACnC,OAAO,EAAE,MAAM;IAWnB,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,MAAM,CAAC,KAAK,EAAE,aAAa;IAM3B,OAAO;CAIV;AAGD,qBAAa,UAAW,SAAQ,KAAK;IAOtB,IAAI,EAAE,SAAS;IANnB,MAAM,EAAE,MAAM,CAAC,SAAS,EAAG,aAAa,CAAC,CAAA;IAChD,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,OAAO,CAAiC;gBAG5C,SAAS,EAAE,aAAa,EACjB,IAAI,EAAE,SAAS,EACtB,OAAO,EAAE,MAAM;IAWnB,MAAM,CAAC,KAAK,EAAE,aAAa;IAM3B,OAAO,CAAC,IAAI,EAAE,SAAS;CAI1B;AAGD,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,KAAK;IAG1B,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IACvB,UAAU,EAAE,+BAA+B,CAAC,CAAC,CAAC;IAC9C,OAAO,EAAE,iBAAiB,EAAE;gBAJnC,SAAS,EAAE,aAAa,EACjB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,EACvB,UAAU,EAAE,+BAA+B,CAAC,CAAC,CAAC,EAC9C,OAAO,EAAE,iBAAiB,EAAE,EACnC,OAAO,EAAE,MAAM;IAMnB,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,MAAM,CAAC,KAAK,EAAE,aAAa;IAM3B,OAAO;CAIV;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAA"}

package/dist/query.js

@@ -1,24 +1,16 @@
 import { Future } from "fluent-future";
 import { ErrQueryTimeout } from "./error";
-export const QueryState = {
-    Parsing: 0,
-    Executing: 1,
-    Completed: 2,
-    Failed: 3
-};
 export class Query {
-    constructor(statement) {
+    constructor(statement, timeout) {
         this.statement = statement;
-    }
-    startTimeout(timeout) {
         this._timer = setTimeout(() => {
             this.reject(ErrQueryTimeout);
         }, timeout);
     }
 }
 export class SimpleQuery extends Query {
-    constructor(statement, text, args, columns) {
-        super(statement);
+    constructor(statement, text, args, columns, timeout) {
+        super(statement, timeout);
         this.text = text;
         this.args = args;
         this.columns = columns;
@@ -41,8 +33,8 @@ export class SimpleQuery extends Query {
     }
 }
 export class ParseQuery extends Query {
-    constructor(statement, text) {
-        super(statement);
+    constructor(statement, text, timeout) {
+        super(statement, timeout);
         this.text = text;
         const { future, reject, resolve } = Future.withResolvers();
         this.future = future;
@@ -59,8 +51,8 @@ export class ParseQuery extends Query {
     }
 }
 export class StreamQuery extends Query {
-    constructor(statement, text, args, controller, columns) {
-        super(statement);
+    constructor(statement, text, args, controller, columns, timeout) {
+        super(statement, timeout);
         this.text = text;
         this.args = args;
         this.controller = controller;

package/dist/transaction.d.ts

@@ -13,15 +13,14 @@ export declare class Transaction {
      * Returns true if the transaction is still open (not committed or rolled back).
      */
     get isActive(): boolean;
-    private checkActive;
     /**
      * Commits the current transaction.
      */
-    commit(): Future<Record<string, any>[], PostgresError>;
+    commit(): Future<void, PostgresError>;
     /**
      * Rolls back the current transaction.
      */
-    rollback(): Future<Record<string, any>[], PostgresError>;
+    rollback(): Future<void, PostgresError>;
     /**
      * Executes a query within the current transaction.
      */

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,eAAe,CAAA;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC;;;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;IACI,MAAM;IAOb;;OAEG;IACI,QAAQ;IAOf;;OAEG;IACI,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAK3F;;;;;;;;;OASG;IACI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;CAW9E"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,eAAe,CAAA;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAwB,aAAa,EAAE,MAAM,SAAS,CAAA;AAE7D;;;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;;OAEG;IACI,MAAM;IAQb;;OAEG;IACI,QAAQ;IAQf;;OAEG;IACI,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAM3F;;;;;;;;;OASG;IACI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;CAW9E"}

package/dist/transaction.js

@@ -1,5 +1,6 @@
 import { Begin, Future } from "fluent-future";
 import { IdentifierClause } from "./clauses";
+import { ErrTransactionClosed } from "./error";
 /**
  * Represents an active SQL transaction.
  * All queries are executed on a single dedicated connection.
@@ -15,32 +16,32 @@ export class Transaction {
     get isActive() {
         return !this.isFinished;
     }
-    checkActive() {
-        if (this.isFinished) {
-            throw new Error("Transaction is finished");
-        }
-    }
     /**
      * Commits the current transaction.
      */
     commit() {
-        this.checkActive();
+        if (this.isFinished)
+            return Future.reject(ErrTransactionClosed);
         return this.conn.query `COMMIT`
-            .tap(() => this.isFinished = true);
+            .tap(() => this.isFinished = true)
+            .map(() => { });
     }
     /**
      * Rolls back the current transaction.
      */
     rollback() {
-        this.checkActive();
+        if (this.isFinished)
+            return Future.reject(ErrTransactionClosed);
         return this.conn.query `ROLLBACK`
-            .tap(() => this.isFinished = true);
+            .tap(() => this.isFinished = true)
+            .map(() => { });
     }
     /**
      * Executes a query within the current transaction.
      */
     query(strings, ...values) {
-        this.checkActive();
+        if (this.isFinished)
+            return Future.reject(ErrTransactionClosed);
         return this.conn.query(strings, ...values);
     }
     /**
@@ -54,7 +55,8 @@ export class Transaction {
      * });
      */
     savepoint(name, callback) {
-        this.checkActive();
+        if (this.isFinished)
+            return Future.reject(ErrTransactionClosed);
         return Begin()
             .andThen(() => this.conn.query `SAVEPOINT ${IdentifierClause.create(name)}`)
             .andThen(() => Future.of(callback(this))

package/dist/types.d.ts

@@ -1,9 +1,10 @@
+import { Connection } from "./connection";
+import { PostgresError } from "./error";
 import { DataTypeOid } from "./protocol/constants";
-export type PreparedStatement<TResult extends any, Tparams extends any[]> = {
-    text: string;
-    name: string;
-    execute: (...args: Tparams) => Promise<TResult[]>;
+export type Branded<T, Brand> = T & {
+    __brand: Brand;
 };
+export type ValueOF<T extends Record<string, unknown>> = T[keyof T];
 export type CompiledSqlQuery = {
     text: string;
     args: (string | null)[];
@@ -12,16 +13,56 @@ export type ClauseStrategyParams = {
     text: string;
     args: any[];
 };
-export type CompileSQLParams = {
-    templates: TemplateStringsArray;
-    args: any[];
-};
 export type ColumnDescription = {
     name: string;
     typeOID: DataTypeOid;
 };
-export type Branded<T, Brand> = T & {
-    __brand: Brand;
+export type AuthorizationParams = {
+    host: string;
+    port: number;
+    user: string;
+    database: string;
+    password?: string;
 };
-export type ValueOF<T extends Record<string, unknown>> = T[keyof T];
+type LogLevel = "none" | "error" | "notice" | "query";
+export type ConnectionPartialConfig = {
+    user: string;
+    password?: string;
+    host: string;
+    port: number;
+    database: string;
+    logLevel?: LogLevel;
+    int8toBigint?: boolean;
+    queryTimeout?: number;
+    syncShedule?: "Tick" | "Immediate";
+};
+export type ConnectionConfig = {
+    user: string;
+    password?: string;
+    host: string;
+    port: number;
+    database: string;
+    logLevel: LogLevel;
+    int8toBigint: boolean;
+    queryTimeout: number;
+    syncShedule: "Tick" | "Immediate";
+};
+export type StatementName = Branded<string, 'StatementName'>;
+export type QueryText = Branded<string, 'QueryText'>;
+export type ChannelName = Branded<string, "ChannelName">;
+export type QueryMeta = {
+    statement: StatementName;
+    columns: ColumnDescription[];
+};
+export type PoolPartialConfig = ConnectionPartialConfig & {
+    max?: number;
+};
+export type PoolConfig = ConnectionPartialConfig & {
+    max: number;
+};
+export type Waiter = {
+    resolve: (conn: Connection) => void;
+    reject: (err: PostgresError) => void;
+};
+export {};
 //# 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,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAElD,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,CAAC;IACb,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,WAAW,CAAA;CACvB,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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m2k-5f/pgtx",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "type": "module",
   "description": "Blazing-fast PostgreSQL driver with pipeline support.",
   "files": [