knex 2.5.0 → 2.5.1

package/lib/raw.js

@@ -1,139 +1,139 @@
-// Raw
-// -------
-const { EventEmitter } = require('events');
-const debug = require('debug');
-const assign = require('lodash/assign');
-const isPlainObject = require('lodash/isPlainObject');
-const reduce = require('lodash/reduce');
-
-const {
-  replaceRawArrBindings,
-  replaceKeyBindings,
-} = require('./formatter/rawFormatter');
-const helpers = require('./util/helpers');
-const saveAsyncStack = require('./util/save-async-stack');
-const { nanoid } = require('./util/nanoid');
-const { isNumber, isObject } = require('./util/is');
-const {
-  augmentWithBuilderInterface,
-} = require('./builder-interface-augmenter');
-
-const debugBindings = debug('knex:bindings');
-
-class Raw extends EventEmitter {
-  constructor(client) {
-    super();
-
-    this.client = client;
-
-    this.sql = '';
-    this.bindings = [];
-
-    // Todo: Deprecate
-    this._wrappedBefore = undefined;
-    this._wrappedAfter = undefined;
-    if (client && client.config) {
-      this._debug = client.config.debug;
-      saveAsyncStack(this, 4);
-    }
-  }
-  set(sql, bindings) {
-    this.sql = sql;
-    this.bindings =
-      (isObject(bindings) && !bindings.toSQL) || bindings === undefined
-        ? bindings
-        : [bindings];
-
-    return this;
-  }
-
-  timeout(ms, { cancel } = {}) {
-    if (isNumber(ms) && ms > 0) {
-      this._timeout = ms;
-      if (cancel) {
-        this.client.assertCanCancelQuery();
-        this._cancelOnTimeout = true;
-      }
-    }
-    return this;
-  }
-
-  // Wraps the current sql with `before` and `after`.
-  wrap(before, after) {
-    this._wrappedBefore = before;
-    this._wrappedAfter = after;
-    return this;
-  }
-
-  // Calls `toString` on the Knex object.
-  toString() {
-    return this.toQuery();
-  }
-
-  // Returns the raw sql for the query.
-  toSQL(method, tz) {
-    let obj;
-    if (Array.isArray(this.bindings)) {
-      obj = replaceRawArrBindings(this, this.client);
-    } else if (this.bindings && isPlainObject(this.bindings)) {
-      obj = replaceKeyBindings(this, this.client);
-    } else {
-      obj = {
-        method: 'raw',
-        sql: this.sql,
-        bindings: this.bindings === undefined ? [] : [this.bindings],
-      };
-    }
-
-    if (this._wrappedBefore) {
-      obj.sql = this._wrappedBefore + obj.sql;
-    }
-    if (this._wrappedAfter) {
-      obj.sql = obj.sql + this._wrappedAfter;
-    }
-
-    obj.options = reduce(this._options, assign, {});
-
-    if (this._timeout) {
-      obj.timeout = this._timeout;
-      if (this._cancelOnTimeout) {
-        obj.cancelOnTimeout = this._cancelOnTimeout;
-      }
-    }
-
-    obj.bindings = obj.bindings || [];
-    if (helpers.containsUndefined(obj.bindings)) {
-      const undefinedBindingIndices = helpers.getUndefinedIndices(
-        this.bindings
-      );
-      debugBindings(obj.bindings);
-      throw new Error(
-        `Undefined binding(s) detected for keys [${undefinedBindingIndices}] when compiling RAW query: ${obj.sql}`
-      );
-    }
-
-    obj.__knexQueryUid = nanoid();
-
-    Object.defineProperties(obj, {
-      toNative: {
-        value: () => ({
-          sql: this.client.positionBindings(obj.sql),
-          bindings: this.client.prepBindings(obj.bindings),
-        }),
-        enumerable: false,
-      },
-    });
-
-    return obj;
-  }
-}
-
-// Workaround to avoid circular dependency between wrappingFormatter.unwrapRaw and rawFormatter
-Raw.prototype.isRawInstance = true;
-
-// Allow the `Raw` object to be utilized with full access to the relevant
-// promise API.
-augmentWithBuilderInterface(Raw);
-helpers.addQueryContext(Raw);
-
-module.exports = Raw;
+// Raw
+// -------
+const { EventEmitter } = require('events');
+const debug = require('debug');
+const assign = require('lodash/assign');
+const isPlainObject = require('lodash/isPlainObject');
+const reduce = require('lodash/reduce');
+
+const {
+  replaceRawArrBindings,
+  replaceKeyBindings,
+} = require('./formatter/rawFormatter');
+const helpers = require('./util/helpers');
+const saveAsyncStack = require('./util/save-async-stack');
+const { nanoid } = require('./util/nanoid');
+const { isNumber, isObject } = require('./util/is');
+const {
+  augmentWithBuilderInterface,
+} = require('./builder-interface-augmenter');
+
+const debugBindings = debug('knex:bindings');
+
+class Raw extends EventEmitter {
+  constructor(client) {
+    super();
+
+    this.client = client;
+
+    this.sql = '';
+    this.bindings = [];
+
+    // Todo: Deprecate
+    this._wrappedBefore = undefined;
+    this._wrappedAfter = undefined;
+    if (client && client.config) {
+      this._debug = client.config.debug;
+      saveAsyncStack(this, 4);
+    }
+  }
+  set(sql, bindings) {
+    this.sql = sql;
+    this.bindings =
+      (isObject(bindings) && !bindings.toSQL) || bindings === undefined
+        ? bindings
+        : [bindings];
+
+    return this;
+  }
+
+  timeout(ms, { cancel } = {}) {
+    if (isNumber(ms) && ms > 0) {
+      this._timeout = ms;
+      if (cancel) {
+        this.client.assertCanCancelQuery();
+        this._cancelOnTimeout = true;
+      }
+    }
+    return this;
+  }
+
+  // Wraps the current sql with `before` and `after`.
+  wrap(before, after) {
+    this._wrappedBefore = before;
+    this._wrappedAfter = after;
+    return this;
+  }
+
+  // Calls `toString` on the Knex object.
+  toString() {
+    return this.toQuery();
+  }
+
+  // Returns the raw sql for the query.
+  toSQL(method, tz) {
+    let obj;
+    if (Array.isArray(this.bindings)) {
+      obj = replaceRawArrBindings(this, this.client);
+    } else if (this.bindings && isPlainObject(this.bindings)) {
+      obj = replaceKeyBindings(this, this.client);
+    } else {
+      obj = {
+        method: 'raw',
+        sql: this.sql,
+        bindings: this.bindings === undefined ? [] : [this.bindings],
+      };
+    }
+
+    if (this._wrappedBefore) {
+      obj.sql = this._wrappedBefore + obj.sql;
+    }
+    if (this._wrappedAfter) {
+      obj.sql = obj.sql + this._wrappedAfter;
+    }
+
+    obj.options = reduce(this._options, assign, {});
+
+    if (this._timeout) {
+      obj.timeout = this._timeout;
+      if (this._cancelOnTimeout) {
+        obj.cancelOnTimeout = this._cancelOnTimeout;
+      }
+    }
+
+    obj.bindings = obj.bindings || [];
+    if (helpers.containsUndefined(obj.bindings)) {
+      const undefinedBindingIndices = helpers.getUndefinedIndices(
+        this.bindings
+      );
+      debugBindings(obj.bindings);
+      throw new Error(
+        `Undefined binding(s) detected for keys [${undefinedBindingIndices}] when compiling RAW query: ${obj.sql}`
+      );
+    }
+
+    obj.__knexQueryUid = nanoid();
+
+    Object.defineProperties(obj, {
+      toNative: {
+        value: () => ({
+          sql: this.client.positionBindings(obj.sql),
+          bindings: this.client.prepBindings(obj.bindings),
+        }),
+        enumerable: false,
+      },
+    });
+
+    return obj;
+  }
+}
+
+// Workaround to avoid circular dependency between wrappingFormatter.unwrapRaw and rawFormatter
+Raw.prototype.isRawInstance = true;
+
+// Allow the `Raw` object to be utilized with full access to the relevant
+// promise API.
+augmentWithBuilderInterface(Raw);
+helpers.addQueryContext(Raw);
+
+module.exports = Raw;

