knex 0.21.20 → 0.21.21

package/lib/schema/builder.js

@@ -1,82 +1,82 @@
-const { inherits } = require('util');
-const { EventEmitter } = require('events');
-const toArray = require('lodash/toArray');
-const { addQueryContext } = require('../helpers');
-const saveAsyncStack = require('../util/save-async-stack');
-
-// 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.
-function SchemaBuilder(client) {
-  this.client = client;
-  this._sequence = [];
-
-  if (client.config) {
-    this._debug = client.config.debug;
-    saveAsyncStack(this, 4);
-  }
-}
-
-inherits(SchemaBuilder, EventEmitter);
-
-// Each of the schema builder methods just add to the
-// "_sequence" array for consistency.
-[
-  'createTable',
-  'createTableIfNotExists',
-  'createSchema',
-  'createSchemaIfNotExists',
-  'dropSchema',
-  'dropSchemaIfExists',
-  'createExtension',
-  'createExtensionIfNotExists',
-  'dropExtension',
-  'dropExtensionIfExists',
-  'table',
-  'alterTable',
-  'hasTable',
-  'hasColumn',
-  'dropTable',
-  'renameTable',
-  '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';
-    this._sequence.push({
-      method,
-      args: toArray(arguments),
-    });
-    return this;
-  };
-});
-
-require('../interface')(SchemaBuilder);
-addQueryContext(SchemaBuilder);
-
-SchemaBuilder.prototype.withSchema = function (schemaName) {
-  this._schema = schemaName;
-  return this;
-};
-
-SchemaBuilder.prototype.toString = function () {
-  return this.toQuery();
-};
-
-SchemaBuilder.prototype.toSQL = function () {
-  return this.client.schemaCompiler(this).toSQL();
-};
-
-module.exports = SchemaBuilder;
+const { inherits } = require('util');
+const { EventEmitter } = require('events');
+const toArray = require('lodash/toArray');
+const { addQueryContext } = require('../helpers');
+const saveAsyncStack = require('../util/save-async-stack');
+
+// 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.
+function SchemaBuilder(client) {
+  this.client = client;
+  this._sequence = [];
+
+  if (client.config) {
+    this._debug = client.config.debug;
+    saveAsyncStack(this, 4);
+  }
+}
+
+inherits(SchemaBuilder, EventEmitter);
+
+// Each of the schema builder methods just add to the
+// "_sequence" array for consistency.
+[
+  'createTable',
+  'createTableIfNotExists',
+  'createSchema',
+  'createSchemaIfNotExists',
+  'dropSchema',
+  'dropSchemaIfExists',
+  'createExtension',
+  'createExtensionIfNotExists',
+  'dropExtension',
+  'dropExtensionIfExists',
+  'table',
+  'alterTable',
+  'hasTable',
+  'hasColumn',
+  'dropTable',
+  'renameTable',
+  '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';
+    this._sequence.push({
+      method,
+      args: toArray(arguments),
+    });
+    return this;
+  };
+});
+
+require('../interface')(SchemaBuilder);
+addQueryContext(SchemaBuilder);
+
+SchemaBuilder.prototype.withSchema = function (schemaName) {
+  this._schema = schemaName;
+  return this;
+};
+
+SchemaBuilder.prototype.toString = function () {
+  return this.toQuery();
+};
+
+SchemaBuilder.prototype.toSQL = function () {
+  return this.client.schemaCompiler(this).toSQL();
+};
+
+module.exports = SchemaBuilder;

package/lib/schema/columnbuilder.js

