@m2k-5f/pgtx 2.5.2 → 2.6.0

package/dist/connection.js

@@ -5,12 +5,11 @@ import { compileSqlTemplate } from "./utils/template-compiler";
 import { Transaction } from "./transaction";
 import { SocketConnector } from "./protocol/socket-connector";
 import { Queue } from "./queue";
-import { Query, QueryState, StreamQuery } from "./query";
+import { ParseQuery, SimpleQuery, StreamQuery } from "./query";
 import { sql } from ".";
 import { Begin, Future, Ok } from 'fluent-future';
-import { PostgresError } from "./error";
-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";
 /**
  * Represents a single dedicated connection to the PostgreSQL database.
  *
@@ -45,28 +44,19 @@ export class Connection {
     _nextStatement() {
         return `s-${this._stmtCounter++}`;
     }
-    _checkOpened() {
-        if (!this.isOpened)
-            throw ErrConnectionClosed;
-    }
-    constructor(socket, writer, logLevel, params) {
-        this._isFlushing = false;
+    constructor(socket, logLevel, params) {
+        this._activeBatch = null;
         this._isOpened = true;
         this._isReconnecting = false;
-        this._pipelinesQueue = new Queue();
-        this._described = new Map();
-        this._describingPending = new Set();
+        this._cachedBuffer = ConnectionRequestWriter.new();
+        this._batchQueue = new Queue();
         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._socket = new SocketConnector(socket, (type, _, reader) => this._handlePacket(type, reader), () => this._registerReconnect());
     }
     /**
      * Creates a new database connection.
@@ -89,7 +79,39 @@ export class Connection {
     static new(params) {
         const writer = ConnectionRequestWriter.new();
         return createAuthorizedSocket(writer, params)
-            .andThen(socket => Ok(new Connection(socket, writer, params.logLevel || 'error', params)));
+            .andThen(socket => Ok(new Connection(socket, params.logLevel || 'error', params)));
+    }
+    _registerBatch() {
+        if (!this._activeBatch) {
+            const batch = new Batch(this._cachedBuffer.clear());
+            this._activeBatch = batch;
+            setImmediate(() => {
+                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.
@@ -116,16 +138,32 @@ export class Connection {
      * ```
      */
     query(templates, ...params) {
-        this._checkOpened();
-        this._registerFlush();
-        const { text, args } = compileSqlTemplate({ templates, args: params });
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        if (this._isReconnecting)
+            return Future.reject(ErrConnectionReconnecting);
+        const { text, args } = compileSqlTemplate(templates, params);
         if (this._logLevel === 'query') {
             console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
-        const query = this._createQuery(text, args);
-        this._writeQuery(query);
-        query.startTimeout(this.params.queryTimeout || 30000);
-        return query.future;
+        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);
+            return query.future;
+        }
+        if (!this._parsing.has(text)) {
+            const parseQuery = new ParseQuery(this._nextStatement(), text);
+            this._parsing.set(text, parseQuery.future);
+            batch.registerQuery(parseQuery, this.params.queryTimeout || 30000);
+        }
+        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);
+            return query.future;
+        });
     }
     /**
      * Starts a managed transaction on this connection.
@@ -149,7 +187,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`)
@@ -175,7 +216,10 @@ export class Connection {
      * ```
      */
     notify(channelName, payload = "") {
-        this._checkOpened();
+        if (!this._isOpened)
+            return Future.reject(ErrConnectionClosed);
+        if (this._isReconnecting)
+            return Future.reject(ErrConnectionReconnecting);
         return this.query `select pg_notify(${channelName}, ${payload})`;
     }
     /**
@@ -190,7 +234,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());
         }
@@ -210,7 +257,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();
         }
@@ -248,9 +298,11 @@ export class Connection {
      * }
      */
     stream(templates, ...params) {
-        this._checkOpened();
-        this._registerFlush();
-        const { text, args } = compileSqlTemplate({ templates, args: params });
+        if (!this._isOpened)
+            throw ErrConnectionClosed;
+        if (this._isReconnecting)
+            throw ErrConnectionReconnecting;
+        const { text, args } = compileSqlTemplate(templates, params);
         if (this._logLevel === 'query') {
             console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
@@ -260,148 +312,71 @@ export class Connection {
                 controller = c;
             }
         });
