knex 3.2.3 → 3.2.4

package/lib/schema/viewbuilder.js

@@ -1,92 +1,92 @@
-const helpers = require('../util/helpers');
-const extend = require('lodash/extend');
-const assign = require('lodash/assign');
-
-class ViewBuilder {
-  constructor(client, method, viewName, fn) {
-    this.client = client;
-    this._method = method;
-    this._schemaName = undefined;
-    this._columns = undefined;
-    this._fn = fn;
-    this._viewName = viewName;
-    this._statements = [];
-    this._single = {};
-  }
-
-  setSchema(schemaName) {
-    this._schemaName = schemaName;
-  }
-
-  columns(columns) {
-    this._columns = columns;
-  }
-
-  as(selectQuery) {
-    this._selectQuery = selectQuery;
-  }
-
-  checkOption() {
-    throw new Error(
-      'check option definition is not supported by this dialect.'
-    );
-  }
-
-  localCheckOption() {
-    throw new Error(
-      'check option definition is not supported by this dialect.'
-    );
-  }
-
-  cascadedCheckOption() {
-    throw new Error(
-      'check option definition is not supported by this dialect.'
-    );
-  }
-
-  toSQL() {
-    if (this._method === 'alter') {
-      extend(this, AlterMethods);
-    }
-    this._fn.call(this, this);
-    return this.client.viewCompiler(this).toSQL();
-  }
-}
-
-const AlterMethods = {
-  column(column) {
-    const self = this;
-    return {
-      rename: function (newName) {
-        self._statements.push({
-          grouping: 'alterView',
-          method: 'renameColumn',
-          args: [column, newName],
-        });
-        return this;
-      },
-      defaultTo: function (defaultValue) {
-        self._statements.push({
-          grouping: 'alterView',
-          method: 'defaultTo',
-          args: [column, defaultValue],
-        });
-        return this;
-      },
-    };
-  },
-};
-
-helpers.addQueryContext(ViewBuilder);
-
-ViewBuilder.extend = (methodName, fn) => {
-  if (Object.prototype.hasOwnProperty.call(ViewBuilder.prototype, methodName)) {
-    throw new Error(
-      `Can't extend ViewBuilder with existing method ('${methodName}').`
-    );
-  }
-
-  assign(ViewBuilder.prototype, { [methodName]: fn });
-};
-
-module.exports = ViewBuilder;
+const helpers = require('../util/helpers');
+const extend = require('lodash/extend');
+const assign = require('lodash/assign');
+
+class ViewBuilder {
+  constructor(client, method, viewName, fn) {
+    this.client = client;
+    this._method = method;
+    this._schemaName = undefined;
+    this._columns = undefined;
+    this._fn = fn;
+    this._viewName = viewName;
+    this._statements = [];
+    this._single = {};
+  }
+
+  setSchema(schemaName) {
+    this._schemaName = schemaName;
+  }
+
+  columns(columns) {
+    this._columns = columns;
+  }
+
+  as(selectQuery) {
+    this._selectQuery = selectQuery;
+  }
+
+  checkOption() {
+    throw new Error(
+      'check option definition is not supported by this dialect.'
+    );
+  }
+
+  localCheckOption() {
+    throw new Error(
+      'check option definition is not supported by this dialect.'
+    );
+  }
+
+  cascadedCheckOption() {
+    throw new Error(
+      'check option definition is not supported by this dialect.'
+    );
+  }
+
+  toSQL() {
+    if (this._method === 'alter') {
+      extend(this, AlterMethods);
+    }
+    this._fn.call(this, this);
+    return this.client.viewCompiler(this).toSQL();
+  }
+}
+
+const AlterMethods = {
+  column(column) {
+    const self = this;
+    return {
+      rename: function (newName) {
+        self._statements.push({
+          grouping: 'alterView',
+          method: 'renameColumn',
+          args: [column, newName],
+        });
+        return this;
+      },
+      defaultTo: function (defaultValue) {
+        self._statements.push({
+          grouping: 'alterView',
+          method: 'defaultTo',
+          args: [column, defaultValue],
+        });
+        return this;
+      },
+    };
+  },
+};
+
+helpers.addQueryContext(ViewBuilder);
+
+ViewBuilder.extend = (methodName, fn) => {
+  if (Object.prototype.hasOwnProperty.call(ViewBuilder.prototype, methodName)) {
+    throw new Error(
+      `Can't extend ViewBuilder with existing method ('${methodName}').`
+    );
+  }
+
+  assign(ViewBuilder.prototype, { [methodName]: fn });
+};
+
+module.exports = ViewBuilder;

package/lib/schema/viewcompiler.js

