postgrejs 2.12.0

package/cjs/connection/intl-connection.js

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

package/cjs/connection/pool.js

@@ -0,0 +1,226 @@
+"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));
+        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

@@ -0,0 +1,148 @@
+"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;