@m2k-5f/pgtx 2.8.0 → 2.8.1

package/dist/connection.d.ts

@@ -17,7 +17,6 @@ export declare class Connection {
     private _writer;
     private _sheduled;
     private _queue;
-    private _executingCounter;
     private _closing;
     private _closed;
     private _reconnecting;
@@ -27,6 +26,9 @@ export declare class Connection {
     private _listeningCallbacks;
     private _stmtCounter;
     private _nextStatement;
+    private _logError;
+    private _logQuery;
+    private _logNotice;
     private _registerShedule;
     private _shedule;
     private _registerQuery;
@@ -86,6 +88,7 @@ export declare class Connection {
     get isOpened(): boolean;
     /** Whether the connection is closed or closing. */
     get isClosed(): boolean;
+    private _tryFinishClosing;
     /**
      * Closes the connection, awaiting for all pending queries. Not usable afterward.
      */

package/dist/connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiC,uBAAuB,EAAuC,GAAG,EAAiB,MAAM,SAAS,CAAA;AACzI,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAK3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAA;AACjD,OAAO,EAAkD,aAAa,EAAE,MAAM,SAAS,CAAA;AAevF;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IAEzC,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,iBAAiB,CAAI;IAE7B,OAAO,CAAC,QAAQ,CAAsD;IACtE,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,aAAa,CAA2C;IAEhE,OAAO,CAAC,OAAO,CAAiB;IAEhC,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,QAAQ,CAA8D;IAE9E,OAAO,CAAC,mBAAmB,CAAyD;IACpF,OAAO,CAAC,YAAY,CAAI;IAExB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,cAAc;IA6BtB,OAAO;IAYP;;;OAGG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB;IAkB1C;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAatE,OAAO,CAAC,aAAa;IA+DrB;;;;;OAKG;IACH,OAAO,CAAC,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAazD,OAAO,CAAC,eAAe;IA+DvB;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IA2BvE,OAAO,CAAC,cAAc;IAkEtB;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAoB7D,2EAA2E;IAC3E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAOhD,sFAAsF;IACtF,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAe/D,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC;IAoB/F,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,qBAAqB;IAW7B,OAAO,KAAK,aAAa,GAExB;IAGD,OAAO,CAAC,aAAa;IA6HrB,kDAAkD;IAClD,IAAI,QAAQ,YAEX;IAGD,mDAAmD;IACnD,IAAI,QAAQ,YAEX;IAGD;;OAEG;IACH,KAAK;CAwBR"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiC,uBAAuB,EAAuC,GAAG,EAAiB,MAAM,SAAS,CAAA;AACzI,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAK3C,OAAO,EAAS,MAAM,EAAM,MAAM,eAAe,CAAA;AACjD,OAAO,EAAkD,aAAa,EAAE,MAAM,SAAS,CAAA;AAgBvF;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IAEzC,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAA6B;IAE3C,OAAO,CAAC,QAAQ,CAAsD;IACtE,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,aAAa,CAA2C;IAEhE,OAAO,CAAC,OAAO,CAAiB;IAEhC,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,QAAQ,CAA6D;IAE7E,OAAO,CAAC,mBAAmB,CAAyD;IACpF,OAAO,CAAC,YAAY,CAAI;IAExB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,cAAc;IA6BtB,OAAO;IAYP;;;OAGG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB;IAkB1C;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAatE,OAAO,CAAC,aAAa;IAmDrB;;;;;OAKG;IACH,OAAO,CAAC,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IAazD,OAAO,CAAC,eAAe;IAmDvB;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE;IA2BvE,OAAO,CAAC,cAAc;IAwDtB;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAoB7D,2EAA2E;IAC3E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW;IAOhD,sFAAsF;IACtF,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAe/D,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC;IAoB/F,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,qBAAqB;IAW7B,OAAO,KAAK,aAAa,GAExB;IAGD,OAAO,CAAC,aAAa;IA4GrB,kDAAkD;IAClD,IAAI,QAAQ,YAEX;IAGD,mDAAmD;IACnD,IAAI,QAAQ,YAEX;IAGD,OAAO,CAAC,iBAAiB;IAczB;;OAEG;IACH,KAAK;CAoBR"}

package/dist/connection.js

@@ -29,6 +29,28 @@ export class Connection {
     _nextStatement() {
         return `s-${this._stmtCounter++}`;
     }
+    _logError(error) {
+        if (this.config.logLevel === 'error' || this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
+            console.log(`\n\x1b[31m┌─ ERROR ────────────────────────────────────────\x1b[0m\n`
+                + `\x1b[31m│\x1b[0m ${error}\n`
+                + `\x1b[31m└────────────────────────────────────────────────\x1b[0m\n`);
+        }
+    }
+    _logQuery(text, args) {
+        if (this.config.logLevel === 'query') {
+            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`);
+        }
+    }
+    _logNotice(notice) {
+        if (this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
+            console.log(`\n\x1b[33m┌─ NOTICE ───────────────────────────────────────\x1b[0m\n`
+                + `\x1b[33m│\x1b[0m ${notice}\n`
+                + `\x1b[33m└────────────────────────────────────────────────\x1b[0m\n`);
+        }
+    }
     _registerShedule() {
         if (!this._sheduled) {
             this._sheduled = true;
@@ -67,12 +89,11 @@ export class Connection {
         this._writer = ConnectionRequestBuffer.new(65536);
         this._sheduled = false;
         this._queue = new Queue();
-        this._executingCounter = 0;
         this._closing = null;
         this._closed = false;
         this._reconnecting = null;
-        this._parsed = {};
-        this._parsing = {};
+        this._parsed = new Map();
+        this._parsing = new Map();
         this._listeningCallbacks = new Map();
         this._stmtCounter = 0;
         this.config = config;
@@ -113,37 +134,29 @@ export class Connection {
         return this._performQuery(text, args, resolvers);
     }
     _performQuery(text, args, resolvers) {
-        if (this.config.logLevel === 'query') {
-            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`);
-        }
-        this._executingCounter++;
-        const parsed = this._parsed[text];
+        this._logQuery(text, args);
+        const parsed = this._parsed.get(text);
         if (parsed) {
             const query = new CollectQuery(parsed, text, args, parsed.columns, resolvers, this.config.queryTimeout);
             const err = this._registerQuery(query);
             if (err) {
-                this._executingCounter--;
                 query.error(err);
-                return query.resolvers.future;
+                this._logError(err);
             }
             return query.resolvers.future;
         }
-        if (!this._parsing[text]) {
+        if (!this._parsing.has(text)) {
             const parseQuery = new ParseQuery({ statement: this._nextStatement(), columns: EMPTY_ARRAY, parameters: EMPTY_ARRAY }, text, Future.withResolvers(), this.config.queryTimeout);
             this._registerQuery(parseQuery);
-            this._parsing[text] = parseQuery.resolvers.future;
+            this._parsing.set(text, parseQuery.resolvers.future);
         }
-        const parsing = this._parsing[text];
+        const parsing = this._parsing.get(text);
         return parsing.andThen(meta => {
             const query = new CollectQuery(meta, text, args, meta.columns, resolvers, this.config.queryTimeout);
             const err = this._registerQuery(query);
             if (err) {
-                this._executingCounter--;
                 query.error(err);
-                return query.resolvers.future;
+                this._logError(err);
             }
             return query.resolvers.future;
         });
@@ -164,37 +177,29 @@ export class Connection {
         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`);
-        }
-        this._executingCounter++;
-        const parsed = this._parsed[text];
+        this._logQuery(text, args);
+        const parsed = this._parsed.get(text);
         if (parsed) {
             const query = new ExecuteQuery(parsed, text, args, resolvers, this.config.queryTimeout);
             const err = this._registerQuery(query);
             if (err) {
-                this._executingCounter--;
                 query.error(err);
-                return query.resolvers.future;
+                this._logError(err);
             }
             return query.resolvers.future;
         }
-        if (!this._parsing[text]) {
+        if (!this._parsing.has(text)) {
             const parseQuery = new ParseQuery({ statement: this._nextStatement(), columns: EMPTY_ARRAY, parameters: EMPTY_ARRAY }, text, Future.withResolvers(), this.config.queryTimeout);
             this._registerQuery(parseQuery);
-            this._parsing[text] = parseQuery.resolvers.future;
+            this._parsing.set(text, parseQuery.resolvers.future);
         }
-        const parsing = this._parsing[text];
+        const parsing = this._parsing.get(text);
         return parsing.andThen(meta => {
             const query = new ExecuteQuery(meta, text, args, resolvers, this.config.queryTimeout);
             const err = this._registerQuery(query);
             if (err) {
-                this._executingCounter--;
                 query.error(err);
-                return query.resolvers.future;
+                this._logError(err);
             }
             return query.resolvers.future;
         });
@@ -226,36 +231,30 @@ export class Connection {
         return stream;
     }
     _performStream(text, args, controller) {
-        if (this.config.logLevel === 'query') {
-            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`);
-        }
-        this._executingCounter++;
-        const parsed = this._parsed[text];
+        this._logQuery(text, args);
+        const parsed = this._parsed.get(text);
         if (parsed) {
             const query = new StreamQuery(parsed, text, args, controller, parsed.columns, this.config.queryTimeout);
             const err = this._registerQuery(query);
             if (err) {
-                this._executingCounter--;
                 controller.error(err);
+                this._logError(err);
             }
             return;
         }
-        if (!this._parsing[text]) {
+        if (!this._parsing.has(text)) {
             const parseQuery = new ParseQuery({ statement: this._nextStatement(), columns: EMPTY_ARRAY, parameters: EMPTY_ARRAY }, text, Future.withResolvers(), this.config.queryTimeout);
             this._registerQuery(parseQuery);
-            this._parsing[text] = parseQuery.resolvers.future;
+            this._parsing.set(text, parseQuery.resolvers.future);
         }
-        const parsing = this._parsing[text];
+        const parsing = this._parsing.get(text);
         parsing
             .tap(meta => {
             const query = new StreamQuery(meta, text, args, controller, null, this.config.queryTimeout);
             const err = this._registerQuery(query);
             if (err) {
-                this._executingCounter--;
                 controller.error(err);
+                this._logError(err);
             }
         })
             .tapErr(err => {
@@ -337,10 +336,9 @@ export class Connection {
     }
     _performReconnect() {
         this._socket.destroy();
-        this._parsed = {};
-        this._parsing = {};
+        this._parsed.clear();
+        this._parsing.clear();
         this._sheduled = false;
-        this._executingCounter = 0;
         while (this._queue.hasMore) {
             this._queue.shift.error(ErrConnectionReconnecting);
         }
@@ -382,16 +380,16 @@ export class Connection {
                     const query = this._currentQuery;
                     const columns = reader.readRowDescription();
                     query.meta.columns = columns;
-                    delete this._parsing[query.text];
-                    this._parsed[query.text] = query.meta;
+                    this._parsing.delete(query.text);
+                    this._parsed.set(query.text, query.meta);
                     query.complete();
                 }
                 break;
             case ResponseTypes.NoData:
                 {
                     const query = this._currentQuery;
-                    delete this._parsing[query.text];
-                    this._parsed[query.text] = query.meta;
+                    this._parsing.delete(query.text);
+                    this._parsed.set(query.text, query.meta);
                     query.complete();
                 }
                 break;
@@ -410,40 +408,29 @@ export class Connection {
                     reader.skipBytes(length);
                     const query = this._currentQuery;
                     query.complete();
-                    this._executingCounter--;
                 }
                 break;
             case ResponseTypes.ErrorResponse:
                 {
                     const error = reader.readErrorResponse();
-                    if (this.config.logLevel === 'error' || this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
-                        console.log(`\n\x1b[31m┌─ ERROR ────────────────────────────────────────\x1b[0m\n`
-                            + `\x1b[31m│\x1b[0m ${error}\n`
-                            + `\x1b[31m└────────────────────────────────────────────────\x1b[0m\n`);
-                    }
+                    this._logError(error);
                     const query = this._currentQuery;
-                    if (error.isParseError) {
-                        delete this._parsing[query.text];
-                    }
+                    if (query instanceof ParseQuery)
+                        this._parsing.delete(query.text);
                     query.error(error);
-                    this._executingCounter--;
                 }
                 break;
             case ResponseTypes.ReadyForQuery:
                 {
                     reader.skipBytes(length);
                     this._queue.next();
-                    this._closing && !this._executingCounter && this._closing.resolve();
+                    this._tryFinishClosing();
                 }
                 break;
             case ResponseTypes.Notice:
                 {
-                    const message = reader.readErrorResponse();
-                    if (this.config.logLevel === 'notice' || this.config.logLevel === 'query') {
-                        console.log(`\n\x1b[33m┌─ NOTICE ───────────────────────────────────────\x1b[0m\n`
-                            + `\x1b[33m│\x1b[0m ${message}\n`
-                            + `\x1b[33m└────────────────────────────────────────────────\x1b[0m\n`);
-                    }
+                    const notice = reader.readErrorResponse();
+                    this._logNotice(notice);
                 }
                 break;
             case ResponseTypes.NotificationResponse:
@@ -470,6 +457,19 @@ export class Connection {
     get isClosed() {
         return this._closed || !!this._closing;
     }
+    _tryFinishClosing() {
+        if (!this._closing)
+            return;
+        if (this._queue.hasMore)
+            return;
+        setTimeout(() => {
+            if (!this._closing)
+                return;
+            if (!this._queue.hasMore) {
+                this._closing.resolve();
+            }
+        }, 0);
+    }
     /**
      * Closes the connection, awaiting for all pending queries. Not usable afterward.
      */
@@ -479,11 +479,6 @@ export class Connection {
         if (this._closing) {
             return this._closing.future;
         }
-        if (!this._executingCounter) {
-            this._closed = true;
-            this._socket.destroy();
-            return Future.resolve();
-        }
         const closing = Future.withResolvers();
         this._closing = closing;
         closing.future.tap(() => {
@@ -491,6 +486,7 @@ export class Connection {
             this._closed = true;
             this._socket.destroy();
         });
+        this._tryFinishClosing();
         return closing.future;
     }
 }

package/dist/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,sBAAsB,CAAA;AAEhE,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;AAEzH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,OAAO,GAAG,aAAa,CAcjH"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,sBAAsB,CAAA;AAGhE,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;AAgCzH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,OAAO,GAAG,aAAa,CAqBjH"}

package/dist/error.js

@@ -1,3 +1,4 @@
+import { handlers } from "./protocol/types";
 export class PostgresError extends Error {
     constructor(message, code = 'undeclared', detail = '', severity = '', where = '', hint = '', position = '', dataType = '', constraint = '') {
         super(message);
@@ -51,14 +52,43 @@ export const ErrSSLDenied = new PostgresError("SSL is required but server denied
 export const ErrDatabaseNotFound = new PostgresError('Database with that dsn not found');
 export const ErrUntrustedCertificate = new PostgresError("Database SSL certificate is untrusted or self-signed");
 export const ErrCertificateFileNotFound = new PostgresError("The SSL certificate file specified in caPath was not found");
+function describeValue(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (typeof value === 'bigint')
+        return `${value}n`;
+    if (typeof value === 'string') {
+        return value.length > 60 ? `${JSON.stringify(value.slice(0, 60))}…` : JSON.stringify(value);
+    }
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+        return `Uint8Array(length=${value.length})`;
+    }
+    if (value instanceof Date) {
+        return `Date(${isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString()})`;
+    }
+    if (Array.isArray(value)) {
+        const preview = value.slice(0, 5).map(describeValue).join(', ');
+        return `[${preview}${value.length > 5 ? ', …' : ''}] (length=${value.length})`;
+    }
+    if (typeof value === 'object') {
+        try {
+            const json = JSON.stringify(value);
+            return json.length > 120 ? `${json.slice(0, 120)}…` : json;
+        }
+        catch {
+            return Object.prototype.toString.call(value);
+        }
+    }
+    return String(value);
+}
 export function createBindTypeError(index, expectedType, actualValue) {
-    const position = (index + 1).toString();
-    const actualType = actualValue === null ? 'null' : typeof actualValue;
-    const message = `Bind error: Parameter $${position} type mismatch. Expected ${expectedType}, received "${actualType}(${actualValue})".`;
-    return new PostgresError(message, '22000', // code
-    `The parameter at position $${position} failed client-side binary validation.`, // detail
-    'ERROR', // severity
-    'writeBind() inside driver', // where
-    `Ensure that the argument passed as $${position} matches the PostgreSQL schema requirements.` // hint
-    );
+    const position = index + 1;
+    const info = handlers[expectedType];
+    const expectedPgType = info?.pgType ?? `oid ${expectedType}`;
+    const expectedJsShape = info?.jsShape ?? '(тип не описан в справочнике)';
+    const message = `Bind error: Parameter $${position} type mismatch. ` +
+        `Expected PostgreSQL type "${expectedPgType}" (${expectedJsShape}), received: ${describeValue(actualValue)}.`;
+    return new PostgresError(message, '22000', `Parameter $${position} failed client-side binary validation for pg type "${expectedPgType}".`, 'ERROR', 'writeBind() inside driver', `Pass a value matching ${expectedJsShape} for $${position}.`, '', expectedPgType);
 }

package/dist/protocol/types.d.ts

@@ -4,7 +4,11 @@ import { DataTypeOid } from "./constants";
 type BindValidator = (value: unknown) => boolean;
 type BindWriter = (request: ConnectionRequestBuffer, value: any) => void;
 type FieldReader = (response: ConnectionResponseBuffer, fieldLength: number, int8toBigint: boolean) => unknown;
-interface BindHandler {
+export interface BindHandler {
+    /** Имя типа в PostgreSQL — используется в сообщениях об ошибках. */
+    pgType: string;
+    /** Ожидаемая JS-форма значения — используется в сообщениях об ошибках. */
+    jsShape: string;
     validate: BindValidator;
     write: BindWriter;
     read: FieldReader;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/protocol/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAA;AAEvD,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;AAChD,KAAK,UAAU,GAAG,CAAC,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;AACxE,KAAK,WAAW,GAAG,CACf,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,OAAO,KACpB,OAAO,CAAA;AAEZ,UAAU,WAAW;IACjB,QAAQ,EAAE,aAAa,CAAA;IACvB,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,WAAW,CAAA;CACpB;AASD,eAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAsY9D,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/protocol/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAA;AAEvD,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;AAChD,KAAK,UAAU,GAAG,CAAC,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;AACxE,KAAK,WAAW,GAAG,CACf,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,OAAO,KACpB,OAAO,CAAA;AAEZ,MAAM,WAAW,WAAW;IACxB,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAA;IACd,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,aAAa,CAAA;IACvB,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,WAAW,CAAA;CACpB;AASD,eAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CA2d9D,CAAA"}

package/dist/protocol/types.js

@@ -5,36 +5,50 @@ const isPoint = (value) => value !== null &&
     'y' in value && typeof value.y === 'number';
 export const handlers = {
     [DataTypeOids.Bool]: {
+        pgType: 'bool',
+        jsShape: 'boolean',
         validate: (v) => typeof v === 'boolean',
         write: (req, v) => req.writeBinaryBool(v),
         read: (res) => res.readBool(),
     },
     [DataTypeOids.Text]: {
+        pgType: 'text',
+        jsShape: 'string',
         validate: (v) => typeof v === 'string',
         write: (req, v) => req.writeBinaryString(v),
         read: (res, len) => res.readRawString(len),
     },
     [DataTypeOids.Varchar]: {
+        pgType: 'varchar',
+        jsShape: 'string',
         validate: (v) => typeof v === 'string',
         write: (req, v) => req.writeBinaryString(v),
         read: (res, len) => res.readRawString(len),
     },
     [DataTypeOids.Char]: {
+        pgType: 'char',
+        jsShape: 'string',
         validate: (v) => typeof v === 'string',
         write: (req, v) => req.writeBinaryString(v),
         read: (res, len) => res.readRawString(len),
     },
     [DataTypeOids.Bpchar]: {
+        pgType: 'bpchar',
+        jsShape: 'string',
         validate: (v) => typeof v === 'string',
         write: (req, v) => req.writeBinaryString(v),
         read: (res, len) => res.readRawString(len),
     },
     [DataTypeOids.Name]: {
+        pgType: 'name',
+        jsShape: 'string',
         validate: (v) => typeof v === 'string' && Buffer.byteLength(v, 'utf-8') <= 63,
         write: (req, v) => req.writeBinaryString(v),
         read: (res, len) => res.readRawString(len),
     },
     [DataTypeOids.Int2]: {
+        pgType: 'int2',
+        jsShape: 'number (-32768..32767)',
         validate: (v) => typeof v === 'number' &&
             Number.isInteger(v) &&
             v >= -32768 &&
@@ -43,6 +57,8 @@ export const handlers = {
         read: (res) => res.readInt16(),
     },
     [DataTypeOids.Int4]: {
+        pgType: 'int4',
+        jsShape: 'number (-2147483648..2147483647)',
         validate: (v) => typeof v === 'number' &&
             Number.isInteger(v) &&
             v >= -2147483648 &&
@@ -51,6 +67,8 @@ export const handlers = {
         read: (res) => res.readInt32(),
     },
     [DataTypeOids.Int8]: {
+        pgType: 'int8',
+        jsShape: 'bigint | number (safe integer)',
         validate: (v) => typeof v === 'bigint' ||
             (typeof v === 'number' && Number.isSafeInteger(v)),
         write: (req, v) => typeof v === 'bigint'
@@ -59,58 +77,80 @@ export const handlers = {
         read: (res, _len, int8toBigint) => int8toBigint ? res.readBigInt64() : res.readInt64(),
     },
     [DataTypeOids.Float4]: {
+        pgType: 'float4',
+        jsShape: 'number',
         validate: (v) => typeof v === 'number' && Number.isFinite(v),
         write: (req, v) => req.writeBinaryFloat4(v),
         read: (res) => res.readFloat32(),
     },
     [DataTypeOids.Float8]: {
+        pgType: 'float8',
+        jsShape: 'number',
         validate: (v) => typeof v === 'number' && Number.isFinite(v),
         write: (req, v) => req.writeBinaryFloat8(v),
         read: (res) => res.readFloat64(),
     },
     [DataTypeOids.Bytea]: {
+        pgType: 'bytea',
+        jsShape: 'Buffer | Uint8Array',
         validate: (v) => Buffer.isBuffer(v) || v instanceof Uint8Array,
         write: (req, v) => req.writeBinaryBytea(v),
         read: (res, len) => res.readBytes(len),
     },
     [DataTypeOids.Timestamp]: {
+        pgType: 'timestamp',
+        jsShape: 'Date',
         validate: (v) => v instanceof Date,
         write: (req, v) => req.writeBinaryTimestamp(v),
         read: (res) => res.readBinaryTimestamp(),
     },
     [DataTypeOids.Timestamptz]: {
+        pgType: 'timestamptz',
+        jsShape: 'Date',
         validate: (v) => v instanceof Date,
         write: (req, v) => req.writeBinaryTimestamp(v),
         read: (res) => res.readBinaryTimestamp(),
     },
     [DataTypeOids.Point]: {
+        pgType: 'point',
+        jsShape: '{ x: number, y: number }',
         validate: isPoint,
         write: (req, v) => req.writeBinaryPoint(v),
         read: (res) => res.readBinaryPoint(),
     },
     [DataTypeOids.Numeric]: {
+        pgType: 'numeric',
+        jsShape: 'string ("[-]digits[.digits]")',
         validate: (v) => (typeof v === 'string' && /^-?\d*\.?\d+$/.test(v)),
         write: (req, v) => req.writeBinaryNumeric(v),
         read: (res) => res.readBinaryNumeric(),
     },
     [DataTypeOids.Date]: {
+        pgType: 'date',
+        jsShape: 'Date',
         validate: (v) => v instanceof Date,
         write: (req, v) => req.writeBinaryDate(v),
         read: (res) => res.readBinaryDate(),
     },
     [DataTypeOids.Time]: {
+        pgType: 'time',
+        jsShape: 'string ("HH:MM:SS.mmm")',
         validate: (v) => typeof v === 'string' &&
             /^(\d{2}):(\d{2}):(\d{2})\.(\d{3})$/.test(v),
         write: (req, v) => req.writeBinaryTime(v),
         read: (res) => res.readBinaryTime(),
     },
     [DataTypeOids.Timetz]: {
+        pgType: 'timetz',
+        jsShape: 'string ("HH:MM:SS.mmm±HH:MM")',
         validate: (v) => typeof v === 'string' &&
             /^(\d{2}):(\d{2}):(\d{2})\.(\d{3})([+-])(\d{2}):(\d{2})$/.test(v),
         write: (req, v) => req.writeBinaryTimetz(v),
         read: (res) => res.readBinaryTimetz(),
     },
     [DataTypeOids.Interval]: {
+        pgType: 'interval',
+        jsShape: '{ months: number, days: number, microseconds: number | bigint }',
         validate: (v) => v !== null &&
             typeof v === 'object' &&
             'months' in v && typeof v.months === 'number' &&
@@ -121,64 +161,88 @@ export const handlers = {
         read: (res) => res.readBinaryInterval(),
     },
     [DataTypeOids.Json]: {
+        pgType: 'json',
+        jsShape: 'unknown (JSON-serializable)',
         validate: (_v) => true,
         write: (req, v) => req.writeBinaryJson(v),
         read: (res, len) => res.readBinaryJson(len),
     },
     [DataTypeOids.Jsonb]: {
+        pgType: 'jsonb',
+        jsShape: 'unknown (JSON-serializable)',
         validate: (_v) => true,
         write: (req, v) => req.writeBinaryJsonb(v),
         read: (res, len) => res.readBinaryJsonb(len),
     },
     [DataTypeOids.Uuid]: {
+        pgType: 'uuid',
+        jsShape: 'string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")',
         validate: (v) => typeof v === 'string' &&
             /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(v),
         write: (req, v) => req.writeBinaryUuid(v),
         read: (res) => res.readBinaryUuid(),
     },
     [DataTypeOids.Cidr]: {
+        pgType: 'cidr',
+        jsShape: 'string (IPv4/IPv6 address or CIDR)',
         validate: (v) => typeof v === 'string',
         write: (req, v) => req.writeBinaryCidr(v),
         read: (res, len) => res.readBinaryInet(len),
     },
     [DataTypeOids.Inet]: {
+        pgType: 'inet',
+        jsShape: 'string (IPv4/IPv6 address or CIDR)',
         validate: (v) => typeof v === 'string',
         write: (req, v) => req.writeBinaryInet(v),
         read: (res, len) => res.readBinaryInet(len),
     },
     [DataTypeOids.Macaddr]: {
+        pgType: 'macaddr',
+        jsShape: 'string ("xx:xx:xx:xx:xx:xx")',
         validate: (v) => typeof v === 'string' &&
             /^([0-9a-f]{2}:){5}[0-9a-f]{2}$/i.test(v),
         write: (req, v) => req.writeBinaryMacaddr(v),
         read: (res) => res.readBinaryMacaddr(),
     },
     [DataTypeOids.Oid]: {
+        pgType: 'oid',
+        jsShape: 'number',
         validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0,
         write: (req, v) => req.writeBinaryOid(v),
         read: (res) => res.readBinaryOid(),
     },
     [DataTypeOids.Xid]: {
+        pgType: 'xid',
+        jsShape: 'number',
         validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0,
         write: (req, v) => req.writeBinaryXid(v),
         read: (res) => res.readBinaryXid(),
     },
     [DataTypeOids.Cid]: {
+        pgType: 'cid',
+        jsShape: 'number',
         validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0,
         write: (req, v) => req.writeBinaryCid(v),
         read: (res) => res.readBinaryCid(),
     },
     [DataTypeOids.Regproc]: {
+        pgType: 'regproc',
+        jsShape: 'number',
         validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0,
         write: (req, v) => req.writeBinaryRegproc(v),
         read: (res) => res.readBinaryRegproc(),
     },
     [DataTypeOids.Lseg]: {
+        pgType: 'lseg',
+        jsShape: '{ a: Point, b: Point }',
         validate: (v) => v !== null && typeof v === 'object' &&
             isPoint(v.a) && isPoint(v.b),
         write: (req, v) => req.writeBinaryLseg(v),
         read: (res) => res.readBinaryLseg(),
     },
     [DataTypeOids.Path]: {
+        pgType: 'path',
+        jsShape: '{ closed: boolean, points: Point[] }',
         validate: (v) => v !== null && typeof v === 'object' &&
             typeof v.closed === 'boolean' &&
             Array.isArray(v.points) &&
@@ -187,12 +251,16 @@ export const handlers = {
         read: (res) => res.readBinaryPath(),
     },
     [DataTypeOids.Box]: {
+        pgType: 'box',
+        jsShape: '{ high: Point, low: Point }',
         validate: (v) => v !== null && typeof v === 'object' &&
             isPoint(v.high) && isPoint(v.low),
         write: (req, v) => req.writeBinaryBox(v),
         read: (res) => res.readBinaryBox(),
     },
     [DataTypeOids.Polygon]: {
+        pgType: 'polygon',
+        jsShape: '{ points: Point[] }',
         validate: (v) => v !== null && typeof v === 'object' &&
             Array.isArray(v.points) &&
             v.points.every(isPoint),
@@ -200,6 +268,8 @@ export const handlers = {
         read: (res) => res.readBinaryPolygon(),
     },
     [DataTypeOids.Line]: {
+        pgType: 'line',
+        jsShape: '{ a: number, b: number, c: number }',
         validate: (v) => v !== null && typeof v === 'object' &&
             typeof v.a === 'number' &&
             typeof v.b === 'number' &&
@@ -208,21 +278,29 @@ export const handlers = {
         read: (res) => res.readBinaryLine(),
     },
     [DataTypeOids.BoolArray]: {
+        pgType: 'bool[]',
+        jsShape: '(boolean | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null || typeof el === 'boolean'),
         write: (req, v) => req.writeBinaryBoolArray(v),
         read: (res, len) => res.readBinaryArray(len, () => res.readBool()),
     },
     [DataTypeOids.Int2Array]: {
+        pgType: 'int2[]',
+        jsShape: '(number | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null || (typeof el === 'number' && Number.isInteger(el) && el >= -32768 && el <= 32767)),
         write: (req, v) => req.writeBinaryInt2Array(v),
         read: (res, len) => res.readBinaryArray(len, () => res.readInt16()),
     },
     [DataTypeOids.Int4Array]: {
+        pgType: 'int4[]',
+        jsShape: '(number | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null || (typeof el === 'number' && Number.isInteger(el) && el >= -2147483648 && el <= 2147483647)),
         write: (req, v) => req.writeBinaryInt4Array(v),
         read: (res, len) => res.readBinaryArray(len, () => res.readInt32()),
     },
     [DataTypeOids.Int8Array]: {
+        pgType: 'int8[]',
+        jsShape: '(number | bigint | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null ||
             typeof el === 'bigint' ||
             (typeof el === 'number' && Number.isSafeInteger(el))),
@@ -230,31 +308,43 @@ export const handlers = {
         read: (res, len, int8toBigint) => res.readBinaryArray(len, () => int8toBigint ? res.readBigInt64() : res.readInt64()),
     },
     [DataTypeOids.TextArray]: {
+        pgType: 'text[]',
+        jsShape: '(string | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null || typeof el === 'string'),
         write: (req, v) => req.writeBinaryTextArray(v),
         read: (res, len) => res.readBinaryArray(len, (l) => res.readRawString(l)),
     },
     [DataTypeOids.VarcharArray]: {
+        pgType: 'varchar[]',
+        jsShape: '(string | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null || typeof el === 'string'),
         write: (req, v) => req.writeBinaryVarcharArray(v),
         read: (res, len) => res.readBinaryArray(len, (l) => res.readRawString(l)),
     },
     [DataTypeOids.JsonArray]: {
+        pgType: 'json[]',
+        jsShape: 'unknown[]',
         validate: (v) => Array.isArray(v),
         write: (req, v) => req.writeBinaryJsonArray(v),
         read: (res, len) => res.readBinaryArray(len, (l) => res.readBinaryJson(l)),
     },
     [DataTypeOids.JsonbArray]: {
+        pgType: 'jsonb[]',
+        jsShape: 'unknown[]',
         validate: (v) => Array.isArray(v),
         write: (req, v) => req.writeBinaryJsonbArray(v),
         read: (res, len) => res.readBinaryArray(len, (l) => res.readBinaryJsonb(l)),
     },
     [DataTypeOids.UuidArray]: {
+        pgType: 'uuid[]',
+        jsShape: '(string | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null || (typeof el === 'string' && /^[0-9a-f-]{36}$/i.test(el))),
         write: (req, v) => req.writeBinaryUuidArray(v),
         read: (res, len) => res.readBinaryArray(len, () => res.readBinaryUuid()),
     },
     [DataTypeOids.NumericArray]: {
+        pgType: 'numeric[]',
+        jsShape: '(string | null)[]',
         validate: (v) => Array.isArray(v) && v.every(el => el == null ||
             (typeof el === 'number' && Number.isFinite(el)) ||
             (typeof el === 'string' && /^-?\d*\.?\d+$/.test(el))),

package/package.json

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