pg-promise 11.4.0 → 11.4.2

package/lib/text.js

@@ -9,32 +9,32 @@
 
 /* All error messages used in the module */
 
-const streamVersion = require(`../package.json`)
-    .devDependencies[`pg-query-stream`];
+const streamVersion = require('../package.json')
+    .devDependencies['pg-query-stream'];
 
 module.exports = {
-    nativeError: `Failed to initialize Native Bindings.`,
+    nativeError: 'Failed to initialize Native Bindings.',
 
     /* Database errors */
-    queryDisconnected: `Cannot execute a query on a disconnected client.`,
-    invalidQuery: `Invalid query format.`,
-    invalidFunction: `Invalid function name.`,
-    invalidProc: `Invalid procedure name.`,
-    invalidMask: `Invalid Query Result Mask specified.`,
-    looseQuery: `Querying against a released or lost connection.`,
+    queryDisconnected: 'Cannot execute a query on a disconnected client.',
+    invalidQuery: 'Invalid query format.',
+    invalidFunction: 'Invalid function name.',
+    invalidProc: 'Invalid procedure name.',
+    invalidMask: 'Invalid Query Result Mask specified.',
+    looseQuery: 'Querying against a released or lost connection.',
 
     /* result errors */
-    notEmpty: `No return data was expected.`,
-    noData: `No data returned from the query.`,
-    multiple: `Multiple rows were not expected.`,
+    notEmpty: 'No return data was expected.',
+    noData: 'No data returned from the query.',
+    multiple: 'Multiple rows were not expected.',
 
     /* streaming support */
-    nativeStreaming: `Streaming doesn't work with Native Bindings.`,
+    nativeStreaming: 'Streaming doesn\'t work with Native Bindings.',
     invalidStream: `Invalid or missing stream object: pg-query-stream >= v${streamVersion} was expected`,
-    invalidStreamState: `Invalid stream state.`,
-    invalidStreamCB: `Invalid or missing stream initialization callback.`,
+    invalidStreamState: 'Invalid stream state.',
+    invalidStreamCB: 'Invalid or missing stream initialization callback.',
 
     /* connection errors */
-    poolDestroyed: `Connection pool of the database object has been destroyed.`,
-    clientEnd: `Abnormal client.end() call, due to invalid code or failed server connection.`
+    poolDestroyed: 'Connection pool of the database object has been destroyed.',
+    clientEnd: 'Abnormal client.end() call, due to invalid code or failed server connection.'
 };

package/lib/tx-mode.js