package/lib/ref.js

@@ -1,39 +1,39 @@
-const Raw = require('./raw');
-
-class Ref extends Raw {
-  constructor(client, ref) {
-    super(client);
-
-    this.ref = ref;
-    this._schema = null;
-    this._alias = null;
-  }
-
-  withSchema(schema) {
-    this._schema = schema;
-
-    return this;
-  }
-
-  as(alias) {
-    this._alias = alias;
-
-    return this;
-  }
-
-  toSQL() {
-    const string = this._schema ? `${this._schema}.${this.ref}` : this.ref;
-
-    const formatter = this.client.formatter(this);
-
-    const ref = formatter.columnize(string);
-
-    const sql = this._alias ? `${ref} as ${formatter.wrap(this._alias)}` : ref;
-
-    this.set(sql, []);
-
-    return super.toSQL(...arguments);
-  }
-}
-
-module.exports = Ref;
+const Raw = require('./raw');
+
+class Ref extends Raw {
+  constructor(client, ref) {
+    super(client);
+
+    this.ref = ref;
+    this._schema = null;
+    this._alias = null;
+  }
+
+  withSchema(schema) {
+    this._schema = schema;
+
+    return this;
+  }
+
+  as(alias) {
+    this._alias = alias;
+
+    return this;
+  }
+
+  toSQL() {
+    const string = this._schema ? `${this._schema}.${this.ref}` : this.ref;
+
+    const formatter = this.client.formatter(this);
+
+    const ref = formatter.columnize(string);
+
+    const sql = this._alias ? `${ref} as ${formatter.wrap(this._alias)}` : ref;
+
+    this.set(sql, []);
+
+    return super.toSQL(...arguments);
+  }
+}
+
+module.exports = Ref;

