pg-promise 11.4.0 → 11.4.2

package/lib/helpers/column-set.js

@@ -7,15 +7,15 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {InnerState} = require(`../inner-state`);
-const {assert} = require(`../assert`);
-const {TableName} = require(`./table-name`);
-const {Column} = require(`./column`);
+const {InnerState} = require('../inner-state');
+const {assert} = require('../assert');
+const {TableName} = require('./table-name');
+const {Column} = require('./column');
 
 const npm = {
-    os: require(`os`),
-    utils: require(`../utils`),
-    formatting: require(`../formatting`)
+    os: require('os'),
+    utils: require('../utils'),
+    formatting: require('../formatting')
 };
 
 /**
@@ -168,11 +168,11 @@ class ColumnSet extends InnerState {
     constructor(columns, opt) {
         super();
 
-        if (!columns || typeof columns !== `object`) {
-            throw new TypeError(`Invalid parameter 'columns' specified.`);
+        if (!columns || typeof columns !== 'object') {
+            throw new TypeError('Invalid parameter \'columns\' specified.');
         }
 
-        opt = assert(opt, [`table`, `inherit`]);
+        opt = assert(opt, ['table', 'inherit']);
 
         if (!npm.utils.isNull(opt.table)) {
             this.table = (opt.table instanceof TableName) ? opt.table : new TableName(opt.table);
@@ -234,7 +234,7 @@ class ColumnSet extends InnerState {
             const c = this.columns[i];
             // ColumnSet is simple when the source objects require no preparation,
             // and should be used directly:
-            if (c.prop || c.init || `def` in c) {
+            if (c.prop || c.init || 'def' in c) {
                 this._inner.isSimple = false;
                 break;
             }
@@ -329,12 +329,12 @@ class ColumnSet extends InnerState {
  */
 ColumnSet.prototype.assign = function (options) {
     const _i = this._inner;
-    const hasPrefix = options && options.prefix && typeof options.prefix === `string`;
+    const hasPrefix = options && options.prefix && typeof options.prefix === 'string';
     if (_i.updates && !hasPrefix) {
         return _i.updates;
     }
     let dynamic = hasPrefix;
-    const hasSource = options && options.source && typeof options.source === `object`;
+    const hasSource = options && options.source && typeof options.source === 'object';
     let list = this.columns.filter(c => {
         if (c.cnd) {
             return false;
@@ -351,8 +351,8 @@ ColumnSet.prototype.assign = function (options) {
         return true;
     });
 
-    const prefix = hasPrefix ? npm.formatting.as.alias(options.prefix) + `.` : ``;
-    list = list.map(c => prefix + c.escapedName + `=` + c.variable + c.castText).join();
+    const prefix = hasPrefix ? npm.formatting.as.alias(options.prefix) + '.' : '';
+    list = list.map(c => prefix + c.escapedName + '=' + c.variable + c.castText).join();
 
     if (!dynamic) {
         _i.updates = list;
@@ -400,13 +400,13 @@ ColumnSet.prototype.assign = function (options) {
  *
  */
 ColumnSet.prototype.assignColumns = function (options) {
-    options = assert(options, [`from`, `to`, `skip`]);
-    const skip = (typeof options.skip === `string` && [options.skip]) || ((Array.isArray(options.skip) || typeof options.skip === `function`) && options.skip);
-    const from = (typeof options.from === `string` && options.from && (npm.formatting.as.alias(options.from) + `.`)) || ``;
-    const to = (typeof options.to === `string` && options.to && (npm.formatting.as.alias(options.to) + `.`)) || ``;
-    const iterator = typeof skip === `function` ? c => !skip.call(c, c) : c => skip.indexOf(c.name) === -1;
+    options = assert(options, ['from', 'to', 'skip']);
+    const skip = (typeof options.skip === 'string' && [options.skip]) || ((Array.isArray(options.skip) || typeof options.skip === 'function') && options.skip);
+    const from = (typeof options.from === 'string' && options.from && (npm.formatting.as.alias(options.from) + '.')) || '';
+    const to = (typeof options.to === 'string' && options.to && (npm.formatting.as.alias(options.to) + '.')) || '';
+    const iterator = typeof skip === 'function' ? c => !skip.call(c, c) : c => skip.indexOf(c.name) === -1;
     const cols = skip ? this.columns.filter(iterator) : this.columns;
-    return cols.map(c => to + c.escapedName + `=` + from + c.escapedName).join();
+    return cols.map(c => to + c.escapedName + '=' + from + c.escapedName).join();
 };
 
 /**
@@ -583,7 +583,7 @@ ColumnSet.prototype.prepare = function (source) {
         if (c.init) {
             target[a.name] = c.init.call(source, a);
         } else {
-            if (a.exists || `def` in c) {
+            if (a.exists || 'def' in c) {
                 target[a.name] = a.value;
             }
         }
@@ -600,7 +600,7 @@ function colDesc(column, source) {
     if (a.exists) {
         a.value = source[a.name];
     } else {
-        a.value = `def` in column ? column.def : undefined;
+        a.value = 'def' in column ? column.def : undefined;
     }
     return a;
 }
@@ -622,21 +622,21 @@ ColumnSet.prototype.toString = function (level) {
     const gap0 = npm.utils.messageGap(level),
         gap1 = npm.utils.messageGap(level + 1),
         lines = [
-            `ColumnSet {`
+            'ColumnSet {'
         ];
     if (this.table) {
-        lines.push(gap1 + `table: ` + this.table);
+        lines.push(gap1 + 'table: ' + this.table);
     }
     if (this.columns.length) {
-        lines.push(gap1 + `columns: [`);
+        lines.push(gap1 + 'columns: [');
         this.columns.forEach(c => {
             lines.push(c.toString(2));
         });
-        lines.push(gap1 + `]`);
+        lines.push(gap1 + ']');
     } else {
-        lines.push(gap1 + `columns: []`);
+        lines.push(gap1 + 'columns: []');
     }
-    lines.push(gap0 + `}`);
+    lines.push(gap0 + '}');
     return lines.join(npm.os.EOL);
 };
 

package/lib/helpers/column.js

@@ -7,14 +7,14 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {InnerState} = require(`../inner-state`);
-const {assert} = require(`../assert`);
+const {InnerState} = require('../inner-state');
+const {assert} = require('../assert');
 
 const npm = {
-    os: require(`os`),
-    utils: require(`../utils`),
-    formatting: require(`../formatting`),
-    patterns: require(`../patterns`)
+    os: require('os'),
+    utils: require('../utils'),
+    formatting: require('../formatting'),
+    patterns: require('../patterns')
 };
 
 /**
@@ -132,18 +132,18 @@ class Column extends InnerState {
     constructor(col) {
         super();
 
-        if (typeof col === `string`) {
+        if (typeof col === 'string') {
             const info = parseColumn(col);
             this.name = info.name;
-            if (`mod` in info) {
+            if ('mod' in info) {
                 this.mod = info.mod;
             }
-            if (`cnd` in info) {
+            if ('cnd' in info) {
                 this.cnd = info.cnd;
             }
         } else {
-            col = assert(col, [`name`, `prop`, `mod`, `cast`, `cnd`, `def`, `init`, `skip`]);
-            if (`name` in col) {
+            col = assert(col, ['name', 'prop', 'mod', 'cast', 'cnd', 'def', 'init', 'skip']);
+            if ('name' in col) {
                 if (!npm.utils.isText(col.name)) {
                     throw new TypeError(`Invalid 'name' value: ${npm.utils.toJson(col.name)}. A non-empty string was expected.`);
                 }
@@ -165,7 +165,7 @@ class Column extends InnerState {
                     }
                 }
                 if (!npm.utils.isNull(col.mod)) {
-                    if (typeof col.mod !== `string` || !isValidMod(col.mod)) {
+                    if (typeof col.mod !== 'string' || !isValidMod(col.mod)) {
                         throw new TypeError(`Invalid 'mod' value: ${npm.utils.toJson(col.mod)}.`);
                     }
                     this.mod = col.mod; // optional format modifier;
@@ -173,25 +173,25 @@ class Column extends InnerState {
                 if (!npm.utils.isNull(col.cast)) {
                     this.cast = parseCast(col.cast); // optional SQL type casting
                 }
-                if (`cnd` in col) {
+                if ('cnd' in col) {
                     this.cnd = !!col.cnd;
                 }
-                if (`def` in col) {
+                if ('def' in col) {
                     this.def = col.def; // optional default
                 }
-                if (typeof col.init === `function`) {
+                if (typeof col.init === 'function') {
                     this.init = col.init; // optional value override (overrides 'def' also)
                 }
-                if (typeof col.skip === `function`) {
+                if (typeof col.skip === 'function') {
                     this.skip = col.skip;
                 }
             } else {
-                throw new TypeError(`Invalid column details.`);
+                throw new TypeError('Invalid column details.');
             }
         }
 
-        const variable = `\${` + (this.prop || this.name) + (this.mod || ``) + `}`;
-        const castText = this.cast ? (`::` + this.cast) : ``;
+        const variable = '${' + (this.prop || this.name) + (this.mod || '') + '}';
+        const castText = this.cast ? ('::' + this.cast) : '';
         const escapedName = npm.formatting.as.name(this.name);
 
         this.extendState({variable, castText, escapedName});
@@ -251,8 +251,8 @@ class Column extends InnerState {
 }
 
 function parseCast(name) {
-    if (typeof name === `string`) {
-        const s = name.replace(/^[:\s]*|\s*$/g, ``);
+    if (typeof name === 'string') {
+        const s = name.replace(/^[:\s]*|\s*$/g, '');
         if (s) {
             return s;
         }
@@ -264,7 +264,7 @@ function parseColumn(name) {
     const m = name.match(npm.patterns.validColumn);
     if (m && m[0] === name) {
         const res = {};
-        if (name[0] === `?`) {
+        if (name[0] === '?') {
             res.cnd = true;
             name = name.substr(1);
         }
@@ -306,31 +306,31 @@ Column.prototype.toString = function (level) {
     const gap0 = npm.utils.messageGap(level),
         gap1 = npm.utils.messageGap(level + 1),
         lines = [
-            gap0 + `Column {`,
-            gap1 + `name: ` + npm.utils.toJson(this.name)
+            gap0 + 'Column {',
+            gap1 + 'name: ' + npm.utils.toJson(this.name)
         ];
-    if (`prop` in this) {
-        lines.push(gap1 + `prop: ` + npm.utils.toJson(this.prop));
+    if ('prop' in this) {
+        lines.push(gap1 + 'prop: ' + npm.utils.toJson(this.prop));
     }
-    if (`mod` in this) {
-        lines.push(gap1 + `mod: ` + npm.utils.toJson(this.mod));
+    if ('mod' in this) {
+        lines.push(gap1 + 'mod: ' + npm.utils.toJson(this.mod));
     }
-    if (`cast` in this) {
-        lines.push(gap1 + `cast: ` + npm.utils.toJson(this.cast));
+    if ('cast' in this) {
+        lines.push(gap1 + 'cast: ' + npm.utils.toJson(this.cast));
     }
-    if (`cnd` in this) {
-        lines.push(gap1 + `cnd: ` + npm.utils.toJson(this.cnd));
+    if ('cnd' in this) {
+        lines.push(gap1 + 'cnd: ' + npm.utils.toJson(this.cnd));
     }
-    if (`def` in this) {
-        lines.push(gap1 + `def: ` + npm.utils.toJson(this.def));
+    if ('def' in this) {
+        lines.push(gap1 + 'def: ' + npm.utils.toJson(this.def));
     }
-    if (`init` in this) {
-        lines.push(gap1 + `init: [Function]`);
+    if ('init' in this) {
+        lines.push(gap1 + 'init: [Function]');
     }
-    if (`skip` in this) {
-        lines.push(gap1 + `skip: [Function]`);
+    if ('skip' in this) {
+        lines.push(gap1 + 'skip: [Function]');
     }
-    lines.push(gap0 + `}`);
+    lines.push(gap0 + '}');
     return lines.join(npm.os.EOL);
 };
 

package/lib/helpers/index.js

@@ -7,10 +7,10 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {Column} = require(`./column`);
-const {ColumnSet} = require(`./column-set`);
-const {TableName} = require(`./table-name`);
-const method = require(`./methods`);
+const {Column} = require('./column');
+const {ColumnSet} = require('./column-set');
+const {TableName} = require('./table-name');
+const method = require('./methods');
 
 /**
  * @namespace helpers

package/lib/helpers/methods/concat.js

@@ -7,10 +7,10 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {QueryFile} = require(`../../query-file`);
+const {QueryFile} = require('../../query-file');
 
 const npm = {
-    formatting: require(`../../formatting`)
+    formatting: require('../../formatting')
 };
 
 /**
@@ -50,22 +50,22 @@ const npm = {
  */
 function concat(queries, capSQL) {
     if (!Array.isArray(queries)) {
-        throw new TypeError(`Parameter 'queries' must be an array.`);
+        throw new TypeError('Parameter \'queries\' must be an array.');
     }
     const fmOptions = {capSQL};
     const all = queries.map((q, index) => {
-        if (typeof q === `string`) {
+        if (typeof q === 'string') {
             // a simple query string without parameters:
             return clean(q);
         }
-        if (q && typeof q === `object`) {
+        if (q && typeof q === 'object') {
             if (q instanceof QueryFile) {
                 // QueryFile object:
                 return clean(q[npm.formatting.as.ctf.toPostgres]());
             }
-            if (`query` in q) {
+            if ('query' in q) {
                 // object {query, values, options}:
-                let opt = q.options && typeof q.options === `object` ? q.options : {};
+                let opt = q.options && typeof q.options === 'object' ? q.options : {};
                 opt = opt.capSQL === undefined ? Object.assign(opt, fmOptions) : opt;
                 return clean(npm.formatting.as.format(q.query, q.values, opt));
             }
@@ -73,12 +73,12 @@ function concat(queries, capSQL) {
         throw new Error(`Invalid query element at index ${index}.`);
     });
 
-    return all.filter(q => q).join(`;`);
+    return all.filter(q => q).join(';');
 }
 
 function clean(q) {
     // removes from the query all leading and trailing symbols ' ', '\t' and ';'
-    return q.replace(/^[\s;]*|[\s;]*$/g, ``);
+    return q.replace(/^[\s;]*|[\s;]*$/g, '');
 }
 
 module.exports = {concat};

package/lib/helpers/methods/index.js

@@ -1,8 +1,8 @@
-const {concat} = require(`./concat`);
-const {insert} = require(`./insert`);
-const {update} = require(`./update`);
-const {values} = require(`./values`);
-const {sets} = require(`./sets`);
+const {concat} = require('./concat');
+const {insert} = require('./insert');
+const {update} = require('./update');
+const {values} = require('./values');
+const {sets} = require('./sets');
 
 module.exports = {
     concat,

package/lib/helpers/methods/insert.js

@@ -7,12 +7,12 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {TableName} = require(`../table-name`);
-const {ColumnSet} = require(`../column-set`);
+const {TableName} = require('../table-name');
+const {ColumnSet} = require('../column-set');
 
 const npm = {
-    formatting: require(`../../formatting`),
-    utils: require(`../../utils`)
+    formatting: require('../../formatting'),
+    utils: require('../../utils')
 };
 
 /**
@@ -90,14 +90,14 @@ const npm = {
  */
 function insert(data, columns, table, capSQL) {
 
-    if (!data || typeof data !== `object`) {
-        throw new TypeError(`Invalid parameter 'data' specified.`);
+    if (!data || typeof data !== 'object') {
+        throw new TypeError('Invalid parameter \'data\' specified.');
     }
 
     const isArray = Array.isArray(data);
 
     if (isArray && !data.length) {
-        throw new TypeError(`Cannot generate an INSERT from an empty array.`);
+        throw new TypeError('Cannot generate an INSERT from an empty array.');
     }
 
     if (columns instanceof ColumnSet) {
@@ -106,17 +106,17 @@ function insert(data, columns, table, capSQL) {
         }
     } else {
         if (isArray && npm.utils.isNull(columns)) {
-            throw new TypeError(`Parameter 'columns' is required when inserting multiple records.`);
+            throw new TypeError('Parameter \'columns\' is required when inserting multiple records.');
         }
         columns = new ColumnSet(columns || data);
     }
 
     if (!columns.columns.length) {
-        throw new Error(`Cannot generate an INSERT without any columns.`);
+        throw new Error('Cannot generate an INSERT without any columns.');
     }
 
     if (!table) {
-        throw new Error(`Table name is unknown.`);
+        throw new Error('Table name is unknown.');
     }
 
     if (!(table instanceof TableName)) {
@@ -131,18 +131,18 @@ function insert(data, columns, table, capSQL) {
 
     if (isArray) {
         return query + data.map((d, index) => {
-            if (!d || typeof d !== `object`) {
+            if (!d || typeof d !== 'object') {
                 throw new Error(`Invalid insert object at index ${index}.`);
             }
-            return `(` + format(columns.variables, columns.prepare(d), fmOptions) + `)`;
+            return '(' + format(columns.variables, columns.prepare(d), fmOptions) + ')';
         }).join();
     }
-    return query + `(` + format(columns.variables, columns.prepare(data), fmOptions) + `)`;
+    return query + '(' + format(columns.variables, columns.prepare(data), fmOptions) + ')';
 }
 
 const sql = {
-    lowCase: `insert into $1^($2^) values`,
-    capCase: `INSERT INTO $1^($2^) VALUES`
+    lowCase: 'insert into $1^($2^) values',
+    capCase: 'INSERT INTO $1^($2^) VALUES'
 };
 
 module.exports = {insert};

package/lib/helpers/methods/sets.js

@@ -7,11 +7,11 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {ColumnSet} = require(`../column-set`);
+const {ColumnSet} = require('../column-set');
 
 const npm = {
-    format: require(`../../formatting`).as.format,
-    utils: require(`../../utils`)
+    format: require('../../formatting').as.format,
+    utils: require('../../utils')
 };
 
 /**
@@ -66,8 +66,8 @@ const npm = {
  */
 function sets(data, columns, capSQL) {
 
-    if (!data || typeof data !== `object` || Array.isArray(data)) {
-        throw new TypeError(`Invalid parameter 'data' specified.`);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw new TypeError('Invalid parameter \'data\' specified.');
     }
 
     if (!(columns instanceof ColumnSet)) {

package/lib/helpers/methods/update.js

@@ -7,13 +7,13 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {assert} = require(`../../assert`);
-const {TableName} = require(`../table-name`);
-const {ColumnSet} = require(`../column-set`);
+const {assert} = require('../../assert');
+const {TableName} = require('../table-name');
+const {ColumnSet} = require('../column-set');
 
 const npm = {
-    formatting: require(`../../formatting`),
-    utils: require(`../../utils`)
+    formatting: require('../../formatting'),
+    utils: require('../../utils')
 };
 
 /**
@@ -147,14 +147,14 @@ const npm = {
  */
 function update(data, columns, table, options, capSQL) {
 
-    if (!data || typeof data !== `object`) {
-        throw new TypeError(`Invalid parameter 'data' specified.`);
+    if (!data || typeof data !== 'object') {
+        throw new TypeError('Invalid parameter \'data\' specified.');
     }
 
     const isArray = Array.isArray(data);
 
     if (isArray && !data.length) {
-        throw new TypeError(`Cannot generate an UPDATE from an empty array.`);
+        throw new TypeError('Cannot generate an UPDATE from an empty array.');
     }
 
     if (columns instanceof ColumnSet) {
@@ -163,20 +163,20 @@ function update(data, columns, table, options, capSQL) {
         }
     } else {
         if (isArray && npm.utils.isNull(columns)) {
-            throw new TypeError(`Parameter 'columns' is required when updating multiple records.`);
+            throw new TypeError('Parameter \'columns\' is required when updating multiple records.');
         }
         columns = new ColumnSet(columns || data);
     }
 
-    options = assert(options, [`tableAlias`, `valueAlias`, `emptyUpdate`]);
+    options = assert(options, ['tableAlias', 'valueAlias', 'emptyUpdate']);
 
     const format = npm.formatting.as.format,
-        useEmptyUpdate = `emptyUpdate` in options,
+        useEmptyUpdate = 'emptyUpdate' in options,
         fmOptions = {capSQL};
 
     if (isArray) {
-        const tableAlias = npm.formatting.as.alias(npm.utils.isNull(options.tableAlias) ? `t` : options.tableAlias);
-        const valueAlias = npm.formatting.as.alias(npm.utils.isNull(options.valueAlias) ? `v` : options.valueAlias);
+        const tableAlias = npm.formatting.as.alias(npm.utils.isNull(options.tableAlias) ? 't' : options.tableAlias);
+        const valueAlias = npm.formatting.as.alias(npm.utils.isNull(options.valueAlias) ? 'v' : options.valueAlias);
 
         const q = capSQL ? sql.multi.capCase : sql.multi.lowCase;
 
@@ -188,13 +188,13 @@ function update(data, columns, table, options, capSQL) {
 
         checkTable();
 
-        const targetCols = actualColumns.map(c => c.escapedName + `=` + valueAlias + `.` + c.escapedName).join();
+        const targetCols = actualColumns.map(c => c.escapedName + '=' + valueAlias + '.' + c.escapedName).join();
 
         const values = data.map((d, index) => {
-            if (!d || typeof d !== `object`) {
+            if (!d || typeof d !== 'object') {
                 throw new Error(`Invalid update object at index ${index}.`);
             }
-            return `(` + format(columns.variables, columns.prepare(d), fmOptions) + `)`;
+            return '(' + format(columns.variables, columns.prepare(d), fmOptions) + ')';
         }).join();
 
         return format(q, [table.name, tableAlias, targetCols, values, valueAlias, columns.names], fmOptions);
@@ -217,7 +217,7 @@ function update(data, columns, table, options, capSQL) {
             table = new TableName(table);
         }
         if (!table) {
-            throw new Error(`Table name is unknown.`);
+            throw new Error('Table name is unknown.');
         }
     }
 
@@ -226,19 +226,19 @@ function update(data, columns, table, options, capSQL) {
             if (useEmptyUpdate) {
                 return true;
             }
-            throw new Error(`Cannot generate an UPDATE without any columns.`);
+            throw new Error('Cannot generate an UPDATE without any columns.');
         }
     }
 }
 
 const sql = {
     single: {
-        lowCase: `update $1^ set `,
-        capCase: `UPDATE $1^ SET `
+        lowCase: 'update $1^ set ',
+        capCase: 'UPDATE $1^ SET '
     },
     multi: {
-        lowCase: `update $1^ as $2^ set $3^ from (values$4^) as $5^($6^)`,
-        capCase: `UPDATE $1^ AS $2^ SET $3^ FROM (VALUES$4^) AS $5^($6^)`
+        lowCase: 'update $1^ as $2^ set $3^ from (values$4^) as $5^($6^)',
+        capCase: 'UPDATE $1^ AS $2^ SET $3^ FROM (VALUES$4^) AS $5^($6^)'
     }
 };
 

package/lib/helpers/methods/values.js

@@ -7,11 +7,11 @@
  * Removal or modification of this copyright notice is prohibited.
  */
 
-const {ColumnSet} = require(`../column-set`);
+const {ColumnSet} = require('../column-set');
 
 const npm = {
-    formatting: require(`../../formatting`),
-    utils: require(`../../utils`)
+    formatting: require('../../formatting'),
+    utils: require('../../utils')
 };
 
 /**
@@ -81,21 +81,21 @@ const npm = {
  */
 function values(data, columns, capSQL) {
 
-    if (!data || typeof data !== `object`) {
-        throw new TypeError(`Invalid parameter 'data' specified.`);
+    if (!data || typeof data !== 'object') {
+        throw new TypeError('Invalid parameter \'data\' specified.');
     }
 
     const isArray = Array.isArray(data);
 
     if (!(columns instanceof ColumnSet)) {
         if (isArray && npm.utils.isNull(columns)) {
-            throw new TypeError(`Parameter 'columns' is required when generating multi-row values.`);
+            throw new TypeError('Parameter \'columns\' is required when generating multi-row values.');
         }
         columns = new ColumnSet(columns || data);
     }
 
     if (!columns.columns.length) {
-        throw new Error(`Cannot generate values without any columns.`);
+        throw new Error('Cannot generate values without any columns.');
     }
 
     const format = npm.formatting.as.format,
@@ -103,13 +103,13 @@ function values(data, columns, capSQL) {
 
     if (isArray) {
         return data.map((d, index) => {
-            if (!d || typeof d !== `object`) {
+            if (!d || typeof d !== 'object') {
                 throw new Error(`Invalid object at index ${index}.`);
             }
-            return `(` + format(columns.variables, columns.prepare(d), fmOptions) + `)`;
+            return '(' + format(columns.variables, columns.prepare(d), fmOptions) + ')';
         }).join();
     }
-    return `(` + format(columns.variables, columns.prepare(data), fmOptions) + `)`;
+    return '(' + format(columns.variables, columns.prepare(data), fmOptions) + ')';
 }
 
 module.exports = {values};