postgrejs 2.12.0

package/esm/protocol/sasl.js

@@ -0,0 +1,102 @@
+/* eslint-disable no-bitwise */
+import crypto from 'crypto';
+export 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.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.pbkdf2Sync(text, Buffer.from(salt, 'base64'), iterations, 32, 'sha256');
+    }
+    const encode64 = str => Buffer.from(str).toString('base64');
+    function hmac(key, msg) {
+        return crypto.createHmac('sha256', key).update(msg).digest();
+    }
+    function hash(data) {
+        return crypto.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 || (SASL = {}));

package/esm/protocol/smart-buffer.js

@@ -0,0 +1,168 @@
+import * as os from 'os';
+import { writeBigUInt64BE } from '../util/bigint-methods.js';
+import { BufferReader } from './buffer-reader.js';
+export class SmartBuffer extends 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
+            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;
+    }
+}
+SmartBuffer.DEFAULT_PAGE_SIZE = 4096;
+SmartBuffer.DEFAULT_MAX_SIZE = Math.min(Math.floor(os.totalmem() / 2), 1024 * 1024 * 1024 * 2);

package/esm/safe-event-emitter.js

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'events';
+export class SafeEventEmitter extends EventEmitter {
+    emit(event, ...args) {
+        try {
+            if (event === 'error' && !this.listenerCount('error'))
+                return false;
+            return super.emit(event, ...args);
+        }
+        catch (ignored) {
+            return false;
+        }
+    }
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/util/array-calculatedim.js

@@ -0,0 +1,15 @@
+export 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;
+}

package/esm/util/bigint-methods.js

@@ -0,0 +1,37 @@
+/* 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
+export 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));
+}
+export 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;
+}

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

@@ -0,0 +1,26 @@
+import { toInt, toIntDef } from 'putil-varhelpers';
+export function configFromEnv() {
+    const env = process.env;
+    const result = {};
+    result.host = env.PGHOST || env.PGHOSTADDR;
+    if (env.PGPORT)
+        result.port = 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 = toIntDef(env.PGCONNECT_TIMEOUT, 30000);
+    if (env.PGMAX_BUFFER_SIZE) {
+        result.buffer = { maxLength: toInt(env.PGMAX_BUFFER_SIZE) };
+    }
+    return result;
+}

package/esm/util/connection-config.js

@@ -0,0 +1,57 @@
+import merge from 'putil-merge';
+import { configFromEnv } from './config-from-env.js';
+export function getConnectionConfig(config) {
+    const cfg = configFromEnv();
+    if (typeof config === 'string') {
+        merge(cfg, parseConnectionString(config));
+    }
+    else if (typeof config === 'object') {
+        merge(cfg, config);
+    }
+    if (cfg.host) {
+        const x = parseConnectionString('' + cfg.host);
+        merge(cfg, x);
+    }
+    cfg.user = cfg.user || 'postgres';
+    cfg.database = cfg.database || 'postgres';
+    cfg.host = cfg.host || '127.0.0.1';
+    return cfg;
+}
+export 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;
+}

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

@@ -0,0 +1,9 @@
+export 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;
+}

package/esm/util/decode-binaryarray.js

@@ -0,0 +1,35 @@
+import { BufferReader } from '../protocol/buffer-reader.js';
+export function decodeBinaryArray(buf, decoder, options = {}) {
+    if (!buf.length)
+        return null;
+    const io = new 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);
+}

package/esm/util/encode-binaryarray.js

@@ -0,0 +1,41 @@
+import { DataTypeOIDs } from '../constants.js';
+import { arrayCalculateDim } from './array-calculatedim.js';
+export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCalculateDimFn) {
+    encodeCalculateDimFn = encodeCalculateDimFn || arrayCalculateDim;
+    itemOid = itemOid || 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);
+}

package/esm/util/escape-literal.js

@@ -0,0 +1,23 @@
+// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+export function escapeLiteral(str) {
+    let backSlash = false;
+    let out = "'";
+    let i;
+    let c;
+    const l = str.length;
+    for (i = 0; i < l; i++) {
+        c = str[i];
+        if (c === "'")
+            out += c + c;
+        else if (c === '\\') {
+            out += c + c;
+            backSlash = true;
+        }
+        else
+            out += c;
+    }
+    out += "'";
+    if (backSlash)
+        out = ' E' + out;
+    return out;
+}

package/esm/util/fast-parseint.js

@@ -0,0 +1,28 @@
+export function fastParseInt(str) {
+    /* istanbul ignore next */
+    if (typeof str === 'number')
+        return Math.floor(str);
+    // noinspection SuspiciousTypeOfGuard
+    if (typeof str !== 'string')
+        return NaN;
+    const strLength = str.length;
+    let res = 0;
+    let i = 0;
+    let neg = false;
+    if (str.startsWith('-')) {
+        neg = true;
+        i++;
+    }
+    do {
+        const charCode = str.charCodeAt(i);
+        /* istanbul ignore next */
+        if (charCode === 46)
+            return res;
+        /* istanbul ignore next */
+        if (charCode < 48 || charCode > 57)
+            return NaN;
+        res *= 10;
+        res += charCode - 48;
+    } while (++i < strLength);
+    return neg ? -res : res;
+}