@@ -7,9 +7,9 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {InnerState} = require(`./inner-state`);
-const {addInspection} = require(`./utils`);
-const {assert} = require(`./assert`);
+const {InnerState} = require('./inner-state');
+const {addInspection} = require('./utils');
+const {assert} = require('./assert');
 
 /**
  * @enum {number}
@@ -103,42 +103,42 @@ const isolationLevel = {
 class TransactionMode extends InnerState {
 
     constructor(options) {
-        options = assert(options, [`tiLevel`, `deferrable`, `readOnly`]);
+        options = assert(options, ['tiLevel', 'deferrable', 'readOnly']);
         const {readOnly, deferrable} = options;
         let {tiLevel} = options;
-        let level, accessMode, deferrableMode, begin = `begin`;
+        let level, accessMode, deferrableMode, begin = 'begin';
         tiLevel = (tiLevel > 0) ? parseInt(tiLevel) : 0;
 
         if (tiLevel > 0 && tiLevel < 4) {
-            const values = [`serializable`, `repeatable read`, `read committed`];
-            level = `isolation level ` + values[tiLevel - 1];
+            const values = ['serializable', 'repeatable read', 'read committed'];
+            level = 'isolation level ' + values[tiLevel - 1];
         }
         if (readOnly) {
-            accessMode = `read only`;
+            accessMode = 'read only';
         } else {
             if (readOnly !== undefined) {
-                accessMode = `read write`;
+                accessMode = 'read write';
             }
         }
         // From the official documentation: http://www.postgresql.org/docs/9.5/static/sql-set-transaction.html
         // The DEFERRABLE transaction property has no effect unless the transaction is also SERIALIZABLE and READ ONLY
         if (tiLevel === isolationLevel.serializable && readOnly) {
             if (deferrable) {
-                deferrableMode = `deferrable`;
+                deferrableMode = 'deferrable';
             } else {
                 if (deferrable !== undefined) {
-                    deferrableMode = `not deferrable`;
+                    deferrableMode = 'not deferrable';
                 }
             }
         }
         if (level) {
-            begin += ` ` + level;
+            begin += ' ' + level;
         }
         if (accessMode) {
-            begin += ` ` + accessMode;
+            begin += ' ' + accessMode;
         }
         if (deferrableMode) {
-            begin += ` ` + deferrableMode;
+            begin += ' ' + deferrableMode;
         }
 
         super({begin, capBegin: begin.toUpperCase()});

package/lib/types/index.js

@@ -7,9 +7,9 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {ServerFormatting} = require(`./server-formatting`);
-const {PreparedStatement} = require(`./prepared-statement`);
-const {ParameterizedQuery} = require(`./parameterized-query`);
+const {ServerFormatting} = require('./server-formatting');
+const {PreparedStatement} = require('./prepared-statement');
+const {ParameterizedQuery} = require('./parameterized-query');
 
 module.exports = {
     ServerFormatting,

package/lib/types/parameterized-query.js

@@ -7,14 +7,14 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {ServerFormatting} = require(`./server-formatting`);
-const {ParameterizedQueryError} = require(`../errors`);
-const {QueryFile} = require(`../query-file`);
-const {assert} = require(`../assert`);
+const {ServerFormatting} = require('./server-formatting');
+const {ParameterizedQueryError} = require('../errors');
+const {QueryFile} = require('../query-file');
+const {assert} = require('../assert');
 
 const npm = {
-    EOL: require(`os`).EOL,
-    utils: require(`../utils`)
+    EOL: require('os').EOL,
+    utils: require('../utils')
 };
 
 /**
@@ -86,12 +86,12 @@ const npm = {
  */
 class ParameterizedQuery extends ServerFormatting {
     constructor(options) {
-        if (typeof options === `string` || options instanceof QueryFile) {
+        if (typeof options === 'string' || options instanceof QueryFile) {
             options = {
                 text: options
             };
         } else {
-            options = assert(options, [`text`, `values`, `binary`, `rowMode`]);
+            options = assert(options, ['text', 'values', 'binary', 'rowMode']);
         }
         super(options);
     }
@@ -133,7 +133,7 @@ ParameterizedQuery.prototype.parse = function () {
     }
 
     if (!npm.utils.isText(_i.target.text)) {
-        errors.push(`Property 'text' must be a non-empty text string.`);
+        errors.push('Property \'text\' must be a non-empty text string.');
     }
 
     if (!npm.utils.isNull(values)) {
@@ -174,24 +174,24 @@ ParameterizedQuery.prototype.toString = function (level) {
     const gap = npm.utils.messageGap(level + 1);
     const pq = this.parse();
     const lines = [
-        `ParameterizedQuery {`
+        'ParameterizedQuery {'
     ];
     if (npm.utils.isText(pq.text)) {
-        lines.push(gap + `text: "` + pq.text + `"`);
+        lines.push(gap + 'text: "' + pq.text + '"');
     }
     if (this.values !== undefined) {
-        lines.push(gap + `values: ` + npm.utils.toJson(this.values));
+        lines.push(gap + 'values: ' + npm.utils.toJson(this.values));
     }
     if (this.binary !== undefined) {
-        lines.push(gap + `binary: ` + npm.utils.toJson(this.binary));
+        lines.push(gap + 'binary: ' + npm.utils.toJson(this.binary));
     }
     if (this.rowMode !== undefined) {
-        lines.push(gap + `rowMode: ` + npm.utils.toJson(this.rowMode));
+        lines.push(gap + 'rowMode: ' + npm.utils.toJson(this.rowMode));
     }
     if (this.error !== undefined) {
-        lines.push(gap + `error: ` + this.error.toString(level + 1));
+        lines.push(gap + 'error: ' + this.error.toString(level + 1));
     }
-    lines.push(npm.utils.messageGap(level) + `}`);
+    lines.push(npm.utils.messageGap(level) + '}');
     return lines.join(npm.EOL);
 };
 

package/lib/types/prepared-statement.js

@@ -7,14 +7,14 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {ServerFormatting} = require(`./server-formatting`);
-const {PreparedStatementError} = require(`../errors`);
-const {QueryFile} = require(`../query-file`);
-const {assert} = require(`../assert`);
+const {ServerFormatting} = require('./server-formatting');
+const {PreparedStatementError} = require('../errors');
+const {QueryFile} = require('../query-file');
+const {assert} = require('../assert');
 
 const npm = {
-    EOL: require(`os`).EOL,
-    utils: require(`../utils`)
+    EOL: require('os').EOL,
+    utils: require('../utils')
 };
 
 /**
@@ -89,7 +89,7 @@ const npm = {
  */
 class PreparedStatement extends ServerFormatting {
     constructor(options) {
-        options = assert(options, [`name`, `text`, `values`, `binary`, `rowMode`, `rows`]);
+        options = assert(options, ['name', 'text', 'values', 'binary', 'rowMode', 'rows']);
         super(options);
     }
 
@@ -161,7 +161,7 @@ PreparedStatement.prototype.parse = function () {
     _i.currentError = undefined;
 
     if (!npm.utils.isText(_i.target.name)) {
-        errors.push(`Property 'name' must be a non-empty text string.`);
+        errors.push('Property \'name\' must be a non-empty text string.');
     }
 
     if (qf) {
@@ -173,7 +173,7 @@ PreparedStatement.prototype.parse = function () {
         }
     }
     if (!npm.utils.isText(_i.target.text)) {
-        errors.push(`Property 'text' must be a non-empty text string.`);
+        errors.push('Property \'text\' must be a non-empty text string.');
     }
 
     if (!npm.utils.isNull(values)) {
@@ -218,28 +218,28 @@ PreparedStatement.prototype.toString = function (level) {
     const gap = npm.utils.messageGap(level + 1);
     const ps = this.parse();
     const lines = [
-        `PreparedStatement {`,
-        gap + `name: ` + npm.utils.toJson(this.name)
+        'PreparedStatement {',
+        gap + 'name: ' + npm.utils.toJson(this.name)
     ];
     if (npm.utils.isText(ps.text)) {
-        lines.push(gap + `text: "` + ps.text + `"`);
+        lines.push(gap + 'text: "' + ps.text + '"');
     }
     if (this.values !== undefined) {
-        lines.push(gap + `values: ` + npm.utils.toJson(this.values));
+        lines.push(gap + 'values: ' + npm.utils.toJson(this.values));
     }
     if (this.binary !== undefined) {
-        lines.push(gap + `binary: ` + npm.utils.toJson(this.binary));
+        lines.push(gap + 'binary: ' + npm.utils.toJson(this.binary));
     }
     if (this.rowMode !== undefined) {
-        lines.push(gap + `rowMode: ` + npm.utils.toJson(this.rowMode));
+        lines.push(gap + 'rowMode: ' + npm.utils.toJson(this.rowMode));
     }
     if (this.rows !== undefined) {
-        lines.push(gap + `rows: ` + npm.utils.toJson(this.rows));
+        lines.push(gap + 'rows: ' + npm.utils.toJson(this.rows));
     }
     if (this.error) {
-        lines.push(gap + `error: ` + this.error.toString(level + 1));
+        lines.push(gap + 'error: ' + this.error.toString(level + 1));
     }
-    lines.push(npm.utils.messageGap(level) + `}`);
+    lines.push(npm.utils.messageGap(level) + '}');
     return lines.join(npm.EOL);
 };
 

package/lib/types/server-formatting.js

@@ -1,6 +1,6 @@
-const {InnerState} = require(`../inner-state`);
-const {addInspection} = require(`../utils`);
-const utils = require(`../utils`);
+const {InnerState} = require('../inner-state');
+const {addInspection} = require('../utils');
+const utils = require('../utils');
 
 /**
  * @private

package/lib/utils/color.js

@@ -1,4 +1,4 @@
-const util = require(`util`);
+const util = require('util');
 
 class ColorConsole {
 

package/lib/utils/index.js

@@ -8,9 +8,9 @@
  */
 
 const npm = {
-    path: require(`path`),
-    util: require(`util`),
-    patterns: require(`../patterns`)
+    path: require('path'),
+    util: require('util'),
+    patterns: require('../patterns')
 };
 
 ////////////////////////////////////////////
@@ -22,7 +22,7 @@ function isNull(value) {
 ////////////////////////////////////////////////////////
 // Verifies parameter for being a non-empty text string;
 function isText(txt) {
-    return txt && typeof txt === `string` && /\S/.test(txt);
+    return txt && typeof txt === 'string' && /\S/.test(txt);
 }
 
 ///////////////////////////////////////////////////////////
@@ -31,8 +31,8 @@ function isText(txt) {
 // Proper configuration is having NODE_ENV = 'development', but this
 // method only checks for 'dev' being present, and regardless of the case.
 function isDev() {
-    const env = global.process.env.NODE_ENV || ``;
-    return env.toLowerCase().indexOf(`dev`) !== -1;
+    const env = global.process.env.NODE_ENV || '';
+    return env.toLowerCase().indexOf('dev') !== -1;
 }
 
 /////////////////////////////////////////////
@@ -59,13 +59,13 @@ function addReadProp(obj, name, value, hidden) {
 // Converts a connection string or object into its safe copy:
 // if password is present, it is masked with symbol '#'.
 function getSafeConnection(cn) {
-    const maskPassword = cs => cs.replace(/:(?![/])([^@]+)/, (_, m) => `:` + new Array(m.length + 1).join(`#`));
-    if (typeof cn === `object`) {
+    const maskPassword = cs => cs.replace(/:(?![/])([^@]+)/, (_, m) => ':' + new Array(m.length + 1).join('#'));
+    if (typeof cn === 'object') {
         const copy = Object.assign({}, cn);
-        if (typeof copy.password === `string`) {
-            copy.password = copy.password.replace(/./g, `#`);
+        if (typeof copy.password === 'string') {
+            copy.password = copy.password.replace(/./g, '#');
         }
-        if (typeof copy.connectionString === `string`) {
+        if (typeof copy.connectionString === 'string') {
             copy.connectionString = maskPassword(copy.connectionString);
         }
         return copy;
@@ -76,7 +76,7 @@ function getSafeConnection(cn) {
 ///////////////////////////////////////////
 // Returns a space gap for console output;
 function messageGap(level) {
-    return ` `.repeat(level * 4);
+    return ' '.repeat(level * 4);
 }
 
 /////////////////////////////////////////
@@ -92,10 +92,10 @@ function getLocalStack(startIdx, maxLines) {
     startIdx = startIdx || 0;
     const endIdx = maxLines > 0 ? startIdx + maxLines : undefined;
     return new Error().stack
-        .split(`\n`)
+        .split('\n')
         .filter(line => line.match(/\(.+\)/))
         .slice(startIdx, endIdx)
-        .join(`\n`);
+        .join('\n');
 }
 
 //////////////////////////////
@@ -113,14 +113,14 @@ function InternalError(error) {
 //  - value - the value; set when 'has' = true
 function getIfHas(obj, prop) {
     const result = {valid: true};
-    if (prop.indexOf(`.`) === -1) {
+    if (prop.indexOf('.') === -1) {
         result.has = prop in obj;
         result.target = obj;
         if (result.has) {
             result.value = obj[prop];
         }
     } else {
-        const names = prop.split(`.`);
+        const names = prop.split('.');
         let missing, target;
         for (let i = 0; i < names.length; i++) {
             const n = names[i];
@@ -147,7 +147,7 @@ function getIfHas(obj, prop) {
 /////////////////////////////////////////////////////////////////////////
 // Checks if the property exists in the object or value or its prototype;
 function hasProperty(value, prop) {
-    return (value && typeof value === `object` && prop in value) ||
+    return (value && typeof value === 'object' && prop in value) ||
         value !== null && value !== undefined && value[prop] !== undefined;
 }
 
@@ -161,10 +161,10 @@ function addInspection(type, cb) {
 // Identifies a general connectivity error, after which no more queries can be executed.
 // This is for detecting when to skip executing ROLLBACK for a failed transaction.
 function isConnectivityError(err) {
-    const code = err && typeof err.code === `string` && err.code;
+    const code = err && typeof err.code === 'string' && err.code;
     const cls = code && code.substr(0, 2); // Error Class
     // istanbul ignore next (we cannot test-cover all error cases):
-    return code === `ECONNRESET` || (cls === `08` && code !== `08P01`) || (cls === `57` && code !== `57014`);
+    return code === 'ECONNRESET' || (cls === '08' && code !== '08P01') || (cls === '57' && code !== '57014');
     // Code 'ECONNRESET' - Connectivity issue handled by the driver.
     // Class 08 - Connection Exception (except for 08P01, for protocol violation).
     // Class 57 - Operator Intervention (except for 57014, for cancelled queries).
@@ -176,7 +176,7 @@ function isConnectivityError(err) {
 // Does JSON.stringify, with support for BigInt (irreversible)
 function toJson(data) {
     if (data !== undefined) {
-        return JSON.stringify(data, (_, v) => typeof v === `bigint` ? `${v}#bigint` : v)
+        return JSON.stringify(data, (_, v) => typeof v === 'bigint' ? `${v}#bigint` : v)
             .replace(/"(-?\d+)#bigint"/g, (_, a) => a);
     }
 }

package/lib/utils/public.js

@@ -7,13 +7,13 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {assert} = require(`../assert`);
+const {assert} = require('../assert');
 
 const npm = {
-    fs: require(`fs`),
-    path: require(`path`),
-    utils: require(`./`),
-    package: require(`../../package.json`)
+    fs: require('fs'),
+    path: require('path'),
+    utils: require('./'),
+    package: require('../../package.json')
 };
 
 /**
@@ -38,7 +38,7 @@ const npm = {
  *
  */
 function camelize(text) {
-    text = text.replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : ``);
+    text = text.replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
     return text.substr(0, 1).toLowerCase() + text.substr(1);
 }
 
@@ -65,7 +65,7 @@ function camelize(text) {
  *
  */
 function camelizeVar(text) {
-    text = text.replace(/[^a-zA-Z0-9$_\-\s.]/g, ``).replace(/^[0-9_\-\s.]+/, ``);
+    text = text.replace(/[^a-zA-Z0-9$_\-\s.]/g, '').replace(/^[0-9_\-\s.]+/, '');
     return camelize(text);
 }
 
@@ -89,28 +89,28 @@ function _enumSql(dir, options, cb, namePath) {
         if (stat.isDirectory()) {
             if (options.recursive) {
                 const dirName = camelizeVar(file);
-                const np = namePath ? (namePath + `.` + dirName) : dirName;
+                const np = namePath ? (namePath + '.' + dirName) : dirName;
                 const t = _enumSql(fullPath, options, cb, np);
                 if (Object.keys(t).length) {
                     if (!dirName.length || dirName in tree) {
                         if (!options.ignoreErrors) {
-                            throw new Error(`Empty or duplicate camelized folder name: ` + fullPath);
+                            throw new Error('Empty or duplicate camelized folder name: ' + fullPath);
                         }
                     }
                     tree[dirName] = t;
                 }
             }
         } else {
-            if (npm.path.extname(file).toLowerCase() === `.sql`) {
-                const name = camelizeVar(file.replace(/\.[^/.]+$/, ``));
+            if (npm.path.extname(file).toLowerCase() === '.sql') {
+                const name = camelizeVar(file.replace(/\.[^/.]+$/, ''));
                 if (!name.length || name in tree) {
                     if (!options.ignoreErrors) {
-                        throw new Error(`Empty or duplicate camelized file name: ` + fullPath);
+                        throw new Error('Empty or duplicate camelized file name: ' + fullPath);
                     }
                 }
                 tree[name] = fullPath;
                 if (cb) {
-                    const result = cb(fullPath, name, namePath ? (namePath + `.` + name) : name);
+                    const result = cb(fullPath, name, namePath ? (namePath + '.' + name) : name);
                     if (result !== undefined) {
                         tree[name] = result;
                     }
@@ -185,11 +185,11 @@ function _enumSql(dir, options, cb, namePath) {
  */
 function enumSql(dir, options, cb) {
     if (!npm.utils.isText(dir)) {
-        throw new TypeError(`Parameter 'dir' must be a non-empty text string.`);
+        throw new TypeError('Parameter \'dir\' must be a non-empty text string.');
     }
-    options = assert(options, [`recursive`, `ignoreErrors`]);
-    cb = (typeof cb === `function`) ? cb : null;
-    return _enumSql(dir, options, cb, ``);
+    options = assert(options, ['recursive', 'ignoreErrors']);
+    cb = (typeof cb === 'function') ? cb : null;
+    return _enumSql(dir, options, cb, '');
 }
 
 /**
@@ -236,26 +236,26 @@ function enumSql(dir, options, cb) {
  */
 function taskArgs(args) {
 
-    if (!args || typeof args.length !== `number`) {
-        throw new TypeError(`Parameter 'args' must be an array-like object of arguments.`);
+    if (!args || typeof args.length !== 'number') {
+        throw new TypeError('Parameter \'args\' must be an array-like object of arguments.');
     }
 
     let options = args[0], cb;
-    if (typeof options === `function`) {
+    if (typeof options === 'function') {
         cb = options;
         options = {};
         if (cb.name) {
             options.tag = cb.name;
         }
     } else {
-        if (typeof args[1] === `function`) {
+        if (typeof args[1] === 'function') {
             cb = args[1];
         }
-        if (typeof options === `string` || typeof options === `number`) {
+        if (typeof options === 'string' || typeof options === 'number') {
             options = {tag: options};
         } else {
-            options = (typeof options === `object` && options) || {};
-            if (!(`tag` in options) && cb && cb.name) {
+            options = (typeof options === 'object' && options) || {};
+            if (!('tag' in options) && cb && cb.name) {
                 options.tag = cb.name;
             }
         }
@@ -263,7 +263,7 @@ function taskArgs(args) {
 
     const res = [options, cb];
 
-    Object.defineProperty(res, `options`, {
+    Object.defineProperty(res, 'options', {
         get: function () {
             return this[0];
         },
@@ -273,7 +273,7 @@ function taskArgs(args) {
         enumerable: true
     });
 
-    Object.defineProperty(res, `cb`, {
+    Object.defineProperty(res, 'cb', {
         get: function () {
             return this[1];
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-promise",
-  "version": "11.4.0",
+  "version": "11.4.2",
   "description": "PostgreSQL interface for Node.js",
   "main": "lib/index.js",
   "typings": "typescript/pg-promise.d.ts",
@@ -47,17 +47,17 @@
     "spex": "3.2.0"
   },
   "devDependencies": {
-    "@types/node": "18.15.0",
+    "@types/node": "18.15.3",
     "bluebird": "3.7.2",
     "coveralls": "3.1.1",
-    "cspell": "6.28.0",
-    "eslint": "8.35.0",
+    "cspell": "6.30.0",
+    "eslint": "8.36.0",
     "istanbul": "0.4.5",
     "jasmine-node": "3.0.0",
     "jsdoc": "4.0.2",
     "JSONStream": "1.3.5",
     "pg-query-stream": "4.4.0",
     "tslint": "6.1.3",
-    "typescript": "4.9.5"
+    "typescript": "5.0.2"
   }
 }

package/typescript/pg-subset.d.ts

@@ -289,7 +289,7 @@ declare namespace pg {
 
         end(cb: (err: Error) => any): any;
 
-        log: () => void;
+        log: (msg: string, err?: any) => void;
 
         readonly options: { [name: string]: any }; // connection options