postgrejs 2.22.9 → 2.23.1

package/cjs/connection/connection.js

@@ -1,295 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = void 0;
-const constants_js_1 = require("../constants.js");
-const data_type_map_js_1 = require("../data-type-map.js");
-const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
-const bind_param_js_1 = require("./bind-param.js");
-const intl_connection_js_1 = require("./intl-connection.js");
-const prepared_statement_js_1 = require("./prepared-statement.js");
-class Connection extends safe_event_emitter_js_1.SafeEventEmitter {
-    constructor(arg0, arg1) {
-        super();
-        this._notificationListeners = new safe_event_emitter_js_1.SafeEventEmitter();
-        this._closing = false;
-        if (arg0 &&
-            typeof arg0 === 'object' &&
-            typeof arg0.acquire === 'function') {
-            if (!(arg1 instanceof intl_connection_js_1.IntlConnection))
-                throw new TypeError('Invalid argument');
-            this._pool = arg0;
-            this._intlCon = arg1;
-        }
-        else {
-            this._intlCon = new intl_connection_js_1.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 === constants_js_1.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 === constants_js_1.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) {
-        this.emit('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,
-            });
-        }
-        this.emit('query', sql, options);
-        const typeMap = options?.typeMap || data_type_map_js_1.GlobalTypeMap;
-        const paramTypes = options?.params?.map(prm => prm instanceof bind_param_js_1.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 bind_param_js_1.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(prepared_statement_js_1.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 != null) {
-            const i1 = script.lastIndexOf('\n', err.position - 1) + 1;
-            err.lineNr = [...script.substring(0, i1).matchAll(/\n/g)].length + 1;
-            err.colNr = err.position - i1;
-            const lines = script.split('\n');
-            err.line = lines[err.lineNr - 1];
-            err.message += `\n    at line ${err.lineNr} column ${err.colNr}`;
-            if (err.lineNr > 1)
-                err.message += `\n${String(err.lineNr - 1).padStart(3)}| ${lines[err.lineNr - 2]}`;
-            err.message += `\n${String(err.lineNr).padStart(3)}| ${err.line}\n    .${'-'.repeat(Math.max(err.colNr - 1, 0))}^`;
-        }
-        return err;
-    }
-    async _captureErrorStack(promise) {
-        const stack = new Error().stack;
-        return promise.catch(e => {
-            if (e instanceof Error && stack) {
-                if (e.stack && stack) {
-                    e.stack =
-                        e.stack.substring(0, e.stack.indexOf('\n')) +
-                            '\n' +
-                            stack
-                                .split('\n')
-                                .filter((x, i) => i && !x.includes('._captureErrorStack'))
-                                .join('\n');
-                }
-            }
-            throw e;
-        });
-    }
-    [Symbol.asyncDispose]() {
-        return this.close();
-    }
-}
-exports.Connection = Connection;

package/cjs/connection/cursor.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cursor = void 0;
-const tslib_1 = require("tslib");
-const doublylinked_1 = tslib_1.__importDefault(require("doublylinked"));
-const power_tasks_1 = require("power-tasks");
-const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
-const convert_row_to_object_js_1 = require("../util/convert-row-to-object.js");
-const parse_row_js_1 = require("../util/parse-row.js");
-class Cursor extends safe_event_emitter_js_1.SafeEventEmitter {
-    constructor(statement, portal, fields, parsers, queryOptions) {
-        super();
-        this._taskQueue = new power_tasks_1.TaskQueue({ concurrency: 1 });
-        this._rows = new doublylinked_1.default();
-        this._closed = false;
-        this._statement = statement;
-        this._portal = portal;
-        this._parsers = parsers;
-        this._queryOptions = queryOptions;
-        this.fields = fields;
-    }
-    get rowType() {
-        return this._queryOptions.objectRows ? 'object' : 'array';
-    }
-    get isClosed() {
-        return this._closed;
-    }
-    async next() {
-        if (!this._rows.length) {
-            if (this._closed)
-                return;
-            await this._fetchRows();
-        }
-        return this._rows.shift();
-    }
-    async fetch(nRows) {
-        const out = [];
-        if (this._closed)
-            return out;
-        for (let i = 0; i < nRows; i++) {
-            if (!this._rows.length)
-                await this._fetchRows();
-            if (this._rows.length)
-                out.push(this._rows.shift());
-            else
-                break;
-        }
-        return out;
-    }
-    async close() {
-        if (this._closed)
-            return;
-        await this._portal.close();
-        await this._statement.close();
-        this.emit('close');
-        this._closed = true;
-    }
-    async _fetchRows() {
-        if (this._closed)
-            return;
-        const portal = this._portal;
-        await this._taskQueue
-            .enqueue(async () => {
-            const queryOptions = this._queryOptions;
-            const r = await portal.execute(queryOptions.fetchCount || 100);
-            if (r && r.rows && r.rows.length) {
-                if (this._parsers) {
-                    const objectRows = queryOptions.objectRows;
-                    const fields = this.fields;
-                    const rows = r.rows;
-                    for (let i = 0; i < rows.length; i++) {
-                        const row = rows[i];
-                        (0, parse_row_js_1.parseRow)(this._parsers, row, this._queryOptions);
-                        if (objectRows)
-                            rows[i] = (0, convert_row_to_object_js_1.convertRowToObject)(fields, row);
-                    }
-                }
-                this._rows.push(...r.rows);
-                this.emit('fetch', r.rows);
-            }
-            else {
-                await this.close();
-            }
-        })
-            .toPromise();
-    }
-    [Symbol.asyncDispose]() {
-        return this.close();
-    }
-}
-exports.Cursor = Cursor;