package/esm/util/get-parsers.js

@@ -0,0 +1,38 @@
+import { DataFormat } from '../constants.js';
+import { decodeBinaryArray } from './decode-binaryarray.js';
+import { parsePostgresArray } from './parse-array.js';
+const DefaultColumnParser = (v) => v;
+export function getParsers(typeMap, fields) {
+    const parsers = new Array(fields.length);
+    const l = fields.length;
+    let f;
+    let i;
+    for (i = 0; i < l; i++) {
+        f = fields[i];
+        const dataTypeReg = typeMap.get(f.dataTypeId);
+        if (dataTypeReg) {
+            const isArray = !!dataTypeReg.elementsOID;
+            if (f.format === DataFormat.binary) {
+                const decode = dataTypeReg.parseBinary;
+                if (decode) {
+                    parsers[i] = !isArray
+                        ? decode
+                        : (v, options) => decodeBinaryArray(v, decode, options);
+                }
+            }
+            else if (f.format === DataFormat.text) {
+                const parse = dataTypeReg.parseText;
+                if (parse) {
+                    parsers[i] = !isArray
+                        ? parse
+                        : (v, options) => parsePostgresArray(v, {
+                            transform: x => parse(x, options),
+                            separator: dataTypeReg.arraySeparator,
+                        });
+                }
+            }
+        }
+        parsers[i] = parsers[i] || DefaultColumnParser;
+    }
+    return parsers;
+}

package/esm/util/parse-array.js

@@ -0,0 +1,57 @@
+export function parsePostgresArray(s, opts) {
+    if (!s)
+        return;
+    const sep = (opts?.separator || ',').substring(0, 1);
+    const transform = opts?.transform;
+    const len = s.length;
+    let idx = 0;
+    const out = [];
+    const iterate = (arr) => {
+        let c;
+        let exactlyValue = false;
+        let token = '';
+        let quote = '';
+        while (idx < len) {
+            c = s.charAt(idx++);
+            if (!quote) {
+                if (!token && c === '{') {
+                    const a = [];
+                    arr.push(a);
+                    iterate(a);
+                    continue;
+                }
+                if (c === '}' || c === sep) {
+                    if (token) {
+                        if (token === 'NULL' && !exactlyValue)
+                            arr.push(null);
+                        else
+                            arr.push(transform ? transform(token) : token);
+                        exactlyValue = false;
+                    }
+                    token = '';
+                    if (c === '}')
+                        return;
+                    continue;
+                }
+            }
+            if (c === '\\') {
+                c = s.charAt(idx++);
+                token += c;
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                if (quote && quote === c) {
+                    quote = '';
+                }
+                else {
+                    exactlyValue = true;
+                    quote = c;
+                }
+                continue;
+            }
+            token += c;
+        }
+    };
+    iterate(out);
+    return out.length ? out[0] : undefined;
+}