@@ -1,138 +1,138 @@
-/* eslint max-len:0 */
-
-// View Compiler
-// -------
-const { pushQuery } = require('./internal/helpers');
-const groupBy = require('lodash/groupBy');
-const { columnize: columnize_ } = require('../formatter/wrappingFormatter');
-
-class ViewCompiler {
-  constructor(client, viewBuilder) {
-    this.client = client;
-    this.viewBuilder = viewBuilder;
-    this._commonBuilder = this.viewBuilder;
-    this.method = viewBuilder._method;
-    this.schemaNameRaw = viewBuilder._schemaName;
-    this.viewNameRaw = viewBuilder._viewName;
-    this.single = viewBuilder._single;
-    this.selectQuery = viewBuilder._selectQuery;
-    this.columns = viewBuilder._columns;
-    this.grouped = groupBy(viewBuilder._statements, 'grouping');
-
-    this.formatter = client.formatter(viewBuilder);
-    this.bindings = [];
-    this.formatter.bindings = this.bindings;
-    this.bindingsHolder = this;
-
-    this.sequence = [];
-  }
-
-  // Convert the tableCompiler toSQL
-  toSQL() {
-    this[this.method]();
-    return this.sequence;
-  }
-
-  // Column Compilation
-  // -------
-
-  create() {
-    this.createQuery(this.columns, this.selectQuery);
-  }
-
-  createOrReplace() {
-    throw new Error('replace views is not supported by this dialect.');
-  }
-
-  createMaterializedView() {
-    throw new Error('materialized views are not supported by this dialect.');
-  }
-
-  createQuery(columns, selectQuery, materialized, replace) {
-    const createStatement =
-      'create ' +
-      (materialized ? 'materialized ' : '') +
-      (replace ? 'or replace ' : '') +
-      'view ';
-    const columnList = columns
-      ? ' (' +
-        columnize_(
-          columns,
-          this.viewBuilder,
-          this.client,
-          this.bindingsHolder
-        ) +
-        ')'
-      : '';
-    let sql = createStatement + this.viewName() + columnList;
-    sql += ' as ';
-    sql += selectQuery.toString();
-    switch (this.single.checkOption) {
-      case 'default_option':
-        sql += ' with check option';
-        break;
-      case 'local':
-        sql += ' with local check option';
-        break;
-      case 'cascaded':
-        sql += ' with cascaded check option';
-        break;
-      default:
-        break;
-    }
-    this.pushQuery({
-      sql,
-    });
-  }
-
-  renameView(from, to) {
-    throw new Error(
-      'rename view is not supported by this dialect (instead drop, then create another view).'
-    );
-  }
-
-  refreshMaterializedView() {
-    throw new Error('materialized views are not supported by this dialect.');
-  }
-
-  alter() {
-    this.alterView();
-  }
-
-  alterView() {
-    const alterView = this.grouped.alterView || [];
-    for (let i = 0, l = alterView.length; i < l; i++) {
-      const statement = alterView[i];
-      if (this[statement.method]) {
-        this[statement.method].apply(this, statement.args);
-      } else {
-        this.client.logger.error(`Debug: ${statement.method} does not exist`);
-      }
-    }
-    for (const item in this.single) {
-      if (typeof this[item] === 'function') this[item](this.single[item]);
-    }
-  }
-
-  renameColumn(from, to) {
-    throw new Error('rename column of views is not supported by this dialect.');
-  }
-
-  defaultTo(column, defaultValue) {
-    throw new Error(
-      'change default values of views is not supported by this dialect.'
-    );
-  }
-
-  viewName() {
-    const name = this.schemaNameRaw
-      ? `${this.schemaNameRaw}.${this.viewNameRaw}`
-      : this.viewNameRaw;
-
-    return this.formatter.wrap(name);
-  }
-}
-
-ViewCompiler.prototype.pushQuery = pushQuery;
-
-module.exports = ViewCompiler;
+/* eslint max-len:0 */
+
+// View Compiler
+// -------
+const { pushQuery } = require('./internal/helpers');
+const groupBy = require('lodash/groupBy');
+const { columnize: columnize_ } = require('../formatter/wrappingFormatter');
+
+class ViewCompiler {
+  constructor(client, viewBuilder) {
+    this.client = client;
+    this.viewBuilder = viewBuilder;
+    this._commonBuilder = this.viewBuilder;
+    this.method = viewBuilder._method;
+    this.schemaNameRaw = viewBuilder._schemaName;
+    this.viewNameRaw = viewBuilder._viewName;
+    this.single = viewBuilder._single;
+    this.selectQuery = viewBuilder._selectQuery;
+    this.columns = viewBuilder._columns;
+    this.grouped = groupBy(viewBuilder._statements, 'grouping');
+
+    this.formatter = client.formatter(viewBuilder);
+    this.bindings = [];
+    this.formatter.bindings = this.bindings;
+    this.bindingsHolder = this;
+
+    this.sequence = [];
+  }
+
+  // Convert the tableCompiler toSQL
+  toSQL() {
+    this[this.method]();
+    return this.sequence;
+  }
+
+  // Column Compilation
+  // -------
+
+  create() {
+    this.createQuery(this.columns, this.selectQuery);
+  }
+
+  createOrReplace() {
+    throw new Error('replace views is not supported by this dialect.');
+  }
+
+  createMaterializedView() {
+    throw new Error('materialized views are not supported by this dialect.');
+  }
+
+  createQuery(columns, selectQuery, materialized, replace) {
+    const createStatement =
+      'create ' +
+      (materialized ? 'materialized ' : '') +
+      (replace ? 'or replace ' : '') +
+      'view ';
+    const columnList = columns
+      ? ' (' +
+        columnize_(
+          columns,
+          this.viewBuilder,
+          this.client,
+          this.bindingsHolder
+        ) +
+        ')'
+      : '';
+    let sql = createStatement + this.viewName() + columnList;
+    sql += ' as ';
+    sql += selectQuery.toString();
+    switch (this.single.checkOption) {
+      case 'default_option':
+        sql += ' with check option';
+        break;
+      case 'local':
+        sql += ' with local check option';
+        break;
+      case 'cascaded':
+        sql += ' with cascaded check option';
+        break;
+      default:
+        break;
+    }
+    this.pushQuery({
+      sql,
+    });
+  }
+
+  renameView(from, to) {
+    throw new Error(
+      'rename view is not supported by this dialect (instead drop, then create another view).'
+    );
+  }
+
+  refreshMaterializedView() {
+    throw new Error('materialized views are not supported by this dialect.');
+  }
+
+  alter() {
+    this.alterView();
+  }
+
+  alterView() {
+    const alterView = this.grouped.alterView || [];
+    for (let i = 0, l = alterView.length; i < l; i++) {
+      const statement = alterView[i];
+      if (this[statement.method]) {
+        this[statement.method].apply(this, statement.args);
+      } else {
+        this.client.logger.error(`Debug: ${statement.method} does not exist`);
+      }
+    }
+    for (const item in this.single) {
+      if (typeof this[item] === 'function') this[item](this.single[item]);
+    }
+  }
+
+  renameColumn(from, to) {
+    throw new Error('rename column of views is not supported by this dialect.');
+  }
+
+  defaultTo(column, defaultValue) {
+    throw new Error(
+      'change default values of views is not supported by this dialect.'
+    );
+  }
+
+  viewName() {
+    const name = this.schemaNameRaw
+      ? `${this.schemaNameRaw}.${this.viewNameRaw}`
+      : this.viewNameRaw;
+
+    return this.formatter.wrap(name);
+  }
+}
+
+ViewCompiler.prototype.pushQuery = pushQuery;
+
+module.exports = ViewCompiler;

