knex 0.21.20 → 0.21.21

package/lib/helpers.js

@@ -1,92 +1,92 @@
-const isPlainObject = require('lodash/isPlainObject');
-const isTypedArray = require('lodash/isTypedArray');
-const { CLIENT_ALIASES } = require('./constants');
-const { isFunction } = require('./util/is');
-
-// Check if the first argument is an array, otherwise uses all arguments as an
-// array.
-
-function normalizeArr() {
-  const args = new Array(arguments.length);
-  for (let i = 0; i < args.length; i++) {
-    args[i] = arguments[i];
-  }
-  if (Array.isArray(args[0])) {
-    return args[0];
-  }
-  return args;
-}
-
-function containsUndefined(mixed) {
-  let argContainsUndefined = false;
-
-  if (isTypedArray(mixed)) return false;
-
-  if (mixed && isFunction(mixed.toSQL)) {
-    //Any QueryBuilder or Raw will automatically be validated during compile.
-    return argContainsUndefined;
-  }
-
-  if (Array.isArray(mixed)) {
-    for (let i = 0; i < mixed.length; i++) {
-      if (argContainsUndefined) break;
-      argContainsUndefined = containsUndefined(mixed[i]);
-    }
-  } else if (isPlainObject(mixed)) {
-    Object.keys(mixed).forEach((key) => {
-      if (!argContainsUndefined) {
-        argContainsUndefined = containsUndefined(mixed[key]);
-      }
-    });
-  } else {
-    argContainsUndefined = mixed === undefined;
-  }
-
-  return argContainsUndefined;
-}
-
-function getUndefinedIndices(mixed) {
-  const indices = [];
-
-  if (Array.isArray(mixed)) {
-    mixed.forEach((item, index) => {
-      if (containsUndefined(item)) {
-        indices.push(index);
-      }
-    });
-  } else if (isPlainObject(mixed)) {
-    Object.keys(mixed).forEach((key) => {
-      if (containsUndefined(mixed[key])) {
-        indices.push(key);
-      }
-    });
-  } else {
-    indices.push(0);
-  }
-
-  return indices;
-}
-
-function addQueryContext(Target) {
-  // Stores or returns (if called with no arguments) context passed to
-  // wrapIdentifier and postProcessResponse hooks
-  Target.prototype.queryContext = function (context) {
-    if (context === undefined) {
-      return this._queryContext;
-    }
-    this._queryContext = context;
-    return this;
-  };
-}
-
-function resolveClientNameWithAliases(clientName) {
-  return CLIENT_ALIASES[clientName] || clientName;
-}
-
-module.exports = {
-  addQueryContext,
-  containsUndefined,
-  normalizeArr,
-  resolveClientNameWithAliases,
-  getUndefinedIndices,
-};
+const isPlainObject = require('lodash/isPlainObject');
+const isTypedArray = require('lodash/isTypedArray');
+const { CLIENT_ALIASES } = require('./constants');
+const { isFunction } = require('./util/is');
+
+// Check if the first argument is an array, otherwise uses all arguments as an
+// array.
+
+function normalizeArr() {
+  const args = new Array(arguments.length);
+  for (let i = 0; i < args.length; i++) {
+    args[i] = arguments[i];
+  }
+  if (Array.isArray(args[0])) {
+    return args[0];
+  }
+  return args;
+}
+
+function containsUndefined(mixed) {
+  let argContainsUndefined = false;
+
+  if (isTypedArray(mixed)) return false;
+
+  if (mixed && isFunction(mixed.toSQL)) {
+    //Any QueryBuilder or Raw will automatically be validated during compile.
+    return argContainsUndefined;
+  }
+
+  if (Array.isArray(mixed)) {
+    for (let i = 0; i < mixed.length; i++) {
+      if (argContainsUndefined) break;
+      argContainsUndefined = containsUndefined(mixed[i]);
+    }
+  } else if (isPlainObject(mixed)) {
+    Object.keys(mixed).forEach((key) => {
+      if (!argContainsUndefined) {
+        argContainsUndefined = containsUndefined(mixed[key]);
+      }
+    });
+  } else {
+    argContainsUndefined = mixed === undefined;
+  }
+
+  return argContainsUndefined;
+}
+
+function getUndefinedIndices(mixed) {
+  const indices = [];
+
+  if (Array.isArray(mixed)) {
+    mixed.forEach((item, index) => {
+      if (containsUndefined(item)) {
+        indices.push(index);
+      }
+    });
+  } else if (isPlainObject(mixed)) {
+    Object.keys(mixed).forEach((key) => {
+      if (containsUndefined(mixed[key])) {
+        indices.push(key);
+      }
+    });
+  } else {
+    indices.push(0);
+  }
+
+  return indices;
+}
+
+function addQueryContext(Target) {
+  // Stores or returns (if called with no arguments) context passed to
+  // wrapIdentifier and postProcessResponse hooks
+  Target.prototype.queryContext = function (context) {
+    if (context === undefined) {
+      return this._queryContext;
+    }
+    this._queryContext = context;
+    return this;
+  };
+}
+
+function resolveClientNameWithAliases(clientName) {
+  return CLIENT_ALIASES[clientName] || clientName;
+}
+
+module.exports = {
+  addQueryContext,
+  containsUndefined,
+  normalizeArr,
+  resolveClientNameWithAliases,
+  getUndefinedIndices,
+};