-        const query = this._createStream(text, args, controller);
-        this._writeQuery(query);
-        query.startTimeout(this.params.queryTimeout || 30000);
+        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);
+            return stream;
+        }
+        if (!this._parsing.has(text)) {
+            const parseQuery = new ParseQuery(this._nextStatement(), text);
+            this._parsing.set(text, parseQuery.future);
+            batch.registerQuery(parseQuery, this.params.queryTimeout || 30000);
+        }
+        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);
+        })
+            .catch(err => controller.error(err));
         return stream;
     }
     _streamWithController(templates, params, controller) {
-        this._checkOpened();
-        this._registerFlush();
-        const { text, args } = compileSqlTemplate({ templates, args: params });
+        if (!this._isOpened)
+            throw ErrConnectionClosed;
+        if (this._isReconnecting)
+            throw ErrConnectionReconnecting;
+        const { text, args } = compileSqlTemplate(templates, params);
         if (this._logLevel === 'query') {
             console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
         }
-        const query = this._createStream(text, args, controller);
-        this._writeQuery(query);
-        query.startTimeout(this.params.queryTimeout || 30000);
-        return query;
-    }
-    _createQuery(text, args) {
+        const batch = this._registerBatch();
         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);
+            batch.registerQuery(query, this.params.queryTimeout || 30000);
         }
-        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) {
-        if (query.state === QueryState.Parsing) {
-            this._writer
-                .writeParse(query.statementName, query.text)
-                .writeDescribe(query.statementName)
-                .writeBind("", query.statementName, query.args)
-                .writeExecute("");
-        }
-        if (query.state === QueryState.Describing) {
-            this._writer
-                .writeDescribe(query.statementName)
-                .writeBind("", query.statementName, query.args)
-                .writeExecute("");
-        }
-        if (query.state === QueryState.Executing) {
-            this._writer
-                .writeBind("", query.statementName, query.args)
-                .writeExecute("");
-        }
-        this._pipelinesQueue.last.push(query);
-    }
-    _registerFlush() {
-        if (!this._isFlushing) {
-            this._isFlushing = true;
-            this._pipelinesQueue.push(new Queue());
-            setImmediate(() => {
-                this._flush();
-            });
-        }
-    }
-    _flush() {
-        if (!this._isOpened) {
-            this._rejectPipeline(ErrConnectionClosed);
-            return;
-        }
-        if (this._isReconnecting) {
-            this._reconnect().then(() => {
-                this._isFlushing = false;
-                this._socket.write(this._writer.writeSync());
-                this._writer.clear();
-            });
-        }
-        else {
-            this._isFlushing = false;
-            this._socket.write(this._writer.writeSync());
-            this._writer.clear();
+        if (!this._parsing.has(text)) {
+            const parseQuery = new ParseQuery(this._nextStatement(), text);
+            this._parsing.set(text, parseQuery.future);
+            batch.registerQuery(parseQuery, this.params.queryTimeout || 30000);
         }
+        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);
+        })
+            .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() {
-        this._resetConnectionState(ErrConnectionReconnecring);
         const socket = await createAuthorizedSocket(ConnectionRequestWriter.new(), this.params);
         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)
@@ -412,14 +387,11 @@ export class Connection {
         return Promise.all(promises);
     }
     _getCurrentQuery() {
-        return this._pipelinesQueue.current.current;
+        return this._batchQueue.current.current;
     }
-    _rejectPipeline(error) {
-        if (this._pipelinesQueue.isFree)
-            return;
-        const queue = this._pipelinesQueue.current;
-        while (queue.hasMore) {
-            queue.shift.reject(error);
+    _rejectAllBatches(cause) {
+        while (this._batchQueue.hasMore) {
+            this._batchQueue.shift.reject(cause);
         }
     }
     _handlePacket(type, reader) {
@@ -427,10 +399,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:
@@ -452,46 +420,36 @@ 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));
                 }
                 break;
             case ResponseTypes.ComandComplete:
                 {
                     reader.readCommandComplete();
-                    if (this._pipelinesQueue.isFree) {
-                        this.close();
-                        break;
-                    }
                     const query = this._getCurrentQuery();
-                    if (!query) {
-                        this.close();
-                        break;
-                    }
-                    query.state = QueryState.Completed;
-                    this._pipelinesQueue.current.next();
                     query.resolve();
+                    this._batchQueue.current.next();
                 }
                 break;
             case ResponseTypes.ErrorResponse:
