postgrejs 2.12.0

package/cjs/protocol/protocol.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Protocol = void 0;
+var Protocol;
+(function (Protocol) {
+    Protocol.VERSION_MAJOR = 3;
+    Protocol.VERSION_MINOR = 0;
+    // https://www.postgresql.org/docs/9.3/protocol-message-formats.html
+    let BackendMessageCode;
+    (function (BackendMessageCode) {
+        BackendMessageCode[BackendMessageCode["Authentication"] = 82] = "Authentication";
+        BackendMessageCode[BackendMessageCode["BackendKeyData"] = 75] = "BackendKeyData";
+        BackendMessageCode[BackendMessageCode["BindComplete"] = 50] = "BindComplete";
+        BackendMessageCode[BackendMessageCode["CloseComplete"] = 51] = "CloseComplete";
+        BackendMessageCode[BackendMessageCode["CommandComplete"] = 67] = "CommandComplete";
+        BackendMessageCode[BackendMessageCode["CopyData"] = 100] = "CopyData";
+        BackendMessageCode[BackendMessageCode["CopyDone"] = 99] = "CopyDone";
+        BackendMessageCode[BackendMessageCode["CopyInResponse"] = 103] = "CopyInResponse";
+        BackendMessageCode[BackendMessageCode["CopyOutResponse"] = 72] = "CopyOutResponse";
+        BackendMessageCode[BackendMessageCode["CopyBothResponse"] = 87] = "CopyBothResponse";
+        BackendMessageCode[BackendMessageCode["DataRow"] = 68] = "DataRow";
+        BackendMessageCode[BackendMessageCode["EmptyQueryResponse"] = 73] = "EmptyQueryResponse";
+        BackendMessageCode[BackendMessageCode["ErrorResponse"] = 69] = "ErrorResponse";
+        BackendMessageCode[BackendMessageCode["FunctionCallResponse"] = 86] = "FunctionCallResponse";
+        BackendMessageCode[BackendMessageCode["NegotiateProtocolVersion"] = 118] = "NegotiateProtocolVersion";
+        BackendMessageCode[BackendMessageCode["NoData"] = 110] = "NoData";
+        BackendMessageCode[BackendMessageCode["NoticeResponse"] = 78] = "NoticeResponse";
+        BackendMessageCode[BackendMessageCode["NotificationResponse"] = 65] = "NotificationResponse";
+        BackendMessageCode[BackendMessageCode["ParameterDescription"] = 116] = "ParameterDescription";
+        BackendMessageCode[BackendMessageCode["ParameterStatus"] = 83] = "ParameterStatus";
+        BackendMessageCode[BackendMessageCode["ParseComplete"] = 49] = "ParseComplete";
+        BackendMessageCode[BackendMessageCode["PortalSuspended"] = 115] = "PortalSuspended";
+        BackendMessageCode[BackendMessageCode["ReadyForQuery"] = 90] = "ReadyForQuery";
+        BackendMessageCode[BackendMessageCode["RowDescription"] = 84] = "RowDescription";
+    })(BackendMessageCode = Protocol.BackendMessageCode || (Protocol.BackendMessageCode = {}));
+    let FrontendMessageCode;
+    (function (FrontendMessageCode) {
+        FrontendMessageCode[FrontendMessageCode["Bind"] = 66] = "Bind";
+        FrontendMessageCode[FrontendMessageCode["Close"] = 67] = "Close";
+        FrontendMessageCode[FrontendMessageCode["CopyData"] = 100] = "CopyData";
+        FrontendMessageCode[FrontendMessageCode["CopyDone"] = 99] = "CopyDone";
+        FrontendMessageCode[FrontendMessageCode["CopyFail"] = 102] = "CopyFail";
+        FrontendMessageCode[FrontendMessageCode["Describe"] = 68] = "Describe";
+        FrontendMessageCode[FrontendMessageCode["Execute"] = 69] = "Execute";
+        FrontendMessageCode[FrontendMessageCode["Flush"] = 72] = "Flush";
+        FrontendMessageCode[FrontendMessageCode["FunctionCall"] = 70] = "FunctionCall";
+        FrontendMessageCode[FrontendMessageCode["Parse"] = 80] = "Parse";
+        FrontendMessageCode[FrontendMessageCode["PasswordMessage"] = 112] = "PasswordMessage";
+        FrontendMessageCode[FrontendMessageCode["Query"] = 81] = "Query";
+        FrontendMessageCode[FrontendMessageCode["Sync"] = 83] = "Sync";
+        FrontendMessageCode[FrontendMessageCode["Terminate"] = 88] = "Terminate";
+    })(FrontendMessageCode = Protocol.FrontendMessageCode || (Protocol.FrontendMessageCode = {}));
+    let AuthenticationMessageKind;
+    (function (AuthenticationMessageKind) {
+        AuthenticationMessageKind["KerberosV5"] = "KerberosV5";
+        AuthenticationMessageKind["CleartextPassword"] = "CleartextPassword";
+        AuthenticationMessageKind["MD5Password"] = "MD5Password";
+        AuthenticationMessageKind["SCMCredential"] = "SCMCredential";
+        AuthenticationMessageKind["GSS"] = "GSS";
+        AuthenticationMessageKind["SSPI"] = "SSPI";
+        AuthenticationMessageKind["GSSContinue"] = "GSSContinue";
+        AuthenticationMessageKind["SASL"] = "SASL";
+        AuthenticationMessageKind["SASLContinue"] = "SASLContinue";
+        AuthenticationMessageKind["SASLFinal"] = "SASLFinal";
+    })(AuthenticationMessageKind = Protocol.AuthenticationMessageKind || (Protocol.AuthenticationMessageKind = {}));
+    let DataFormat;
+    (function (DataFormat) {
+        DataFormat[DataFormat["text"] = 0] = "text";
+        DataFormat[DataFormat["binary"] = 1] = "binary";
+    })(DataFormat = Protocol.DataFormat || (Protocol.DataFormat = {}));
+})(Protocol || (exports.Protocol = Protocol = {}));