package/lib/util/finally-mixin.js

@@ -1,13 +1,13 @@
-const noop = require('./noop');
-
-const finallyMixin = (prototype) =>
-  Object.assign(prototype, {
-    finally(onFinally) {
-      return this.then().finally(onFinally);
-    },
-  });
-
-// FYI: Support for `Promise.prototype.finally` was not introduced until Node 9.
-//      Therefore, Knex will need to conditionally inject support for `.finally(..)`
-//      until support for Node 8 is officially dropped.
-module.exports = Promise.prototype.finally ? finallyMixin : noop;
+const noop = require('./noop');
+
+const finallyMixin = (prototype) =>
+  Object.assign(prototype, {
+    finally(onFinally) {
+      return this.then().finally(onFinally);
+    },
+  });
+
+// FYI: Support for `Promise.prototype.finally` was not introduced until Node 9.
+//      Therefore, Knex will need to conditionally inject support for `.finally(..)`
+//      until support for Node 8 is officially dropped.
+module.exports = Promise.prototype.finally ? finallyMixin : noop;

package/lib/util/helpers.js

@@ -1,95 +1,95 @@
-const isPlainObject = require('lodash/isPlainObject');
-const isTypedArray = require('lodash/isTypedArray');
-const { CLIENT_ALIASES } = require('../constants');
-const { isFunction } = require('./is');
-
-// Check if the first argument is an array, otherwise uses all arguments as an
-// array.
-function normalizeArr(...args) {
-  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;
-}
-
-function toNumber(val, fallback) {
-  if (val === undefined || val === null) return fallback;
-  const number = parseInt(val, 10);
-  return isNaN(number) ? fallback : number;
-}
-
-module.exports = {
-  addQueryContext,
-  containsUndefined,
-  getUndefinedIndices,
-  normalizeArr,
-  resolveClientNameWithAliases,
-  toNumber,
-};
+const isPlainObject = require('lodash/isPlainObject');
+const isTypedArray = require('lodash/isTypedArray');
+const { CLIENT_ALIASES } = require('../constants');
+const { isFunction } = require('./is');
+
+// Check if the first argument is an array, otherwise uses all arguments as an
+// array.
+function normalizeArr(...args) {
+  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;
+}
+
+function toNumber(val, fallback) {
+  if (val === undefined || val === null) return fallback;
+  const number = parseInt(val, 10);
+  return isNaN(number) ? fallback : number;
+}
+
+module.exports = {
+  addQueryContext,
+  containsUndefined,
+  getUndefinedIndices,
+  normalizeArr,
+  resolveClientNameWithAliases,
+  toNumber,
+};