@m2k-5f/pgtx 2.2.0 → 2.3.1

package/dist/pool.d.ts

@@ -1,5 +1,7 @@
 import { Connection, ConnectionParams } from "./connection";
 import { Transaction } from "./transaction";
+import { Future } from "fluent-future";
+import { PostgresError } from "./error";
 type PoolParams = ConnectionParams & {
     max?: number;
 };
@@ -35,7 +37,7 @@ type PoolParams = ConnectionParams & {
  * }
  *
  * // Clean up
- * await pool.close()
+ *  pool.close()
  * ```
  */
 export declare class Pool {
@@ -65,7 +67,7 @@ export declare class Pool {
      * }
      * ```
      */
-    acquire(): Promise<Connection>;
+    acquire(): Future<Connection, Error>;
     /**
      * Releases the connection back to the pool.
      *
@@ -103,7 +105,7 @@ export declare class Pool {
      * })
      * ```
      */
-    begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Promise<T>;
+    begin<T>(txCallback: (transaction: Transaction) => Promise<T>): Future<T, Error>;
     /**
      * Executes a one-off query using pipeline.
      *
@@ -127,7 +129,7 @@ export declare class Pool {
      * const users = await pool.query<User>`SELECT * FROM users`
      * ```
      */
-    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): Promise<T[]>;
+    query<T extends Record<string, any>>(templates: TemplateStringsArray, ...args: any[]): Future<T[], Error>;
     /**
      * Sends an asynchronous notification to a channel via `pg_notify`.
      *
@@ -139,7 +141,7 @@ export declare class Pool {
      * await pool.notify('events', 'hello')
      * ```
      */
-    notify(channelName: string, payload?: string): Promise<[]>;
+    notify(channelName: string, payload?: string): Future<[], PostgresError>;
     /**
      * Number of available (idle) connections in the pool.
      */
@@ -157,10 +159,10 @@ export declare class Pool {
      *
      * @example
      * ```ts
-     * await pool.close()
+     *  pool.close()
      * ```
      */
-    close(): Promise<void>;
+    close(): void;
 }
 export {};
 //# sourceMappingURL=pool.d.ts.map

package/dist/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAK3C,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IACG,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IA6BpC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYhF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAmCnG;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,OAAO,CAAC,EAAE,CAAC;IAIlF;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACG,KAAK;CAed"}
+{"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,EAAE,MAAM,EAAW,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,KAAK,UAAU,GAAG,gBAAgB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IA0BP;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU;IAoBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IAW7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAiCpF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GACuB,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IAIhG;;OAEG;IACH,IAAI,IAAI,WAEP;IAGD;;;OAGG;IACH,IAAI,KAAK,WAER;IAGD;;;;;;;;;;OAUG;IACH,KAAK;CAeR"}

package/dist/pool.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = void 0;
-const connection_1 = require("./connection");
-const queue_1 = require("./queue");
+import { Connection } from "./connection";
+import { Queue } from "./queue";
+import { Future, Resolve } from "fluent-future";
 /**
  * The main entry point for Pgtx.
  * Manages a connection pool and provides high-level API for queries and transactions.
@@ -35,18 +33,18 @@ const queue_1 = require("./queue");
  * }
  *
  * // Clean up
- * await pool.close()
+ *  pool.close()
  * ```
  */