package/cjs/protocol/sasl.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SASL = void 0;
+/* eslint-disable no-bitwise */
+const crypto_1 = __importDefault(require("crypto"));
+var SASL;
+(function (SASL) {
+    const CLIENT_KEY = 'Client Key';
+    const SERVER_KEY = 'Server Key';
+    const GS2_HEADER = 'n,,';
+    function createSession(username, mechanism) {
+        const nonce = crypto_1.default.randomBytes(18).toString('base64');
+        const clientFirstMessage = `${GS2_HEADER}${firstMessageBare(username, nonce)}`;
+        return {
+            username,
+            mechanism,
+            nonce,
+            clientFirstMessage,
+        };
+    }
+    SASL.createSession = createSession;
+    function continueSession(session, password, data) {
+        const s = data.toString();
+        const items = s.split(',');
+        let nonce = '';
+        let salt = '';
+        let iteration = 0;
+        for (const i of items) {
+            switch (i[0]) {
+                case 'r':
+                    nonce = i.substring(2);
+                    break;
+                case 's':
+                    salt = i.substring(2);
+                    break;
+                case 'i':
+                    iteration = parseInt(i.substring(2), 10);
+                    break;
+            }
+        }
+        if (!nonce)
+            throw new Error('SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing');
+        if (!salt)
+            throw new Error('SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing');
+        if (!iteration)
+            throw new Error('SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing');
+        if (!nonce.startsWith(session.nonce))
+            throw new Error('SASL: Server nonce does not start with client nonce');
+        const serverFirstMessage = `r=${nonce},s=${salt},i=${iteration}`;
+        const clientFinalMessageWithoutProof = `c=${encode64(GS2_HEADER)},r=${nonce}`;
+        const authMessage = `${firstMessageBare(session.username, session.nonce)},${serverFirstMessage},${clientFinalMessageWithoutProof}`;
+        const saltPass = hi(password, salt, iteration);
+        const clientKey = hmac(saltPass, CLIENT_KEY);
+        const storedKey = hash(clientKey);
+        const clientSignature = hmac(storedKey, authMessage);
+        const clientProofBytes = xor(clientKey, clientSignature);
+        const clientProof = clientProofBytes.toString('base64');
+        const serverKey = hmac(saltPass, SERVER_KEY);
+        const serverSignatureBytes = hmac(serverKey, authMessage);
+        session.serverSignature = serverSignatureBytes.toString('base64');
+        session.clientFinalMessage = clientFinalMessageWithoutProof + ',p=' + clientProof;
+    }
+    SASL.continueSession = continueSession;
+    function finalizeSession(session, data) {
+        let serverSignature = '';
+        const arr = data.split(',');
+        for (const s of arr) {
+            if (s[0] === 'v')
+                serverSignature = s.substr(2);
+        }
+        if (serverSignature !== session.serverSignature)
+            throw new Error('SASL: Server signature does not match');
+    }
+    SASL.finalizeSession = finalizeSession;
+    function firstMessageBare(username, nonce) {
+        return `n=${username},r=${nonce}`;
+    }
+    /**
+     * Hi() is, essentially, PBKDF2 [RFC2898] with HMAC() as the
+     * pseudorandom function (PRF) and with dkLen == output length of
+     * HMAC() == output length of H()
+     */
+    function hi(text, salt, iterations) {
+        return crypto_1.default.pbkdf2Sync(text, Buffer.from(salt, 'base64'), iterations, 32, 'sha256');
+    }
+    const encode64 = str => Buffer.from(str).toString('base64');
+    function hmac(key, msg) {
+        return crypto_1.default.createHmac('sha256', key).update(msg).digest();
+    }
+    function hash(data) {
+        return crypto_1.default.createHash('sha256').update(data).digest();
+    }
+    function xor(a, b) {
+        a = Buffer.isBuffer(a) ? a : Buffer.from(a);
+        b = Buffer.isBuffer(b) ? b : Buffer.from(b);
+        if (a.length !== b.length)
+            throw new Error('Buffers must be of the same length');
+        const l = a.length;
+        const out = Buffer.allocUnsafe(l);
+        for (let i = 0; i < l; i++) {
+            out[i] = a[i] ^ b[i];
+        }
+        return out;
+    }
+})(SASL || (exports.SASL = SASL = {}));