package/lib/schema/builder.js

@@ -1,115 +1,115 @@
-const { EventEmitter } = require('events');
-const toArray = require('lodash/toArray');
-const assign = require('lodash/assign');
-const { addQueryContext } = require('../util/helpers');
-const saveAsyncStack = require('../util/save-async-stack');
-const {
-  augmentWithBuilderInterface,
-} = require('../builder-interface-augmenter');
-
-// Constructor for the builder instance, typically called from
-// `knex.builder`, accepting the current `knex` instance,
-// and pulling out the `client` and `grammar` from the current
-// knex instance.
-class SchemaBuilder extends EventEmitter {
-  constructor(client) {
-    super();
-    this.client = client;
-    this._sequence = [];
-
-    if (client.config) {
-      this._debug = client.config.debug;
-      saveAsyncStack(this, 4);
-    }
-  }
-
-  withSchema(schemaName) {
-    this._schema = schemaName;
-    return this;
-  }
-
-  toString() {
-    return this.toQuery();
-  }
-
-  toSQL() {
-    return this.client.schemaCompiler(this).toSQL();
-  }
-
-  async generateDdlCommands() {
-    return await this.client.schemaCompiler(this).generateDdlCommands();
-  }
-}
-
-// Each of the schema builder methods just add to the
-// "_sequence" array for consistency.
-[
-  'createTable',
-  'createTableIfNotExists',
-  'createTableLike',
-  'createView',
-  'createViewOrReplace',
-  'createMaterializedView',
-  'refreshMaterializedView',
-  'dropView',
-  'dropViewIfExists',
-  'dropMaterializedView',
-  'dropMaterializedViewIfExists',
-  'createSchema',
-  'createSchemaIfNotExists',
-  'dropSchema',
-  'dropSchemaIfExists',
-  'createExtension',
-  'createExtensionIfNotExists',
-  'dropExtension',
-  'dropExtensionIfExists',
-  'table',
-  'alterTable',
-  'view',
-  'alterView',
-  'hasTable',
-  'hasColumn',
-  'dropTable',
-  'renameTable',
-  'renameView',
-  'dropTableIfExists',
-  'raw',
-].forEach(function (method) {
-  SchemaBuilder.prototype[method] = function () {
-    if (method === 'createTableIfNotExists') {
-      this.client.logger.warn(
-        [
-          'Use async .hasTable to check if table exists and then use plain .createTable. Since ',
-          '.createTableIfNotExists actually just generates plain "CREATE TABLE IF NOT EXIST..." ',
-          'query it will not work correctly if there are any alter table queries generated for ',
-          'columns afterwards. To not break old migrations this function is left untouched for now',
-          ', but it should not be used when writing new code and it is removed from documentation.',
-        ].join('')
-      );
-    }
-    if (method === 'table') method = 'alterTable';
-    if (method === 'view') method = 'alterView';
-    this._sequence.push({
-      method,
-      args: toArray(arguments),
-    });
-    return this;
-  };
-});
-
-SchemaBuilder.extend = (methodName, fn) => {
-  if (
-    Object.prototype.hasOwnProperty.call(SchemaBuilder.prototype, methodName)
-  ) {
-    throw new Error(
-      `Can't extend SchemaBuilder with existing method ('${methodName}').`
-    );
-  }
-
-  assign(SchemaBuilder.prototype, { [methodName]: fn });
-};
-
-augmentWithBuilderInterface(SchemaBuilder);
-addQueryContext(SchemaBuilder);
-
-module.exports = SchemaBuilder;
+const { EventEmitter } = require('events');
+const toArray = require('lodash/toArray');
+const assign = require('lodash/assign');
+const { addQueryContext } = require('../util/helpers');
+const saveAsyncStack = require('../util/save-async-stack');
+const {
+  augmentWithBuilderInterface,
+} = require('../builder-interface-augmenter');
+
+// Constructor for the builder instance, typically called from
+// `knex.builder`, accepting the current `knex` instance,
+// and pulling out the `client` and `grammar` from the current
+// knex instance.
+class SchemaBuilder extends EventEmitter {
+  constructor(client) {
+    super();
+    this.client = client;
+    this._sequence = [];
+
+    if (client.config) {
+      this._debug = client.config.debug;
+      saveAsyncStack(this, 4);
+    }
+  }
+
+  withSchema(schemaName) {
+    this._schema = schemaName;
+    return this;
+  }
+
+  toString() {
+    return this.toQuery();
+  }
+
+  toSQL() {
+    return this.client.schemaCompiler(this).toSQL();
+  }
+
+  async generateDdlCommands() {
+    return await this.client.schemaCompiler(this).generateDdlCommands();
+  }
+}
+
+// Each of the schema builder methods just add to the
+// "_sequence" array for consistency.
+[
+  'createTable',
+  'createTableIfNotExists',
+  'createTableLike',
+  'createView',
+  'createViewOrReplace',
+  'createMaterializedView',
+  'refreshMaterializedView',
+  'dropView',
+  'dropViewIfExists',
+  'dropMaterializedView',
+  'dropMaterializedViewIfExists',
+  'createSchema',
+  'createSchemaIfNotExists',
+  'dropSchema',
+  'dropSchemaIfExists',
+  'createExtension',
+  'createExtensionIfNotExists',
+  'dropExtension',
+  'dropExtensionIfExists',
+  'table',
+  'alterTable',
+  'view',
+  'alterView',
+  'hasTable',
+  'hasColumn',
+  'dropTable',
+  'renameTable',
+  'renameView',
+  'dropTableIfExists',
+  'raw',
+].forEach(function (method) {
+  SchemaBuilder.prototype[method] = function () {
+    if (method === 'createTableIfNotExists') {
+      this.client.logger.warn(
+        [
+          'Use async .hasTable to check if table exists and then use plain .createTable. Since ',
+          '.createTableIfNotExists actually just generates plain "CREATE TABLE IF NOT EXIST..." ',
+          'query it will not work correctly if there are any alter table queries generated for ',
+          'columns afterwards. To not break old migrations this function is left untouched for now',
+          ', but it should not be used when writing new code and it is removed from documentation.',
+        ].join('')
+      );
+    }
+    if (method === 'table') method = 'alterTable';
+    if (method === 'view') method = 'alterView';
+    this._sequence.push({
+      method,
+      args: toArray(arguments),
+    });
+    return this;
+  };
+});
+
+SchemaBuilder.extend = (methodName, fn) => {
+  if (
+    Object.prototype.hasOwnProperty.call(SchemaBuilder.prototype, methodName)
+  ) {
+    throw new Error(
+      `Can't extend SchemaBuilder with existing method ('${methodName}').`
+    );
+  }
+
+  assign(SchemaBuilder.prototype, { [methodName]: fn });
+};
+
+augmentWithBuilderInterface(SchemaBuilder);
+addQueryContext(SchemaBuilder);
+
+module.exports = SchemaBuilder;