@m2k-5f/pgtx 1.4.11 → 2.0.0

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionRequestWriter = exports.ConnectionRequestBuffer = void 0;
+const constants_1 = require("./constants");
+class ConnectionRequestBuffer {
+    constructor(buffer, offset = 0, lastRequestLenByteOffset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+        this.lastRequestLenByteOffset = lastRequestLenByteOffset;
+    }
+    static new(capacity) {
+        return new ConnectionRequestBuffer(Buffer.alloc(capacity));
+    }
+    ensureCapacity(needed) {
+        const required = needed + this.offset;
+        if (required <= this.buffer.length)
+            return;
+        let newCapacity = this.buffer.length * 2;
+        if (newCapacity < required) {
+            newCapacity = required;
+        }
+        const buffer = Buffer.alloc(newCapacity);
+        this.buffer.copy(buffer, 0, 0, this.offset);
+        this.buffer = buffer;
+        return this;
+    }
+    writeCString(string) {
+        this.ensureCapacity(Buffer.byteLength(string) + 1);
+        this.offset += this.buffer.write(string, this.offset, 'utf-8');
+        this.buffer[this.offset] = 0;
+        this.offset++;
+        return this;
+    }
+    writeString(string) {
+        this.ensureCapacity(Buffer.byteLength(string));
+        this.offset += this.buffer.write(string, this.offset, 'utf-8');
+        return this;
+    }
+    writeInt32(number) {
+        this.ensureCapacity(4);
+        this.buffer.writeInt32BE(number, this.offset);
+        this.offset += 4;
+        return this;
+    }
+    writeInt16(number) {
+        this.ensureCapacity(2);
+        this.buffer.writeInt16BE(number, this.offset);
+        this.offset += 2;
+        return this;
+    }
+    writeChar(char) {
+        this.ensureCapacity(1);
+        this.buffer[this.offset] = char.charCodeAt(0);
+        this.offset++;
+        return this;
+    }
+    startRequest(requestType) {
+        this.writeChar(requestType);
+        this.lastRequestLenByteOffset = this.offset;
+        return this.writeInt32(0);
+    }
+    startMessage() {
+        this.lastRequestLenByteOffset = this.offset;
+        return this.writeInt32(0);
+    }
+    endRequest() {
+        this.buffer.writeInt32BE(this.offset - (this.lastRequestLenByteOffset), this.lastRequestLenByteOffset);
+        return this;
+    }
+    asBuffer() {
+        return this.buffer.subarray(0, this.offset);
+    }
+    clear() {
+        this.offset = 0;
+        this.lastRequestLenByteOffset = 0;
+    }
+}
+exports.ConnectionRequestBuffer = ConnectionRequestBuffer;
+class ConnectionRequestWriter {
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    static new() {
+        return new ConnectionRequestWriter(ConnectionRequestBuffer.new(65536));
+    }
+    writeQuery(text) {
+        this.buffer.startRequest(constants_1.RequestTypes.SimpleQuery)
+            .writeCString(text)
+            .endRequest();
+        return this;
+    }
+    writeParse(name, text) {
+        this.buffer.startRequest(constants_1.RequestTypes.Parse)
+            .writeCString(name)
+            .writeCString(text)
+            .writeInt16(0)
+            .endRequest();
+        return this;
+    }
+    writeDescribe(statementName) {
+        this.buffer.startRequest(constants_1.RequestTypes.Describe)
+            .writeChar('S')
+            .writeCString(statementName)
+            .endRequest();
+        return this;
+    }
+    writeBind(portName, statementName, params) {
+        const request = this.buffer.startRequest(constants_1.RequestTypes.Bind)
+            .writeCString(portName)
+            .writeCString(statementName)
+            .writeInt16(0)
+            .writeInt16(params.length);
+        params.forEach(param => {
+            request.writeInt32(param ? Buffer.byteLength(param) : -1);
+            param && request.writeString(param);
+        });
+        request.writeInt16(0).endRequest();
+        return this;
+    }
+    writeClose(name) {
+        this.buffer.startRequest(constants_1.RequestTypes.Close)
+            .writeChar("P")
+            .writeCString(name)
+            .endRequest();
+        return this;
+    }
+    writeStartup(user, database) {
+        this.buffer.startMessage()
+            .writeInt32(196608)
+            .writeCString('user').writeCString(user)
+            .writeCString('database').writeCString(database)
+            .writeChar('\0')
+            .endRequest();
+        return this;
+    }
+    writeExecute(portName) {
+        this.buffer.startRequest(constants_1.RequestTypes.Execute)
+            .writeCString(portName)
+            .writeInt32(0)
+            .endRequest();
+        return this;
+    }
+    writeSync() {
+        this.buffer.startRequest(constants_1.RequestTypes.Sync).endRequest();
+        return this;
+    }
+    writePassword(password) {
+        this.buffer.startRequest(constants_1.RequestTypes.Password)
+            .writeCString(password)
+            .endRequest();
+        return this;
+    }
+    writeSaslInitial(mechanism, clientFirstMessage) {
+        this.buffer.startRequest(constants_1.RequestTypes.Password)
+            .writeCString(mechanism)
+            .writeInt32(Buffer.byteLength(clientFirstMessage, 'utf-8'))
+            .writeString(clientFirstMessage)
+            .endRequest();
+        return this;
+    }
+    writeSaslResponse(clientFinalMessage) {
+        this.buffer.startRequest(constants_1.RequestTypes.Password)
+            .writeString(clientFinalMessage)
+            .endRequest();
+        return this;
+    }
+    asBuffer() {
+        return this.buffer.asBuffer();
+    }
+    clear() {
+        this.buffer.clear();
+        return this;
+    }
+}
+exports.ConnectionRequestWriter = ConnectionRequestWriter;

