postgrejs 2.12.0

package/cjs/util/escape-literal.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeLiteral = void 0;
+// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+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;
+}
+exports.escapeLiteral = escapeLiteral;

package/cjs/util/fast-parseint.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastParseInt = void 0;
+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;
+}
+exports.fastParseInt = fastParseInt;

package/cjs/util/get-parsers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsers = void 0;
+const constants_js_1 = require("../constants.js");
+const decode_binaryarray_js_1 = require("./decode-binaryarray.js");
+const parse_array_js_1 = require("./parse-array.js");
+const DefaultColumnParser = (v) => v;
+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 === constants_js_1.DataFormat.binary) {
+                const decode = dataTypeReg.parseBinary;
+                if (decode) {
+                    parsers[i] = !isArray
+                        ? decode
+                        : (v, options) => (0, decode_binaryarray_js_1.decodeBinaryArray)(v, decode, options);
+                }
+            }
+            else if (f.format === constants_js_1.DataFormat.text) {
+                const parse = dataTypeReg.parseText;
+                if (parse) {
+                    parsers[i] = !isArray
+                        ? parse
+                        : (v, options) => (0, parse_array_js_1.parsePostgresArray)(v, {
+                            transform: x => parse(x, options),
+                            separator: dataTypeReg.arraySeparator,
+                        });
+                }
+            }
+        }
+        parsers[i] = parsers[i] || DefaultColumnParser;
+    }
+    return parsers;
+}
+exports.getParsers = getParsers;

package/cjs/util/parse-array.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePostgresArray = void 0;
+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;
+}
+exports.parsePostgresArray = parsePostgresArray;

package/cjs/util/parse-datetime.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDateTime = void 0;
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const fast_parseint_js_1 = require("./fast-parseint.js");
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const TIMESTAMP_PATTERN = 
+// eslint-disable-next-line
+/^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
+const INFINITY_PATTERN = /^-?infinity$/;
+function parseDateTime(str, parseTime, parseTimeZone, utc) {
+    let m = str.match(TIMESTAMP_PATTERN);
+    if (!m) {
+        m = str.match(INFINITY_PATTERN);
+        if (m)
+            return Number(str.replace('i', 'I'));
+        return new Date('invalid');
+    }
+    const args = [1970, 0, 1, 0, 0, 0, 0];
+    const l = parseTime ? 7 : 3;
+    for (let i = 0; i < l; i++) {
+        const s = m[i + 1];
+        args[i] = (0, fast_parseint_js_1.fastParseInt)(s) || 0;
+    }
+    // Months starts from 0
+    if (args[1] > 0)
+        args[1]--;
+    if (parseTimeZone && parseTime && m[9]) {
+        const r = m[9] === '-' ? -1 : 1;
+        args[3] -= ((0, fast_parseint_js_1.fastParseInt)(m[10]) || 0) * r;
+        args[4] -= ((0, fast_parseint_js_1.fastParseInt)(m[11]) || 0) * r;
+        return new Date(Date.UTC(...args));
+    }
+    if (m[8] || utc)
+        return new Date(Date.UTC(...args));
+    return new Date(...args);
+}
+exports.parseDateTime = parseDateTime;

package/cjs/util/parse-row.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRow = void 0;
+function parseRow(parsers, row, options) {
+    const l = row.length;
+    let i;
+    for (i = 0; i < l; i++) {
+        row[i] = row[i] == null ? null : parsers[i].call(undefined, row[i], options);
+    }
+}
+exports.parseRow = parseRow;

package/cjs/util/parse-time.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTime = exports.TIME_PATTERN = exports.STRICT_TIME_PATTERN = void 0;
+const fast_parseint_js_1 = require("./fast-parseint.js");
+// eslint-disable-next-line
+// noinspection RegExpUnnecessaryNonCapturingGroup
+exports.STRICT_TIME_PATTERN = /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
+// noinspection RegExpUnnecessaryNonCapturingGroup
+exports.TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
+function parseTime(str, parseTimeZone, utc) {
+    const m = str.match(exports.TIME_PATTERN);
+    if (!m)
+        return new Date('invalid');
+    const args = [1970, 0, 1, 0, 0, 0, 0];
+    for (let i = 1; i < 4; i++) {
+        const s = m[i];
+        args[i + 2] = (0, fast_parseint_js_1.fastParseInt)(s) || 0;
+    }
+    if (parseTimeZone && m[6]) {
+        const r = m[9] === '-' ? -1 : 1;
+        args[3] -= ((0, fast_parseint_js_1.fastParseInt)(m[7]) || 0) * r;
+        args[4] -= ((0, fast_parseint_js_1.fastParseInt)(m[8]) || 0) * r;
+        return new Date(Date.UTC(...args));
+    }
+    if (m[5] || utc)
+        return new Date(Date.UTC(...args));
+    return new Date(...args);
+}
+exports.parseTime = parseTime;

