@m2k-5f/pgtx 2.5.4 → 2.6.1

package/dist/connection.js

@@ -1,19 +1,16 @@
-import { nextTick } from "process";
 import { ConnectionRequestWriter } from "./protocol/connection-request-writer";
 import { createAuthorizedSocket } from "./protocol/socket-authorization";
 import { ResponseTypes } from "./protocol/constants";
 import { compileSqlTemplate } from "./utils/template-compiler";
 import { Transaction } from "./transaction";
 import { SocketConnector } from "./protocol/socket-connector";
-import { Queue, RingQueue } from "./queue";
-import { Query, QueryState, StreamQuery } from "./query";
+import { Queue } from "./queue";
+import { ParseQuery, SimpleQuery, StreamQuery } from "./query";
 import { sql } from ".";
 import { Begin, Future, Ok } from 'fluent-future';
-import { PostgresError } from "./error";
-const ErrBatchOverflowed = new PostgresError(`BatchOverflowError: Connection queue capacity exceeded.
-    Please increase the batch capacity parameter in your connection config.`);
-const ErrConnectionClosed = new PostgresError("Connection is closed", 'connection_closed', "", "ERROR");
-const ErrConnectionReconnecring = new PostgresError("Connection are reconnecting", "connection_reconnecting", "", "ERROR");
+import { ErrConnectionClosed, ErrConnectionReconnecting } from "./error";
+import { Batch } from "./batch";
+import { nextTick } from "process";
 /**
  * Represents a single dedicated connection to the PostgreSQL database.
  *
@@ -48,28 +45,18 @@ export class Connection {
     _nextStatement() {
         return `s-${this._stmtCounter++}`;
     }
-    _checkOpened() {
-        if (!this.isOpened)
-            throw ErrConnectionClosed;
-    }
-    constructor(socket, writer, logLevel, params) {
-        this._isFlushing = false;
+    constructor(config, socket) {
+        this._activeBatch = null;
         this._isOpened = true;
         this._isReconnecting = false;
+        this._cachedBuffer = ConnectionRequestWriter.new();
         this._batchQueue = new Queue();
-        this._described = new Map();
-        this._describingPending = new Set();
         this._parsed = new Map();
-        this._parsingPending = new Map();
+        this._parsing = new Map();
         this._listeningCallbacks = new Map();
         this._stmtCounter = 0;
-        this.params = params;
-        this._logLevel = logLevel;
-        this._socket = new SocketConnector(socket, (type, _, reader) => this._handlePacket(type, reader), (err) => {
-            // console.log(err)
-            this._registerReconnect();
-        });
-        this._writer = writer;
+        this.config = config;
+        this._socket = new SocketConnector(socket, (type, _, reader) => this._handlePacket(type, reader), () => this._registerReconnect());
     }
     /**
      * Creates a new database connection.
@@ -89,10 +76,49 @@ 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, writer, 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;
+            (this.config.syncShedule === 'Immediate' ? setImmediate : nextTick)(() => {
+                this._sync(batch);
+            });
+            return batch;
+        }
+        return this._activeBatch;
+    }
+    _sync(batch) {
+        if (!this._isOpened) {
+            batch.reject(ErrConnectionClosed);
+            return;
+        }
+        if (this._isReconnecting) {
+            this._reconnect()
+                .then(() => {
+                this._activeBatch = null;
+                void this._restoreSubscriptions();
+                this._socket.write(this._registerBatch().end());
+                this._batchQueue.push(this._registerBatch());
+            })
+                .then(() => {
+                this._isReconnecting = false;
+            });
+        }
+        this._socket.write(batch.end());
+        this._activeBatch = null;
+        this._batchQueue.push(batch);
     }
     /**
      * Executes a query using tagged template literals.
@@ -119,16 +145,31 @@ export class Connection {
      * ```
      */
     query(templates, ...params) {
-        this._checkOpened();
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        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 query = this._createQuery(text, args);
-        if (this._writeQuery(query))
-            return Future.reject(ErrBatchOverflowed);
-        query.startTimeout(this.params.queryTimeout || 30000);
-        return query.future;
+        if (this._parsed.has(text)) {
+            const meta = this._parsed.get(text);
+            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, this.config.queryTimeout);
+            this._parsing.set(text, parseQuery.future);
+            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.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
+            return query.future;
+        });
     }
     /**
      * Starts a managed transaction on this connection.
@@ -152,7 +193,10 @@ export class Connection {
      * ```
      */
     begin(txCallback) {
-        this._checkOpened();
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        if (this._isReconnecting)
+            return Future.reject(ErrConnectionReconnecting);
         const tx = new Transaction(this);
         return Begin()
             .andThen(() => tx.query `BEGIN`)
@@ -178,8 +222,11 @@ export class Connection {
      * ```
      */
     notify(channelName, payload = "") {
-        this._checkOpened();
-        return this.query `select pg_notify(${channelName}, ${payload})`;
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        if (this._isReconnecting)
+            return Future.reject(ErrConnectionReconnecting);
+        return this.query `select pg_notify(${channelName}, ${payload})`.map(() => { });
     }
     /**
      * Subscribes a callback to a channel. Sends `LISTEN` on the first subscription.
@@ -193,7 +240,10 @@ export class Connection {
      * ```
      */
     listen(channelName, callback) {
-        this._checkOpened();
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        if (this._isReconnecting)
+            return Future.reject(ErrConnectionReconnecting);
         if (!this._listeningCallbacks.has(channelName)) {
             this._listeningCallbacks.set(channelName, new Set());
         }
@@ -213,7 +263,10 @@ export class Connection {
      * ```
      */
     unlisten(channelName, callback) {
-        this._checkOpened();
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        if (this._isReconnecting)
+            return Future.reject(ErrConnectionReconnecting);
         if (!this._listeningCallbacks.has(channelName)) {
             return Ok();
         }
@@ -251,9 +304,12 @@ export class Connection {
      * }
      */
     stream(templates, ...params) {
-        this._checkOpened();
+        if (!this._isOpened)
+            throw ErrConnectionClosed;
+        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;
@@ -262,150 +318,69 @@ export class Connection {
                 controller = c;
             }
         });
-        const query = this._createStream(text, args, controller);
-        if (this._writeQuery(query))
-            throw ErrBatchOverflowed;
-        query.startTimeout(this.params.queryTimeout || 30000);
+        if (this._parsed.has(text)) {
+            const meta = this._parsed.get(text);
+            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, this.config.queryTimeout);
+            this._parsing.set(text, parseQuery.future);
+            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.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
+        })
+            .catch(err => controller.error(err));
         return stream;
     }
     _streamWithController(templates, params, controller) {
-        this._checkOpened();
+        if (!this._isOpened)
+            throw ErrConnectionClosed;
+        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 query = this._createStream(text, args, controller);
-        if (this._writeQuery(query))
-            throw ErrBatchOverflowed;
-        query.startTimeout(this.params.queryTimeout || 30000);
-        return query;
-    }
-    _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(text, args, QueryState.Executing, statementName, columns);
-            }
-            else {
-                if (this._describingPending.has(statementName)) {
-                    return new Query(text, args, QueryState.Executing, statementName);
-                }
-                else {
-                    this._describingPending.add(statementName);
-                    return new Query(text, args, QueryState.Describing, statementName);
-                }
-            }
+            const meta = this._parsed.get(text);
+            const query = new StreamQuery(meta.statement, text, args, controller, meta.columns, this.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
         }
-        else {
-            if (this._parsingPending.has(text)) {
-                const statementName = this._parsingPending.get(text);
-                return new Query(text, args, QueryState.Describing, statementName);
-            }
-            else {
-                const statementName = this._nextStatement();
-                this._parsingPending.set(text, statementName);
-                return new Query(text, args, QueryState.Parsing, statementName);
-            }
-        }
-    }
-    _createStream(text, args, controller) {
-        if (this._parsed.has(text)) {
-            const statementName = this._parsed.get(text);
-            if (this._described.has(statementName)) {
-                const columns = this._described.get(statementName);
-                return new StreamQuery(text, args, QueryState.Executing, statementName, controller, columns);
-            }
-            else {
-                if (this._describingPending.has(statementName)) {
-                    return new StreamQuery(text, args, QueryState.Executing, statementName, controller);
-                }
-                else {
-                    this._describingPending.add(statementName);
-                    return new StreamQuery(text, args, QueryState.Describing, statementName, controller);
-                }
-            }
-        }
-        else {
-            if (this._parsingPending.has(text)) {
-                const statementName = this._parsingPending.get(text);
-                return new StreamQuery(text, args, QueryState.Describing, statementName, controller);
-            }
-            else {
-                const statementName = this._nextStatement();
-                this._parsingPending.set(text, statementName);
-                return new StreamQuery(text, args, QueryState.Parsing, statementName, controller);
-            }
-        }
-    }
-    _writeQuery(query) {
-        const batch = this._registerFlush();
-        if (batch.isFull)
-            return true;
-        batch.push(query);
-        if (query.state === QueryState.Parsing) {
-            this._writer
-                .writeParse(query.statementName, query.text)
-                .writeDescribe(query.statementName);
-        }
-        if (query.state === QueryState.Describing) {
-            this._writer
-                .writeDescribe(query.statementName);
-        }
-        this._writer
-            .writeBind("", query.statementName, query.args)
-            .writeExecute("");
-    }
-    _registerFlush() {
-        if (!this._isFlushing) {
-            this._isFlushing = true;
-            const batch = new RingQueue(this.params.batchCapacity);
-            this._batchQueue.push(batch);
-            this.params.flushShedule === 'nextTick'
-                ? nextTick(() => this._flush())
-                : setImmediate(() => this._flush());
-            return batch;
-        }
-        return this._batchQueue.last;
-    }
-    _flush() {
-        if (!this._isOpened) {
-            this._rejectPipeline(ErrConnectionClosed);
-            return;
-        }
-        if (this._isReconnecting) {
-            this._reconnect().then(() => {
-                this._socket.write(this._writer.writeSync());
-                this._writer.clear();
-                this._isFlushing = false;
-            });
-        }
-        else {
-            this._socket.write(this._writer.writeSync());
-            this._writer.clear();
-            this._isFlushing = false;
+        if (!this._parsing.has(text)) {
+            const parseQuery = new ParseQuery(this._nextStatement(), text, this.config.queryTimeout);
+            this._parsing.set(text, parseQuery.future);
+            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.config.queryTimeout);
+            this._registerBatch().registerQuery(query);
+        })
+            .catch(err => controller.error(err));
     }
     _registerReconnect() {
+        if (this._isReconnecting)
+            return;
         this._isReconnecting = true;
-        this._rejectPipeline(ErrConnectionReconnecring);
     }
     _resetConnectionState(cause) {
         this._parsed.clear();
-        this._described.clear();
-        this._describingPending.clear();
-        this._parsingPending.clear();
-        this._writer.clear();
-        this._rejectPipeline(cause);
+        this._parsing.clear();
+        this._activeBatch = null;
+        this._rejectAllBatches(cause);
     }
     async _reconnect() {
-        console.log('reconnecting');
-        this._resetConnectionState(ErrConnectionReconnecring);
-        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;
-        void this._restoreSubscriptions();
-        this._isReconnecting = false;
+        this._resetConnectionState(ErrConnectionReconnecting);
     }
     _restoreSubscriptions() {
         if (this._listeningCallbacks.size === 0)
@@ -418,12 +393,9 @@ export class Connection {
     _getCurrentQuery() {
         return this._batchQueue.current.current;
     }
-    _rejectPipeline(error) {
-        if (this._batchQueue.isFree)
-            return;
-        const queue = this._batchQueue.current;
-        while (queue.hasMore) {
-            queue.shift.reject(error);
+    _rejectAllBatches(cause) {
+        while (this._batchQueue.hasMore) {
+            this._batchQueue.shift.reject(cause);
         }
     }
     _handlePacket(type, reader) {
@@ -431,10 +403,6 @@ export class Connection {
             case ResponseTypes.ParseComplete:
                 {
                     reader.readParseComplete();
-                    const query = this._getCurrentQuery();
-                    this._parsingPending.delete(query.text);
-                    this._parsed.set(query.text, query.statementName);
-                    query.state = QueryState.Describing;
                 }
                 break;
             case ResponseTypes.BindComplete:
@@ -456,65 +424,47 @@ export class Connection {
                 {
                     reader.readNoData();
                     const query = this._getCurrentQuery();
-                    this._describingPending.delete(query.statementName);
-                    this._described.set(query.statementName, []);
-                    query.state = QueryState.Executing;
-                    query.columns = [];
+                    const meta = { statement: query.statement, columns: [] };
+                    this._parsing.delete(query.text);
+                    query.resolve(meta);
+                    this._parsed.set(query.text, meta);
+                    this._batchQueue.current.next();
                 }
                 break;
             case ResponseTypes.RowDescription:
                 {
                     const columns = reader.readRowDescription();
                     const query = this._getCurrentQuery();
-                    this._describingPending.delete(query.statementName);
-                    this._described.set(query.statementName, columns);
-                    query.state = QueryState.Executing;
-                    query.columns = columns;
+                    const meta = { statement: query.statement, columns };
+                    this._parsing.delete(query.text);
+                    query.resolve(meta);
+                    this._parsed.set(query.text, meta);
+                    this._batchQueue.current.next();
                 }
                 break;
             case ResponseTypes.DataRow:
                 {
                     let query = this._getCurrentQuery();
-                    if (!query.columns) {
-                        query.columns = this._described.get(query.statementName);
-                    }
-                    query.push(reader.readDataRow(query.columns, this.params.int8toBigint));
+                    query.push(reader.readDataRow(query.columns, this.config.int8toBigint));
                 }
                 break;
             case ResponseTypes.ComandComplete:
                 {
                     reader.readCommandComplete();
-                    if (this._batchQueue.isFree) {
-                        this.close();
-                        break;
-                    }
                     const query = this._getCurrentQuery();
-                    if (!query) {
-                        this.close();
-                        break;
-                    }
-                    query.state = QueryState.Completed;
-                    this._batchQueue.current.next();
                     query.resolve();
+                    this._batchQueue.current.next();
                 }
                 break;
             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();
-                    switch (query.state) {
-                        case QueryState.Parsing:
-                            this._parsingPending.delete(query.text);
-                            break;
-                        case QueryState.Describing:
-                            this._describingPending.delete(query.statementName);
-                            break;
-                    }
-                    query.state = QueryState.Failed;
-                    this._rejectPipeline(error);
+                    this._parsing.delete(query.text);
+                    this._batchQueue.current.reject(error);
                 }
                 break;
             case ResponseTypes.ReadyForQuery:
@@ -526,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`);
                     }
                 }
@@ -540,7 +490,7 @@ export class Connection {
                     callbackSet.forEach(cb => cb(payload));
                 }
                 break;
-            default: console.warn('Undeclared response type: ', type);
+            default: console.log('Undeclared response type: ', type);
         }
     }
     /**
@@ -563,9 +513,6 @@ export class Connection {
     close() {
         this._isOpened = false;
         this._socket.destroy();
-        while (this._batchQueue.hasMore) {
-            this._rejectPipeline(ErrConnectionClosed);
-            this._batchQueue.next();
-        }
+        this._rejectAllBatches(ErrConnectionClosed);
     }
 }

package/dist/error.d.ts

@@ -15,4 +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"}
+{"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,3 +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,CAA0B;IAC5C,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAQ;IAEzB,OAAO,CAAC,YAAY;gBAIR,MAAM,EAAE,UAAU;IAM9B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO;IA2BP;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAiBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAY7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IAIhG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAWR"}
+{"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"}