postgrejs 2.12.0

package/esm/connection/cursor.js

@@ -0,0 +1,86 @@
+import DoublyLinked from 'doublylinked';
+import { TaskQueue } from 'power-tasks';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { convertRowToObject } from '../util/convert-row-to-object.js';
+import { parseRow } from '../util/parse-row.js';
+export class Cursor extends SafeEventEmitter {
+    constructor(statement, portal, fields, parsers, queryOptions) {
+        super();
+        this._taskQueue = new TaskQueue({ concurrency: 1 });
+        this._rows = new DoublyLinked();
+        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];
+                        parseRow(this._parsers, row, this._queryOptions);
+                        if (objectRows)
+                            rows[i] = convertRowToObject(fields, row);
+                    }
+                }
+                this._rows.push(...r.rows);
+                this.emit('fetch', r.rows);
+            }
+            else {
+                await this.close();
+            }
+        })
+            .toPromise();
+    }
+    [Symbol.asyncDispose]() {
+        return this.close();
+    }
+}

package/esm/connection/intl-connection.js

@@ -0,0 +1,238 @@
+import { TaskQueue } from 'power-tasks';
+import { coerceToBoolean } from 'putil-varhelpers';
+import { ConnectionState } from '../constants.js';
+import { GlobalTypeMap } from '../data-type-map.js';
+import { PgSocket } from '../protocol/pg-socket.js';
+import { Protocol } from '../protocol/protocol.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { getConnectionConfig } from '../util/connection-config.js';
+import { convertRowToObject } from '../util/convert-row-to-object.js';
+import { escapeLiteral } from '../util/escape-literal.js';
+import { getParsers } from '../util/get-parsers.js';
+import { parseRow } from '../util/parse-row.js';
+import { wrapRowDescription } from '../util/wrap-row-description.js';
+const DataFormat = Protocol.DataFormat;
+export class IntlConnection extends SafeEventEmitter {
+    constructor(config) {
+        super();
+        this._refCount = 0;
+        this.transactionStatus = 'I';
+        this.statementQueue = new TaskQueue({ concurrency: 1 });
+        this._config = Object.freeze(getConnectionConfig(config));
+        this.socket = new 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 === 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 = ' + escapeLiteral(this.config.schema) + ';';
+        if (this.config.timezone)
+            startupCommand += 'SET timezone TO ' + escapeLiteral(this.config.timezone) + ';';
+        if (startupCommand)
+            await this.execute(startupCommand, { autoCommit: true });
+        this.emit('ready');
+    }
+    async close() {
+        if (this.state === ConnectionState.CLOSED)
+            return;
+        this.statementQueue.clearQueue();
+        return new Promise(resolve => {
+            if (this.socket.state === 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
+                    : 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 === ConnectionState.CLOSING)
+            throw new Error('Connection is closing');
+        if (this.state === 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 || GlobalTypeMap;
+            return await this.socket.capture(async (code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                    case Protocol.BackendMessageCode.CopyInResponse:
+                    case Protocol.BackendMessageCode.CopyOutResponse:
+                    case Protocol.BackendMessageCode.EmptyQueryResponse:
+                        break;
+                    case Protocol.BackendMessageCode.RowDescription:
+                        fields = msg.fields;
+                        parsers = getParsers(typeMap, fields);
+                        current.fields = wrapRowDescription(typeMap, fields, DataFormat.text);
+                        current.rows = [];
+                        break;
+                    case Protocol.BackendMessageCode.DataRow:
+                        let row = msg.columns.map((x) => x.toString('utf8'));
+                        parseRow(parsers, row, opts);
+                        if (opts.objectRows && current.fields)
+                            row = convertRowToObject(current.fields, row);
+                        if (cb)
+                            cb('row', row);
+                        current.rows = current.rows || [];
+                        current.rows.push(row);
+                        break;
+                    case 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.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 !== ConnectionState.READY)
+            return;
+        this.emit('error', err);
+    }
+}
+export function getIntlConnection(connection) {
+    return connection._intlCon;
+}

package/esm/connection/pool.js

@@ -0,0 +1,222 @@
+import { Pool as LightningPool } from 'lightning-pool';
+import { coerceToBoolean, coerceToInt } from 'putil-varhelpers';
+import { ConnectionState } from '../constants.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { getConnectionConfig } from '../util/connection-config.js';
+import { Connection } from './connection.js';
+import { getIntlConnection, IntlConnection } from './intl-connection.js';
+export class Pool extends SafeEventEmitter {
+    constructor(config) {
+        super();
+        this._notificationListeners = new SafeEventEmitter();
+        const cfg = getConnectionConfig(config);
+        this.config = Object.freeze(cfg);
+        const poolOptions = {};
+        poolOptions.acquireMaxRetries = coerceToInt(cfg.acquireMaxRetries, 0);
+        poolOptions.acquireRetryWait = coerceToInt(cfg.acquireRetryWait, 2000);
+        poolOptions.acquireTimeoutMillis = coerceToInt(cfg.acquireTimeoutMillis, 0);
+        poolOptions.idleTimeoutMillis = coerceToInt(cfg.idleTimeoutMillis, 30000);
+        poolOptions.max = coerceToInt(cfg.max, 10);
+        poolOptions.maxQueue = coerceToInt(cfg.maxQueue, 1000);
+        poolOptions.max = coerceToInt(cfg.max, 10);
+        poolOptions.min = coerceToInt(cfg.min, 0);
+        poolOptions.minIdle = coerceToInt(cfg.minIdle, 0);
+        poolOptions.validation = 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 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 === 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 !== ConnectionState.READY)
+                    throw new Error('Connection is not active');
+                await intlCon.execute('select 1;');
+            },
+        };
+        this._pool = new LightningPool(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(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(getIntlConnection(connection)));
+        return statement;
+    }
+    release(connection) {
+        return this._pool.releaseAsync(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(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();
+    }
+}

package/esm/connection/portal.js

@@ -0,0 +1,144 @@
+import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
+import { GlobalTypeMap } from '../data-type-map.js';
+import { Protocol } from '../protocol/protocol.js';
+import { getIntlConnection } from './intl-connection.js';
+export class Portal {
+    constructor(statement, name) {
+        this._columnFormat = 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 = getIntlConnection(this.connection);
+        intoCon.ref();
+        try {
+            const socket = intoCon.socket;
+            this._columnFormat = queryOptions.columnFormat != null ? queryOptions.columnFormat : Protocol.DataFormat.binary;
+            socket.sendBindMessage({
+                typeMap: queryOptions.typeMap || 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.BackendMessageCode.BindComplete:
+                        done();
+                        break;
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
+                }
+            });
+        }
+        finally {
+            intoCon.unref();
+        }
+    }
+    async retrieveFields() {
+        const intoCon = 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.BackendMessageCode.NoticeResponse:
+                        break;
+                    case Protocol.BackendMessageCode.NoData:
+                        done();
+                        break;
+                    case 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 = 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.BackendMessageCode.NoticeResponse:
+                        break;
+                    case Protocol.BackendMessageCode.NoData:
+                        done(undefined, { code });
+                        break;
+                    case Protocol.BackendMessageCode.DataRow:
+                        if (Array.isArray(this._columnFormat)) {
+                            rows.push(msg.columns.map((buf, i) => this._columnFormat[i] === Protocol.DataFormat.text ? buf.toString('utf8') : buf));
+                        }
+                        else if (this._columnFormat === Protocol.DataFormat.binary)
+                            rows.push(msg.columns);
+                        else
+                            rows.push(msg.columns.map((buf) => buf.toString('utf8')));
+                        break;
+                    case Protocol.BackendMessageCode.PortalSuspended:
+                        done(undefined, { code, rows });
+                        break;
+                    case 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 = 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.BackendMessageCode.NoticeResponse:
+                        break;
+                    case Protocol.BackendMessageCode.CloseComplete:
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        intoCon.transactionStatus = msg.status;
+                        done();
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
+                }
+            });
+        }
+        finally {
+            intoCon.unref();
+        }
+    }
+}