package/cjs/util/stringify-arrayliteral.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyArrayLiteral = void 0;
+const array_calculatedim_js_1 = require("./array-calculatedim.js");
+function stringifyArrayLiteral(value, options, encode) {
+    const dim = (0, array_calculatedim_js_1.arrayCalculateDim)(value);
+    const writeDim = (arr, level) => {
+        const elemCount = dim[level];
+        const out = [];
+        for (let i = 0; i < elemCount; i++) {
+            let x = arr && arr[i];
+            if (level < dim.length - 1) {
+                if (x != null && !Array.isArray(x))
+                    x = [x];
+                out.push(writeDim(x, level + 1));
+                continue;
+            }
+            // if value is null
+            if (x == null) {
+                out.push('NULL');
+                continue;
+            }
+            if (Array.isArray(x)) {
+                out.push(stringifyArrayLiteral(x, options, encode));
+                continue;
+            }
+            if (encode)
+                x = encode(x, options || {});
+            out.push(escapeArrayItem('' + x));
+        }
+        return '{' + out.join(',') + '}';
+    };
+    return writeDim(value, 0);
+}
+exports.stringifyArrayLiteral = stringifyArrayLiteral;
+function escapeArrayItem(str) {
+    return '"' + str.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+}

package/cjs/util/stringify-for-sql.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyValueForSQL = exports.stringifyArrayForSQL = void 0;
+const uuid_type_js_1 = require("../data-types/uuid-type.js");
+const escape_literal_js_1 = require("./escape-literal.js");
+function stringifyArrayForSQL(v, options, encode) {
+    const arr = v.map(x => stringifyValueForSQL(x, options, encode));
+    return 'ARRAY[' + arr.join(',') + ']';
+}
+exports.stringifyArrayForSQL = stringifyArrayForSQL;
+function stringifyValueForSQL(v, options, encode) {
+    if (v == null)
+        return 'null';
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    if (Array.isArray(v))
+        return stringifyArrayForSQL(v, options, encode);
+    if (encode)
+        v = encode(v, options || {});
+    if (typeof v === 'number')
+        return '' + v;
+    if (typeof v === 'bigint')
+        return v.toString();
+    if (typeof v === 'string' && uuid_type_js_1.UuidType.isType(v))
+        return (0, escape_literal_js_1.escapeLiteral)('' + v) + '::uuid';
+    if (typeof v === 'object')
+        return (0, escape_literal_js_1.escapeLiteral)(JSON.stringify(v)) + '::json';
+    return (0, escape_literal_js_1.escapeLiteral)('' + v);
+}
+exports.stringifyValueForSQL = stringifyValueForSQL;

package/cjs/util/wrap-row-description.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapRowDescription = void 0;
+const constants_js_1 = require("../constants.js");
+function wrapRowDescription(typeMap, fields, columnFormat) {
+    return fields.map((f, idx) => {
+        const cf = Array.isArray(columnFormat) ? columnFormat[idx] : columnFormat;
+        const x = {
+            fieldName: f.fieldName,
+            tableId: f.tableId,
+            columnId: f.columnId,
+            dataTypeId: f.dataTypeId,
+            dataTypeName: constants_js_1.DataTypeNames[f.dataTypeId] || '',
+            jsType: cf === constants_js_1.DataFormat.binary ? 'Buffer' : 'string',
+        };
+        x.isArray = x.dataTypeName.startsWith('_');
+        if (x.isArray) {
+            x.elementDataTypeName = x.dataTypeName.substring(1);
+            for (const oid of Object.keys(constants_js_1.DataTypeNames)) {
+                if (constants_js_1.DataTypeNames[oid] === x.elementDataTypeName)
+                    x.elementDataTypeId = parseInt(oid, 10);
+            }
+        }
+        if (f.fixedSize && f.fixedSize > 0)
+            x.fixedSize = f.fixedSize;
+        if (f.modifier && f.modifier > 0)
+            x.modifier = f.modifier;
+        const reg = typeMap.get(x.dataTypeId);
+        if (reg) {
+            x.jsType = reg.jsType;
+        }
+        return x;
+    });
+}
+exports.wrapRowDescription = wrapRowDescription;

package/esm/connection/bind-param.js

@@ -0,0 +1,6 @@
+export class BindParam {
+    constructor(oid, value) {
+        this.oid = oid;
+        this.value = value;
+    }
+}

package/esm/connection/connection.js