package/cjs/protocol/smart-buffer.js

@@ -0,0 +1,195 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartBuffer = void 0;
+const os = __importStar(require("os"));
+const bigint_methods_js_1 = require("../util/bigint-methods.js");
+const buffer_reader_js_1 = require("./buffer-reader.js");
+class SmartBuffer extends buffer_reader_js_1.BufferReader {
+    constructor(cfg) {
+        // @ts-ignore
+        super(Buffer.allocUnsafe((cfg?.pageSize ? parseInt(cfg.pageSize, 10) : 0) || SmartBuffer.DEFAULT_PAGE_SIZE));
+        this._lastHouseKeep = 0;
+        this._stMaxPages = 1;
+        this._length = 0;
+        this._houseKeepInterval = cfg?.houseKeepInterval || 5000;
+        this.pageSize = this.buffer.length;
+        this.maxSize = cfg?.maxLength || SmartBuffer.DEFAULT_MAX_SIZE;
+        this._length = 0;
+    }
+    get capacity() {
+        return this.buffer.length;
+    }
+    get length() {
+        return this._length;
+    }
+    start() {
+        this.offset = 0;
+        this._length = 0;
+        if (this._houseKeepTimer) {
+            clearTimeout(this._houseKeepTimer);
+            this._houseKeepTimer = undefined;
+        }
+        return this;
+    }
+    flush() {
+        if (this._houseKeepTimer)
+            clearTimeout(this._houseKeepTimer);
+        const length = this.length;
+        this._length = 0;
+        const out = this.buffer.slice(0, length);
+        const pages = length ? Math.ceil(length / this.pageSize) : 1;
+        this._stMaxPages = Math.max(this._stMaxPages, pages);
+        if (this._lastHouseKeep < Date.now() + this._houseKeepInterval)
+            this._houseKeep();
+        this._houseKeepTimer = setTimeout(() => {
+            this._houseKeepTimer = undefined;
+            this._houseKeep();
+        }, this._houseKeepInterval).unref();
+        return out;
+    }
+    growSize(len) {
+        const endOffset = this.offset + len;
+        if (this.capacity < endOffset) {
+            if (endOffset > this.maxSize)
+                throw new Error('Buffer limit exceeded.');
+            const newSize = Math.ceil(endOffset / this.pageSize) * this.pageSize;
+            const newBuffer = Buffer.allocUnsafe(newSize);
+            this.buffer.copy(newBuffer);
+            this.buffer = newBuffer;
+        }
+        this._length = Math.max(this.length, endOffset);
+        return this;
+    }
+    fill(value = 0, len = 1) {
+        this.growSize(len);
+        this.buffer.fill(value, this.offset, this.offset + len);
+        this.offset += len;
+        return this;
+    }
+    writeCString(str, encoding) {
+        const len = str ? Buffer.byteLength(str, encoding) : 0;
+        this.growSize(len + 1);
+        if (str) {
+            this.buffer.write(str, this.offset, encoding);
+            this.offset += len;
+        }
+        this.writeUInt8(0);
+        return this;
+    }
+    writeLString(str, encoding) {
+        const len = str ? Buffer.byteLength(str, encoding) : 0;
+        this.growSize(len + 4);
+        this.writeInt32BE(str == null ? -1 : len);
+        if (str) {
+            if (encoding)
+                this.offset += this.buffer.write(str, this.offset, encoding);
+            else
+                this.offset += this.buffer.write(str, this.offset);
+        }
+        return this;
+    }
+    writeString(str, encoding) {
+        if (str) {
+            const len = Buffer.byteLength(str, encoding);
+            this.growSize(len);
+            this.offset += this.buffer.write(str, this.offset, encoding);
+        }
+        return this;
+    }
+    writeInt8(n) {
+        this.growSize(1);
+        this.buffer.writeInt8(n, this.offset);
+        this.offset++;
+        return this;
+    }
+    writeUInt8(n) {
+        this.growSize(1);
+        this.buffer.writeUInt8(n, this.offset);
+        this.offset++;
+        return this;
+    }
+    writeUInt16BE(n) {
+        this.growSize(2);
+        this.buffer.writeUInt16BE(n, this.offset);
+        this.offset += 2;
+        return this;
+    }
+    writeUInt32BE(n) {
+        this.growSize(4);
+        this.buffer.writeUInt32BE(n, this.offset);
+        this.offset += 4;
+        return this;
+    }
+    writeInt16BE(n) {
+        this.growSize(2);
+        this.buffer.writeInt16BE(n, this.offset);
+        this.offset += 2;
+        return this;
+    }
+    writeInt32BE(n) {
+        this.growSize(4);
+        this.buffer.writeInt32BE(n, this.offset);
+        this.offset += 4;
+        return this;
+    }
+    writeBigInt64BE(n) {
+        n = typeof n === 'bigint' ? n : BigInt(n);
+        this.growSize(8);
+        if (typeof this.buffer.writeBigInt64BE === 'function')
+            this.buffer.writeBigInt64BE(n, this.offset);
+        else
+            (0, bigint_methods_js_1.writeBigUInt64BE)(this.buffer, n, this.offset);
+        this.offset += 8;
+        return this;
+    }
+    writeFloatBE(n) {
+        this.growSize(4);
+        this.buffer.writeFloatBE(n, this.offset);
+        this.offset += 4;
+        return this;
+    }
+    writeDoubleBE(n) {
+        this.growSize(8);
+        this.buffer.writeDoubleBE(n, this.offset);
+        this.offset += 8;
+        return this;
+    }
+    writeBuffer(buffer) {
+        this.growSize(buffer.length);
+        buffer.copy(this.buffer, this.offset, 0, buffer.length);
+        this.offset += buffer.length;
+        return this;
+    }
+    _houseKeep() {
+        const needSize = this._stMaxPages * this.pageSize;
+        if (this.buffer.length > needSize)
+            this.buffer = Buffer.allocUnsafe(needSize);
+        this._stMaxPages = this.length ? Math.ceil(this.length / this.pageSize) : 1;
+    }
+}
+exports.SmartBuffer = SmartBuffer;
+SmartBuffer.DEFAULT_PAGE_SIZE = 4096;
+SmartBuffer.DEFAULT_MAX_SIZE = Math.min(Math.floor(os.totalmem() / 2), 1024 * 1024 * 1024 * 2);

