postgrejs 2.22.7 → 2.23.0

package/cjs/connection/pool.js

@@ -1,236 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = void 0;
-const lightning_pool_1 = require("lightning-pool");
-const putil_varhelpers_1 = require("putil-varhelpers");
-const constants_js_1 = require("../constants.js");
-const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
-const connection_config_js_1 = require("../util/connection-config.js");
-const connection_js_1 = require("./connection.js");
-const intl_connection_js_1 = require("./intl-connection.js");
-class Pool extends safe_event_emitter_js_1.SafeEventEmitter {
-    constructor(config) {
-        super();
-        this._notificationListeners = new safe_event_emitter_js_1.SafeEventEmitter();
-        const cfg = (0, connection_config_js_1.getConnectionConfig)(config);
-        this.config = Object.freeze(cfg);
-        const poolOptions = {};
-        poolOptions.acquireMaxRetries = (0, putil_varhelpers_1.coerceToInt)(cfg.acquireMaxRetries, 0);
-        poolOptions.acquireRetryWait = (0, putil_varhelpers_1.coerceToInt)(cfg.acquireRetryWait, 2000);
-        poolOptions.acquireTimeoutMillis = (0, putil_varhelpers_1.coerceToInt)(cfg.acquireTimeoutMillis, 0);
-        poolOptions.idleTimeoutMillis = (0, putil_varhelpers_1.coerceToInt)(cfg.idleTimeoutMillis, 30000);
-        poolOptions.max = (0, putil_varhelpers_1.coerceToInt)(cfg.max, 10);
-        poolOptions.maxQueue = (0, putil_varhelpers_1.coerceToInt)(cfg.maxQueue, 1000);
-        poolOptions.max = (0, putil_varhelpers_1.coerceToInt)(cfg.max, 10);
-        poolOptions.min = (0, putil_varhelpers_1.coerceToInt)(cfg.min, 0);
-        poolOptions.minIdle = (0, putil_varhelpers_1.coerceToInt)(cfg.minIdle, 0);
-        poolOptions.validation = (0, putil_varhelpers_1.coerceToBoolean)(cfg.validation, false);
-        const poolFactory = {
-            create: async () => {
-                /* istanbul ignore next */
-                if (this.listenerCount('debug')) {
-                    this.emit('debug', {
-                        location: 'Pool.factory.create',
-                        pool: this,
-                        message: `new connection creating`,
-                    });
-                }
-                const intlCon = new intl_connection_js_1.IntlConnection(cfg);
-                await intlCon.connect();
-                intlCon.on('close', () => this._pool.destroy(intlCon));
-                /* istanbul ignore next */
-                if (this.listenerCount('debug')) {
-                    this.emit('debug', {
-                        location: 'Pool.factory.create',
-                        pool: this,
-                        message: `[${intlCon.processID}] connection created`,
-                    });
-                }
-                return intlCon;
-            },
-            destroy: intlCon => {
-                /* istanbul ignore next */
-                if (this.listenerCount('debug')) {
-                    this.emit('debug', {
-                        location: 'Pool.factory.destroy',
-                        pool: this,
-                        message: `[${intlCon.processID}] connection destroy`,
-                    });
-                }
-                return intlCon.close();
-            },
-            reset: async (intlCon) => {
-                /* istanbul ignore next */
-                if (this.listenerCount('debug')) {
-                    this.emit('debug', {
-                        location: 'Pool.factory.reset',
-                        pool: this,
-                        message: `[${intlCon.processID}] connection reset`,
-                    });
-                }
-                try {
-                    if (intlCon.state === constants_js_1.ConnectionState.READY) {
-                        await intlCon.execute('ROLLBACK;UNLISTEN *');
-                    }
-                }
-                finally {
-                    intlCon.removeAllListeners();
-                    intlCon.once('close', () => this._pool.destroy(intlCon));
-                    intlCon._refCount = 0;
-                }
-            },
-            validate: async (intlCon) => {
-                /* istanbul ignore next */
-                if (this.listenerCount('debug')) {
-                    this.emit('debug', {
-                        location: 'Pool.factory.validate',
-                        pool: this,
-                        message: `[${intlCon.processID}] connection validate`,
-                    });
-                }
-                if (intlCon.state !== constants_js_1.ConnectionState.READY)
-                    throw new Error('Connection is not active');
-                await intlCon.execute('select 1;');
-            },
-        };
-        this._pool = new lightning_pool_1.Pool(poolFactory, poolOptions);
-        this._pool.on('return', (...args) => this.emit('release', ...args));
-        this._pool.on('error', (...args) => this.emit('error', ...args));
-        this._pool.on('acquire', (...args) => this.emit('acquire', ...args));
-        this._pool.on('destroy', (...args) => this.emit('destroy', ...args));
-        this._pool.start();
-    }
-    /**
-     * Returns number of connections that are currently acquired
-     */
-    get acquiredConnections() {
-        return this._pool.acquired;
-    }
-    /**
-     * Returns number of unused connections in the pool
-     */
-    get idleConnections() {
-        return this._pool.available;
-    }
-    /**
-     * Returns total number of connections in the pool regardless of whether they are idle or in use
-     */
-    get totalConnections() {
-        return this._pool.size;
-    }
-    /**
-     * Obtains a connection from the connection pool
-     */
-    async acquire() {
-        const intlCon = await this._pool.acquire();
-        /* istanbul ignore next */
-        if (this.listenerCount('debug')) {
-            this.emit('debug', {
-                location: 'Pool.acquire',
-                pool: this,
-                message: `[${intlCon.processID}] acquired`,
-            });
-        }
-        const connection = new connection_js_1.Connection(this, intlCon);
-        /* istanbul ignore next */
-        if (this.listenerCount('debug'))
-            connection.on('debug', (...args) => this.emit('debug', ...args));
-        if (this.listenerCount('execute'))
-            connection.on('execute', (...args) => this.emit('execute', ...args));
-        if (this.listenerCount('query'))
-            connection.on('query', (...args) => this.emit('query', ...args));
-        return connection;
-    }
-    /**
-     * Shuts down the pool and destroys all resources.
-     */
-    async close(terminateWait) {
-        this._notificationListeners.removeAllListeners();
-        await this._notificationConnection?.close(terminateWait);
-        const ms = terminateWait == null ? 10000 : terminateWait;
-        return this._pool.closeAsync(ms);
-    }
-    /**
-     * Executes a script
-     */
-    async execute(sql, options) {
-        const connection = await this.acquire();
-        try {
-            return await connection.execute(sql, options);
-        }
-        finally {
-            await this.release(connection);
-        }
-    }
-    /**
-     * Executes a query
-     */
-    async query(sql, options) {
-        const connection = await this.acquire();
-        try {
-            return await connection.query(sql, options);
-        }
-        finally {
-            await this.release(connection);
-        }
-    }
-    async prepare(sql, options) {
-        const connection = await this.acquire();
-        const statement = await connection.prepare(sql, options);
-        statement.once('close', () => this._pool.release((0, intl_connection_js_1.getIntlConnection)(connection)));
-        return statement;
-    }
-    release(connection) {
-        return this._pool.releaseAsync((0, intl_connection_js_1.getIntlConnection)(connection));
-    }
-    async listen(channel, callback) {
-        if (!/^[A-Z]\w+$/i.test(channel))
-            throw new TypeError(`Invalid channel name`);
-        this._notificationListeners.on(channel, callback);
-        await this._initNotificationConnection();
-    }
-    async unListen(channel) {
-        if (!/^[A-Z]\w+$/i.test(channel))
-            throw new TypeError(`Invalid channel name`);
-        this._notificationListeners.removeAllListeners(channel);
-        if (!this._notificationListeners.eventNames().length) {
-            await this.unListenAll();
-        }
-        else if (this._notificationConnection)
-            await this._notificationConnection.unListen(channel);
-    }
-    async unListenAll() {
-        this._notificationListeners.removeAllListeners();
-        if (this._notificationConnection) {
-            const conn = this._notificationConnection;
-            this._notificationConnection = undefined;
-            await conn.close();
-        }
-    }
-    async _initNotificationConnection() {
-        if (this._notificationConnection)
-            return;
-        const conn = (this._notificationConnection = new connection_js_1.Connection(this.config));
-        // Reconnect on connection lost
-        conn.on('close', () => reConnect());
-        const registerEvents = async () => {
-            const channels = this._notificationListeners.eventNames();
-            for (const channel of channels) {
-                const fns = this._notificationListeners.listeners(channel);
-                for (const fn of fns) {
-                    await conn.listen(channel, fn);
-                }
-            }
-        };
-        const reConnect = async () => {
-            setTimeout(() => {
-                if (!this._notificationListeners.eventNames().length)
-                    return;
-                conn.connect().catch(() => reConnect());
-            }, 500).unref();
-        };
-        await conn.connect();
-        await registerEvents();
-    }
-}
-exports.Pool = Pool;