@@ -501,22 +459,14 @@ export class Connection {
                         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:
                 {
                     reader.readReadyForQuery();
-                    this._pipelinesQueue.next();
+                    this._batchQueue.next();
                 }
                 break;
             case ResponseTypes.Notice:
@@ -536,7 +486,7 @@ export class Connection {
                     callbackSet.forEach(cb => cb(payload));
                 }
                 break;
-            default: console.warn('Undeclared response type: ', type);
+            default: console.log('Undeclared response type: ', type);
         }
     }
     /**
@@ -559,9 +509,6 @@ export class Connection {
     close() {
         this._isOpened = false;
         this._socket.destroy();
-        while (this._pipelinesQueue.hasMore) {
-            this._rejectPipeline(ErrConnectionClosed);
-            this._pipelinesQueue.next();
-        }
+        this._rejectAllBatches(ErrConnectionClosed);
     }
 }

package/dist/error.d.ts

@@ -15,4 +15,7 @@ export declare class PostgresError extends Error {
     get isTimeout(): boolean;
     get isConnectionFailure(): boolean;
 }
+export declare const ErrQueryTimeout: 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,eAAe,eAA8C,CAAA;AAE1E,eAAO,MAAM,mBAAmB,eAA8E,CAAA;AAC9G,eAAO,MAAM,yBAAyB,eAA2F,CAAA"}

package/dist/error.js

@@ -31,3 +31,6 @@ export class PostgresError extends Error {
         return this.code.startsWith('08') || this.code.startsWith('57') && this.code !== '57014';
     }
 }
+export const ErrQueryTimeout = new PostgresError('Query timeout', '57014');
+export const ErrConnectionClosed = new PostgresError("Connection is closed", 'connection_closed', "", "ERROR");
+export const ErrConnectionReconnecting = new PostgresError("Connection are reconnecting", "connection_reconnecting", "", "ERROR");

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

package/dist/pool.js

@@ -1,5 +1,5 @@
 import { Connection } from "./connection";
-import { Queue } from "./queue";
+import { Queue, RingQueue } from "./queue";
 import { Begin, Future, Ok } from "fluent-future";
 import { PostgresError } from "./error";
 const ErrPoolClosed = new PostgresError('Pool closed');
@@ -44,12 +44,12 @@ export class Pool {
             throw new Error('Pool closed');
     }
     constructor(params) {
-        this._available = new Queue();
         this._total = 0;
         this._waiting = new Queue();
         this._isClosed = false;
         this._config = params;
         this._max = params.max || 20;
+        this._available = new RingQueue(this._max);
     }
     /**
      * Acquires a dedicated connection from the pool.

package/dist/protocol/connection-request-writer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-request-writer.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-request-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAA;AAGvD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,wBAAwB;IAHpC,OAAO;IAOP,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM;IAK3B,OAAO,CAAC,cAAc;IAmBtB,YAAY,CAAC,MAAM,EAAE,MAAM;IAY3B,WAAW,CAAC,MAAM,EAAE,MAAM;IAS1B,UAAU,CAAC,MAAM,EAAE,MAAM;IAUzB,UAAU,CAAC,MAAM,EAAE,MAAM;IAUzB,SAAS,CAAC,IAAI,EAAE,MAAM;IAStB,YAAY,CAAC,WAAW,EAAE,WAAW;IAQrC,YAAY;IAMZ,UAAU;IAUV,QAAQ;IAKR,KAAK;CAIR;AAGD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,MAAM;IADlB,OAAO;IAIP,MAAM,CAAC,GAAG;IAMV,UAAU,CAAC,IAAI,EAAE,MAAM;IASvB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM;IAW1C,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,EAAE;IAUxC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IAmBtF,UAAU,CAAC,IAAI,EAAE,MAAM;IAUvB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAY3C,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE;IAUlC,SAAS;IAOT,aAAa,CAAC,QAAQ,EAAE,MAAM;IAS9B,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM;IAW9D,iBAAiB,CAAC,kBAAkB,EAAE,MAAM;IAS5C,QAAQ;IAKR,KAAK;CAKR"}
+{"version":3,"file":"connection-request-writer.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-request-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAA;AAGvD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,wBAAwB;IAHpC,OAAO;IAOP,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM;IAK3B,OAAO,CAAC,cAAc;IAoBtB,YAAY,CAAC,MAAM,EAAE,MAAM;IAY3B,WAAW,CAAC,MAAM,EAAE,MAAM;IAS1B,UAAU,CAAC,MAAM,EAAE,MAAM;IAUzB,UAAU,CAAC,MAAM,EAAE,MAAM;IAUzB,SAAS,CAAC,IAAI,EAAE,MAAM;IAStB,YAAY,CAAC,WAAW,EAAE,WAAW;IAQrC,YAAY;IAMZ,UAAU;IAYV,QAAQ;IAKR,KAAK;CAIR;AAGD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,MAAM;IADlB,OAAO;IAIP,MAAM,CAAC,GAAG;IAMV,UAAU,CAAC,IAAI,EAAE,MAAM;IASvB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM;IAW1C,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,EAAE;IAUxC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IAmBtF,UAAU,CAAC,IAAI,EAAE,MAAM;IAUvB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAY3C,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE;IAUlC,SAAS;IAOT,aAAa,CAAC,QAAQ,EAAE,MAAM;IAS9B,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM;IAW9D,iBAAiB,CAAC,kBAAkB,EAAE,MAAM;IAS5C,QAAQ;IAKR,KAAK;CAKR"}

package/dist/protocol/connection-request-writer.js

@@ -61,6 +61,7 @@ export class ConnectionRequestBuffer {
         return this.writeInt32(0);
     }
     endRequest() {
+        this.ensureCapacity(4);
         this.buffer.writeInt32BE(this.offset - (this.lastRequestLenByteOffset), this.lastRequestLenByteOffset);
         return this;
     }

package/dist/query.d.ts

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