package/cjs/safe-event-emitter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeEventEmitter = void 0;
+const events_1 = require("events");
+class SafeEventEmitter extends events_1.EventEmitter {
+    emit(event, ...args) {
+        try {
+            if (event === 'error' && !this.listenerCount('error'))
+                return false;
+            return super.emit(event, ...args);
+        }
+        catch (ignored) {
+            return false;
+        }
+    }
+}
+exports.SafeEventEmitter = SafeEventEmitter;

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/util/array-calculatedim.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayCalculateDim = void 0;
+function arrayCalculateDim(arr) {
+    if (!arr || arr.length === 0)
+        return [0];
+    const dim = [arr.length];
+    const iterate = (a, level) => {
+        for (let i = 0; i < a.length; i++) {
+            if (Array.isArray(a[i])) {
+                dim[level] = Math.max(dim[level] || 0, a[i].length);
+                iterate(a[i], level + 1);
+            }
+        }
+    };
+    iterate(arr, 1);
+    return dim;
+}
+exports.arrayCalculateDim = arrayCalculateDim;

package/cjs/util/bigint-methods.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBigUInt64BE = exports.readBigInt64BE = void 0;
+/* eslint-disable no-bitwise */
+const big0 = BigInt(0);
+const beAnd = BigInt('0xffffffff');
+const big32 = BigInt(32);
+// https://github.com/nodejs/node/blob/v13.9.0/lib/internal/buffer.js
+function readBigInt64BE(buf, offset = 0) {
+    const first = buf[offset];
+    const last = buf[offset + 7];
+    if (first === undefined || last === undefined)
+        return big0;
+    const val = (first << 24) + // Overflow
+        buf[++offset] * 2 ** 16 +
+        buf[++offset] * 2 ** 8 +
+        buf[++offset];
+    return ((BigInt(val) << big32) + BigInt(buf[++offset] * 2 ** 24 + buf[++offset] * 2 ** 16 + buf[++offset] * 2 ** 8 + last));
+}
+exports.readBigInt64BE = readBigInt64BE;
+function writeBigUInt64BE(buf, value, offset = 0) {
+    // @ts-ignore
+    let lo = Number(value & beAnd);
+    buf[offset + 7] = lo;
+    lo = lo >> 8;
+    buf[offset + 6] = lo;
+    lo = lo >> 8;
+    buf[offset + 5] = lo;
+    lo = lo >> 8;
+    buf[offset + 4] = lo;
+    // @ts-ignore
+    let hi = Number((value >> big32) & beAnd);
+    buf[offset + 3] = hi;
+    hi = hi >> 8;
+    buf[offset + 2] = hi;
+    hi = hi >> 8;
+    buf[offset + 1] = hi;
+    hi = hi >> 8;
+    buf[offset] = hi;
+    return offset + 8;
+}
+exports.writeBigUInt64BE = writeBigUInt64BE;