package/lib/index.js

@@ -1,3 +1,3 @@
-const Knex = require('./knex');
-
-module.exports = Knex;
+const Knex = require('./knex');
+
+module.exports = Knex;

package/lib/interface.js

@@ -1,115 +1,115 @@
-const clone = require('lodash/clone');
-const isEmpty = require('lodash/isEmpty');
-const { callbackify } = require('util');
-const finallyMixin = require('./util/finally-mixin');
-
-function augmentWithBuilderInterface(Target) {
-  Target.prototype.toQuery = function (tz) {
-    let data = this.toSQL(this._method, tz);
-    if (!Array.isArray(data)) data = [data];
-    if (!data.length) {
-      return '';
-    }
-    return data
-      .map((statement) => {
-        return this.client._formatQuery(statement.sql, statement.bindings, tz);
-      })
-      .reduce((a, c) => a.concat(a.endsWith(';') ? '\n' : ';\n', c));
-  };
-
-  // Create a new instance of the `Runner`, passing in the current object.
-  Target.prototype.then = function (/* onFulfilled, onRejected */) {
-    let result = this.client.runner(this).run();
-
-    if (this.client.config.asyncStackTraces) {
-      result = result.catch((err) => {
-        err.originalStack = err.stack;
-        const firstLine = err.stack.split('\n')[0];
-
-        // a hack to get a callstack into the client code despite this
-        // node.js bug https://github.com/nodejs/node/issues/11865
-        // see lib/util/save-async-stack.js for more details
-        const { error, lines } = this._asyncStack;
-        const stackByLines = error.stack.split('\n');
-        const asyncStack = stackByLines.slice(lines);
-        asyncStack.unshift(firstLine);
-
-        // put the fake more helpful "async" stack on the thrown error
-        err.stack = asyncStack.join('\n');
-        throw err;
-      });
-    }
-
-    return result.then.apply(result, arguments);
-  };
-
-  // Add additional "options" to the builder. Typically used for client specific
-  // items, like the `mysql` and `sqlite3` drivers.
-  Target.prototype.options = function (opts) {
-    this._options = this._options || [];
-    this._options.push(clone(opts) || {});
-    return this;
-  };
-
-  // Sets an explicit "connection" we wish to use for this query.
-  Target.prototype.connection = function (connection) {
-    this._connection = connection;
-    return this;
-  };
-
-  // Set a debug flag for the current schema query stack.
-  Target.prototype.debug = function (enabled) {
-    this._debug = arguments.length ? enabled : true;
-    return this;
-  };
-
-  // Set the transaction object for this query.
-  Target.prototype.transacting = function (transaction) {
-    if (transaction && transaction.client) {
-      if (!transaction.client.transacting) {
-        transaction.client.logger.warn(
-          `Invalid transaction value: ${transaction.client}`
-        );
-      } else {
-        this.client = transaction.client;
-      }
-    }
-    if (isEmpty(transaction)) {
-      this.client.logger.error(
-        'Invalid value on transacting call, potential bug'
-      );
-      throw Error(
-        'Invalid transacting value (null, undefined or empty object)'
-      );
-    }
-    return this;
-  };
-
-  // Initializes a stream.
-  Target.prototype.stream = function (options) {
-    return this.client.runner(this).stream(options);
-  };
-
-  // Initialize a stream & pipe automatically.
-  Target.prototype.pipe = function (writable, options) {
-    return this.client.runner(this).pipe(writable, options);
-  };
-
-  Target.prototype.asCallback = function (cb) {
-    const promise = this.then();
-    callbackify(() => promise)(cb);
-    return promise;
-  };
-
-  Target.prototype.catch = function (onReject) {
-    return this.then().catch(onReject);
-  };
-
-  Object.defineProperty(Target.prototype, Symbol.toStringTag, {
-    get: () => 'object',
-  });
-
-  finallyMixin(Target.prototype);
-}
-
-module.exports = augmentWithBuilderInterface;
+const clone = require('lodash/clone');
+const isEmpty = require('lodash/isEmpty');
+const { callbackify } = require('util');
+const finallyMixin = require('./util/finally-mixin');
+
+function augmentWithBuilderInterface(Target) {
+  Target.prototype.toQuery = function (tz) {
+    let data = this.toSQL(this._method, tz);
+    if (!Array.isArray(data)) data = [data];
+    if (!data.length) {
+      return '';
+    }
+    return data
+      .map((statement) => {
+        return this.client._formatQuery(statement.sql, statement.bindings, tz);
+      })
+      .reduce((a, c) => a.concat(a.endsWith(';') ? '\n' : ';\n', c));
+  };
+
+  // Create a new instance of the `Runner`, passing in the current object.
+  Target.prototype.then = function (/* onFulfilled, onRejected */) {
+    let result = this.client.runner(this).run();
+
+    if (this.client.config.asyncStackTraces) {
+      result = result.catch((err) => {
+        err.originalStack = err.stack;
+        const firstLine = err.stack.split('\n')[0];
+
+        // a hack to get a callstack into the client code despite this
+        // node.js bug https://github.com/nodejs/node/issues/11865
+        // see lib/util/save-async-stack.js for more details
+        const { error, lines } = this._asyncStack;
+        const stackByLines = error.stack.split('\n');
+        const asyncStack = stackByLines.slice(lines);
+        asyncStack.unshift(firstLine);
+
+        // put the fake more helpful "async" stack on the thrown error
+        err.stack = asyncStack.join('\n');
+        throw err;
+      });
+    }
+
+    return result.then.apply(result, arguments);
+  };
+
+  // Add additional "options" to the builder. Typically used for client specific
+  // items, like the `mysql` and `sqlite3` drivers.
+  Target.prototype.options = function (opts) {
+    this._options = this._options || [];
+    this._options.push(clone(opts) || {});
+    return this;
+  };
+
+  // Sets an explicit "connection" we wish to use for this query.
+  Target.prototype.connection = function (connection) {
+    this._connection = connection;
+    return this;
+  };
+
+  // Set a debug flag for the current schema query stack.
+  Target.prototype.debug = function (enabled) {
+    this._debug = arguments.length ? enabled : true;
+    return this;
+  };
+
+  // Set the transaction object for this query.
+  Target.prototype.transacting = function (transaction) {
+    if (transaction && transaction.client) {
+      if (!transaction.client.transacting) {
+        transaction.client.logger.warn(
+          `Invalid transaction value: ${transaction.client}`
+        );
+      } else {
+        this.client = transaction.client;
+      }
+    }
+    if (isEmpty(transaction)) {
+      this.client.logger.error(
+        'Invalid value on transacting call, potential bug'
+      );
+      throw Error(
+        'Invalid transacting value (null, undefined or empty object)'
+      );
+    }
+    return this;
+  };
+
+  // Initializes a stream.
+  Target.prototype.stream = function (options) {
+    return this.client.runner(this).stream(options);
+  };
+
+  // Initialize a stream & pipe automatically.
+  Target.prototype.pipe = function (writable, options) {
+    return this.client.runner(this).pipe(writable, options);
+  };
+
+  Target.prototype.asCallback = function (cb) {
+    const promise = this.then();
+    callbackify(() => promise)(cb);
+    return promise;
+  };
+
+  Target.prototype.catch = function (onReject) {
+    return this.then().catch(onReject);
+  };
+
+  Object.defineProperty(Target.prototype, Symbol.toStringTag, {
+    get: () => 'object',
+  });
+
+  finallyMixin(Target.prototype);
+}
+
+module.exports = augmentWithBuilderInterface;

