@m2k-5f/pgtx 2.7.1 → 2.7.3

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

@@ -1,4 +1,4 @@
-import { DataTypeOids } from "./constants";
+import { DataTypeOids, INT4Length } from "./constants";
 import { PostgresError } from "../error";
 const columnValueCache = new Map();
 const POSTGRES_EPOCH_MS = 946684800000;
@@ -39,16 +39,14 @@ export class ConnectionResponseBuffer {
     hasMore() {
         return this.caret < this.buffer.length;
     }
-    readRawBinaryString(length) {
-        const text = this.buffer.toString('latin1', this.caret, this.caret + length);
-        this.caret += length;
-        return text;
-    }
     readBinaryDate() {
         const daysSince2000 = this.readInt32();
         const ms = POSTGRES_EPOCH_MS + (daysSince2000 * 86400000);
         return new Date(ms);
     }
+    readByte() {
+        return this.buffer[this.caret++];
+    }
     readBinaryTimestamp() {
         const microSecondsSince2000 = this.readInt64();
         const msSince2000 = Number(microSecondsSince2000 / 1000);
@@ -94,6 +92,53 @@ export class ConnectionResponseBuffer {
         this.caret += 8;
         return (hi * 4294967296) + lo;
     }
+    readNumeric() {
+        const ndigits = this.readInt16();
+        const weight = this.readInt16();
+        const sign = this.readInt16();
+        const dscale = this.readInt16();
+        if (sign === 0xC000 || sign === -16384)
+            return 'NaN';
+        const digits = new Array(ndigits);
+        for (let i = 0; i < ndigits; i++) {
+            digits[i] = this.readInt16();
+        }
+        const highExp = Math.max(weight, 0);
+        const lowExp = Math.min(weight - ndigits + 1, -1);
+        let intPart = '';
+        for (let exp = highExp; exp >= 0; exp--) {
+            const idx = weight - exp;
+            const digit = (idx >= 0 && idx < ndigits) ? digits[idx] : 0;
+            intPart += exp === highExp ? String(digit) : String(digit).padStart(4, '0');
+        }
+        if (intPart === '')
+            intPart = '0';
+        let fracPart = '';
+        for (let exp = -1; exp >= lowExp; exp--) {
+            const idx = weight - exp;
+            const digit = (idx >= 0 && idx < ndigits) ? digits[idx] : 0;
+            fracPart += String(digit).padStart(4, '0');
+        }
+        if (dscale > 0) {
+            fracPart = fracPart.padEnd(dscale, '0').slice(0, dscale);
+        }
+        else {
+            fracPart = '';
+        }
+        const negative = sign === 0x4000 || sign === 16384;
+        const result = fracPart ? `${intPart}.${fracPart}` : intPart;
+        return negative ? `-${result}` : result;
+    }
+    readBinaryTimetz() {
+        const time = this.readBinaryTime();
+        const zoneOffsetSeconds = this.readInt32();
+        const offsetMinutesTotal = -zoneOffsetSeconds / 60;
+        const sign = offsetMinutesTotal >= 0 ? '+' : '-';
+        const abs = Math.abs(offsetMinutesTotal);
+        const offH = Math.floor(abs / 60);
+        const offM = abs % 60;
+        return `${time}${sign}${String(offH).padStart(2, '0')}:${String(offM).padStart(2, '0')}`;
+    }
     readFloat32() {
         const value = this.buffer.readFloatBE(this.caret);
         this.caret += 4;
@@ -127,33 +172,25 @@ export class ConnectionResponseBuffer {
         }
         return hash >>> 0;
     }
-}
-export class ConnectionResponseReader {
-    constructor(buffer) {
-        this.buffer = buffer;
-    }
-    static from(buffer) {
-        return new ConnectionResponseReader(ConnectionResponseBuffer.from(buffer));
-    }
     readType() {
-        return { type: this.buffer.readChar(), length: this.buffer.readInt32() };
+        return { type: this.readByte(), length: this.readInt32() - INT4Length };
     }
     readAuthentication() {
-        return this.buffer.readInt32();
+        return this.readInt32();
     }
     readMD5Salt() {
-        return this.buffer.readBytes(4);
+        return this.readBytes(4);
     }
     readParameterStatus() {
         return {
-            name: this.buffer.readCString(),
-            value: this.buffer.readCString()
+            name: this.readCString(),
+            value: this.readCString()
         };
     }
     readBackendKeyData() {
         return {
-            PID: this.buffer.readInt32(),
-            secret: this.buffer.readInt32()
+            PID: this.readInt32(),
+            secret: this.readInt32()
         };
     }
     readErrorResponse() {
@@ -167,10 +204,10 @@ export class ConnectionResponseReader {
         let dataType = '';
         let constraint = '';
         while (true) {
-            const marker = this.buffer.readChar();
+            const marker = this.readChar();
             if (marker === '\0')
                 break;
-            const text = this.buffer.readCString();
+            const text = this.readCString();
             switch (marker) {
                 case 'S':
                     severity = text;
@@ -204,12 +241,12 @@ export class ConnectionResponseReader {
         return new PostgresError(message, code, detail, severity, where, hint, position, dataType, constraint);
     }
     readReadyForQuery() {
-        return this.buffer.readChar();
+        return this.readByte();
     }
     readSaslMechanisms() {
         const mechanisms = [];
         while (true) {
-            const mech = this.buffer.readCString();
+            const mech = this.readCString();
             if (mech === "")
                 break;
             mechanisms.push(mech);
@@ -217,29 +254,29 @@ export class ConnectionResponseReader {
         return mechanisms;
     }
     readSaslMessage(length) {
-        return this.buffer.readRawString(length - 4 - 4);
+        return this.readRawString(length - 4);
     }
     readRowDescription() {
-        const columnsCount = this.buffer.readInt16();
+        const columnsCount = this.readInt16();
         const columns = new Array(columnsCount);
         for (let i = 0; i < columnsCount; i++) {
-            const name = this.buffer.readCString();
-            this.buffer.readInt32();
-            this.buffer.readInt16();
+            const name = this.readCString();
+            this.readInt32();
+            this.readInt16();
             columns[i] = {
                 name: name,
-                typeOID: this.buffer.readInt32(),
+                typeOID: this.readInt32(),
             };
-            this.buffer.readInt32();
-            this.buffer.readInt32();
+            this.readInt32();
+            this.readInt32();
         }
         return columns;
     }
     readDataRow(descriptions, int8toBigint) {
-        const fieldsCount = this.buffer.readInt16();
+        const fieldsCount = this.readInt16();
         const row = {};
         for (let i = 0; i < fieldsCount; i++) {
-            const fieldLength = this.buffer.readInt32();
+            const fieldLength = this.readInt32();
             const desc = descriptions[i];
             const key = desc.name;
             if (fieldLength === -1) {
@@ -259,89 +296,105 @@ export class ConnectionResponseReader {
                                 cacheForColumn = new Map();
                                 columnValueCache.set(i, cacheForColumn);
                             }
-                            const byteHash = this.buffer.getBufferHash(fieldLength);
+                            const byteHash = this.getBufferHash(fieldLength);
                             let cachedString = cacheForColumn.get(byteHash);
                             if (cachedString === undefined) {
-                                cachedString = this.buffer.readRawString(fieldLength);
-                                if (cacheForColumn.size < 512) {
-                                    cacheForColumn.set(byteHash, cachedString);
+                                cachedString = this.readRawString(fieldLength);
+                                if (cacheForColumn.size > 512) {
+                                    cacheForColumn.clear();
                                 }
+                                cacheForColumn.set(byteHash, cachedString);
                             }
                             else {
-                                this.buffer.skipBytes(fieldLength);
+                                this.skipBytes(fieldLength);
                             }
                             row[key] = cachedString;
                         }
                         else {
-                            row[key] = this.buffer.readRawString(fieldLength);
+                            row[key] = this.readRawString(fieldLength);
                         }
                     }
                     break;
                 case DataTypeOids.Int2:
                     {
-                        row[key] = this.buffer.readInt16();
+                        row[key] = this.readInt16();
                     }
                     break;
                 case DataTypeOids.Int4:
                     {
-                        row[key] = this.buffer.readInt32();
+                        row[key] = this.readInt32();
                     }
                     break;
                 case DataTypeOids.Int8:
                     {
-                        row[key] = int8toBigint ? this.buffer.readBigInt64() : this.buffer.readInt64();
+                        row[key] = int8toBigint ? this.readBigInt64() : this.readInt64();
                     }
                     break;
                 case DataTypeOids.Float4:
                     {
-                        row[key] = this.buffer.readFloat32();
+                        row[key] = this.readFloat32();
                     }
                     break;
                 case DataTypeOids.Float8:
                     {
-                        row[key] = this.buffer.readFloat64();
+                        row[key] = this.readFloat64();
                     }
                     break;
                 case DataTypeOids.Bool:
                     {
-                        row[key] = this.buffer.readBool();
+                        row[key] = this.readBool();
                     }
                     break;
                 case DataTypeOids.Bytea:
                     {
-                        row[key] = this.buffer.readBytes(fieldLength);
+                        row[key] = this.readBytes(fieldLength);
                     }
                     break;
                 case DataTypeOids.Jsonb:
                     {
-                        this.buffer.skipBytes(1);
-                        row[key] = JSON.parse(this.buffer.readRawString(fieldLength - 1));
+                        this.skipBytes(1);
+                        row[key] = JSON.parse(this.readRawString(fieldLength - 1));
                     }
                     break;
                 case DataTypeOids.Json:
                     {
-                        row[key] = JSON.parse(this.buffer.readRawString(fieldLength));
+                        row[key] = JSON.parse(this.readRawString(fieldLength));
                     }
                     break;
                 case DataTypeOids.Date:
                     {
-                        row[key] = this.buffer.readBinaryDate();
+                        row[key] = this.readBinaryDate();
                     }
                     break;
                 case DataTypeOids.Timestamp:
                 case DataTypeOids.Timestamptz:
                     {
-                        row[key] = this.buffer.readBinaryTimestamp();
+                        row[key] = this.readBinaryTimestamp();
                     }
                     break;
                 case DataTypeOids.Uuid:
                     {
-                        row[key] = this.buffer.readUuid();
+                        row[key] = this.readUuid();
+                    }
+                    break;
+                case DataTypeOids.Time:
+                    {
+                        row[key] = this.readBinaryTime();
+                    }
+                    break;
+                case DataTypeOids.Timetz:
+                    {
+                        row[key] = this.readBinaryTimetz();
+                    }
+                    break;
+                case DataTypeOids.Numeric:
+                    {
+                        row[key] = this.readNumeric();
                     }
                     break;
                 default:
                     {
-                        this.buffer.skipBytes(fieldLength);
+                        this.skipBytes(fieldLength);
                         row[key] = null;
                     }
                     break;
@@ -350,33 +403,20 @@ export class ConnectionResponseReader {
         return row;
     }
     readNotificationResponse() {
-        this.buffer.readInt32();
-        const name = this.buffer.readCString();
-        const payload = this.buffer.readCString();
+        this.readInt32();
+        const name = this.readCString();
+        const payload = this.readCString();
         return { name, payload };
     }
     readCommandComplete() {
-        return this.buffer.readCString();
-    }
-    hasMore() {
-        return this.buffer.hasMore();
-    }
-    hasFullPacket() {
-        return this.buffer.hasFullPacket();
-    }
-    getResidualBuffer() {
-        return this.buffer.getResidualBuffer();
+        return this.readCString();
     }
-    readParseComplete() { }
-    readBindComplete() { }
     readParameterDescription() {
-        const count = this.buffer.readInt16();
+        const count = this.readInt16();
+        const description = Array(count);
         for (let i = 0; i < count; i++) {
-            this.buffer.readInt32();
+            description[i] = this.readInt32();
         }
-    }
-    readNoData() { }
-    skip(count) {
-        this.buffer.skipBytes(count);
+        return description;
     }
 }

package/dist/protocol/constants.d.ts

@@ -1,35 +1,36 @@
 import { ValueOF } from "../types";
 export declare const RequestTypes: {
-    readonly SimpleQuery: "Q";
-    readonly Parse: "P";
-    readonly Bind: "B";
-    readonly Execute: "E";
-    readonly Sync: "S";
-    readonly Password: "p";
-    readonly Describe: "D";
-    readonly Close: "C";
+    readonly SimpleQuery: 81;
+    readonly Parse: 80;
+    readonly Bind: 66;
+    readonly Execute: 69;
+    readonly Sync: 83;
+    readonly Password: 112;
+    readonly Describe: 68;
+    readonly Close: 67;
 };
 export type RequestType = ValueOF<typeof RequestTypes>;
 export declare const ResponseTypes: {
-    readonly RowDescription: "T";
-    readonly DataRow: "D";
-    readonly ComandComplete: "C";
-    readonly ReadyForQuery: "Z";
-    readonly ErrorResponse: "E";
-    readonly NoticeResponse: "N";
-    readonly Authentication: "R";
-    readonly BackendKeyData: "K";
-    readonly ParamaterStatus: "S";
-    readonly ParseComplete: "1";
-    readonly BindComplete: "2";
-    readonly CloseComplete: "3";
-    readonly ParameterDescription: "t";
-    readonly NoData: "n";
-    readonly Notice: "N";
-    readonly NotificationResponse: "A";
-    readonly SSLOk: "S";
-    readonly SSLDenied: "N";
+    readonly RowDescription: 84;
+    readonly DataRow: 68;
+    readonly ComandComplete: 67;
+    readonly ReadyForQuery: 90;
+    readonly ErrorResponse: 69;
+    readonly NoticeResponse: 78;
+    readonly Authentication: 82;
+    readonly BackendKeyData: 75;
+    readonly ParamaterStatus: 83;
+    readonly ParseComplete: 49;
+    readonly BindComplete: 50;
+    readonly CloseComplete: 51;
+    readonly ParameterDescription: 116;
+    readonly NoData: 110;
+    readonly Notice: 78;
+    readonly NotificationResponse: 65;
+    readonly SSLOk: 83;
+    readonly SSLDenied: 78;
 };
+export type ResponseType = ValueOF<typeof ResponseTypes>;
 export declare const DataTypeOids: {
     readonly Bool: 16;
     readonly Bytea: 17;
@@ -78,7 +79,7 @@ export declare const DataTypeOids: {
     readonly NumericArray: 1231;
 };
 export type DataTypeOid = typeof DataTypeOids[keyof typeof DataTypeOids];
-export type ResponseType = ValueOF<typeof ResponseTypes>;
+export declare const INT4Length = 4;
 export declare const AuthenticationCodes: {
     readonly Ok: 0;
     readonly CleartextPassword: 3;
@@ -89,9 +90,15 @@ export declare const AuthenticationCodes: {
 };
 export type AuthenticationCode = ValueOF<typeof AuthenticationCodes>;
 export declare const TransactionStatuses: {
-    readonly Idle: "I";
-    readonly InTransactionBlock: "T";
-    readonly FailedTransactionBlock: "E";
+    readonly Idle: 73;
+    readonly InTransactionBlock: 84;
+    readonly FailedTransactionBlock: 69;
 };
 export type TransactionStatus = ValueOF<typeof TransactionStatuses>;
+export declare const DescribeType: {
+    readonly Statement: "S";
+    readonly Portal: "P";
+};
+export type DescribeType = ValueOF<typeof DescribeType>;
+export declare const EMPTY_ARRAY: never[];
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/protocol/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAElC,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAA;AAGtD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CAmBhB,CAAA;AAGV,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAIzE,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,aAAa,CAAC,CAAA;AAGxD,eAAO,MAAM,mBAAmB;;;;;;;CAOtB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAGpE,eAAO,MAAM,mBAAmB;;;;CAItB,CAAA;AAEV,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/protocol/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAElC,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAA;AAGtD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CAmBhB,CAAA;AAEV,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,aAAa,CAAC,CAAA;AAGxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAEzE,eAAO,MAAM,UAAU,IAAI,CAAA;AAG3B,eAAO,MAAM,mBAAmB;;;;;;;CAOtB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAGpE,eAAO,MAAM,mBAAmB;;;;CAItB,CAAA;AAEV,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAGnE,eAAO,MAAM,YAAY;;;CAGf,CAAA;AAEV,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,eAAO,MAAM,WAAW,EAAwB,KAAK,EAAE,CAAA"}

package/dist/protocol/constants.js

@@ -1,32 +1,32 @@
 export const RequestTypes = {
-    SimpleQuery: "Q",
-    Parse: "P",
-    Bind: "B",
-    Execute: "E",
-    Sync: "S",
-    Password: "p",
-    Describe: 'D',
-    Close: "C"
+    SimpleQuery: 81, // "Q"
+    Parse: 80, // "P"
+    Bind: 66, // "B"
+    Execute: 69, // "E"
+    Sync: 83, // "S"
+    Password: 112, // "p"
+    Describe: 68, // "D"
+    Close: 67 // "C"
 };
 export const ResponseTypes = {
-    RowDescription: "T",
-    DataRow: "D",
-    ComandComplete: "C",
-    ReadyForQuery: "Z",
-    ErrorResponse: "E",
-    NoticeResponse: "N",
-    Authentication: "R",
-    BackendKeyData: "K",
-    ParamaterStatus: "S",
-    ParseComplete: "1",
-    BindComplete: "2",
-    CloseComplete: "3",
-    ParameterDescription: "t",
-    NoData: "n",
-    Notice: "N",
-    NotificationResponse: "A",
-    SSLOk: "S",
-    SSLDenied: "N"
+    RowDescription: 84, // "T"
+    DataRow: 68, // "D"
+    ComandComplete: 67, // "C"
+    ReadyForQuery: 90, // "Z"
+    ErrorResponse: 69, // "E"
+    NoticeResponse: 78, // "N"
+    Authentication: 82, // "R"
+    BackendKeyData: 75, // "K"
+    ParamaterStatus: 83, // "S"
+    ParseComplete: 49, // "1"
+    BindComplete: 50, // "2"
+    CloseComplete: 51, // "3"
+    ParameterDescription: 116, // "t"
+    NoData: 110, // "n"
+    Notice: 78, // "N"
+    NotificationResponse: 65, // "A"
+    SSLOk: 83, // "S"
+    SSLDenied: 78 // "N"
 };
 export const DataTypeOids = {
     Bool: 16,
@@ -75,6 +75,7 @@ export const DataTypeOids = {
     UuidArray: 2951,
     NumericArray: 1231
 };
+export const INT4Length = 4;
 export const AuthenticationCodes = {
     Ok: 0,
     CleartextPassword: 3,
@@ -84,7 +85,12 @@ export const AuthenticationCodes = {
     SASLFinal: 12,
 };
 export const TransactionStatuses = {
-    Idle: "I",
-    InTransactionBlock: "T",
-    FailedTransactionBlock: "E",
+    Idle: 73, // "I"
+    InTransactionBlock: 84, // "T"
+    FailedTransactionBlock: 69, // "E"
 };
+export const DescribeType = {
+    Statement: "S",
+    Portal: "P",
+};
+export const EMPTY_ARRAY = Object.freeze([]);

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":"AAKA,OAAO,EAA4J,aAAa,EAAE,MAAM,UAAU,CAAA;AAClM,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEtC,OAAO,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAA;AAEnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAI3C,eAAO,MAAM,YAAY,GAAI,QAAQ,gBAAgB,kCASpD,CAAA;AAGD,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,EAAE,QAAQ,gBAAgB,kCA+ErE,CAAA;AAGD,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,EAAE,QAAQ,gBAAgB,kCAyHvE,CAAA"}
+{"version":3,"file":"socket-authorization.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-authorization.ts"],"names":[],"mappings":"AAIA,OAAO,EAA4J,aAAa,EAAE,MAAM,UAAU,CAAA;AAClM,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEtC,OAAO,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAM3C,eAAO,MAAM,YAAY,GAAI,QAAQ,gBAAgB,kCASpD,CAAA;AAGD,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,EAAE,QAAQ,gBAAgB,kCA+ErE,CAAA;AAGD,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,EAAE,QAAQ,gBAAgB,kCAyHvE,CAAA"}

package/dist/protocol/socket-authorization.js

@@ -1,4 +1,3 @@
-import { ConnectionRequestWriter } from "./connection-request-writer";
 import { calculateScramAuth, generateNonce } from "../security/sasl";
 import { SocketConnector } from "./socket-connector";
 import { AuthenticationCodes, ResponseTypes } from "./constants";
@@ -8,6 +7,7 @@ import { Future } from "fluent-future";
 import { connect } from "node:tls";
 import { createConnection } from "node:net";
 import { readFileSync } from "node:fs";
+import { ConnectionRequestBuffer } from "./connection-request-writer";
 export const createSocket = (config) => {
     const { future, resolve, reject } = Future.withResolvers();
     const socket = createConnection({ host: config.host, port: config.port });
@@ -19,7 +19,7 @@ export const upgradeSocket = (socket, config) => {
     if (config.ssl === 'disable')
         return Future.resolve(socket);
     const { future, reject, resolve } = Future.withResolvers();
-    const writer = ConnectionRequestWriter.new();
+    const writer = ConnectionRequestBuffer.new(2048);
     const onError = () => {
         cleanup();
         reject(ErrSocketFailedDuringAuth);
@@ -84,7 +84,7 @@ export const upgradeSocket = (socket, config) => {
 };
 export const authorizeSocket = (socket, config) => {
     const { future, reject, resolve } = Future.withResolvers();
-    const writer = ConnectionRequestWriter.new();
+    const writer = ConnectionRequestBuffer.new(2048);
     const nonce = generateNonce();
     let clientMessage = '';
     let serverMessage = '';
@@ -127,7 +127,7 @@ export const authorizeSocket = (socket, config) => {
             case AuthenticationCodes.CleartextPassword:
                 {
                     if (!config.password)
-                        throw ErrPasswordRequired;
+                        return reject(ErrPasswordRequired);
                     connector.write(writer.writePassword(config.password));
                     writer.clear();
                 }
@@ -136,7 +136,7 @@ export const authorizeSocket = (socket, config) => {
                 {
                     const salt = reader.readMD5Salt();
                     if (!config.password)
-                        throw ErrPasswordRequired;
+                        return reject(ErrPasswordRequired);
                     const password = encryptMd5(config.password, config.user, salt);
                     connector.write(writer.writePassword(password));
                     writer.clear();
@@ -146,7 +146,7 @@ export const authorizeSocket = (socket, config) => {
                 {
                     reader.readSaslMechanisms();
                     if (!config.password)
-                        throw ErrPasswordRequired;
+                        return reject(ErrPasswordRequired);
                     clientMessage = `n=${config.user},r=${nonce}`;
                     connector.write(writer.writeSaslInitial('SCRAM-SHA-256', `n,,${clientMessage}`));
                     writer.clear();
@@ -156,7 +156,7 @@ export const authorizeSocket = (socket, config) => {
                 {
                     serverMessage = reader.readSaslMessage(length);
                     if (!config.password)
-                        throw ErrPasswordRequired;
+                        return reject(ErrPasswordRequired);
                     const parts = Object.fromEntries(serverMessage.split(',').map(x => x.split('=')));
                     const serverNonce = parts.r;
                     const saltBase64 = parts.s;

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

@@ -1,7 +1,7 @@
 import { Socket } from 'net';
 import { ResponseType } from './constants';
-import { ConnectionResponseReader } from '../protocol/connection-response-reader';
-import { ConnectionRequestWriter } from '../protocol/connection-request-writer';
+import { ConnectionResponseBuffer } from './connection-response-reader';
+import { ConnectionRequestBuffer } from './connection-request-writer';
 export declare class SocketConnector {
     private _socket;
     private residualBuffer;
@@ -9,8 +9,8 @@ export declare class SocketConnector {
     private _onClose;
     private _onData;
     private _destroyed;
-    constructor(_socket: Socket, onData: (type: ResponseType, length: number, reader: ConnectionResponseReader) => void, onError: (error: unknown) => void);
-    write(writer: ConnectionRequestWriter): void;
+    constructor(_socket: Socket, onData: (type: ResponseType, length: number, reader: ConnectionResponseBuffer) => void, onError: (error: unknown) => void);
+    write(writer: ConnectionRequestBuffer): void;
     unwrapSocket(): Socket;
     destroy(): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"socket-connector.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAA;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAA;AAE/E,qBAAa,eAAe;IAQpB,OAAO,CAAC,OAAO;IAPnB,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAAQ;gBAGd,OAAO,EAAE,MAAM,EACvB,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,KAAK,IAAI,EACtF,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI;IA4CrC,KAAK,CAAC,MAAM,EAAE,uBAAuB;IAKrC,YAAY;IASZ,OAAO;CAGV"}
+{"version":3,"file":"socket-connector.d.ts","sourceRoot":"","sources":["../../src/protocol/socket-connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAErE,qBAAa,eAAe;IAQpB,OAAO,CAAC,OAAO;IAPnB,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAAQ;gBAGd,OAAO,EAAE,MAAM,EACvB,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,KAAK,IAAI,EACtF,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI;IA4CrC,KAAK,CAAC,MAAM,EAAE,uBAAuB;IAKrC,YAAY;IASZ,OAAO;CAGV"}

package/dist/protocol/socket-connector.js

@@ -1,4 +1,4 @@
-import { ConnectionResponseReader } from '../protocol/connection-response-reader';
+import { ConnectionResponseBuffer } from './connection-response-reader';
 export class SocketConnector {
     constructor(_socket, onData, onError) {
         this._socket = _socket;
@@ -23,7 +23,7 @@ export class SocketConnector {
                 ? Buffer.concat([this.residualBuffer, buffer])
                 : buffer;
             this.residualBuffer = null;
-            const reader = ConnectionResponseReader.from(currentBuffer);
+            const reader = ConnectionResponseBuffer.from(currentBuffer);
             while (reader.hasMore()) {
                 if (!reader.hasFullPacket()) {
                     this.residualBuffer = reader.getResidualBuffer();