package/cjs/util/config-from-env.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configFromEnv = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+function configFromEnv() {
+    const env = process.env;
+    const result = {};
+    result.host = env.PGHOST || env.PGHOSTADDR;
+    if (env.PGPORT)
+        result.port = (0, putil_varhelpers_1.toIntDef)(env.PGPORT, 5432);
+    if (env.PGDATABASE)
+        result.database = env.PGDATABASE;
+    if (env.PGUSER)
+        result.user = env.PGUSER;
+    if (env.PGPASSWORD)
+        result.password = env.PGPASSWORD;
+    if (env.PGAPPNAME)
+        result.applicationName = env.PGAPPNAME;
+    if (env.PGTZ)
+        result.timezone = env.PGTZ;
+    if (env.PGSCHEMA)
+        result.schema = env.PGSCHEMA;
+    if (env.PGCONNECT_TIMEOUT)
+        result.connectTimeoutMs = (0, putil_varhelpers_1.toIntDef)(env.PGCONNECT_TIMEOUT, 30000);
+    if (env.PGMAX_BUFFER_SIZE) {
+        result.buffer = { maxLength: (0, putil_varhelpers_1.toInt)(env.PGMAX_BUFFER_SIZE) };
+    }
+    return result;
+}
+exports.configFromEnv = configFromEnv;