package/lib/knex.js

@@ -1,42 +1,42 @@
-const Raw = require('./raw');
-const Client = require('./client');
-const QueryBuilder = require('./query/builder');
-const QueryInterface = require('./query/methods');
-
-const makeKnex = require('./util/make-knex');
-const { KnexTimeoutError } = require('./util/timeout');
-const fakeClient = require('./util/fake-client');
-const { resolveConfig } = require('./config-resolver');
-
-function Knex(config) {
-  const { resolvedConfig, Dialect } = resolveConfig(...arguments);
-
-  const newKnex = makeKnex(new Dialect(resolvedConfig));
-  if (resolvedConfig.userParams) {
-    newKnex.userParams = resolvedConfig.userParams;
-  }
-  return newKnex;
-}
-
-// Expose Client on the main Knex namespace.
-Knex.Client = Client;
-
-Knex.KnexTimeoutError = KnexTimeoutError;
-
-Knex.QueryBuilder = {
-  extend: function (methodName, fn) {
-    QueryBuilder.extend(methodName, fn);
-    QueryInterface.push(methodName);
-  },
-};
-
-// Run a "raw" query, though we can't do anything with it other than put
-// it in a query statement.
-Knex.raw = (sql, bindings) => {
-  console.warn(
-    'global Knex.raw is deprecated, use knex.raw (chain off an initialized knex object)'
-  );
-  return new Raw(fakeClient).set(sql, bindings);
-};
-
-module.exports = Knex;
+const Raw = require('./raw');
+const Client = require('./client');
+const QueryBuilder = require('./query/builder');
+const QueryInterface = require('./query/methods');
+
+const makeKnex = require('./util/make-knex');
+const { KnexTimeoutError } = require('./util/timeout');
+const fakeClient = require('./util/fake-client');
+const { resolveConfig } = require('./config-resolver');
+
+function Knex(config) {
+  const { resolvedConfig, Dialect } = resolveConfig(...arguments);
+
+  const newKnex = makeKnex(new Dialect(resolvedConfig));
+  if (resolvedConfig.userParams) {
+    newKnex.userParams = resolvedConfig.userParams;
+  }
+  return newKnex;
+}
+
+// Expose Client on the main Knex namespace.
+Knex.Client = Client;
+
+Knex.KnexTimeoutError = KnexTimeoutError;
+
+Knex.QueryBuilder = {
+  extend: function (methodName, fn) {
+    QueryBuilder.extend(methodName, fn);
+    QueryInterface.push(methodName);
+  },
+};
+
+// Run a "raw" query, though we can't do anything with it other than put
+// it in a query statement.
+Knex.raw = (sql, bindings) => {
+  console.warn(
+    'global Knex.raw is deprecated, use knex.raw (chain off an initialized knex object)'
+  );
+  return new Raw(fakeClient).set(sql, bindings);
+};
+
+module.exports = Knex;