package/dist/protocol/connection-response-reader.d.ts

@@ -0,0 +1,49 @@
+import { AuthenticationCode, ResponseType, TransactionStatus } from "./constants";
+import { ColumnDescription } from "../types";
+export declare class ConnectionResponseBuffer {
+    private buffer;
+    private caret;
+    private constructor();
+    static from(buffer: Buffer): ConnectionResponseBuffer;
+    readChar(): string;
+    readInt32(): number;
+    readInt16(): number;
+    readCString(): string;
+    readRawString(length: number): string;
+    readBytes(length: number): Buffer;
+    hasMore(): boolean;
+    hasFullPacket(): boolean;
+    getResidualBuffer(): Buffer<ArrayBufferLike>;
+}
+export declare class ConnectionResponseReader {
+    private buffer;
+    private currentPacketLength;
+    private constructor();
+    static from(buffer: Buffer): ConnectionResponseReader;
+    readType(): ResponseType;
+    readAuthentication(): AuthenticationCode;
+    readMD5Salt(): Buffer<ArrayBufferLike>;
+    readParameterStatus(): {
+        name: string;
+        value: string;
+    };
+    readBackendKeyData(): {
+        PID: number;
+        secret: number;
+    };
+    readErrorResponse(): string;
+    readReadyForQuery(): TransactionStatus;
+    readSaslMechanisms(): string[];
+    readSaslMessage(): string;
+    readRowDescription(): ColumnDescription[];
+    readDataRow(): (string | null)[];
+    readCommandComplete(): string;
+    hasMore(): boolean;
+    hasFullPacket(): boolean;
+    getResidualBuffer(): Buffer<ArrayBufferLike>;
+    readParseComplete(): void;
+    readBindComplete(): void;
+    readParameterDescription(): void;
+    readNoData(): void;
+}
+//# sourceMappingURL=connection-response-reader.d.ts.map

