@depup/pg-promise 12.6.2-depup.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2018 Vitaly Tomilov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @depup/pg-promise
+
+> Dependency-bumped version of [pg-promise](https://www.npmjs.com/package/pg-promise)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/pg-promise
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [pg-promise](https://www.npmjs.com/package/pg-promise) @ 12.6.2 |
+| Processed | 2026-03-09 |
+| Smoke test | passed |
+| Deps updated | 0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/pg-promise
+
+License inherited from the original package.

package/lib/assert.js

@@ -0,0 +1,10 @@
+const {assertOptions} = require('assert-options');
+
+// this to allow override options-related errors globally (for pg-promise)
+global.pgPromiseAssert = assertOptions;
+
+module.exports = {
+    assert() {
+        return global.pgPromiseAssert.apply(null, [...arguments]);
+    }
+};

package/lib/connect.js

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2015-present, Vitaly Tomilov
+ *
+ * See the LICENSE file at the top-level directory of this distribution
+ * for licensing information.
+ *
+ * Removal or modification of this copyright notice is prohibited.
+ */
+
+const {Events} = require('./events');
+const {ColorConsole} = require('./utils/color');
+
+const npm = {
+    utils: require('./utils'),
+    text: require('./text'),
+    formatting: require('./formatting')
+};
+
+function poolConnect(ctx, db) {
+    return new Promise((resolve, reject) => {
+        const p = db.$pool;
+        if (p.ending) {
+            db.$destroy();
+            const err = new Error(npm.text.poolDestroyed);
+            Events.error(ctx.options, err, {
+                dc: ctx.dc
+            });
+            reject(err);
+            return;
+        }
+        p.connect((err, client) => {
+            if (err) {
+                Events.error(ctx.options, err, {
+                    cn: npm.utils.getSafeConnection(ctx.cn),
+                    dc: ctx.dc
+                });
+                reject(err);
+            } else {
+                if ('$useCount' in client) {
+                    // Make sure useCount drops to 1, if it ever reaches the maximum integer number;
+                    // We do not drop it to zero, to avoid rerun of initialization queries that
+                    // usually check for useCount === 0;
+                    // istanbul ignore if
+                    if (client.$useCount >= Number.MAX_SAFE_INTEGER) {
+                        client.$useCount = 1; // resetting; cannot auto-test this
+                    } else {
+                        client.$useCount = ++client.$useCount;
+                    }
+                } else {
+                    Object.defineProperty(client, '$useCount', {
+                        value: 0,
+                        configurable: false,
+                        enumerable: false,
+                        writable: true
+                    });
+                    setSchema(client, ctx);
+                }
+                setCtx(client, ctx);
+                const end = lockClientEnd(client);
+                client.on('error', onError);
+                resolve({
+                    client,
+                    useCount: client.$useCount,
+                    release(kill) {
+                        client.end = end;
+                        client.release(kill || client.$connectionError);
+                        Events.disconnect(ctx, client);
+                        client.removeListener('error', onError);
+                    }
+                });
+                Events.connect(ctx, client, client.$useCount);
+            }
+        });
+    });
+}
+
+function directConnect(ctx, config) {
+    return new Promise((resolve, reject) => {
+        const client = new config.pgp.pg.Client(ctx.cn);
+        client.connect(err => {
+            if (err) {
+                Events.error(ctx.options, err, {
+                    cn: npm.utils.getSafeConnection(ctx.cn),
+                    dc: ctx.dc
+                });
+                reject(err);
+            } else {
+                setSchema(client, ctx);
+                setCtx(client, ctx);
+                const end = lockClientEnd(client);
+                client.on('error', onError);
+                resolve({
+                    client,
+                    useCount: 0,
+                    release() {
+                        client.end = end;
+                        const p = new Promise((res, rej) => client.end().then(res).catch(rej));
+                        Events.disconnect(ctx, client);
+                        client.removeListener('error', onError);
+                        return p;
+                    }
+                });
+                Events.connect(ctx, client, 0);
+            }
+        });
+    });
+}
+
+// this event only happens when the connection is lost physically,
+// which cannot be tested automatically; removing from coverage:
+// istanbul ignore next
+function onError(err) {
+    const ctx = this.$ctx;
+    const cn = npm.utils.getSafeConnection(ctx.cn);
+    Events.error(ctx.options, err, {cn, dc: ctx.dc});
+    if (ctx.cnOptions && typeof ctx.cnOptions.onLost === 'function' && !ctx.notified) {
+        try {
+            ctx.cnOptions.onLost.call(this, err, {
+                cn,
+                dc: ctx.dc,
+                start: ctx.start,
+                client: this
+            });
+        } catch (e) {
+            ColorConsole.error(e && e.stack || e);
+        }
+        ctx.notified = true;
+    }
+}
+
+function lockClientEnd(client) {
+    const end = client.end;
+    client.end = doNotCall => {
+        // This call can happen only in the following two cases:
+        // 1. the client made the call directly, against the library's documentation (invalid code)
+        // 2. connection with the server broke, and the pool is terminating all clients forcefully.
+        ColorConsole.error(`${npm.text.clientEnd}\n${npm.utils.getLocalStack(1, 3)}\n`);
+        if (!doNotCall) {
+            end.call(client);
+        }
+    };
+    return end;
+}
+
+function setCtx(client, ctx) {
+    Object.defineProperty(client, '$ctx', {
+        value: ctx,
+        writable: true
+    });
+}
+
+function setSchema(client, ctx) {
+    let s = ctx.options.schema;
+    if (!s) {
+        return;
+    }
+    if (typeof s === 'function') {
+        s = s.call(ctx.dc, ctx.dc);
+    }
+    if (Array.isArray(s)) {
+        s = s.filter(a => a && typeof a === 'string');
+    }
+    if (typeof s === 'string' || (Array.isArray(s) && s.length)) {
+        client.query(npm.formatting.as.format('SET search_path TO $1:name', [s]), err => {
+            // istanbul ignore if;
+            if (err) {
+                // This is unlikely to ever happen, unless the connection is created faulty,
+                // and fails on the very first query, which is impossible to test automatically.
+                throw err;
+            }
+        });
+    }
+}
+
+module.exports = config => ({
+    pool: (ctx, db) => poolConnect(ctx, db),
+    direct: ctx => directConnect(ctx, config)
+});

package/lib/context.js

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2015-present, Vitaly Tomilov
+ *
+ * See the LICENSE file at the top-level directory of this distribution
+ * for licensing information.
+ *
+ * Removal or modification of this copyright notice is prohibited.
+ */
+
+/**
+ * @class ConnectionContext
+ * @private
+ * @summary Internal connection context.
+ *
+ * @param {object} cc
+ * Connection Context.
+ *
+ * @param {object} cc.cn
+ * Connection details
+ *
+ * @param {*} cc.dc
+ * Database Context
+ *
+ * @param {object} cc.options
+ * Library's Initialization Options
+ *
+ * @param {object} cc.db
+ * Database Session we're attached to, if any.
+ *
+ * @param {number} cc.level
+ * Task Level
+ *
+ * @param {number} cc.txLevel
+ * Transaction Level
+ *
+ * @param {object} cc.parentCtx
+ * Connection Context of the parent operation, if any.
+ *
+ */
+class ConnectionContext {
+
+    constructor(cc) {
+        this.cn = cc.cn; // connection details;
+        this.dc = cc.dc; // database context;
+        this.options = cc.options; // library options;
+        this.db = cc.db; // database session;
+        this.level = cc.level; // task level;
+        this.txLevel = cc.txLevel; // transaction level;
+        this.parentCtx = null; // parent context
+        this.taskCtx = null; // task context
+        this.start = null; // Date/Time when connected
+        this.txCount = 0;
+    }
+
+    connect(db) {
+        this.db = db;
+        this.start = new Date();
+    }
+
+    disconnect(kill) {
+        if (this.db) {
+            const p = this.db.release(kill);
+            this.db = null;
+            return p;
+        }
+    }
+
+    clone() {
+        const obj = new ConnectionContext(this);
+        obj.parent = this;
+        obj.parentCtx = this.taskCtx;
+        return obj;
+    }
+
+    get nextTxCount() {
+        let txCurrent = this, txTop = this;
+        while (txCurrent.parent) {
+            txCurrent = txCurrent.parent;
+            if (txCurrent.taskCtx && txCurrent.taskCtx.isTX) {
+                txTop = txCurrent;
+            }
+        }
+        return txTop.txCount++;
+    }
+}
+
+/**
+ * Connection Context
+ * @module context
+ * @author Vitaly Tomilov
+ * @private
+ */
+module.exports = {ConnectionContext};

package/lib/database-pool.js

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2015-present, Vitaly Tomilov
+ *
+ * See the LICENSE file at the top-level directory of this distribution
+ * for licensing information.
+ *
+ * Removal or modification of this copyright notice is prohibited.
+ */
+
+const {ColorConsole} = require('./utils/color');
+
+const npm = {
+    utils: require('./utils')
+};
+
+/**
+ * @class DatabasePool
+ * @static
+ * @private
+ */
+class DatabasePool {
+
+    /**
+     * Global instance of the database pool repository.
+     *
+     * @returns {{dbMap: {}, dbs: Array}}
+     */
+    static get instance() {
+        const s = Symbol.for('pgPromiseDatabasePool');
+        let scope = global[s];
+        if (!scope) {
+            scope = {
+                dbMap: {}, // map of used database context keys (connection + dc)
+                dbs: [] // all database objects
+            };
+            global[s] = scope;
+        }
+        return scope;
+    }
+
+    /**
+     * @method DatabasePool.register
+     * @static
+     * @description
+     *  - Registers each database object, to make sure no duplicates connections are used,
+     *    and if they are, produce a warning;
+     *  - Registers each Pool object, to be able to release them all when requested.
+     *
+     * @param {Database} db - The new Database object being registered.
+     */
+    static register(db) {
+        const cnKey = DatabasePool.createContextKey(db);
+        npm.utils.addReadProp(db, '$cnKey', cnKey, true);
+        const {dbMap, dbs} = DatabasePool.instance;
+        if (cnKey in dbMap) {
+            dbMap[cnKey]++;
+            /* istanbul ignore if */
+            if (!db.$config.options.noWarnings) {
+                ColorConsole.warn(`WARNING: Creating a duplicate database object for the same connection.\n${npm.utils.getLocalStack(4, 3)}\n`);
+            }
+        } else {
+            dbMap[cnKey] = 1;
+        }
+        dbs.push(db);
+    }
+
+    /**
+     * @method DatabasePool.unregister
+     * @static
+     * @param db
+     */
+    static unregister(db) {
+        const cnKey = db.$cnKey;
+        const {dbMap} = DatabasePool.instance;
+        if (!--dbMap[cnKey]) {
+            delete dbMap[cnKey];
+        }
+    }
+
+    /**
+     * @method DatabasePool.shutDown
+     * @static
+     */
+    static shutDown() {
+        const {instance} = DatabasePool;
+        instance.dbs.forEach(db => {
+            db.$destroy();
+        });
+        instance.dbs.length = 0;
+        instance.dbMap = {};
+    }
+
+    /**
+     * @method DatabasePool.createContextKey
+     * @static
+     * @description
+     * For connections that are objects it reorders the keys alphabetically,
+     * and then serializes the result into a JSON string.
+     *
+     * @param {Database} db - Database instance.
+     */
+    static createContextKey(db) {
+        let cn = db.$cn;
+        if (typeof cn === 'object') {
+            const obj = {}, keys = Object.keys(cn).sort();
+            keys.forEach(name => {
+                obj[name] = cn[name];
+            });
+            cn = obj;
+        }
+        return npm.utils.toJson(npm.utils.getSafeConnection(cn)) + npm.utils.toJson(db.$dc);
+    }
+}
+
+module.exports = {DatabasePool};