@@ -1,117 +1,117 @@
-const extend = require('lodash/extend');
-const toArray = require('lodash/toArray');
-const { addQueryContext } = require('../helpers');
-
-// The chainable interface off the original "column" method.
-function ColumnBuilder(client, tableBuilder, type, args) {
-  this.client = client;
-  this._method = 'add';
-  this._single = {};
-  this._modifiers = {};
-  this._statements = [];
-  this._type = columnAlias[type] || type;
-  this._args = args;
-  this._tableBuilder = tableBuilder;
-
-  // If we're altering the table, extend the object
-  // with the available "alter" methods.
-  if (tableBuilder._method === 'alter') {
-    extend(this, AlterMethods);
-  }
-}
-
-// All of the modifier methods that can be used to modify the current query.
-const modifiers = [
-  'default',
-  'defaultsTo',
-  'defaultTo',
-  'unsigned',
-  'nullable',
-  'first',
-  'after',
-  'comment',
-  'collate',
-];
-
-// Aliases for convenience.
-const aliasMethod = {
-  default: 'defaultTo',
-  defaultsTo: 'defaultTo',
-};
-
-// If we call any of the modifiers (index or otherwise) on the chainable, we pretend
-// as though we're calling `table.method(column)` directly.
-modifiers.forEach(function (method) {
-  const key = aliasMethod[method] || method;
-  ColumnBuilder.prototype[method] = function () {
-    this._modifiers[key] = toArray(arguments);
-    return this;
-  };
-});
-
-addQueryContext(ColumnBuilder);
-
-ColumnBuilder.prototype.notNull = ColumnBuilder.prototype.notNullable = function notNullable() {
-  return this.nullable(false);
-};
-
-['index', 'primary', 'unique'].forEach(function (method) {
-  ColumnBuilder.prototype[method] = function () {
-    if (this._type.toLowerCase().indexOf('increments') === -1) {
-      this._tableBuilder[method].apply(
-        this._tableBuilder,
-        [this._args[0]].concat(toArray(arguments))
-      );
-    }
-    return this;
-  };
-});
-
-// Specify that the current column "references" a column,
-// which may be tableName.column or just "column"
-ColumnBuilder.prototype.references = function (value) {
-  return this._tableBuilder.foreign
-    .call(this._tableBuilder, this._args[0], undefined, this)
-    ._columnBuilder(this)
-    .references(value);
-};
-
-const AlterMethods = {};
-
-// Specify that the column is to be dropped. This takes precedence
-// over all other rules for the column.
-AlterMethods.drop = function () {
-  this._single.drop = true;
-
-  return this;
-};
-
-// Specify the "type" that we're looking to set the
-// Knex takes no responsibility for any data-loss that may
-// occur when changing data types.
-AlterMethods.alterType = function (type) {
-  this._statements.push({
-    grouping: 'alterType',
-    value: type,
-  });
-
-  return this;
-};
-
-// Set column method to alter (default is add).
-AlterMethods.alter = function () {
-  this._method = 'alter';
-
-  return this;
-};
-
-// Alias a few methods for clarity when processing.
-const columnAlias = {
-  float: 'floating',
-  enum: 'enu',
-  boolean: 'bool',
-  string: 'varchar',
-  bigint: 'bigInteger',
-};
-
-module.exports = ColumnBuilder;
+const extend = require('lodash/extend');
+const toArray = require('lodash/toArray');
+const { addQueryContext } = require('../helpers');
+
+// The chainable interface off the original "column" method.
+function ColumnBuilder(client, tableBuilder, type, args) {
+  this.client = client;
+  this._method = 'add';
+  this._single = {};
+  this._modifiers = {};
+  this._statements = [];
+  this._type = columnAlias[type] || type;
+  this._args = args;
+  this._tableBuilder = tableBuilder;
+
+  // If we're altering the table, extend the object
+  // with the available "alter" methods.
+  if (tableBuilder._method === 'alter') {
+    extend(this, AlterMethods);
+  }
+}
+
+// All of the modifier methods that can be used to modify the current query.
+const modifiers = [
+  'default',
+  'defaultsTo',
+  'defaultTo',
+  'unsigned',
+  'nullable',
+  'first',
+  'after',
+  'comment',
+  'collate',
+];
+
+// Aliases for convenience.
+const aliasMethod = {
+  default: 'defaultTo',
+  defaultsTo: 'defaultTo',
+};
+
+// If we call any of the modifiers (index or otherwise) on the chainable, we pretend
+// as though we're calling `table.method(column)` directly.
+modifiers.forEach(function (method) {
+  const key = aliasMethod[method] || method;
+  ColumnBuilder.prototype[method] = function () {
+    this._modifiers[key] = toArray(arguments);
+    return this;
+  };
+});
+
+addQueryContext(ColumnBuilder);
+
+ColumnBuilder.prototype.notNull = ColumnBuilder.prototype.notNullable = function notNullable() {
+  return this.nullable(false);
+};
+
+['index', 'primary', 'unique'].forEach(function (method) {
+  ColumnBuilder.prototype[method] = function () {
+    if (this._type.toLowerCase().indexOf('increments') === -1) {
+      this._tableBuilder[method].apply(
+        this._tableBuilder,
+        [this._args[0]].concat(toArray(arguments))
+      );
+    }
+    return this;
+  };
+});
+
+// Specify that the current column "references" a column,
+// which may be tableName.column or just "column"
+ColumnBuilder.prototype.references = function (value) {
+  return this._tableBuilder.foreign
+    .call(this._tableBuilder, this._args[0], undefined, this)
+    ._columnBuilder(this)
+    .references(value);
+};
+
+const AlterMethods = {};
+
+// Specify that the column is to be dropped. This takes precedence
+// over all other rules for the column.
+AlterMethods.drop = function () {
+  this._single.drop = true;
+
+  return this;
+};
+
+// Specify the "type" that we're looking to set the
+// Knex takes no responsibility for any data-loss that may
+// occur when changing data types.
+AlterMethods.alterType = function (type) {
+  this._statements.push({
+    grouping: 'alterType',
+    value: type,
+  });
+
+  return this;
+};
+
+// Set column method to alter (default is add).
+AlterMethods.alter = function () {
+  this._method = 'alter';
+
+  return this;
+};
+
+// Alias a few methods for clarity when processing.
+const columnAlias = {
+  float: 'floating',
+  enum: 'enu',
+  boolean: 'bool',
+  string: 'varchar',
+  bigint: 'bigInteger',
+};
+
+module.exports = ColumnBuilder;