package/cjs/util/connection-config.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConnectionString = exports.getConnectionConfig = void 0;
+const putil_merge_1 = __importDefault(require("putil-merge"));
+const config_from_env_js_1 = require("./config-from-env.js");
+function getConnectionConfig(config) {
+    const cfg = (0, config_from_env_js_1.configFromEnv)();
+    if (typeof config === 'string') {
+        (0, putil_merge_1.default)(cfg, parseConnectionString(config));
+    }
+    else if (typeof config === 'object') {
+        (0, putil_merge_1.default)(cfg, config);
+    }
+    if (cfg.host) {
+        const x = parseConnectionString('' + cfg.host);
+        (0, putil_merge_1.default)(cfg, x);
+    }
+    cfg.user = cfg.user || 'postgres';
+    cfg.database = cfg.database || 'postgres';
+    cfg.host = cfg.host || '127.0.0.1';
+    return cfg;
+}
+exports.getConnectionConfig = getConnectionConfig;
+function parseConnectionString(str) {
+    if (str.startsWith('/'))
+        str = 'socket:/' + str;
+    if (!str.includes('://'))
+        str = 'postgres://' + str;
+    const parsed = new URL(str);
+    const getFirst = (v) => {
+        return typeof v === 'string' ? v : Array.isArray(v) ? v[0] : '';
+    };
+    const cfg = {};
+    cfg.host = decodeURI(parsed.hostname || '');
+    if (parsed.port)
+        cfg.port = parseInt(parsed.port, 10);
+    if (parsed.protocol === 'socket:' || parsed.protocol === 'unix:') {
+        if (!cfg.host.startsWith('/'))
+            cfg.host = '/' + cfg.host;
+        cfg.host += decodeURI(parsed.pathname || '');
+        if (parsed.searchParams.get('db'))
+            cfg.database = decodeURI(getFirst(parsed.searchParams.get('db')));
+    }
+    else if (parsed.protocol === 'pg:' || parsed.protocol === 'postgres:') {
+        if (parsed.pathname)
+            cfg.database = decodeURI(parsed.pathname.substring(1));
+    }
+    if (parsed.searchParams.get('host'))
+        cfg.host = decodeURI(getFirst(parsed.searchParams.get('host')));
+    if (parsed.searchParams.get('db'))
+        cfg.database = decodeURI(getFirst(parsed.searchParams.get('db')));
+    if (parsed.searchParams.get('schema'))
+        cfg.schema = decodeURI(getFirst(parsed.searchParams.get('schema')));
+    if (parsed.searchParams.get('application_name'))
+        cfg.applicationName = decodeURI(getFirst(parsed.searchParams.get('application_name')));
+    if (parsed.username)
+        cfg.user = parsed.username;
+    if (parsed.password)
+        cfg.password = parsed.password;
+    return cfg;
+}
+exports.parseConnectionString = parseConnectionString;