@@ -0,0 +1,275 @@
+import { ConnectionState } from '../constants.js';
+import { GlobalTypeMap } from '../data-type-map.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { BindParam } from './bind-param.js';
+import { IntlConnection } from './intl-connection.js';
+import { PreparedStatement } from './prepared-statement.js';
+export class Connection extends SafeEventEmitter {
+    constructor(arg0, arg1) {
+        super();
+        this._notificationListeners = new SafeEventEmitter();
+        this._closing = false;
+        if (arg0 && typeof arg0 === 'object' && typeof arg0.acquire === 'function') {
+            if (!(arg1 instanceof IntlConnection))
+                throw new TypeError('Invalid argument');
+            this._pool = arg0;
+            this._intlCon = arg1;
+        }
+        else {
+            this._intlCon = new IntlConnection(arg0);
+        }
+        this._intlCon.on('ready', (...args) => this.emit('ready', ...args));
+        this._intlCon.on('error', (...args) => this.emit('error', ...args));
+        this._intlCon.on('close', (...args) => this.emit('close', ...args));
+        this._intlCon.on('connecting', (...args) => this.emit('connecting', ...args));
+        this._intlCon.on('ready', (...args) => this.emit('ready', ...args));
+        this._intlCon.on('terminate', (...args) => this.emit('terminate', ...args));
+        this._intlCon.on('notification', (msg) => this._handleNotification(msg));
+    }
+    /**
+     * Returns configuration object
+     */
+    get config() {
+        return this._intlCon.config;
+    }
+    /**
+     * Returns true if connection is in a transaction
+     */
+    get inTransaction() {
+        return this._intlCon.inTransaction;
+    }
+    /**
+     * Returns current state of the connection
+     */
+    get state() {
+        return this._intlCon.state;
+    }
+    /**
+     * Returns processId of current session
+     */
+    get processID() {
+        return this._intlCon.processID;
+    }
+    /**
+     * Returns information parameters for current session
+     */
+    get sessionParameters() {
+        return this._intlCon.sessionParameters;
+    }
+    /**
+     * Returns secret key of current session
+     */
+    get secretKey() {
+        return this._intlCon.secretKey;
+    }
+    /**
+     * Connects to the server
+     */
+    async connect() {
+        await this._captureErrorStack(this._intlCon.connect());
+        if (this.state === ConnectionState.READY)
+            this._closing = false;
+    }
+    /**
+     * Closes connection. You can define how long time the connection will
+     * wait for active queries before terminating the connection.
+     * On the end of the given time, it forces to close the socket and than emits `terminate` event.
+     *
+     * @param terminateWait {number} - Determines how long the connection will wait for active queries before terminating.
+     */
+    async close(terminateWait) {
+        this._notificationListeners.removeAllListeners();
+        this._intlCon.statementQueue.clearQueue();
+        if (this.state === ConnectionState.CLOSED || this._closing)
+            return;
+        /* istanbul ignore next */
+        if (this.listenerCount('debug'))
+            this.emit('debug', {
+                location: 'Connection.close',
+                connection: this,
+                message: `[${this.processID}] closing`,
+            });
+        this._closing = true;
+        if (this._intlCon.refCount > 0 && typeof terminateWait === 'number' && terminateWait > 0) {
+            const startTime = Date.now();
+            return this._captureErrorStack(new Promise((resolve, reject) => {
+                /* istanbul ignore next */
+                if (this.listenerCount('debug'))
+                    this.emit('debug', {
+                        location: 'Connection.close',
+                        connection: this,
+                        message: `[${this.processID}] waiting active queries`,
+                    });
+                const timer = setInterval(() => {
+                    if (this._intlCon.refCount <= 0 || Date.now() > startTime + terminateWait) {
+                        clearInterval(timer);
+                        if (this._intlCon.refCount > 0) {
+                            /* istanbul ignore next */
+                            if (this.listenerCount('debug'))
+                                this.emit('debug', {
+                                    location: 'Connection.close',
+                                    connection: this,
+                                    message: `[${this.processID}] terminate`,
+                                });
+                            this.emit('terminate');
+                        }
+                        this._close().then(resolve).catch(reject);
+                    }
+                }, 50);
+            }));
+        }
+        await this._close();
+    }
+    /**
+     * Executes single or multiple SQL scripts using Simple Query protocol.
+     *
+     * @param sql {string} - SQL script that will be executed
+     * @param options {ScriptExecuteOptions} - Execute options
+     */
+    async execute(sql, options) {
+        return this._captureErrorStack(this._intlCon.execute(sql, options)).catch((e) => {
+            throw this._handleError(e, sql);
+        });
+    }
+    async query(sql, options) {
+        this._intlCon.assertConnected();
+        /* istanbul ignore next */
+        if (this.listenerCount('debug'))
+            this.emit('debug', {
+                location: 'Connection.query',
+                connection: this,
+                message: `[${this.processID}] query | ${sql}`,
+                sql,
+            });
+        const typeMap = options?.typeMap || GlobalTypeMap;
+        const paramTypes = options?.params?.map(prm => prm instanceof BindParam ? prm.oid : typeMap.determine(prm));
+        const statement = await this.prepare(sql, { paramTypes, typeMap }).catch((e) => {
+            throw this._handleError(e, sql);
+        });
+        try {
+            const params = options?.params?.map(prm => (prm instanceof BindParam ? prm.value : prm));
+            return await this._captureErrorStack(statement.execute({ ...options, params }));
+        }
+        finally {
+            await statement.close();
+        }
+    }
+    /**
+     * Creates a PreparedStatement instance
+     * @param sql {string} - SQL script that will be executed
+     * @param options {StatementPrepareOptions} - Options
+     */
+    async prepare(sql, options) {
+        /* istanbul ignore next */
+        if (this.listenerCount('debug'))
+            this.emit('debug', {
+                location: 'Connection.prepare',
+                connection: this,
+                message: `[${this.processID}] prepare | ${sql}`,
+                sql,
+            });
+        return await this._captureErrorStack(PreparedStatement.prepare(this, sql, options));
+    }
+    /**
+     * Starts a transaction
+     */
+    startTransaction() {
+        return this._captureErrorStack(this._intlCon.startTransaction());
+    }
+    /**
+     * Commits current transaction
+     */
+    commit() {
+        return this._captureErrorStack(this._intlCon.commit());
+    }
+    /**
+     * Rolls back current transaction
+     */
+    rollback() {
+        return this._captureErrorStack(this._intlCon.rollback());
+    }
+    /**
+     * Starts transaction and creates a savepoint
+     * @param name {string} - Name of the savepoint
+     */
+    async savepoint(name) {
+        if (!this._intlCon.inTransaction)
+            await this._intlCon.startTransaction();
+        return this._captureErrorStack(this._intlCon.savepoint(name));
+    }
+    /**
+     * Rolls back current transaction to given savepoint
+     * @param name {string} - Name of the savepoint
+     */
+    rollbackToSavepoint(name) {
+        return this._captureErrorStack(this._intlCon.rollbackToSavepoint(name));
+    }
+    /**
+     * Releases savepoint
+     * @param name {string} - Name of the savepoint
+     */
+    releaseSavepoint(name) {
+        return this._captureErrorStack(this._intlCon.releaseSavepoint(name));
+    }
+    async listen(channel, callback) {
+        if (!/^[A-Z]\w+$/i.test(channel))
+            throw new TypeError(`Invalid channel name`);
+        const registered = !!this._notificationListeners.eventNames().length;
+        this._notificationListeners.on(channel, callback);
+        if (!registered)
+            await this._captureErrorStack(this.query('LISTEN ' + channel));
+    }
+    async unListen(channel) {
+        if (!/^[A-Z]\w+$/i.test(channel))
+            throw new TypeError(`Invalid channel name`);
+        this._notificationListeners.removeAllListeners(channel);
+        await this._captureErrorStack(this.query('UNLISTEN ' + channel));
+    }
+    async unListenAll() {
+        this._notificationListeners.removeAllListeners();
+        await this._captureErrorStack(this.query('UNLISTEN *'));
+    }
+    _handleNotification(msg) {
+        this.emit('notification', msg);
+        this._notificationListeners.emit(msg.channel, msg);
+    }
+    async _close() {
+        if (this._pool) {
+            await this._captureErrorStack(this._pool.release(this));
+            this.emit('release');
+        }
+        else
+            await this._captureErrorStack(this._intlCon.close());
+        this._closing = false;
+    }
+    _handleError(err, script) {
+        if (err.position) {
+            const i1 = script.lastIndexOf('\n', err.position) + 1;
+            let i2 = script.indexOf('\n', err.position);
+            if (i2 < 0)
+                i2 = Number.MAX_SAFE_INTEGER;
+            err.line = script.substring(i1, i2);
+            err.lineNr = [...script.substring(0, i1).matchAll(/\n/g)].length;
+            err.colNr = err.position - i1;
+            err.message +=
+                `\nAt line ${err.lineNr} column ${err.colNr}` +
+                    `\n |  ${err.line}\n |  ${' '.repeat(Math.max(err.colNr - 2, 0))}-^-`;
+        }
+        return err;
+    }
+    async _captureErrorStack(promise) {
+        const stack = new Error().stack;
+        return promise.catch(e => {
+            if (e instanceof Error && stack) {
+                e.stack = stack
+                    .split('\n')
+                    .filter(x => !x.includes('Connection._captureErrorStack'))
+                    .join('\n');
+            }
+            throw e;
+        });
+    }
+    [Symbol.asyncDispose]() {
+        return this.close();
+    }
+}