package/cjs/connection/portal.js

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Portal = void 0;
-const constants_js_1 = require("../constants.js");
-const data_type_map_js_1 = require("../data-type-map.js");
-const protocol_js_1 = require("../protocol/protocol.js");
-const intl_connection_js_1 = require("./intl-connection.js");
-class Portal {
-    constructor(statement, name) {
-        this._columnFormat = constants_js_1.DEFAULT_COLUMN_FORMAT;
-        this._statement = statement;
-        this._name = name;
-    }
-    get connection() {
-        return this._statement.connection;
-    }
-    get name() {
-        return this._name;
-    }
-    async bind(params, queryOptions) {
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        intoCon.ref();
-        try {
-            const socket = intoCon.socket;
-            this._columnFormat =
-                queryOptions.columnFormat != null
-                    ? queryOptions.columnFormat
-                    : protocol_js_1.Protocol.DataFormat.binary;
-            socket.sendBindMessage({
-                typeMap: queryOptions.typeMap || data_type_map_js_1.GlobalTypeMap,
-                statement: this._statement.name,
-                portal: this.name,
-                paramTypes: this._statement.paramTypes,
-                params,
-                queryOptions,
-            });
-            socket.sendFlushMessage();
-            return await socket.capture(async (code, msg, done) => {
-                switch (code) {
-                    case protocol_js_1.Protocol.BackendMessageCode.BindComplete:
-                        done();
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
-                        break;
-                    default:
-                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
-                }
-            });
-        }
-        finally {
-            intoCon.unref();
-        }
-    }
-    async retrieveFields() {
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        intoCon.ref();
-        try {
-            const socket = intoCon.socket;
-            socket.sendDescribeMessage({ type: 'P', name: this.name });
-            socket.sendFlushMessage();
-            return await socket.capture(async (code, msg, done) => {
-                switch (code) {
-                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.NoData:
-                        done();
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.RowDescription:
-                        done(undefined, msg.fields);
-                        break;
-                    default:
-                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
-                }
-            });
-        }
-        finally {
-            intoCon.unref();
-        }
-    }
-    async execute(fetchCount) {
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        intoCon.ref();
-        try {
-            const socket = intoCon.socket;
-            socket.sendExecuteMessage({
-                portal: this.name,
-                fetchCount: fetchCount || 100,
-            });
-            socket.sendFlushMessage();
-            const rows = [];
-            return await socket.capture(async (code, msg, done) => {
-                switch (code) {
-                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.NoData:
-                        done(undefined, { code });
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.DataRow:
-                        if (Array.isArray(this._columnFormat)) {
-                            rows.push(msg.columns.map((buf, i) => this._columnFormat[i] ===
-                                protocol_js_1.Protocol.DataFormat.text
-                                ? buf.toString('utf8')
-                                : buf));
-                        }
-                        else if (this._columnFormat === protocol_js_1.Protocol.DataFormat.binary)
-                            rows.push(msg.columns);
-                        else
-                            rows.push(msg.columns.map((buf) => buf.toString('utf8')));
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.PortalSuspended:
-                        done(undefined, { code, rows });
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.CommandComplete:
-                        done(undefined, {
-                            code,
-                            rows,
-                            command: msg.command,
-                            rowCount: msg.rowCount,
-                        });
-                        break;
-                    default:
-                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
-                }
-            });
-        }
-        finally {
-            intoCon.unref();
-        }
-    }
-    async close() {
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        intoCon.ref();
-        try {
-            const socket = intoCon.socket;
-            socket.sendCloseMessage({ type: 'P', name: this.name });
-            socket.sendSyncMessage();
-            return await socket.capture(async (code, msg, done) => {
-                switch (code) {
-                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.CloseComplete:
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.ReadyForQuery:
-                        intoCon.transactionStatus = msg.status;
-                        done();
-                        break;
-                    default:
-                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
-                }
-            });
-        }
-        finally {
-            intoCon.unref();
-        }
-    }
-}
-exports.Portal = Portal;