package/dist/protocol/connection-response-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-response-reader.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-response-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,KAAK,CAAI;IAEjB,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ,IAAI,MAAM;IAOlB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,WAAW,IAAI,MAAM;IAQrB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOrC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOjC,OAAO,IAAI,OAAO;IAKlB,aAAa,IAAI,OAAO;IAaxB,iBAAiB;CAGpB;AAGD,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,mBAAmB,CAAK;IAEhC,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ,IAC6B,YAAY;IAIjD,kBAAkB,IAGoB,kBAAkB;IAIxD,WAAW;IAKX,mBAAmB;;;;IAUnB,kBAAkB;;;;IAUlB,iBAAiB;IAgBjB,iBAAiB,IAEoB,iBAAiB;IAItD,kBAAkB,IAAI,MAAM,EAAE;IAa9B,eAAe,IAAI,MAAM;IAOzB,kBAAkB;IAuBlB,WAAW;IAmBX,mBAAmB,IAAI,MAAM;IAM7B,OAAO;IAKP,aAAa;IAKb,iBAAiB;IAKjB,iBAAiB;IAKjB,gBAAgB;IAKhB,wBAAwB;IAQxB,UAAU;CAGb"}

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

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionResponseReader = exports.ConnectionResponseBuffer = void 0;
+class ConnectionResponseBuffer {
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.caret = 0;
+    }
+    static from(buffer) {
+        return new ConnectionResponseBuffer(buffer);
+    }
+    readChar() {
+        const char = String.fromCharCode(this.buffer[this.caret]);
+        this.caret += 1;
+        return char;
+    }
+    readInt32() {
+        const value = this.buffer.readInt32BE(this.caret);
+        this.caret += 4;
+        return value;
+    }
+    readInt16() {
+        const value = this.buffer.readInt16BE(this.caret);
+        this.caret += 2;
+        return value;
+    }
+    readCString() {
+        const end = this.buffer.indexOf(0, this.caret);
+        const text = this.buffer.toString('utf-8', this.caret, end);
+        this.caret = end + 1;
+        return text;
+    }
+    readRawString(length) {
+        const text = this.buffer.toString('utf-8', this.caret, this.caret + length);
+        this.caret += length;
+        return text;
+    }
+    readBytes(length) {
+        const slice = this.buffer.subarray(this.caret, this.caret + length);
+        this.caret += length;
+        return slice;
+    }
+    hasMore() {
+        return this.caret < this.buffer.length;
+    }
+    hasFullPacket() {
+        const availableBytes = this.buffer.length - this.caret;
+        if (availableBytes < 5)
+            return false;
+        const packetLength = this.buffer.readInt32BE(this.caret + 1);
+        if (availableBytes < 1 + packetLength)
+            return false;
+        return true;
+    }
+    getResidualBuffer() {
+        return this.buffer.subarray(this.caret);
+    }
+}
+exports.ConnectionResponseBuffer = ConnectionResponseBuffer;
+class ConnectionResponseReader {
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.currentPacketLength = 0;
+    }
+    static from(buffer) {
+        return new ConnectionResponseReader(ConnectionResponseBuffer.from(buffer));
+    }
+    readType() {
+        return this.buffer.readChar();
+    }
+    readAuthentication() {
+        this.currentPacketLength = this.buffer.readInt32();
+        return this.buffer.readInt32();
+    }
+    readMD5Salt() {
+        return this.buffer.readBytes(4);
+    }
+    readParameterStatus() {
+        this.buffer.readInt32();
+        return {
+            name: this.buffer.readCString(),
+            value: this.buffer.readCString()
+        };
+    }
+    readBackendKeyData() {
+        this.buffer.readInt32();
+        return {
+            PID: this.buffer.readInt32(),
+            secret: this.buffer.readInt32()
+        };
+    }
+    readErrorResponse() {
+        this.buffer.readInt32();
+        let message = '';
+        while (true) {
+            const marker = this.buffer.readChar();
+            if (marker === '\0')
+                break;
+            const text = this.buffer.readCString();
+            if (marker === 'M')
+                message += text;
+        }
+        return message;
+    }
+    readReadyForQuery() {
+        this.buffer.readInt32();
+        return this.buffer.readChar();
+    }
+    readSaslMechanisms() {
+        const mechanisms = [];
+        while (true) {
+            const mech = this.buffer.readCString();
+            if (mech === "")
+                break;
+            mechanisms.push(mech);
+        }
+        return mechanisms;
+    }
+    readSaslMessage() {
+        const dataLength = this.currentPacketLength - 4 - 4;
+        return this.buffer.readRawString(dataLength);
+    }
+    readRowDescription() {
+        this.buffer.readInt32();
+        const columnsCount = this.buffer.readInt16();
+        const columns = new Array(columnsCount);
+        for (let i = 0; i < columnsCount; i++) {
+            const name = this.buffer.readCString();
+            this.buffer.readInt32();
+            this.buffer.readInt16();
+            columns[i] = {
+                name: name,
+                typeOID: this.buffer.readInt32(),
+            };
+            this.buffer.readInt32();
+            this.buffer.readInt32();
+        }
+        return columns;
+    }
+    readDataRow() {
+        this.buffer.readInt32();
+        const fieldsCount = this.buffer.readInt16();
+        const rowValues = [];
+        for (let i = 0; i < fieldsCount; i++) {
+            const fieldLength = this.buffer.readInt32();
+            if (fieldLength === -1) {
+                rowValues.push(null);
+            }
+            else {
+                rowValues.push(this.buffer.readRawString(fieldLength));
+            }
+        }
+        return rowValues;
+    }
+    readCommandComplete() {
+        this.buffer.readInt32();
+        return this.buffer.readCString();
+    }
+    hasMore() {
+        return this.buffer.hasMore();
+    }
+    hasFullPacket() {
+        return this.buffer.hasFullPacket();
+    }
+    getResidualBuffer() {
+        return this.buffer.getResidualBuffer();
+    }
+    readParseComplete() {
+        this.buffer.readInt32();
+    }
+    readBindComplete() {
+        this.buffer.readInt32();
+    }
+    readParameterDescription() {
+        this.buffer.readInt32();
+        const count = this.buffer.readInt16();
+        for (let i = 0; i < count; i++) {
+            this.buffer.readInt32();
+        }
+    }
+    readNoData() {
+        this.buffer.readInt32();
+    }
+}
+exports.ConnectionResponseReader = ConnectionResponseReader;

