@m2k-5f/pgtx 2.7.1 → 2.7.3

package/dist/connection.js

@@ -1,6 +1,5 @@
-import { ConnectionRequestWriter } from "./protocol/connection-request-writer";
-import { ResponseTypes } from "./protocol/constants";
-import { compileSqlTemplate } from "./utils/template-compiler";
+import { DescribeType, EMPTY_ARRAY, ResponseTypes } from "./protocol/constants";
+import { compileSqlTemplate } from "./utils";
 import { Transaction } from "./transaction";
 import { SocketConnector } from "./protocol/socket-connector";
 import { Queue } from "./queue";
@@ -8,9 +7,9 @@ import { CollectQuery, StreamQuery, ExecuteQuery } from "./query";
 import { sql } from ".";
 import { Begin, Future, Ok } from 'fluent-future';
 import { ErrConnectionClosed, ErrConnectionReconnecting } from "./error";
-import { Batch } from "./batch";
 import { nextTick } from "process";
 import { authorizeSocket, createSocket, upgradeSocket } from "./protocol/socket-authorization";
+import { ConnectionRequestBuffer } from "./protocol/connection-request-writer";
 const shedule = {
     Immediate: setImmediate,
     afterMicrotask: setTimeout,
@@ -30,15 +29,43 @@ export class Connection {
     _nextStatement() {
         return `s-${this._stmtCounter++}`;
     }
+    _registerShedule() {
+        if (!this._sheduled) {
+            this._sheduled = true;
+            this._writer.clear();
+            shedule[this.config.syncShedule](() => this._shedule());
+        }
+    }
+    _shedule() {
+        if (this._reconnecting)
+            return;
+        this._socket.write(this._writer);
+        this._writer.clear();
+        this._sheduled = false;
+    }
+    _parseQuery(query) {
+        this._registerShedule();
+        this._writer
+            .writeParse(query.statement, query.text)
+            .writeDescribe(DescribeType.Statement, query.statement);
+    }
+    _registerQuery(query) {
+        this._registerShedule();
+        this._queue.push(query);
+        this._writer
+            .writeBind("", query.statement, query.args, this._parsed[query.text]?.parameters)
+            .writeExecute("")
+            .writeSync();
+    }
     constructor(socket, config) {
-        this._activeBatch = null;
+        this._writer = ConnectionRequestBuffer.new(65536);
+        this._sheduled = false;
+        this._queue = new Queue();
         this._closing = null;
         this._closed = false;
         this._reconnecting = null;
-        this._cachedBuffer = ConnectionRequestWriter.new();
-        this._batchQueue = new Queue();
-        this._parsed = new Map();
-        this._parsing = new Map();
+        this._parsed = {};
+        this._parsing = {};
         this._listeningCallbacks = new Map();
         this._stmtCounter = 0;
         this.config = config;
@@ -54,7 +81,7 @@ export class Connection {
             logLevel: config.logLevel || 'error',
             int8toBigint: config.int8toBigint || false,
             queryTimeout: config.queryTimeout || 30000,
-            syncShedule: config.syncShedule || 'afterMicrotask',
+            syncShedule: config.syncShedule || 'Immediate',
             ssl: config.caPath ? 'require' : (config.ssl || 'prefer')
         };
         return createSocket(conf)
@@ -62,22 +89,6 @@ export class Connection {
             .andThen(socket => authorizeSocket(socket, conf))
             .andThen(socket => Ok(new Connection(socket, conf)));
     }
-    _registerBatch() {
-        if (!this._activeBatch) {
-            const batch = new Batch(this._cachedBuffer.clear());
-            this._activeBatch = batch;
-            shedule[this.config.syncShedule](() => this._sync(batch));
-            return batch;
-        }
-        return this._activeBatch;
-    }
-    _sync(batch) {
-        if (this._reconnecting)
-            return;
-        this._socket.write(batch.end());
-        this._activeBatch = null;
-        this._batchQueue.push(batch);
-    }
     /**
      * Runs a query, binding template values as `$1, $2, ...`.
      * Parameterized queries are cached as prepared statements.
@@ -88,32 +99,36 @@ export class Connection {
     query(templates, ...params) {
         if (this.isClosed)
             return Future.reject(ErrConnectionClosed);
+        const { text, args } = compileSqlTemplate(templates, params);
+        const resolvers = Future.withResolvers();
         if (this._reconnecting)
-            return this._reconnecting.andThen(() => this._performQuery(templates, ...params));
-        return this._performQuery(templates, ...params);
+            return this._reconnecting.andThen(() => this._performQuery(text, args, resolvers));
+        return this._performQuery(text, args, resolvers);
     }
-    _performQuery(templates, ...params) {
-        const { text, args } = compileSqlTemplate(templates, params);
+    _performQuery(text, args, resolvers) {
         if (this.config.logLevel === 'query') {
-            console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
+            console.log(`\n\x1b[36m┌─ QUERY ─────────────────────────────────────────\x1b[0m\n`
+                + `\x1b[36m│\x1b[0m ${text}\n`
+                + `${args.length !== 0 ? `\x1b[36m│\x1b[0m \x1b[90mArguments:\x1b[0m [${args}]\n` : ''}`
+                + `\x1b[36m└────────────────────────────────────────────────\x1b[0m`);
         }
-        if (this._parsed.has(text)) {
-            const meta = this._parsed.get(text);
-            const query = new CollectQuery(meta.statement, text, args, meta.columns, this.config.queryTimeout);
-            this._registerBatch().registerQuery(query);
-            return query.future;
+        const parsed = this._parsed[text];
+        if (parsed) {
+            const query = new CollectQuery(parsed.statement, text, args, parsed.columns, this.config.queryTimeout, resolvers);
+            this._registerQuery(query);
+            return query.resolvers.future;
         }
-        if (this._parsing.has(text)) {
-            const statement = this._parsing.get(text);
-            const query = new CollectQuery(statement, text, args, null, this.config.queryTimeout);
-            this._registerBatch().registerQuery(query);
-            return query.future;
+        const parsing = this._parsing[text];
+        if (parsing) {
+            const query = new CollectQuery(parsing, text, args, null, this.config.queryTimeout, resolvers);
+            this._registerQuery(query);
+            return query.resolvers.future;
         }
-        const query = new CollectQuery(this._nextStatement(), text, args, null, this.config.queryTimeout);
-        this._parsing.set(text, query.statement);
-        this._registerBatch().registerParse(query);
-        this._registerBatch().registerQuery(query);
-        return query.future;
+        const query = new CollectQuery(this._nextStatement(), text, args, null, this.config.queryTimeout, resolvers);
+        this._parsing[text] = query.statement;
+        this._parseQuery(query);
+        this._registerQuery(query);
+        return query.resolvers.future;
     }
     /**
      * Like {@link query}, but for statements that don't return rows (INSERT/UPDATE/DDL/etc).
@@ -124,32 +139,86 @@ export class Connection {
     execute(templates, ...params) {
         if (this.isClosed)
             return Future.reject(ErrConnectionClosed);
+        const { text, args } = compileSqlTemplate(templates, params);
+        const resolvers = Future.withResolvers();
         if (this._reconnecting)
-            return this._reconnecting.andThen(() => this._performExecute(templates, ...params));
-        return this._performExecute(templates, ...params);
+            return this._reconnecting.andThen(() => this._performExecute(text, args, resolvers));
+        return this._performExecute(text, args, resolvers);
+    }
+    _performExecute(text, args, resolvers) {
+        if (this.config.logLevel === 'query') {
+            console.log(`\n\x1b[35m┌─ EXECUTE ──────────────────────────────────────\x1b[0m\n`
+                + `\x1b[35m│\x1b[0m ${text}\n`
+                + `${args.length !== 0 ? `\x1b[35m│\x1b[0m \x1b[90mArguments:\x1b[0m [${args}]\n` : ''}`
+                + `\x1b[35m└────────────────────────────────────────────────\x1b[0m`);
+        }
+        const parsed = this._parsed[text];
+        if (parsed) {
+            const query = new ExecuteQuery(parsed.statement, text, args, this.config.queryTimeout, resolvers);
+            this._registerQuery(query);
+            return query.resolvers.future;
+        }
+        const parsing = this._parsing[text];
+        if (parsing) {
+            const query = new ExecuteQuery(parsing, text, args, this.config.queryTimeout, resolvers);
+            this._registerQuery(query);
+            return query.resolvers.future;
+        }
+        const query = new ExecuteQuery(this._nextStatement(), text, args, this.config.queryTimeout, resolvers);
+        this._parsing[text] = query.statement;
+        this._parseQuery(query);
+        this._registerQuery(query);
+        return query.resolvers.future;
     }
-    _performExecute(templates, ...params) {
+    /**
+     * Streams query results as a `ReadableStream`, without buffering rows in memory.
+     * Ideal for large result sets or piping straight into an HTTP response.
+     *
+     * @example
+     * for await (const row of conn.stream<User>`SELECT * FROM orders`) { ... }
+     */
+    stream(templates, ...params) {
+        if (this.isClosed)
+            throw ErrConnectionClosed;
         const { text, args } = compileSqlTemplate(templates, params);
+        let controller;
+        const stream = new ReadableStream({
+            start: c => {
+                controller = c;
+            }
+        });
+        if (this._reconnecting) {
+            this._reconnecting
+                .tap(() => this._performStream(text, args, controller))
+                .tapErr(err => controller.error(err));
+            return stream;
+        }
+        this._performStream(text, args, controller);
+        return stream;
+    }
+    _performStream(text, args, controller) {
         if (this.config.logLevel === 'query') {
-            console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
+            console.log(`\n\x1b[34m┌─ STREAM ───────────────────────────────────────\x1b[0m\n`
+                + `\x1b[34m│\x1b[0m ${text}\n`
+                + `${args.length !== 0 ? `\x1b[34m│\x1b[0m \x1b[90mArguments:\x1b[0m [${args}]\n` : ''}`
+                + `\x1b[34m└────────────────────────────────────────────────\x1b[0m`);
         }
-        if (this._parsed.has(text)) {
-            const meta = this._parsed.get(text);
-            const query = new ExecuteQuery(meta.statement, text, args, this.config.queryTimeout);
-            this._registerBatch().registerQuery(query);
-            return query.future;
+        const parsed = this._parsed[text];
+        if (parsed) {
+            const query = new StreamQuery(parsed.statement, text, args, controller, parsed.columns, this.config.queryTimeout);
+            this._registerQuery(query);
+            return;
         }
-        if (this._parsing.has(text)) {
-            const statement = this._parsing.get(text);
-            const query = new ExecuteQuery(statement, text, args, this.config.queryTimeout);
-            this._registerBatch().registerQuery(query);
-            return query.future;
+        const parsing = this._parsing[text];
+        if (parsing) {
+            const query = new StreamQuery(parsing, text, args, controller, null, this.config.queryTimeout);
+            this._registerQuery(query);
+            return;
         }
-        const query = new ExecuteQuery(this._nextStatement(), text, args, this.config.queryTimeout);
-        this._parsing.set(text, query.statement);
-        this._registerBatch().registerParse(query);
-        this._registerBatch().registerQuery(query);
-        return query.future;
+        const query = new StreamQuery(this._nextStatement(), text, args, controller, null, this.config.queryTimeout);
+        this._parsing[text] = query.statement;
+        this._parseQuery(query);
+        this._registerQuery(query);
     }
     /**
      * Runs `txCallback` inside `BEGIN`/`COMMIT`, rolling back on error.
@@ -209,53 +278,6 @@ export class Connection {
         }
         return Ok();
     }
-    /**
-     * Streams query results as a `ReadableStream`, without buffering rows in memory.
-     * Ideal for large result sets or piping straight into an HTTP response.
-     *
-     * @example
-     * for await (const row of conn.stream<User>`SELECT * FROM orders`) { ... }
-     */
-    stream(templates, ...params) {
-        if (this.isClosed)
-            throw ErrConnectionClosed;
-        let controller;
-        const stream = new ReadableStream({
-            start: c => {
-                controller = c;
-            }
-        });
-        if (this._reconnecting) {
-            this._reconnecting
-                .tap(() => this._performStream(templates, params, controller))
-                .tapErr(err => controller.error(err));
-            return stream;
-        }
-        this._performStream(templates, params, controller);
-        return stream;
-    }
-    _performStream(templates, params, controller) {
-        const { text, args } = compileSqlTemplate(templates, params);
-        if (this.config.logLevel === 'query') {
-            console.log(`\nQUERY:     ${text}\n${args.length !== 0 ? `ARGUMENTS: [${args}]\n` : ""}`);
-        }
-        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;
-        }
-        if (this._parsing.has(text)) {
-            const statement = this._parsing.get(text);
-            const query = new StreamQuery(statement, text, args, controller, null, this.config.queryTimeout);
-            this._registerBatch().registerQuery(query);
-            return;
-        }
-        const query = new StreamQuery(this._nextStatement(), text, args, controller, null, this.config.queryTimeout);
-        this._parsing.set(text, query.statement);
-        this._registerBatch().registerParse(query);
-        this._registerBatch().registerQuery(query);
-    }
     _reconnect() {
         if (this.isClosed)
             return;
@@ -272,13 +294,13 @@ export class Connection {
     }
     _performReconnect() {
         this._socket.destroy();
-        this._parsed.clear();
-        this._parsing.clear();
-        this._activeBatch?.reject(ErrConnectionReconnecting);
-        this._activeBatch = null;
-        while (this._batchQueue.hasMore) {
-            this._batchQueue.shift.reject(ErrConnectionReconnecting);
+        this._parsed = {};
+        this._parsing = {};
+        this._sheduled = false;
+        while (this._queue.hasMore) {
+            this._queue.shift.error(ErrConnectionReconnecting);
         }
+        this._writer.clear();
         return createSocket(this.config)
             .andThen(socket => upgradeSocket(socket, this.config))
             .andThen(socket => authorizeSocket(socket, this.config))
@@ -296,63 +318,50 @@ export class Connection {
         });
         return Future.all(futures).map(() => { });
     }
-    _getCurrentQuery() {
-        return this._batchQueue.current.current;
+    get _currentQuery() {
+        return this._queue.current;
     }
     _handlePacket(type, length, reader) {
         switch (type) {
             case ResponseTypes.ParseComplete:
-                {
-                    reader.readParseComplete();
-                }
-                break;
+            case ResponseTypes.NoData:
+            case ResponseTypes.CloseComplete: break;
             case ResponseTypes.BindComplete:
                 {
-                    reader.readBindComplete();
-                    const query = this._getCurrentQuery();
+                    const query = this._currentQuery;
                     if (query instanceof ExecuteQuery) {
                         break;
                     }
                     if (!query.columns) {
-                        query.columns = this._parsed.get(query.text).columns;
+                        query.columns = this._parsed[query.text].columns;
                     }
                 }
                 break;
-            case ResponseTypes.CloseComplete:
-                {
-                    reader.readBindComplete();
-                }
-                break;
             case ResponseTypes.ParameterDescription:
                 {
-                    reader.readParameterDescription();
-                }
-                break;
-            case ResponseTypes.NoData:
-                {
-                    reader.readNoData();
-                    const query = this._getCurrentQuery();
-                    const meta = { statement: query.statement, columns: [] };
-                    this._parsing.delete(query.text);
-                    this._parsed.set(query.text, meta);
+                    const query = this._currentQuery;
+                    const description = reader.readParameterDescription();
+                    const meta = {
+                        statement: query.statement,
+                        parameters: description,
+                        columns: EMPTY_ARRAY
+                    };
+                    delete this._parsing[query.text];
+                    this._parsed[query.text] = meta;
                 }
                 break;
             case ResponseTypes.RowDescription:
                 {
+                    const query = this._currentQuery;
                     const columns = reader.readRowDescription();
-                    const query = this._getCurrentQuery();
-                    const meta = {
-                        statement: query.statement, columns
-                    };
-                    this._parsing.delete(query.text);
-                    this._parsed.set(query.text, meta);
+                    this._parsed[query.text].columns = columns;
                 }
                 break;
             case ResponseTypes.DataRow:
                 {
-                    let query = this._getCurrentQuery();
+                    let query = this._currentQuery;
                     if (query instanceof ExecuteQuery) {
-                        reader.skip(length - 4);
+                        reader.skipBytes(length);
                         break;
                     }
                     query.push(reader.readDataRow(query.columns, this.config.int8toBigint));
@@ -360,34 +369,40 @@ export class Connection {
                 break;
             case ResponseTypes.ComandComplete:
                 {
-                    reader.readCommandComplete();
-                    const query = this._getCurrentQuery();
-                    query.resolve();
-                    this._batchQueue.current.next();
+                    reader.skipBytes(length);
+                    const query = this._currentQuery;
+                    query.complete();
                 }
                 break;
             case ResponseTypes.ErrorResponse:
                 {
                     const error = reader.readErrorResponse();
                     if (this.config.logLevel === 'error' || this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
-                        console.log(`\nError:    ${error}\n`);
+                        console.log(`\n\x1b[31m┌─ ERROR ────────────────────────────────────────\x1b[0m\n`
+                            + `\x1b[31m│\x1b[0m ${error}\n`
+                            + `\x1b[31m└────────────────────────────────────────────────\x1b[0m\n`);
+                    }
+                    const query = this._currentQuery;
+                    if (error.isParseError) {
+                        delete this._parsing[query.text];
                     }
-                    this._parsing.clear();
-                    this._batchQueue.current.reject(error);
+                    query.error(error);
                 }
                 break;
             case ResponseTypes.ReadyForQuery:
                 {
-                    reader.readReadyForQuery();
-                    this._batchQueue.next();
-                    this._closing && !this._hasQueries && this._closing.resolve();
+                    reader.skipBytes(length);
+                    this._queue.next();
+                    this._closing && this._queue.isFree && this._closing.resolve();
                 }
                 break;
             case ResponseTypes.Notice:
                 {
                     const message = reader.readErrorResponse();
                     if (this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
-                        console.log(`\nError:    ${message}\n`);
+                        console.log(`\n\x1b[33m┌─ NOTICE ───────────────────────────────────────\x1b[0m\n`
+                            + `\x1b[33m│\x1b[0m ${message}\n`
+                            + `\x1b[33m└────────────────────────────────────────────────\x1b[0m\n`);
                     }
                 }
                 break;
@@ -400,12 +415,13 @@ export class Connection {
                     callbackSet.forEach(cb => cb(payload));
                 }
                 break;
-            default: console.log('Undeclared response type: ', type);
+            default:
+                {
+                    reader.skipBytes(length);
+                }
+                break;
         }
     }
-    get _hasQueries() {
-        return this._batchQueue.hasMore || this._activeBatch;
-    }
     /** Whether the connection is alive and usable. */
     get isOpened() {
         return !this._closing && !this._closed;
@@ -423,7 +439,7 @@ export class Connection {
         if (this._closing) {
             return this._closing.future;
         }
-        if (!this._hasQueries) {
+        if (this._queue.isFree) {
             this._closed = true;
             this._socket.destroy();
             return Future.resolve();

package/dist/error.d.ts

@@ -10,8 +10,11 @@ export declare class PostgresError extends Error {
     constraint: string;
     constructor(message: string, code?: string, detail?: string, severity?: string, where?: string, hint?: string, position?: string, dataType?: string, constraint?: string);
     get isParseError(): boolean;
-    get isDeadlock(): boolean;
+    get isBindError(): boolean;
+    get isPlanInvalidationError(): boolean;
+    get shouldInvalidateStatementCache(): boolean;
     get isConstraintViolation(): boolean;
+    get isDeadlock(): boolean;
     get isTimeout(): boolean;
     get isConnectionFailure(): boolean;
 }

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,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;AACjI,eAAO,MAAM,YAAY,eAA4D,CAAA;AACrF,eAAO,MAAM,mBAAmB,eAAwD,CAAA;AACxF,eAAO,MAAM,uBAAuB,eAA4E,CAAA;AAChH,eAAO,MAAM,0BAA0B,eAAkF,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;IAMlC,IAAI,YAAY,IAAI,OAAO,CAK1B;IAED,IAAI,WAAW,IAAI,OAAO,CAKzB;IAED,IAAI,uBAAuB,IAAI,OAAO,CAErC;IAED,IAAI,8BAA8B,IAAI,OAAO,CAE5C;IAED,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,mBAAmB,IAAI,OAAO,CAEjC;CACJ;AAGD,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;AACjI,eAAO,MAAM,YAAY,eAA4D,CAAA;AACrF,eAAO,MAAM,mBAAmB,eAAwD,CAAA;AACxF,eAAO,MAAM,uBAAuB,eAA4E,CAAA;AAChH,eAAO,MAAM,0BAA0B,eAAkF,CAAA"}

package/dist/error.js

@@ -12,23 +12,31 @@ export class PostgresError extends Error {
         this.constraint = constraint;
         this.name = "PostgresError";
     }
-    // Parse error
     get isParseError() {
-        return this.code.startsWith('42');
+        return (this.code.startsWith('42') ||
+            this.code === '26000');
     }
-    // Execute error
-    get isDeadlock() {
-        return this.code === '40P01';
+    get isBindError() {
+        return (this.code.startsWith('22') ||
+            this.code === '0A000');
+    }
+    get isPlanInvalidationError() {
+        return this.code === '0A000' || this.code === '42P05';
+    }
+    get shouldInvalidateStatementCache() {
+        return this.isParseError || this.isBindError || this.isPlanInvalidationError;
     }
-    // Execute error
     get isConstraintViolation() {
         return this.code.startsWith('23');
     }
+    get isDeadlock() {
+        return this.code === '40P01';
+    }
     get isTimeout() {
         return this.code === '57014';
     }
     get isConnectionFailure() {
-        return this.code.startsWith('08') || this.code.startsWith('57') && this.code !== '57014';
+        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");

package/dist/pool.d.ts

@@ -57,7 +57,7 @@ export declare class Pool {
      * @example
      * for await (const row of pool.stream<User>`SELECT * FROM orders`) { ... }
      */
-    stream<T extends Row>(templates: TemplateStringsArray, ...args: any[]): ReadableStream<T>;
+    stream<T extends Row>(templates: TemplateStringsArray, ...params: any[]): ReadableStream<T>;
     /** Sends a `pg_notify` message on `channelName` (payload ≤ 8000 bytes). */
     notify(channelName: string, payload?: string): Future<void, PostgresError>;
     /**

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,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,EAAE,GAAG,EAAU,MAAM,SAAS,CAAC;AAGrE;;;;;;;;GAQG;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;;;OAGG;IACH,OAAO;IA2BP;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD,wFAAwF;IACxF,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAU7D;;;;;OAKG;IACH,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpE,qEAAqE;IACrE,OAAO,CAAC,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAuBzD;;;;;OAKG;IACH,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAoCzF,2EAA2E;IAC3E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAQhD;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D,kCAAkC;IAClC,IAAI,IAAI,WAEP;IAGD,iDAAiD;IACjD,IAAI,KAAK,WAER;IAGD;;OAEG;IACH,KAAK;CAiBR"}
+{"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,EAAE,GAAG,EAAU,MAAM,SAAS,CAAC;AAIrE;;;;;;;;GAQG;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;;;OAGG;IACH,OAAO;IA2BP;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAUnD,wFAAwF;IACxF,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAU7D;;;;;OAKG;IACH,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAuBpE,qEAAqE;IACrE,OAAO,CAAC,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAuBzD;;;;;OAKG;IACH,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAsC3F,2EAA2E;IAC3E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAQhD;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAY3D,kCAAkC;IAClC,IAAI,IAAI,WAEP;IAGD,iDAAiD;IACjD,IAAI,KAAK,WAER;IAGD;;OAEG;IACH,KAAK;CAiBR"}

package/dist/pool.js

@@ -2,6 +2,7 @@ import { Connection } from "./connection";
 import { Queue, RingQueue } from "./queue";
 import { Begin, Future, Ok } from "fluent-future";
 import { ErrPoolClosed } from "./error";
+import { compileSqlTemplate } from "./utils";
 /**
  * Connection pool and the main entry point for Pgtx.
  *
@@ -134,7 +135,7 @@ export class Pool {
      * @example
      * for await (const row of pool.stream<User>`SELECT * FROM orders`) { ... }
      */
-    stream(templates, ...args) {
+    stream(templates, ...params) {
         if (!this._isOpened)
             throw ErrPoolClosed;
         while (this._available.hasMore) {
@@ -144,7 +145,7 @@ export class Pool {
                 continue;
             }
             this._available.push(conn);
-            return conn.stream(templates, ...args);
+            return conn.stream(templates, ...params);
         }
         let controller;
         const stream = new ReadableStream({
@@ -155,7 +156,8 @@ export class Pool {
         this.acquire()
             .tap(conn => {
             this.release(conn);
-            conn['_performStream'](templates, args, controller);
+            const { text, args } = compileSqlTemplate(templates, params);
+            conn['_performStream'](text, args, controller);
         })
             .catch(err => {
             controller.error(err);