pg-promise 11.4.0 → 11.4.2

package/lib/errors/query-result-error.js

@@ -8,9 +8,9 @@
  */
 
 const npm = {
-    os: require(`os`),
-    utils: require(`../utils`),
-    text: require(`../text`)
+    os: require('os'),
+    utils: require('../utils'),
+    text: require('../text')
 };
 
 /**
@@ -36,9 +36,9 @@ const queryResultErrorCode = {
 };
 
 const errorMessages = [
-    {name: `noData`, message: npm.text.noData},
-    {name: `notEmpty`, message: npm.text.notEmpty},
-    {name: `multiple`, message: npm.text.multiple}
+    {name: 'noData', message: npm.text.noData},
+    {name: 'notEmpty', message: npm.text.notEmpty},
+    {name: 'multiple', message: npm.text.multiple}
 ];
 
 /**
@@ -154,16 +154,16 @@ QueryResultError.prototype.toString = function (level) {
     const gap0 = npm.utils.messageGap(level),
         gap1 = npm.utils.messageGap(level + 1),
         lines = [
-            `QueryResultError {`,
-            gap1 + `code: queryResultErrorCode.` + errorMessages[this.code].name,
-            gap1 + `message: "` + this.message + `"`,
-            gap1 + `received: ` + this.received,
-            gap1 + `query: ` + (typeof this.query === `string` ? `"` + this.query + `"` : npm.utils.toJson(this.query))
+            'QueryResultError {',
+            gap1 + 'code: queryResultErrorCode.' + errorMessages[this.code].name,
+            gap1 + 'message: "' + this.message + '"',
+            gap1 + 'received: ' + this.received,
+            gap1 + 'query: ' + (typeof this.query === 'string' ? '"' + this.query + '"' : npm.utils.toJson(this.query))
         ];
     if (this.values !== undefined) {
-        lines.push(gap1 + `values: ` + npm.utils.toJson(this.values));
+        lines.push(gap1 + 'values: ' + npm.utils.toJson(this.values));
     }
-    lines.push(gap0 + `}`);
+    lines.push(gap0 + '}');
     return lines.join(npm.os.EOL);
 };
 

package/lib/events.js

@@ -7,11 +7,11 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {ColorConsole} = require(`./utils/color`);
+const {ColorConsole} = require('./utils/color');
 
 const npm = {
-    main: require(`./`),
-    utils: require(`./utils`)
+    main: require('./'),
+    utils: require('./utils')
 };
 
 /////////////////////////////////
@@ -57,14 +57,14 @@ class Events {
      * };
      */
     static connect(ctx, client, useCount) {
-        if (typeof ctx.options.connect === `function`) {
+        if (typeof ctx.options.connect === 'function') {
             try {
                 ctx.options.connect({client, dc: ctx.dc, useCount});
             } catch (e) {
                 // have to silence errors here;
                 // cannot allow unhandled errors while connecting to the database,
                 // as it will break the connection logic;
-                Events.unexpected(`connect`, e);
+                Events.unexpected('connect', e);
             }
         }
     }
@@ -99,14 +99,14 @@ class Events {
      * };
      */
     static disconnect(ctx, client) {
-        if (typeof ctx.options.disconnect === `function`) {
+        if (typeof ctx.options.disconnect === 'function') {
             try {
                 ctx.options.disconnect({client, dc: ctx.dc});
             } catch (e) {
                 // have to silence errors here;
                 // cannot allow unhandled errors while disconnecting from the database,
                 // as it will break the disconnection logic;
-                Events.unexpected(`disconnect`, e);
+                Events.unexpected('disconnect', e);
             }
         }
     }
@@ -135,7 +135,7 @@ class Events {
      * };
      */
     static query(options, context) {
-        if (typeof options.query === `function`) {
+        if (typeof options.query === 'function') {
             try {
                 options.query(context);
             } catch (e) {
@@ -210,7 +210,7 @@ class Events {
      * }
      */
     static receive(options, data, result, ctx) {
-        if (typeof options.receive === `function`) {
+        if (typeof options.receive === 'function') {
             try {
                 options.receive({data, result, ctx});
             } catch (e) {
@@ -256,12 +256,12 @@ class Events {
      *
      */
     static task(options, context) {
-        if (typeof options.task === `function`) {
+        if (typeof options.task === 'function') {
             try {
                 options.task(context);
             } catch (e) {
                 // silencing the error, to avoid breaking the task;
-                Events.unexpected(`task`, e);
+                Events.unexpected('task', e);
             }
         }
     }
@@ -301,12 +301,12 @@ class Events {
      *
      */
     static transact(options, context) {
-        if (typeof options.transact === `function`) {
+        if (typeof options.transact === 'function') {
             try {
                 options.transact(context);
             } catch (e) {
                 // silencing the error, to avoid breaking the transaction;
-                Events.unexpected(`transact`, e);
+                Events.unexpected('transact', e);
             }
         }
     }
@@ -352,14 +352,14 @@ class Events {
      *
      */
     static error(options, err, context) {
-        if (typeof options.error === `function`) {
+        if (typeof options.error === 'function') {
             try {
                 options.error(err, context);
             } catch (e) {
                 // have to silence errors here;
                 // throwing unhandled errors while handling an error
                 // notification is simply not acceptable.
-                Events.unexpected(`error`, e);
+                Events.unexpected('error', e);
             }
         }
     }
@@ -450,14 +450,14 @@ class Events {
      *
      */
     static extend(options, obj, dc) {
-        if (typeof options.extend === `function`) {
+        if (typeof options.extend === 'function') {
             try {
                 options.extend.call(obj, obj, dc);
             } catch (e) {
                 // have to silence errors here;
                 // the result of throwing unhandled errors while
                 // extending the protocol would be unpredictable.
-                Events.unexpected(`extend`, e);
+                Events.unexpected('extend', e);
             }
         }
     }

package/lib/formatting.js

@@ -7,12 +7,12 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {assert} = require(`./assert`);
+const {assert} = require('./assert');
 
 const npm = {
-    pgUtils: require(`pg/lib/utils`),
-    patterns: require(`./patterns`),
-    utils: require(`./utils`)
+    pgUtils: require('pg/lib/utils'),
+    patterns: require('./patterns'),
+    utils: require('./utils')
 };
 
 // Format Modification Flags;
@@ -41,8 +41,8 @@ const fmMap = {
 
 // Global symbols for Custom Type Formatting:
 const ctfSymbols = {
-    toPostgres: Symbol.for(`ctf.toPostgres`),
-    rawType: Symbol.for(`ctf.rawType`)
+    toPostgres: Symbol.for('ctf.toPostgres'),
+    rawType: Symbol.for('ctf.rawType')
 };
 
 const maxVariable = 100000; // maximum supported variable is '$100000'
@@ -51,7 +51,7 @@ const maxVariable = 100000; // maximum supported variable is '$100000'
 // Converts a single value into its Postgres format.
 function formatValue({value, fm, cc, options}) {
 
-    if (typeof value === `function`) {
+    if (typeof value === 'function') {
         return formatValue({value: resolveFunc(value, cc), fm, cc});
     }
 
@@ -81,18 +81,18 @@ function formatValue({value, fm, cc, options}) {
 
     if (isNull(value)) {
         throwIfRaw(isRaw);
-        return `null`;
+        return 'null';
     }
 
     switch (typeof value) {
-        case `string`:
+        case 'string':
             return $to.text(value, isRaw);
-        case `boolean`:
+        case 'boolean':
             return $to.bool(value);
-        case `number`:
-        case `bigint`:
+        case 'number':
+        case 'bigint':
             return $to.number(value);
-        case `symbol`:
+        case 'symbol':
             throw new TypeError(`Type Symbol has no meaning for PostgreSQL: ${value.toString()}`);
         default:
             if (value instanceof Date) {
@@ -117,12 +117,12 @@ function formatValue({value, fm, cc, options}) {
 // Top-level empty arrays are formatted as literal '{}' to avoid the necessity of explicit type casting,
 // as the server cannot automatically infer the type of empty non-literal array.
 function formatArray(array, options) {
-    const loop = a => `[` + a.map(value => Array.isArray(value) ? loop(value) : formatValue({
+    const loop = a => '[' + a.map(value => Array.isArray(value) ? loop(value) : formatValue({
         value,
         options
-    })).join() + `]`;
-    const prefix = options && options.capSQL ? `ARRAY` : `array`;
-    return array.length ? (prefix + loop(array)) : `'{}'`;
+    })).join() + ']';
+    const prefix = options && options.capSQL ? 'ARRAY' : 'array';
+    return array.length ? (prefix + loop(array)) : '\'{}\'';
 }
 
 ///////////////////////////////////////////////////////////////////
@@ -131,10 +131,10 @@ function formatCSV(values, options) {
     if (Array.isArray(values)) {
         return values.map(value => formatValue({value, options})).join();
     }
-    if (typeof values === `object` && values !== null) {
+    if (typeof values === 'object' && values !== null) {
         return Object.keys(values).map(v => formatValue({value: values[v], options})).join();
     }
-    return values === undefined ? `` : formatValue({value: values, options});
+    return values === undefined ? '' : formatValue({value: values, options});
 }
 
 ///////////////////////////////
@@ -142,9 +142,9 @@ function formatCSV(values, options) {
 const formatAs = {
 
     object({query, obj, raw, options}) {
-        options = options && typeof options === `object` ? options : {};
+        options = options && typeof options === 'object' ? options : {};
         return query.replace(npm.patterns.namedParameters, name => {
-            const v = formatAs.stripName(name.replace(/^\$[{(<[/]|[\s})>\]/]/g, ``), raw),
+            const v = formatAs.stripName(name.replace(/^\$[{(<[/]|[\s})>\]/]/g, ''), raw),
                 c = npm.utils.getIfHas(obj, v.name);
             if (!c.valid) {
                 throw new Error(`Invalid property name '${v.name}'.`);
@@ -152,11 +152,11 @@ const formatAs = {
             if (c.has) {
                 return formatValue({value: c.value, fm: v.fm, cc: c.target, options});
             }
-            if (v.name === `this`) {
+            if (v.name === 'this') {
                 return formatValue({value: obj, fm: v.fm, options});
             }
-            if (`def` in options) {
-                const d = options.def, value = typeof d === `function` ? d.call(obj, v.name, obj) : d;
+            if ('def' in options) {
+                const d = options.def, value = typeof d === 'function' ? d.call(obj, v.name, obj) : d;
                 return formatValue({value, fm: v.fm, cc: obj, options});
             }
             if (options.partial) {
@@ -168,7 +168,7 @@ const formatAs = {
     },
 
     array({query, array, raw, options}) {
-        options = options && typeof options === `object` ? options : {};
+        options = options && typeof options === 'object' ? options : {};
         return query.replace(npm.patterns.multipleValues, name => {
             const v = formatAs.stripName(name.substr(1), raw);
             const idx = v.name - 1;
@@ -178,8 +178,8 @@ const formatAs = {
             if (idx < array.length) {
                 return formatValue({value: array[idx], fm: v.fm, options});
             }
-            if (`def` in options) {
-                const d = options.def, value = typeof d === `function` ? d.call(array, idx, array) : d;
+            if ('def' in options) {
+                const d = options.def, value = typeof d === 'function' ? d.call(array, idx, array) : d;
                 return formatValue({value, fm: v.fm, options});
             }
             if (options.partial) {
@@ -223,13 +223,13 @@ function isNull(value) {
 function getCTF(value) {
     if (!isNull(value)) {
         let toPostgres = value[ctfSymbols.toPostgres], rawType = !!value[ctfSymbols.rawType];
-        if (typeof toPostgres !== `function`) {
+        if (typeof toPostgres !== 'function') {
             toPostgres = value.toPostgres;
             rawType = !!value.rawType;
         }
-        if (typeof toPostgres === `function`) {
-            if (toPostgres.constructor.name !== `Function`) {
-                throw new Error(`CTF does not support asynchronous toPostgres functions.`);
+        if (typeof toPostgres === 'function') {
+            if (toPostgres.constructor.name !== 'Function') {
+                throw new Error('CTF does not support asynchronous toPostgres functions.');
             }
             return {toPostgres, rawType};
         }
@@ -247,26 +247,26 @@ function wrapText(text) {
 // Replaces each single-quote symbol ' with two,
 // for compliance with PostgreSQL strings.
 function safeText(text) {
-    return text.replace(/'/g, `''`);
+    return text.replace(/'/g, '\'\'');
 }
 
 /////////////////////////////////////////////
 // Throws an exception, if flag 'raw' is set.
 function throwIfRaw(raw) {
     if (raw) {
-        throw new TypeError(`Values null/undefined cannot be used as raw text.`);
+        throw new TypeError('Values null/undefined cannot be used as raw text.');
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Recursively resolves parameter-function, with an optional Calling Context.
 function resolveFunc(value, cc) {
-    while (typeof value === `function`) {
-        if (value.constructor.name !== `Function`) {
+    while (typeof value === 'function') {
+        if (value.constructor.name !== 'Function') {
             // Constructor name for asynchronous functions have different names:
             // - 'GeneratorFunction' for ES6 generators
             // - 'AsyncFunction' for ES7 async functions
-            throw new Error(`Cannot use asynchronous functions with query formatting.`);
+            throw new Error('Cannot use asynchronous functions with query formatting.');
         }
         value = value.call(cc, cc);
     }
@@ -282,15 +282,15 @@ function resolveFunc(value, cc) {
 //    and where * is any of the supported open-close pairs: {}, (), [], <>, //
 //
 function formatQuery(query, values, raw, options) {
-    if (typeof query !== `string`) {
-        throw new TypeError(`Parameter 'query' must be a text string.`);
+    if (typeof query !== 'string') {
+        throw new TypeError('Parameter \'query\' must be a text string.');
     }
     const ctf = getCTF(values);
     if (ctf) {
         // Custom Type Formatting
         return formatQuery(query, resolveFunc(ctf.toPostgres, values), raw || ctf.rawType, options);
     }
-    if (typeof values === `object` && values !== null) {
+    if (typeof values === 'object' && values !== null) {
         if (Array.isArray(values)) {
             // $1, $2,... formatting to be applied;
             return formatAs.array({query, array: values, raw, options});
@@ -307,7 +307,7 @@ function formatQuery(query, values, raw, options) {
 //////////////////////////////////////////////////////
 // Formats a function or stored procedure call query;
 function formatEntity(entity, values, {capSQL, type}) {
-    let prefix = type === `func` ? `select * from` : `call`;
+    let prefix = type === 'func' ? 'select * from' : 'call';
     if (capSQL) {
         prefix = prefix.toUpperCase();
     }
@@ -315,7 +315,7 @@ function formatEntity(entity, values, {capSQL, type}) {
 }
 
 function formatSqlName(name) {
-    return `"${name.replace(/"/g, `""`)}"`;
+    return `"${name.replace(/"/g, '""')}"`;
 }
 
 /**
@@ -426,9 +426,9 @@ const $as = {
         value = resolveFunc(value);
         if (isNull(value)) {
             throwIfRaw(raw);
-            return `null`;
+            return 'null';
         }
-        if (typeof value !== `string`) {
+        if (typeof value !== 'string') {
             value = value.toString();
         }
         return $to.text(value, raw);
@@ -477,16 +477,16 @@ const $as = {
     name(name) {
         name = resolveFunc(name);
         if (name) {
-            if (typeof name === `string`) {
+            if (typeof name === 'string') {
                 return /^\s*\*(\s*)$/.test(name) ? name : formatSqlName(name);
             }
-            if (typeof name === `object`) {
+            if (typeof name === 'object') {
                 const keys = Array.isArray(name) ? name : Object.keys(name);
                 if (!keys.length) {
-                    throw new Error(`Cannot retrieve sql names from an empty array/object.`);
+                    throw new Error('Cannot retrieve sql names from an empty array/object.');
                 }
                 return keys.map(value => {
-                    if (!value || typeof value !== `string`) {
+                    if (!value || typeof value !== 'string') {
                         throw new Error(`Invalid sql name: ${npm.utils.toJson(value)}`);
                     }
                     return formatSqlName(value);
@@ -529,16 +529,16 @@ const $as = {
      */
     alias(name) {
         name = resolveFunc(name);
-        if (name && typeof name === `string`) {
-            return name.split(`.`)
+        if (name && typeof name === 'string') {
+            return name.split('.')
                 .filter(f => f)
                 .map(a => {
                     const m = a.match(/^([a-z_][a-z0-9_$]*|[A-Z_][A-Z0-9_$]*)$/);
                     if (m && m[0] === a) {
                         return a;
                     }
-                    return `"${a.replace(/"/g, `""`)}"`;
-                }).join(`.`);
+                    return `"${a.replace(/"/g, '""')}"`;
+                }).join('.');
         }
         throw new TypeError(`Invalid sql alias: ${npm.utils.toJson(name)}`);
     },
@@ -564,7 +564,7 @@ const $as = {
     value(value) {
         value = resolveFunc(value);
         if (isNull(value)) {
-            throw new TypeError(`Open values cannot be null or undefined.`);
+            throw new TypeError('Open values cannot be null or undefined.');
         }
         return safeText(formatValue({value, fm: fmFlags.raw}));
     },
@@ -588,7 +588,7 @@ const $as = {
         obj = resolveFunc(obj);
         if (isNull(obj)) {
             throwIfRaw(raw);
-            return `null`;
+            return 'null';
         }
         if (obj instanceof Buffer) {
             return $to.buffer(obj, raw);
@@ -609,7 +609,7 @@ const $as = {
     bool(value) {
         value = resolveFunc(value);
         if (isNull(value)) {
-            return `null`;
+            return 'null';
         }
         return $to.bool(value);
     },
@@ -632,7 +632,7 @@ const $as = {
         d = resolveFunc(d);
         if (isNull(d)) {
             throwIfRaw(raw);
-            return `null`;
+            return 'null';
         }
         if (d instanceof Date) {
             return $to.date(d, raw);
@@ -654,10 +654,10 @@ const $as = {
     number(num) {
         num = resolveFunc(num);
         if (isNull(num)) {
-            return `null`;
+            return 'null';
         }
         const t = typeof num;
-        if (t !== `number` && t !== `bigint`) {
+        if (t !== 'number' && t !== 'bigint') {
             throw new TypeError(`${wrapText(num)} is not a number.`);
         }
         return $to.number(num);
@@ -683,10 +683,10 @@ const $as = {
      * @returns {string}
      */
     array(arr, options) {
-        options = assert(options, [`capSQL`]);
+        options = assert(options, ['capSQL']);
         arr = resolveFunc(arr);
         if (isNull(arr)) {
-            return `null`;
+            return 'null';
         }
         if (Array.isArray(arr)) {
             return $to.array(arr, options);
@@ -737,7 +737,7 @@ const $as = {
         data = resolveFunc(data);
         if (isNull(data)) {
             throwIfRaw(raw);
-            return `null`;
+            return 'null';
         }
         return $to.json(data, raw);
     },
@@ -761,9 +761,9 @@ const $as = {
     func(func, raw, cc) {
         if (isNull(func)) {
             throwIfRaw(raw);
-            return `null`;
+            return 'null';
         }
-        if (typeof func !== `function`) {
+        if (typeof func !== 'function') {
             throw new TypeError(`${wrapText(func)} is not a function.`);
         }
         const fm = raw ? fmFlags.raw : null;
@@ -850,7 +850,7 @@ const $as = {
      * The function will throw an error, if any occurs during formatting.
      */
     format(query, values, options) {
-        options = assert(options, [`capSQL`, `partial`, `def`]);
+        options = assert(options, ['capSQL', 'partial', 'def']);
         const ctf = getCTF(query);
         if (ctf) {
             query = ctf.toPostgres.call(query, query);
@@ -868,10 +868,10 @@ const $to = {
         return formatCSV(resolveFunc(values), options);
     },
     bool(value) {
-        return value ? `true` : `false`;
+        return value ? 'true' : 'false';
     },
     buffer(obj, raw) {
-        const s = `\\x${obj.toString(`hex`)}`;
+        const s = `\\x${obj.toString('hex')}`;
         return raw ? s : wrapText(s);
     },
     date(d, raw) {
@@ -883,7 +883,7 @@ const $to = {
         return raw ? s : wrapText(safeText(s));
     },
     number(num) {
-        if (typeof num === `bigint` || Number.isFinite(num)) {
+        if (typeof num === 'bigint' || Number.isFinite(num)) {
             return num.toString();
         }
         // Converting NaN/+Infinity/-Infinity according to Postgres documentation:
@@ -891,12 +891,12 @@ const $to = {
         //
         // NOTE: strings for 'NaN'/'+Infinity'/'-Infinity' are not case-sensitive.
         if (num === Number.POSITIVE_INFINITY) {
-            return wrapText(`+Infinity`);
+            return wrapText('+Infinity');
         }
         if (num === Number.NEGATIVE_INFINITY) {
-            return wrapText(`-Infinity`);
+            return wrapText('-Infinity');
         }
-        return wrapText(`NaN`);
+        return wrapText('NaN');
     },
     text(value, raw) {
         return raw ? value : wrapText(safeText(value));