package/dist/protocol/constants.d.ts

@@ -0,0 +1,46 @@
+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";
+};
+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";
+};
+export type ResponseType = ValueOF<typeof ResponseTypes>;
+export declare const AuthenticationCodes: {
+    readonly Ok: 0;
+    readonly CleartextPassword: 3;
+    readonly MD5Password: 5;
+    readonly SASL: 10;
+    readonly SASLContinue: 11;
+    readonly SASLFinal: 12;
+};
+export type AuthenticationCode = ValueOF<typeof AuthenticationCodes>;
+export declare const TransactionStatuses: {
+    readonly Idle: "I";
+    readonly InTransactionBlock: "T";
+    readonly FailedTransactionBlock: "E";
+};
+export type TransactionStatus = ValueOF<typeof TransactionStatuses>;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;CAgBhB,CAAA;AAGV,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"}

package/dist/protocol/constants.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionStatuses = exports.AuthenticationCodes = exports.ResponseTypes = exports.RequestTypes = void 0;
+exports.RequestTypes = {
+    SimpleQuery: "Q",
+    Parse: "P",
+    Bind: "B",
+    Execute: "E",
+    Sync: "S",
+    Password: "p",
+    Describe: 'D',
+    Close: "C"
+};
+exports.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"
+};
+exports.AuthenticationCodes = {
+    Ok: 0,
+    CleartextPassword: 3,
+    MD5Password: 5,
+    SASL: 10,
+    SASLContinue: 11,
+    SASLFinal: 12,
+};
+exports.TransactionStatuses = {
+    Idle: "I",
+    InTransactionBlock: "T",
+    FailedTransactionBlock: "E",
+};

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

@@ -0,0 +1,11 @@
+import { Socket } from "node:net";
+import { ConnectionRequestWriter } from "./connection-request-writer";
+export type AuthorizationParams = {
+    host: string;
+    port: number;
+    user: string;
+    database: string;
+    password?: string;
+};
+export declare const createAuthorizedSocket: (writer: ConnectionRequestWriter, params: AuthorizationParams) => Promise<Socket>;
+//# sourceMappingURL=socket-authorization.d.ts.map

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