-class Pool {
+export class Pool {
     _checkClosed() {
         if (this._isClosed)
             throw new Error('Pool closed');
     }
     constructor(params) {
-        this._available = new queue_1.Queue();
+        this._available = new Queue();
         this._total = 0;
-        this._waiting = new queue_1.Queue();
+        this._waiting = new Queue();
         this._isClosed = false;
         this._config = params;
         this._max = params.max || 20;
@@ -69,29 +67,24 @@ class Pool {
      * }
      * ```
      */
-    async acquire() {
+    acquire() {
         this._checkClosed();
         while (this._available.hasMore) {
             const conn = this._available.get();
             this._available.next();
             if (conn.isOpened) {
-                return conn;
+                return Resolve(conn);
             }
             this._total--;
         }
         if (this._total < this._max) {
             this._total++;
-            try {
-                return await connection_1.Connection.new(this._config);
-            }
-            catch (err) {
-                this._total--;
-                throw err;
-            }
+            return Future.of(Connection.new(this._config))
+                .tapErr(() => this._total--);
         }
-        return new Promise((resolve, reject) => {
+        return Future.of(new Promise((resolve, reject) => {
             this._waiting.push({ resolve, reject });
-        });
+        }));
     }
     /**
      * Releases the connection back to the pool.
@@ -143,15 +136,11 @@ class Pool {
      * })
      * ```
      */
-    async begin(txCallback) {
+    begin(txCallback) {
         this._checkClosed();
-        const conn = await this.acquire();
-        try {
-            return conn.begin(txCallback);
-        }
-        finally {
-            this.release(conn);
-        }
+        return this.acquire()
+            .andThen(conn => conn.begin(txCallback)
+            .finally(() => this.release(conn)));
     }
     /**
      * Executes a one-off query using pipeline.
@@ -180,26 +169,25 @@ class Pool {
         this._checkClosed();
         while (this._available.hasMore) {
             const conn = this._available.get();
-            if (conn.isOpened) {
-                return conn.query(templates, ...args);
-            }
             this._available.next();
-            this._total--;
+            if (!conn.isOpened) {
+                this._total--;
+                continue;
+            }
+            this._available.push(conn);
+            return conn.query(templates, ...args);
         }
         if (this._total < this._max) {
             this._total++;
-            return connection_1.Connection.new(this._config)
-                .catch(err => {
-                this._total--;
-                throw err;
-            })
-                .then(conn => {
+            return Future.of(Connection.new(this._config))
+                .tapErr(() => this._total--)
+                .andThen(conn => {
                 this.release(conn);
                 return conn.query(templates, ...args);
             });
         }
         return this.acquire()
-            .then(conn => {
+            .andThen(conn => {
             this.release(conn);
             return conn.query(templates, ...args);
         });
@@ -239,10 +227,10 @@ class Pool {
      *
      * @example
      * ```ts
-     * await pool.close()
+     *  pool.close()
      * ```
      */
-    async close() {
+    close() {
         while (this._available.hasMore) {
             const conn = this._available.get();
             this._available.next();
@@ -256,4 +244,3 @@ class Pool {
         this._total = 0;
     }
 }
-exports.Pool = Pool;

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionRequestWriter = exports.ConnectionRequestBuffer = void 0;
-const constants_1 = require("./constants");
-class ConnectionRequestBuffer {
+import { RequestTypes } from "./constants";
+export class ConnectionRequestBuffer {
     constructor(buffer, offset = 0, lastRequestLenByteOffset = 0) {
         this.buffer = buffer;
         this.offset = offset;
@@ -75,8 +72,7 @@ class ConnectionRequestBuffer {
         this.lastRequestLenByteOffset = 0;
     }
 }
-exports.ConnectionRequestBuffer = ConnectionRequestBuffer;
-class ConnectionRequestWriter {
+export class ConnectionRequestWriter {
     constructor(buffer) {
         this.buffer = buffer;
     }
@@ -84,13 +80,13 @@ class ConnectionRequestWriter {
         return new ConnectionRequestWriter(ConnectionRequestBuffer.new(65536));
     }
     writeQuery(text) {
-        this.buffer.startRequest(constants_1.RequestTypes.SimpleQuery)
+        this.buffer.startRequest(RequestTypes.SimpleQuery)
             .writeCString(text)
             .endRequest();
         return this;
     }
     writeParse(name, text) {
-        this.buffer.startRequest(constants_1.RequestTypes.Parse)
+        this.buffer.startRequest(RequestTypes.Parse)
             .writeCString(name)
             .writeCString(text)
             .writeInt16(0)
@@ -98,14 +94,14 @@ class ConnectionRequestWriter {
         return this;
     }
     writeDescribe(statementName) {
-        this.buffer.startRequest(constants_1.RequestTypes.Describe)
+        this.buffer.startRequest(RequestTypes.Describe)
             .writeChar('S')
             .writeCString(statementName)
             .endRequest();
         return this;
     }
     writeBind(portName, statementName, params) {
-        const request = this.buffer.startRequest(constants_1.RequestTypes.Bind)
+        const request = this.buffer.startRequest(RequestTypes.Bind)
             .writeCString(portName)
             .writeCString(statementName)
             .writeInt16(0)
@@ -118,7 +114,7 @@ class ConnectionRequestWriter {
         return this;
     }
     writeClose(name) {
-        this.buffer.startRequest(constants_1.RequestTypes.Close)
+        this.buffer.startRequest(RequestTypes.Close)
             .writeChar("P")
             .writeCString(name)
             .endRequest();
@@ -134,24 +130,24 @@ class ConnectionRequestWriter {
         return this;
     }
     writeExecute(portName) {
-        this.buffer.startRequest(constants_1.RequestTypes.Execute)
+        this.buffer.startRequest(RequestTypes.Execute)
             .writeCString(portName)
             .writeInt32(0)
             .endRequest();
         return this;
     }
     writeSync() {
-        this.buffer.startRequest(constants_1.RequestTypes.Sync).endRequest();
+        this.buffer.startRequest(RequestTypes.Sync).endRequest();
         return this;
     }
     writePassword(password) {
-        this.buffer.startRequest(constants_1.RequestTypes.Password)
+        this.buffer.startRequest(RequestTypes.Password)
             .writeCString(password)
             .endRequest();
         return this;
     }
     writeSaslInitial(mechanism, clientFirstMessage) {
-        this.buffer.startRequest(constants_1.RequestTypes.Password)
+        this.buffer.startRequest(RequestTypes.Password)
             .writeCString(mechanism)
             .writeInt32(Buffer.byteLength(clientFirstMessage, 'utf-8'))
             .writeString(clientFirstMessage)
@@ -159,7 +155,7 @@ class ConnectionRequestWriter {
         return this;
     }
     writeSaslResponse(clientFinalMessage) {
-        this.buffer.startRequest(constants_1.RequestTypes.Password)
+        this.buffer.startRequest(RequestTypes.Password)
             .writeString(clientFinalMessage)
             .endRequest();
         return this;
@@ -172,4 +168,3 @@ class ConnectionRequestWriter {
         return this;
     }
 }
-exports.ConnectionRequestWriter = ConnectionRequestWriter;

package/dist/protocol/connection-response-reader.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionResponseReader = exports.ConnectionResponseBuffer = void 0;
-const error_1 = require("../error");
-class ConnectionResponseBuffer {
+import { PostgresError } from "../error";
+export class ConnectionResponseBuffer {
     constructor(buffer) {
         this.buffer = buffer;
         this.caret = 0;
@@ -57,8 +54,7 @@ class ConnectionResponseBuffer {
         return this.buffer.subarray(this.caret);
     }
 }
-exports.ConnectionResponseBuffer = ConnectionResponseBuffer;
-class ConnectionResponseReader {
+export class ConnectionResponseReader {
     constructor(buffer) {
         this.buffer = buffer;
         this.currentPacketLength = 0;
@@ -136,7 +132,7 @@ class ConnectionResponseReader {
                     break;
             }
         }
-        return new error_1.PostgresError(message, code, detail, severity, where, hint, position, dataType, constraint);
+        return new PostgresError(message, code, detail, severity, where, hint, position, dataType, constraint);
     }
     readReadyForQuery() {
         this.buffer.readInt32();
@@ -225,4 +221,3 @@ class ConnectionResponseReader {
         this.buffer.readInt32();
     }
 }
-exports.ConnectionResponseReader = ConnectionResponseReader;

package/dist/protocol/constants.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionStatuses = exports.AuthenticationCodes = exports.ResponseTypes = exports.RequestTypes = void 0;
-exports.RequestTypes = {
+export const RequestTypes = {
     SimpleQuery: "Q",
     Parse: "P",
     Bind: "B",
@@ -11,7 +8,7 @@ exports.RequestTypes = {
     Describe: 'D',
     Close: "C"
 };
-exports.ResponseTypes = {
+export const ResponseTypes = {
     RowDescription: "T",
     DataRow: "D",
     ComandComplete: "C",
@@ -29,7 +26,7 @@ exports.ResponseTypes = {
     Notice: "N",
     NotificationResponse: "A"
 };
-exports.AuthenticationCodes = {
+export const AuthenticationCodes = {
     Ok: 0,
     CleartextPassword: 3,
     MD5Password: 5,
@@ -37,7 +34,7 @@ exports.AuthenticationCodes = {
     SASLContinue: 11,
     SASLFinal: 12,
 };
-exports.TransactionStatuses = {
+export const TransactionStatuses = {
     Idle: "I",
     InTransactionBlock: "T",
     FailedTransactionBlock: "E",

package/dist/protocol/socket-authorization.d.ts

@@ -1,5 +1,7 @@
 import { Socket } from "node:net";
 import { ConnectionRequestWriter } from "./connection-request-writer";
+import { PostgresError } from "../error";
+import { Future } from "fluent-future";
 export type AuthorizationParams = {
     host: string;
     port: number;
@@ -7,5 +9,7 @@ export type AuthorizationParams = {
     database: string;
     password?: string;
 };
-export declare const createAuthorizedSocket: (writer: ConnectionRequestWriter, params: AuthorizationParams) => Promise<Socket>;
+export declare const ErrNonceMismatch: PostgresError;
+export declare const ErrPasswordRequired: PostgresError;
+export declare const createAuthorizedSocket: (writer: ConnectionRequestWriter, params: AuthorizationParams) => Future<Socket, PostgresError>;
 //# sourceMappingURL=socket-authorization.d.ts.map

package/dist/protocol/socket-authorization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket-authorization.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAOrE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAGD,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,QAAQ,mBAAmB,oBAiHlG,CAAA"}
+{"version":3,"file":"socket-authorization.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAKrE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAGtC,MAAM,MAAM,mBAAmB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAGD,eAAO,MAAM,gBAAgB,eAAmF,CAAA;AAChH,eAAO,MAAM,mBAAmB,eAAqE,CAAA;AAIrG,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,QAAQ,mBAAmB,kCAwHlG,CAAA"}

package/dist/protocol/socket-authorization.js

@@ -1,85 +1,86 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAuthorizedSocket = void 0;
-const node_net_1 = require("node:net");
-const sasl_1 = require("../security/sasl");
-const socket_connector_1 = require("./socket-connector");
-const constants_1 = require("./constants");
-const md5_1 = require("../security/md5");
-const createAuthorizedSocket = (writer, params) => {
-    return new Promise((resolve, reject) => {
-        const nonce = (0, sasl_1.generateNonce)();
+import { createConnection } from "node:net";
+import { calculateScramAuth, generateNonce } from "../security/sasl";
+import { SocketConnector } from "./socket-connector";
+import { AuthenticationCodes, ResponseTypes } from "./constants";
+import { encryptMd5 } from "../security/md5";
+import { PostgresError } from "../error";
+import { Future } from "fluent-future";
+export const ErrNonceMismatch = new PostgresError("Protocol violation: server nonce doesn't match client nonce");
+export const ErrPasswordRequired = new PostgresError('The authorization method requires a password.');
+export const createAuthorizedSocket = (writer, params) => {
+    return Future.of(new Promise((resolve, reject) => {
+        const nonce = generateNonce();
         let clientMessage = '';
         let serverMessage = '';
-        const socket = (0, node_net_1.createConnection)({ host: params.host, port: params.port });
-        const connector = new socket_connector_1.SocketConnector(socket, (type, reader) => {
+        const socket = createConnection({ host: params.host, port: params.port });
+        const connector = new SocketConnector(socket, (type, reader) => {
             writer.clear();
             switch (type) {
-                case constants_1.ResponseTypes.Authentication: {
+                case ResponseTypes.Authentication: {
                     switch (reader.readAuthentication()) {
-                        case constants_1.AuthenticationCodes.Ok: break;
-                        case constants_1.AuthenticationCodes.CleartextPassword: {
+                        case AuthenticationCodes.Ok: break;
+                        case AuthenticationCodes.CleartextPassword: {
                             if (!params.password)
-                                throw new Error('The authorization method requires a password.');
+                                throw ErrPasswordRequired;
                             connector.write(writer.writePassword(params.password));
                             break;
                         }
-                        case constants_1.AuthenticationCodes.MD5Password: {
+                        case AuthenticationCodes.MD5Password: {
                             const salt = reader.readMD5Salt();
                             if (!params.password)
-                                throw new Error('The authorization method requires a password.');
-                            const password = (0, md5_1.encryptMd5)(params.password, params.user, salt);
+                                throw ErrPasswordRequired;
+                            const password = encryptMd5(params.password, params.user, salt);
                             connector.write(writer.writePassword(password));
                             break;
                         }
-                        case constants_1.AuthenticationCodes.SASL: {
+                        case AuthenticationCodes.SASL: {
                             reader.readSaslMechanisms();
                             if (!params.password)
-                                throw new Error('The authorization method requires a password.');
+                                throw ErrPasswordRequired;
                             clientMessage = `n=${params.user},r=${nonce}`;
                             connector.write(writer.writeSaslInitial('SCRAM-SHA-256', `n,,${clientMessage}`));
                             break;
                         }
-                        case constants_1.AuthenticationCodes.SASLContinue: {
+                        case AuthenticationCodes.SASLContinue: {
                             serverMessage = reader.readSaslMessage();
                             if (!params.password)
-                                throw new Error('The authorization method requires a password.');
+                                throw ErrPasswordRequired;
                             const parts = Object.fromEntries(serverMessage.split(',').map(x => x.split('=')));
                             const serverNonce = parts.r;
                             const saltBase64 = parts.s;
                             const iterations = parseInt(parts.i, 10);
                             if (!serverNonce.startsWith(nonce)) {
                                 connector.destroy();
-                                return reject("Protocol violation: server nonce doesn't match client nonce");
+                                return reject(ErrNonceMismatch);
                             }
                             const clientFinalMessageWithoutProof = `c=biws,r=${serverNonce}`;
                             const authMessage = `${clientMessage},${serverMessage},${clientFinalMessageWithoutProof}`;
-                            const { clientProof } = (0, sasl_1.calculateScramAuth)(params.password, saltBase64, iterations, authMessage);
+                            const { clientProof } = calculateScramAuth(params.password, saltBase64, iterations, authMessage);
                             const clientFinalMessage = `${clientFinalMessageWithoutProof},p=${clientProof}`;
                             connector.write(writer.writeSaslResponse(clientFinalMessage));
                             break;
                         }
-                        case constants_1.AuthenticationCodes.SASLFinal: {
+                        case AuthenticationCodes.SASLFinal: {
                             reader.readSaslMessage();
                             break;
                         }
                     }
                     break;
                 }
-                case constants_1.ResponseTypes.ParamaterStatus: {
+                case ResponseTypes.ParamaterStatus: {
                     reader.readParameterStatus();
                     break;
                 }
-                case constants_1.ResponseTypes.ErrorResponse: {
-                    const message = reader.readErrorResponse();
+                case ResponseTypes.ErrorResponse: {
+                    const error = reader.readErrorResponse();
                     connector.destroy();
-                    reject(message);
+                    reject(error);
                     return;
                 }
-                case constants_1.ResponseTypes.BackendKeyData: {
+                case ResponseTypes.BackendKeyData: {
                     reader.readBackendKeyData();
                 }
-                case constants_1.ResponseTypes.ReadyForQuery: {
+                case ResponseTypes.ReadyForQuery: {
                     reader.readReadyForQuery();
                     resolve(connector.unwrapSocket());
                     return;
@@ -90,6 +91,9 @@ const createAuthorizedSocket = (writer, params) => {
         });
         connector.write(writer.writeStartup(params.user, params.database));
         writer.clear();
+    }), error => {
+        if (error instanceof PostgresError)
+            return error;
+        return new PostgresError(error.message);
     });
 };
-exports.createAuthorizedSocket = createAuthorizedSocket;

package/dist/protocol/socket-connector.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketConnector = void 0;
-const connection_response_reader_1 = require("../protocol/connection-response-reader");
-class SocketConnector {
+import { ConnectionResponseReader } from '../protocol/connection-response-reader';
+export class SocketConnector {
     constructor(_socket, _onData, _onError) {
         this._socket = _socket;
         this._onData = _onData;
@@ -15,7 +12,7 @@ class SocketConnector {
                 ? Buffer.concat([this.residualBuffer, buffer])
                 : buffer;
             this.residualBuffer = null;
-            const reader = connection_response_reader_1.ConnectionResponseReader.from(currentBuffer);
+            const reader = ConnectionResponseReader.from(currentBuffer);
             while (reader.hasMore()) {
                 if (!reader.hasFullPacket()) {
                     this.residualBuffer = reader.getResidualBuffer();
@@ -46,4 +43,3 @@ class SocketConnector {
     }
     get isDestroyed() { return this._isDestroyed; }
 }
-exports.SocketConnector = SocketConnector;

package/dist/query.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Query = exports.QueryState = void 0;
-exports.QueryState = {
+export const QueryState = {
     Parsing: 0,
     Describing: 1,
     Executing: 2,
     Completed: 3,
     Failed: 4
 };
-class Query {
+export class Query {
     constructor(text, args, state, statementName, columns) {
         this.text = text;
         this.args = args;
@@ -25,4 +22,3 @@ class Query {
         this.state = state;
     }
 }
-exports.Query = Query;

package/dist/queue.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-class Queue {
+export class Queue {
     constructor() {
         this._queue = new Array();
         this._pointer = 0;
@@ -36,4 +33,3 @@ class Queue {
     }
     get isFree() { return this._pointer >= this._queue.length; }
 }
-exports.Queue = Queue;

package/dist/security/md5.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encryptMd5 = void 0;
-const crypto_1 = require("crypto");
-const encryptMd5 = (password, user, salt) => {
-    const stage1 = (0, crypto_1.createHash)('md5').update(password + user).digest('hex');
-    const stage2 = (0, crypto_1.createHash)('md5')
+import { createHash } from "crypto";
+export const encryptMd5 = (password, user, salt) => {
+    const stage1 = createHash('md5').update(password + user).digest('hex');
+    const stage2 = createHash('md5')
         .update(Buffer.concat([Buffer.from(stage1), salt]))
         .digest('hex');
     return 'md5' + stage2;
 };
-exports.encryptMd5 = encryptMd5;

package/dist/security/sasl.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateNonce = generateNonce;
-exports.calculateScramAuth = calculateScramAuth;
-const crypto_1 = require("crypto");
-function generateNonce() {
-    return (0, crypto_1.randomBytes)(18).toString('base64').replace(/[^a-zA-Z0-9]/g, '').substring(0, 24);
+import { randomBytes, createHmac, pbkdf2Sync, createHash } from 'crypto';
+export function generateNonce() {
+    return randomBytes(18).toString('base64').replace(/[^a-zA-Z0-9]/g, '').substring(0, 24);
 }
 function hmac(key, data) {
-    return (0, crypto_1.createHmac)('sha256', key).update(data).digest();
+    return createHmac('sha256', key).update(data).digest();
 }
 function hi(password, salt, iterations) {
-    return (0, crypto_1.pbkdf2Sync)(password, salt, iterations, 32, 'sha256');
+    return pbkdf2Sync(password, salt, iterations, 32, 'sha256');
 }
-function calculateScramAuth(password, saltBase64, iterations, authMessage) {
+export function calculateScramAuth(password, saltBase64, iterations, authMessage) {
     const salt = Buffer.from(saltBase64, 'base64');
     const saltedPassword = hi(password, salt, iterations);
     const clientKey = hmac(saltedPassword, 'Client Key');
-    const storedKey = (0, crypto_1.createHash)('sha256').update(clientKey).digest();
+    const storedKey = createHash('sha256').update(clientKey).digest();
     const clientSignature = hmac(storedKey, authMessage);
     const clientProofBuf = Buffer.alloc(32);
     for (let i = 0; i < 32; i++) {