package/cjs/connection/prepared-statement.js

@@ -1,226 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreparedStatement = void 0;
-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 protocol_js_1 = require("../protocol/protocol.js");
-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 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 cursor_js_1 = require("./cursor.js");
-const intl_connection_js_1 = require("./intl-connection.js");
-const portal_js_1 = require("./portal.js");
-let statementCounter = 0;
-let portalCounter = 0;
-class PreparedStatement extends safe_event_emitter_js_1.SafeEventEmitter {
-    constructor(connection, sql, paramTypes) {
-        super();
-        this._sql = '';
-        this._name = '';
-        this._refCount = 0;
-        this._connection = connection;
-        this._name = 'S_' + ++statementCounter;
-        this._sql = sql;
-        this._paramTypes = paramTypes;
-        this._onErrorSavePoint = 'SP_' + Math.round(Math.random() * 100000000);
-    }
-    static async prepare(connection, sql, options) {
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(connection);
-        intoCon.assertConnected();
-        const socket = intoCon.socket;
-        const statement = new PreparedStatement(connection, sql, options?.paramTypes);
-        await intoCon.statementQueue
-            .enqueue(async () => {
-            intoCon.ref();
-            try {
-                socket.sendParseMessage({
-                    statement: statement.name,
-                    sql: statement.sql,
-                    paramTypes: statement.paramTypes,
-                });
-                socket.sendFlushMessage();
-                try {
-                    await socket.capture(async (code, msg, done) => {
-                        if (code === protocol_js_1.Protocol.BackendMessageCode.ParseComplete)
-                            done();
-                        // May be Protocol.BackendMessageCode.NoticeResponse
-                    });
-                }
-                finally {
-                    socket.sendSyncMessage();
-                    await socket.capture(async (code, msg, done) => {
-                        if (code === protocol_js_1.Protocol.BackendMessageCode.ReadyForQuery)
-                            done();
-                        // May be Protocol.BackendMessageCode.NoticeResponse
-                    });
-                }
-            }
-            finally {
-                intoCon.unref();
-            }
-        })
-            .toPromise();
-        statement._refCount = 1;
-        return statement;
-    }
-    get connection() {
-        return this._connection;
-    }
-    get name() {
-        return this._name;
-    }
-    get sql() {
-        return this._sql;
-    }
-    get paramTypes() {
-        return this._paramTypes;
-    }
-    async execute(options = {}) {
-        const intlCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        const transactionCommand = this.sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
-        let beginFirst = false;
-        let commitLast = false;
-        if (!transactionCommand) {
-            if (!intlCon.inTransaction &&
-                (options?.autoCommit != null
-                    ? options?.autoCommit
-                    : intlCon.config.autoCommit) === false) {
-                beginFirst = true;
-            }
-            if (intlCon.inTransaction && options?.autoCommit)
-                commitLast = true;
-        }
-        if (beginFirst)
-            await intlCon.execute('BEGIN');
-        const rollbackOnError = !transactionCommand &&
-            (options?.rollbackOnError != null
-                ? options.rollbackOnError
-                : (0, putil_varhelpers_1.coerceToBoolean)(intlCon.config.rollbackOnError, true));
-        if (intlCon.inTransaction && rollbackOnError)
-            await intlCon.execute('SAVEPOINT ' + this._onErrorSavePoint);
-        try {
-            const result = await intlCon.statementQueue
-                .enqueue(() => this._execute(options))
-                .toPromise();
-            if (commitLast)
-                await intlCon.execute('COMMIT');
-            else if (intlCon.inTransaction && rollbackOnError) {
-                await intlCon.execute('RELEASE ' + this._onErrorSavePoint + ';');
-            }
-            return result;
-        }
-        catch (e) {
-            if (intlCon.inTransaction && rollbackOnError) {
-                await intlCon.execute('ROLLBACK TO ' + this._onErrorSavePoint + ';');
-            }
-            throw e;
-        }
-    }
-    async close() {
-        --this._refCount;
-        if (this._refCount > 0)
-            return;
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        await intoCon.statementQueue.enqueue(() => this._close()).toPromise();
-    }
-    async cancel() {
-        throw new Error('Not implemented yet');
-    }
-    async _execute(options = {}) {
-        let portal;
-        const intlCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        intlCon.ref();
-        try {
-            const result = { command: undefined };
-            const startTime = Date.now();
-            const t = Date.now();
-            // Create portal
-            const portalName = 'P_' + ++portalCounter;
-            portal = new portal_js_1.Portal(this, portalName);
-            await portal.bind(options.params, options);
-            const fields = await portal.retrieveFields();
-            const typeMap = options.typeMap || data_type_map_js_1.GlobalTypeMap;
-            let parsers;
-            let resultFields;
-            if (fields) {
-                parsers = (0, get_parsers_js_1.getParsers)(typeMap, fields);
-                resultFields = (0, wrap_row_description_js_1.wrapRowDescription)(typeMap, fields, options.columnFormat || constants_js_1.DEFAULT_COLUMN_FORMAT);
-                result.fields = resultFields;
-                result.rowType = options.objectRows ? 'object' : 'array';
-                if (options.cursor) {
-                    result.cursor = new cursor_js_1.Cursor(this, portal, resultFields, parsers, options);
-                    this._refCount++;
-                    portal = undefined;
-                    return result;
-                }
-            }
-            const executeResult = await portal.execute(options.fetchCount);
-            result.executeTime = Date.now() - t;
-            if (executeResult.command)
-                result.command = executeResult.command;
-            if (resultFields && parsers && executeResult.rows) {
-                if (!result.command)
-                    result.command = 'SELECT';
-                const rows = (result.rows = executeResult.rows);
-                const l = rows.length;
-                let row;
-                for (let i = 0; i < l; i++) {
-                    row = rows[i];
-                    (0, parse_row_js_1.parseRow)(parsers, row, options);
-                    if (options.objectRows) {
-                        rows[i] = (0, convert_row_to_object_js_1.convertRowToObject)(resultFields, row);
-                    }
-                }
-            }
-            if (result.command === 'DELETE' ||
-                result.command === 'INSERT' ||
-                result.command === 'UPDATE') {
-                result.rowsAffected = executeResult.rowCount;
-            }
-            result.executeTime = Date.now() - startTime;
-            return result;
-        }
-        finally {
-            intlCon.unref();
-            if (portal)
-                await portal.close();
-        }
-    }
-    async _close() {
-        if (--this._refCount > 0)
-            return;
-        const intoCon = (0, intl_connection_js_1.getIntlConnection)(this.connection);
-        intoCon.ref();
-        try {
-            const socket = intoCon.socket;
-            socket.sendCloseMessage({ type: 'S', name: this.name });
-            socket.sendSyncMessage();
-            await socket.capture(async (code, msg, done) => {
-                switch (code) {
-                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.CloseComplete:
-                        break;
-                    case protocol_js_1.Protocol.BackendMessageCode.ReadyForQuery:
-                        intoCon.transactionStatus = msg.status;
-                        done();
-                        break;
-                    default:
-                        done(new Error(`Server returned unexpected response message (0x${code.toString(16)})`));
-                }
-            });
-        }
-        finally {
-            intoCon.unref();
-        }
-        this.emit('close');
-    }
-    [Symbol.asyncDispose]() {
-        return this.close();
-    }
-}
-exports.PreparedStatement = PreparedStatement;