@@ -0,0 +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"}

package/dist/protocol/socket-authorization.js

@@ -0,0 +1,95 @@
+"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)();
+        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) => {
+            writer.clear();
+            switch (type) {
+                case constants_1.ResponseTypes.Authentication: {
+                    switch (reader.readAuthentication()) {
+                        case constants_1.AuthenticationCodes.Ok: break;
+                        case constants_1.AuthenticationCodes.CleartextPassword: {
+                            if (!params.password)
+                                throw new Error('The authorization method requires a password.');
+                            connector.write(writer.writePassword(params.password));
+                            break;
+                        }
+                        case constants_1.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);
+                            connector.write(writer.writePassword(password));
+                            break;
+                        }
+                        case constants_1.AuthenticationCodes.SASL: {
+                            reader.readSaslMechanisms();
+                            if (!params.password)
+                                throw new Error('The authorization method requires a password.');
+                            clientMessage = `n=${params.user},r=${nonce}`;
+                            connector.write(writer.writeSaslInitial('SCRAM-SHA-256', `n,,${clientMessage}`));
+                            break;
+                        }
+                        case constants_1.AuthenticationCodes.SASLContinue: {
+                            serverMessage = reader.readSaslMessage();
+                            if (!params.password)
+                                throw new Error('The authorization method requires a password.');
+                            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");
+                            }
+                            const clientFinalMessageWithoutProof = `c=biws,r=${serverNonce}`;
+                            const authMessage = `${clientMessage},${serverMessage},${clientFinalMessageWithoutProof}`;
+                            const { clientProof } = (0, sasl_1.calculateScramAuth)(params.password, saltBase64, iterations, authMessage);
+                            const clientFinalMessage = `${clientFinalMessageWithoutProof},p=${clientProof}`;
+                            connector.write(writer.writeSaslResponse(clientFinalMessage));
+                            break;
+                        }
+                        case constants_1.AuthenticationCodes.SASLFinal: {
+                            reader.readSaslMessage();
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case constants_1.ResponseTypes.ParamaterStatus: {
+                    reader.readParameterStatus();
+                    break;
+                }
+                case constants_1.ResponseTypes.ErrorResponse: {
+                    const message = reader.readErrorResponse();
+                    connector.destroy();
+                    reject(message);
+                    return;
+                }
+                case constants_1.ResponseTypes.BackendKeyData: {
+                    reader.readBackendKeyData();
+                }
+                case constants_1.ResponseTypes.ReadyForQuery: {
+                    reader.readReadyForQuery();
+                    resolve(connector.unwrapSocket());
+                    return;
+                }
+            }
+        }, error => {
+            reject(error);
+        });
+        connector.write(writer.writeStartup(params.user, params.database));
+        writer.clear();
+    });
+};
+exports.createAuthorizedSocket = createAuthorizedSocket;

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

@@ -0,0 +1,17 @@
+import { Socket } from 'net';
+import { ResponseType } from './constants';
+import { ConnectionResponseReader } from '../protocol/connection-response-reader';
+import { ConnectionRequestWriter } from '../protocol/connection-request-writer';
+export declare class SocketConnector {
+    private _socket;
+    private _onData;
+    private _onError;
+    private residualBuffer;
+    private _isDestroyed;
+    constructor(_socket: Socket, _onData: (type: ResponseType, reader: ConnectionResponseReader) => void, _onError: (error: Error) => void);
+    write(writer: ConnectionRequestWriter): void;
+    unwrapSocket(): Socket;
+    destroy(): void;
+    get isDestroyed(): boolean;
+}
+//# sourceMappingURL=socket-connector.d.ts.map

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

@@ -0,0 +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;IAKpB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IANpB,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,YAAY,CAAQ;gBAGhB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,wBAAwB,KAAK,IAAI,EACvE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;IA4B5C,KAAK,CAAC,MAAM,EAAE,uBAAuB;IAOrC,YAAY;IAQZ,OAAO;IAMP,IAAI,WAAW,YAA6B;CAC/C"}