package/cjs/util/convert-row-to-object.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowToObject = void 0;
+function convertRowToObject(fields, row) {
+    const out = {};
+    const l = row.length;
+    let i;
+    for (i = 0; i < l; i++) {
+        out[fields[i].fieldName] = row[i];
+    }
+    return out;
+}
+exports.convertRowToObject = convertRowToObject;

package/cjs/util/decode-binaryarray.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBinaryArray = void 0;
+const buffer_reader_js_1 = require("../protocol/buffer-reader.js");
+function decodeBinaryArray(buf, decoder, options = {}) {
+    if (!buf.length)
+        return null;
+    const io = new buffer_reader_js_1.BufferReader(buf);
+    const ndims = io.readInt32BE();
+    io.readInt32BE(); // hasNulls
+    const elementOID = io.readInt32BE(); // element oid
+    if (ndims === 0)
+        return [];
+    const dims = [];
+    const readDim = (level) => {
+        const elemCount = dims[level];
+        const target = new Array(elemCount);
+        for (let i = 0; i < elemCount; i++) {
+            if (level < dims.length - 1) {
+                target[i] = readDim(level + 1);
+                continue;
+            }
+            const len = io.readInt32BE();
+            if (len === -1)
+                target[i] = null;
+            else {
+                const b = io.readBuffer(len);
+                target[i] = decoder(b, { ...options, elementOID });
+            }
+        }
+        return target;
+    };
+    for (let d = 0; d < ndims; d++) {
+        dims[d] = io.readInt32BE();
+        io.readInt32BE(); // LBound
+    }
+    return readDim(0);
+}
+exports.decodeBinaryArray = decodeBinaryArray;

package/cjs/util/encode-binaryarray.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBinaryArray = void 0;
+const constants_js_1 = require("../constants.js");
+const array_calculatedim_js_1 = require("./array-calculatedim.js");
+function encodeBinaryArray(io, value, itemOid, options, encode, encodeCalculateDimFn) {
+    encodeCalculateDimFn = encodeCalculateDimFn || array_calculatedim_js_1.arrayCalculateDim;
+    itemOid = itemOid || constants_js_1.DataTypeOIDs.varchar;
+    const dim = encodeCalculateDimFn(value);
+    const ndims = dim.length;
+    const zeroOffset = io.offset;
+    io.writeInt32BE(ndims) // Number of dimensions
+        .writeInt32BE(0) // reserved for has-null flag
+        .writeInt32BE(itemOid);
+    for (let d = 0; d < ndims; d++) {
+        io.writeInt32BE(dim[d]); // Number of items in dimension
+        io.writeInt32BE(0); // LBound always 0.
+    }
+    let hasNull = false;
+    let pos;
+    const writeDim = (arr, level) => {
+        const elemCount = dim[level];
+        for (let i = 0; i < elemCount; i++) {
+            if (level < dim.length - 1) {
+                writeDim(arr && arr[i], level + 1);
+                continue;
+            }
+            // if value is null
+            if (!arr || arr[i] == null) {
+                hasNull = true;
+                io.writeInt32BE(-1);
+                continue;
+            }
+            io.writeInt32BE(0); // reserved for data len
+            pos = io.offset;
+            encode(io, arr[i], options);
+            // Update item data size
+            io.buffer.writeInt32BE(io.length - pos, pos - 4);
+        }
+    };
+    writeDim(value, 0);
+    if (hasNull)
+        io.buffer.writeInt32BE(1, zeroOffset + 4);
+}
+exports.encodeBinaryArray = encodeBinaryArray;