package/lib/logger.js

@@ -1,76 +1,76 @@
-const color = require('colorette');
-const { inspect } = require('util');
-const { isString, isFunction } = require('./util/is');
-
-class Logger {
-  constructor(config = {}) {
-    const {
-      log: {
-        debug,
-        warn,
-        error,
-        deprecate,
-        inspectionDepth,
-        enableColors,
-      } = {},
-    } = config;
-    this._inspectionDepth = inspectionDepth || 5;
-    this._enableColors = resolveIsEnabledColors(enableColors);
-    this._debug = debug;
-    this._warn = warn;
-    this._error = error;
-    this._deprecate = deprecate;
-  }
-
-  _log(message, userFn, colorFn) {
-    if (userFn != null && !isFunction(userFn)) {
-      throw new TypeError('Extensions to knex logger must be functions!');
-    }
-
-    if (isFunction(userFn)) {
-      userFn(message);
-      return;
-    }
-
-    if (!isString(message)) {
-      message = inspect(message, {
-        depth: this._inspectionDepth,
-        colors: this._enableColors,
-      });
-    }
-
-    console.log(colorFn ? colorFn(message) : message);
-  }
-
-  debug(message) {
-    this._log(message, this._debug);
-  }
-
-  warn(message) {
-    this._log(message, this._warn, color.yellow);
-  }
-
-  error(message) {
-    this._log(message, this._error, color.red);
-  }
-
-  deprecate(method, alternative) {
-    const message = `${method} is deprecated, please use ${alternative}`;
-
-    this._log(message, this._deprecate, color.yellow);
-  }
-}
-
-function resolveIsEnabledColors(enableColorsParam) {
-  if (enableColorsParam != null) {
-    return enableColorsParam;
-  }
-
-  if (process && process.stdout) {
-    return process.stdout.isTTY;
-  }
-
-  return false;
-}
-
-module.exports = Logger;
+const color = require('colorette');
+const { inspect } = require('util');
+const { isString, isFunction } = require('./util/is');
+
+class Logger {
+  constructor(config = {}) {
+    const {
+      log: {
+        debug,
+        warn,
+        error,
+        deprecate,
+        inspectionDepth,
+        enableColors,
+      } = {},
+    } = config;
+    this._inspectionDepth = inspectionDepth || 5;
+    this._enableColors = resolveIsEnabledColors(enableColors);
+    this._debug = debug;
+    this._warn = warn;
+    this._error = error;
+    this._deprecate = deprecate;
+  }
+
+  _log(message, userFn, colorFn) {
+    if (userFn != null && !isFunction(userFn)) {
+      throw new TypeError('Extensions to knex logger must be functions!');
+    }
+
+    if (isFunction(userFn)) {
+      userFn(message);
+      return;
+    }
+
+    if (!isString(message)) {
+      message = inspect(message, {
+        depth: this._inspectionDepth,
+        colors: this._enableColors,
+      });
+    }
+
+    console.log(colorFn ? colorFn(message) : message);
+  }
+
+  debug(message) {
+    this._log(message, this._debug);
+  }
+
+  warn(message) {
+    this._log(message, this._warn, color.yellow);
+  }
+
+  error(message) {
+    this._log(message, this._error, color.red);
+  }
+
+  deprecate(method, alternative) {
+    const message = `${method} is deprecated, please use ${alternative}`;
+
+    this._log(message, this._deprecate, color.yellow);
+  }
+}
+
+function resolveIsEnabledColors(enableColorsParam) {
+  if (enableColorsParam != null) {
+    return enableColorsParam;
+  }
+
+  if (process && process.stdout) {
+    return process.stdout.isTTY;
+  }
+
+  return false;
+}
+
+module.exports = Logger;