package/cjs/connection/intl-connection.js

@@ -1,258 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntlConnection = void 0;
-exports.getIntlConnection = getIntlConnection;
-const power_tasks_1 = require("power-tasks");
-const putil_varhelpers_1 = require("putil-varhelpers");
-const constants_js_1 = require("../constants.js");
-const data_type_map_js_1 = require("../data-type-map.js");
-const pg_socket_js_1 = require("../protocol/pg-socket.js");
-const protocol_js_1 = require("../protocol/protocol.js");
-const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
-const connection_config_js_1 = require("../util/connection-config.js");
-const convert_row_to_object_js_1 = require("../util/convert-row-to-object.js");
-const escape_literal_js_1 = require("../util/escape-literal.js");
-const get_parsers_js_1 = require("../util/get-parsers.js");
-const parse_row_js_1 = require("../util/parse-row.js");
-const wrap_row_description_js_1 = require("../util/wrap-row-description.js");
-const DataFormat = protocol_js_1.Protocol.DataFormat;
-class IntlConnection extends safe_event_emitter_js_1.SafeEventEmitter {
-    constructor(config) {
-        super();
-        this._refCount = 0;
-        this.transactionStatus = 'I';
-        this.statementQueue = new power_tasks_1.TaskQueue({ concurrency: 1 });
-        this._config = Object.freeze((0, connection_config_js_1.getConnectionConfig)(config));
-        this.socket = new pg_socket_js_1.PgSocket(this._config);
-        this.socket.on('error', err => this._onError(err));
-        this.socket.on('close', () => this.emit('close'));
-        this.socket.on('notification', payload => this.emit('notification', payload));
-        this.socket.on('connecting', () => this.emit('connecting'));
-        this._onErrorSavePoint = 'SP_' + Math.round(Math.random() * 100000000);
-    }
-    get config() {
-        return this._config;
-    }
-    get inTransaction() {
-        return this.transactionStatus === 'T' || this.transactionStatus === 'E';
-    }
-    get state() {
-        return this.socket.state;
-    }
-    get refCount() {
-        return this._refCount;
-    }
-    get processID() {
-        return this.socket.processID;
-    }
-    get secretKey() {
-        return this.socket.secretKey;
-    }
-    get sessionParameters() {
-        return this.socket.sessionParameters;
-    }
-    async connect() {
-        if (this.socket.state === constants_js_1.ConnectionState.READY)
-            return;
-        await new Promise((resolve, reject) => {
-            const handleConnectError = (err) => reject(err);
-            this.socket.once('ready', () => {
-                this.socket.removeListener('error', handleConnectError);
-                resolve();
-            });
-            this.socket.once('error', handleConnectError);
-            this.socket.connect();
-        });
-        let startupCommand = '';
-        if (this.config.schema)
-            startupCommand +=
-                'SET search_path = ' + (0, escape_literal_js_1.escapeLiteral)(this.config.schema) + ';';
-        if (this.config.timezone)
-            startupCommand +=
-                'SET timezone TO ' + (0, escape_literal_js_1.escapeLiteral)(this.config.timezone) + ';';
-        if (startupCommand)
-            await this.execute(startupCommand, { autoCommit: true });
-        this.emit('ready');
-    }
-    async close() {
-        if (this.state === constants_js_1.ConnectionState.CLOSED)
-            return;
-        this.statementQueue.clearQueue();
-        return new Promise(resolve => {
-            if (this.socket.state === constants_js_1.ConnectionState.CLOSED)
-                return;
-            this.socket.once('close', resolve);
-            this.socket.sendTerminateMessage(() => {
-                this.socket.close();
-                this.emit('close');
-            });
-        });
-    }
-    async execute(sql, options, cb) {
-        this.assertConnected();
-        return this.statementQueue
-            .enqueue(async () => {
-            const transactionCommand = sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
-            let beginFirst = false;
-            let commitLast = false;
-            if (!transactionCommand) {
-                if (!this.inTransaction &&
-                    (options?.autoCommit != null
-                        ? options?.autoCommit
-                        : this.config.autoCommit) === false) {
-                    beginFirst = true;
-                }
-                if (this.inTransaction && options?.autoCommit)
-                    commitLast = true;
-            }
-            if (beginFirst)
-                await this._execute('BEGIN');
-            const rollbackOnError = !transactionCommand &&
-                (options?.rollbackOnError != null
-                    ? options.rollbackOnError
-                    : (0, putil_varhelpers_1.coerceToBoolean)(this.config.rollbackOnError, true));
-            if (this.inTransaction && rollbackOnError)
-                await this._execute('SAVEPOINT ' + this._onErrorSavePoint);
-            try {
-                const result = await this._execute(sql, options, cb);
-                if (commitLast)
-                    await this._execute('COMMIT');
-                else if (this.inTransaction && rollbackOnError) {
-                    await this._execute('RELEASE ' + this._onErrorSavePoint + ';');
-                }
-                return result;
-            }
-            catch (e) {
-                if (this.inTransaction && rollbackOnError)
-                    await this._execute('ROLLBACK TO ' + this._onErrorSavePoint + ';');
-                throw e;
-            }
-        })
-            .toPromise();
-    }
-    async startTransaction() {
-        if (!this.inTransaction)
-            await this.execute('BEGIN');
-    }
-    async savepoint(name) {
-        if (!(name && name.match(/^[a-zA-Z]\w+$/)))
-            throw new Error(`Invalid savepoint "${name}"`);
-        await this.execute('BEGIN; SAVEPOINT ' + name);
-    }
-    async commit() {
-        if (this.inTransaction)
-            await this.execute('COMMIT');
-    }
-    async rollback() {
-        if (this.inTransaction)
-            await this.execute('ROLLBACK');
-    }
-    async rollbackToSavepoint(name) {
-        if (!(name && name.match(/^[a-zA-Z]\w+$/)))
-            throw new Error(`Invalid savepoint "${name}"`);
-        await this.execute('ROLLBACK TO SAVEPOINT ' + name, { autoCommit: false });
-    }
-    async releaseSavepoint(name) {
-        if (!(name && name.match(/^[a-zA-Z]\w+$/)))
-            throw new Error(`Invalid savepoint "${name}"`);
-        await this.execute('RELEASE SAVEPOINT ' + name, { autoCommit: false });
-    }
-    ref() {
-        this._refCount++;
-    }
-    unref() {
-        this._refCount--;
-        return !this._refCount;
-    }
-    assertConnected() {
-        if (this.state === constants_js_1.ConnectionState.CLOSING)
-            throw new Error('Connection is closing');
-        if (this.state === constants_js_1.ConnectionState.CLOSED)
-            throw new Error('Connection closed');
-    }
-    async _execute(sql, options, cb) {
-        this.ref();
-        try {
-            const startTime = Date.now();
-            const result = {
-                totalCommands: 0,
-                totalTime: 0,
-                results: [],
-            };
-            const opts = options || {};
-            this.socket.sendQueryMessage(sql);
-            let currentStart = Date.now();
-            let parsers;
-            let current = { command: undefined };
-            let fields;
-            const typeMap = opts.typeMap || data_type_map_js_1.GlobalTypeMap;
-            return await this.socket.capture(async (code, msg, done) => {
-                switch (code) {
-                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
-                    case protocol_js_1.Protocol.BackendMessageCode.CopyInResponse:
-                    case protocol_js_1.Protocol.BackendMessageCode.CopyOutResponse:
-                    case protocol_js_1.Protocol.BackendMessageCode.EmptyQueryResponse:
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.RowDescription:
-                        fields = msg.fields;
-                        parsers = (0, get_parsers_js_1.getParsers)(typeMap, fields);
-                        current.fields = (0, wrap_row_description_js_1.wrapRowDescription)(typeMap, fields, DataFormat.text);
-                        current.rows = [];
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.DataRow:
-                        {
-                            let row = msg.columns.map((x) => x.toString('utf8'));
-                            // The null override assumes we can trust PG to always send the RowDescription first
-                            (0, parse_row_js_1.parseRow)(parsers, row, opts);
-                            if (opts.objectRows && current.fields)
-                                row = (0, convert_row_to_object_js_1.convertRowToObject)(current.fields, row);
-                            if (cb)
-                                cb('row', row);
-                            current.rows = current.rows || [];
-                            current.rows.push(row);
-                        }
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.CommandComplete:
-                        // Ignore BEGIN command that we added to sql
-                        current.command = msg.command;
-                        if (current.command === 'DELETE' ||
-                            current.command === 'INSERT' ||
-                            current.command === 'UPDATE') {
-                            current.rowsAffected = msg.rowCount;
-                        }
-                        current.executeTime = Date.now() - currentStart;
-                        if (current.rows)
-                            current.rowType =
-                                opts.objectRows && current.fields ? 'object' : 'array';
-                        result.results.push(current);
-                        if (cb)
-                            cb('command-complete', current);
-                        current = { command: undefined };
-                        currentStart = Date.now();
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.ReadyForQuery:
-                        this.transactionStatus = msg.status;
-                        result.totalTime = Date.now() - startTime;
-                        // Ignore COMMIT command that we added to sql
-                        result.totalCommands = result.results.length;
-                        done(undefined, result);
-                        break;
-                    default:
-                        break;
-                }
-            });
-        }
-        finally {
-            this.unref();
-        }
-    }
-    _onError(err) {
-        if (this.socket.state !== constants_js_1.ConnectionState.READY)
-            return;
-        this.emit('error', err);
-    }
-}
-exports.IntlConnection = IntlConnection;
-function getIntlConnection(connection) {
-    return connection._intlCon;
-}