knex 0.21.20 → 0.21.21

package/lib/dialects/redshift/schema/tablecompiler.js

@@ -1,123 +1,123 @@
-/* eslint max-len: 0 */
-
-// Redshift Table Builder & Compiler
-// -------
-
-const { inherits } = require('util');
-const has = require('lodash/has');
-const TableCompiler_PG = require('../../postgres/schema/tablecompiler');
-
-function TableCompiler_Redshift() {
-  TableCompiler_PG.apply(this, arguments);
-}
-inherits(TableCompiler_Redshift, TableCompiler_PG);
-
-TableCompiler_Redshift.prototype.index = function (
-  columns,
-  indexName,
-  indexType
-) {
-  this.client.logger.warn('Redshift does not support the creation of indexes.');
-};
-
-TableCompiler_Redshift.prototype.dropIndex = function (columns, indexName) {
-  this.client.logger.warn('Redshift does not support the deletion of indexes.');
-};
-
-// TODO: have to disable setting not null on columns that already exist...
-
-// Adds the "create" query to the query sequence.
-TableCompiler_Redshift.prototype.createQuery = function (columns, ifNot) {
-  const createStatement = ifNot
-    ? 'create table if not exists '
-    : 'create table ';
-  let sql =
-    createStatement + this.tableName() + ' (' + columns.sql.join(', ') + ')';
-  if (this.single.inherits)
-    sql += ` like (${this.formatter.wrap(this.single.inherits)})`;
-  this.pushQuery({
-    sql,
-    bindings: columns.bindings,
-  });
-  const hasComment = has(this.single, 'comment');
-  if (hasComment) this.comment(this.single.comment);
-};
-
-TableCompiler_Redshift.prototype.primary = function (columns, constraintName) {
-  const self = this;
-  constraintName = constraintName
-    ? self.formatter.wrap(constraintName)
-    : self.formatter.wrap(`${this.tableNameRaw}_pkey`);
-  if (columns.constructor !== Array) {
-    columns = [columns];
-  }
-  const thiscolumns = self.grouped.columns;
-
-  if (thiscolumns) {
-    for (let i = 0; i < columns.length; i++) {
-      let exists = thiscolumns.find(
-        (tcb) =>
-          tcb.grouping === 'columns' &&
-          tcb.builder &&
-          tcb.builder._method === 'add' &&
-          tcb.builder._args &&
-          tcb.builder._args.indexOf(columns[i]) > -1
-      );
-      if (exists) {
-        exists = exists.builder;
-      }
-      const nullable = !(
-        exists &&
-        exists._modifiers &&
-        exists._modifiers['nullable'] &&
-        exists._modifiers['nullable'][0] === false
-      );
-      if (nullable) {
-        if (exists) {
-          return this.client.logger.warn(
-            'Redshift does not allow primary keys to contain nullable columns.'
-          );
-        } else {
-          return this.client.logger.warn(
-            'Redshift does not allow primary keys to contain nonexistent columns.'
-          );
-        }
-      }
-    }
-  }
-  return self.pushQuery(
-    `alter table ${self.tableName()} add constraint ${constraintName} primary key (${self.formatter.columnize(
-      columns
-    )})`
-  );
-};
-
-// Compiles column add. Redshift can only add one column per ALTER TABLE, so core addColumns doesn't work.  #2545
-TableCompiler_Redshift.prototype.addColumns = function (
-  columns,
-  prefix,
-  colCompilers
-) {
-  if (prefix === this.alterColumnsPrefix) {
-    TableCompiler_PG.prototype.addColumns.call(
-      this,
-      columns,
-      prefix,
-      colCompilers
-    );
-  } else {
-    prefix = prefix || this.addColumnsPrefix;
-    colCompilers = colCompilers || this.getColumns();
-    for (const col of colCompilers) {
-      const quotedTableName = this.tableName();
-      const colCompiled = col.compileColumn();
-
-      this.pushQuery({
-        sql: `alter table ${quotedTableName} ${prefix}${colCompiled}`,
-        bindings: [],
-      });
-    }
-  }
-};
-
-module.exports = TableCompiler_Redshift;
+/* eslint max-len: 0 */
+
+// Redshift Table Builder & Compiler
+// -------
+
+const { inherits } = require('util');
+const has = require('lodash/has');
+const TableCompiler_PG = require('../../postgres/schema/tablecompiler');
+
+function TableCompiler_Redshift() {
+  TableCompiler_PG.apply(this, arguments);
+}
+inherits(TableCompiler_Redshift, TableCompiler_PG);
+
+TableCompiler_Redshift.prototype.index = function (
+  columns,
+  indexName,
+  indexType
+) {
+  this.client.logger.warn('Redshift does not support the creation of indexes.');
+};
+
+TableCompiler_Redshift.prototype.dropIndex = function (columns, indexName) {
+  this.client.logger.warn('Redshift does not support the deletion of indexes.');
+};
+
+// TODO: have to disable setting not null on columns that already exist...
+
+// Adds the "create" query to the query sequence.
+TableCompiler_Redshift.prototype.createQuery = function (columns, ifNot) {
+  const createStatement = ifNot
+    ? 'create table if not exists '
+    : 'create table ';
+  let sql =
+    createStatement + this.tableName() + ' (' + columns.sql.join(', ') + ')';
+  if (this.single.inherits)
+    sql += ` like (${this.formatter.wrap(this.single.inherits)})`;
+  this.pushQuery({
+    sql,
+    bindings: columns.bindings,
+  });
+  const hasComment = has(this.single, 'comment');
+  if (hasComment) this.comment(this.single.comment);
+};
+
+TableCompiler_Redshift.prototype.primary = function (columns, constraintName) {
+  const self = this;
+  constraintName = constraintName
+    ? self.formatter.wrap(constraintName)
+    : self.formatter.wrap(`${this.tableNameRaw}_pkey`);
+  if (columns.constructor !== Array) {
+    columns = [columns];
+  }
+  const thiscolumns = self.grouped.columns;
+
+  if (thiscolumns) {
+    for (let i = 0; i < columns.length; i++) {
+      let exists = thiscolumns.find(
+        (tcb) =>
+          tcb.grouping === 'columns' &&
+          tcb.builder &&
+          tcb.builder._method === 'add' &&
+          tcb.builder._args &&
+          tcb.builder._args.indexOf(columns[i]) > -1
+      );
+      if (exists) {
+        exists = exists.builder;
+      }
+      const nullable = !(
+        exists &&
+        exists._modifiers &&
+        exists._modifiers['nullable'] &&
+        exists._modifiers['nullable'][0] === false
+      );
+      if (nullable) {
+        if (exists) {
+          return this.client.logger.warn(
+            'Redshift does not allow primary keys to contain nullable columns.'
+          );
+        } else {
+          return this.client.logger.warn(
+            'Redshift does not allow primary keys to contain nonexistent columns.'
+          );
+        }
+      }
+    }
+  }
+  return self.pushQuery(
+    `alter table ${self.tableName()} add constraint ${constraintName} primary key (${self.formatter.columnize(
+      columns
+    )})`
+  );
+};
+
+// Compiles column add. Redshift can only add one column per ALTER TABLE, so core addColumns doesn't work.  #2545
+TableCompiler_Redshift.prototype.addColumns = function (
+  columns,
+  prefix,
+  colCompilers
+) {
+  if (prefix === this.alterColumnsPrefix) {
+    TableCompiler_PG.prototype.addColumns.call(
+      this,
+      columns,
+      prefix,
+      colCompilers
+    );
+  } else {
+    prefix = prefix || this.addColumnsPrefix;
+    colCompilers = colCompilers || this.getColumns();
+    for (const col of colCompilers) {
+      const quotedTableName = this.tableName();
+      const colCompiled = col.compileColumn();
+
+      this.pushQuery({
+        sql: `alter table ${quotedTableName} ${prefix}${colCompiled}`,
+        bindings: [],
+      });
+    }
+  }
+};
+
+module.exports = TableCompiler_Redshift;

package/lib/dialects/redshift/transaction.js

@@ -1,18 +1,18 @@
-const Transaction = require('../../transaction');
-
-module.exports = class Redshift_Transaction extends Transaction {
-  savepoint(conn) {
-    this.trxClient.logger('Redshift does not support savepoints.');
-    return Promise.resolve();
-  }
-
-  release(conn, value) {
-    this.trxClient.logger('Redshift does not support savepoints.');
-    return Promise.resolve();
-  }
-
-  rollbackTo(conn, error) {
-    this.trxClient.logger('Redshift does not support savepoints.');
-    return Promise.resolve();
-  }
-};
+const Transaction = require('../../transaction');
+
+module.exports = class Redshift_Transaction extends Transaction {
+  savepoint(conn) {
+    this.trxClient.logger('Redshift does not support savepoints.');
+    return Promise.resolve();
+  }
+
+  release(conn, value) {
+    this.trxClient.logger('Redshift does not support savepoints.');
+    return Promise.resolve();
+  }
+
+  rollbackTo(conn, error) {
+    this.trxClient.logger('Redshift does not support savepoints.');
+    return Promise.resolve();
+  }
+};

package/lib/dialects/sqlite3/formatter.js

@@ -1,21 +1,21 @@
-const Formatter = require('../../formatter');
-const Raw = require('../../raw');
-
-module.exports = class SQlite3_Formatter extends Formatter {
-  values(values) {
-    if (Array.isArray(values)) {
-      if (Array.isArray(values[0])) {
-        return `( values ${values
-          .map((value) => `(${this.parameterize(value)})`)
-          .join(', ')})`;
-      }
-      return `(${this.parameterize(values)})`;
-    }
-
-    if (values instanceof Raw) {
-      return `(${this.parameter(values)})`;
-    }
-
-    return this.parameter(values);
-  }
-};
+const Formatter = require('../../formatter');
+const Raw = require('../../raw');
+
+module.exports = class SQlite3_Formatter extends Formatter {
+  values(values) {
+    if (Array.isArray(values)) {
+      if (Array.isArray(values[0])) {
+        return `( values ${values
+          .map((value) => `(${this.parameterize(value)})`)
+          .join(', ')})`;
+      }
+      return `(${this.parameterize(values)})`;
+    }
+
+    if (values instanceof Raw) {
+      return `(${this.parameter(values)})`;
+    }
+
+    return this.parameter(values);
+  }
+};

package/lib/dialects/sqlite3/index.js

@@ -1,169 +1,169 @@
-// SQLite3
-// -------
-const defaults = require('lodash/defaults');
-const map = require('lodash/map');
-const { promisify, inherits } = require('util');
-
-const Client = require('../../client');
-
-const QueryCompiler = require('./query/compiler');
-const SchemaCompiler = require('./schema/compiler');
-const ColumnCompiler = require('./schema/columncompiler');
-const TableCompiler = require('./schema/tablecompiler');
-const SQLite3_DDL = require('./schema/ddl');
-const SQLite3_Formatter = require('./formatter');
-
-function Client_SQLite3(config) {
-  Client.call(this, config);
-  if (config.useNullAsDefault === undefined) {
-    this.logger.warn(
-      'sqlite does not support inserting default values. Set the ' +
-        '`useNullAsDefault` flag to hide this warning. ' +
-        '(see docs http://knexjs.org/#Builder-insert).'
-    );
-  }
-}
-
-inherits(Client_SQLite3, Client);
-
-Object.assign(Client_SQLite3.prototype, {
-  dialect: 'sqlite3',
-
-  driverName: 'sqlite3',
-
-  _driver() {
-    return require('sqlite3');
-  },
-
-  schemaCompiler() {
-    return new SchemaCompiler(this, ...arguments);
-  },
-
-  queryCompiler() {
-    return new QueryCompiler(this, ...arguments);
-  },
-
-  columnCompiler() {
-    return new ColumnCompiler(this, ...arguments);
-  },
-
-  tableCompiler() {
-    return new TableCompiler(this, ...arguments);
-  },
-
-  ddl(compiler, pragma, connection) {
-    return new SQLite3_DDL(this, compiler, pragma, connection);
-  },
-
-  wrapIdentifierImpl(value) {
-    return value !== '*' ? `\`${value.replace(/`/g, '``')}\`` : '*';
-  },
-
-  // Get a raw connection from the database, returning a promise with the connection object.
-  acquireRawConnection() {
-    return new Promise((resolve, reject) => {
-      const db = new this.driver.Database(
-        this.connectionSettings.filename,
-        (err) => {
-          if (err) {
-            return reject(err);
-          }
-          resolve(db);
-        }
-      );
-    });
-  },
-
-  // Used to explicitly close a connection, called internally by the pool when
-  // a connection times out or the pool is shutdown.
-  async destroyRawConnection(connection) {
-    const close = promisify((cb) => connection.close(cb));
-    return close();
-  },
-
-  // Runs the query on the specified connection, providing the bindings and any
-  // other necessary prep work.
-  _query(connection, obj) {
-    const { method } = obj;
-    let callMethod;
-    switch (method) {
-      case 'insert':
-      case 'update':
-      case 'counter':
-      case 'del':
-        callMethod = 'run';
-        break;
-      default:
-        callMethod = 'all';
-    }
-    return new Promise(function (resolver, rejecter) {
-      if (!connection || !connection[callMethod]) {
-        return rejecter(
-          new Error(`Error calling ${callMethod} on connection.`)
-        );
-      }
-      connection[callMethod](obj.sql, obj.bindings, function (err, response) {
-        if (err) return rejecter(err);
-        obj.response = response;
-
-        // We need the context here, as it contains
-        // the "this.lastID" or "this.changes"
-        obj.context = this;
-        return resolver(obj);
-      });
-    });
-  },
-
-  _stream(connection, sql, stream) {
-    const client = this;
-    return new Promise(function (resolver, rejecter) {
-      stream.on('error', rejecter);
-      stream.on('end', resolver);
-      return client
-        ._query(connection, sql)
-        .then((obj) => obj.response)
-        .then((rows) => rows.forEach((row) => stream.write(row)))
-        .catch(function (err) {
-          stream.emit('error', err);
-        })
-        .then(function () {
-          stream.end();
-        });
-    });
-  },
-
-  // Ensures the response is returned in the same format as other clients.
-  processResponse(obj, runner) {
-    const ctx = obj.context;
-    let { response } = obj;
-    if (obj.output) return obj.output.call(runner, response);
-    switch (obj.method) {
-      case 'select':
-      case 'pluck':
-      case 'first':
-        if (obj.method === 'pluck') response = map(response, obj.pluck);
-        return obj.method === 'first' ? response[0] : response;
-      case 'insert':
-        return [ctx.lastID];
-      case 'del':
-      case 'update':
-      case 'counter':
-        return ctx.changes;
-      default:
-        return response;
-    }
-  },
-
-  poolDefaults() {
-    return defaults(
-      { min: 1, max: 1 },
-      Client.prototype.poolDefaults.call(this)
-    );
-  },
-
-  formatter() {
-    return new SQLite3_Formatter(this, ...arguments);
-  },
-});
-
-module.exports = Client_SQLite3;
+// SQLite3
+// -------
+const defaults = require('lodash/defaults');
+const map = require('lodash/map');
+const { promisify, inherits } = require('util');
+
+const Client = require('../../client');
+
+const QueryCompiler = require('./query/compiler');
+const SchemaCompiler = require('./schema/compiler');
+const ColumnCompiler = require('./schema/columncompiler');
+const TableCompiler = require('./schema/tablecompiler');
+const SQLite3_DDL = require('./schema/ddl');
+const SQLite3_Formatter = require('./formatter');
+
+function Client_SQLite3(config) {
+  Client.call(this, config);
+  if (config.useNullAsDefault === undefined) {
+    this.logger.warn(
+      'sqlite does not support inserting default values. Set the ' +
+        '`useNullAsDefault` flag to hide this warning. ' +
+        '(see docs http://knexjs.org/#Builder-insert).'
+    );
+  }
+}
+
+inherits(Client_SQLite3, Client);
+
+Object.assign(Client_SQLite3.prototype, {
+  dialect: 'sqlite3',
+
+  driverName: 'sqlite3',
+
+  _driver() {
+    return require('sqlite3');
+  },
+
+  schemaCompiler() {
+    return new SchemaCompiler(this, ...arguments);
+  },
+
+  queryCompiler() {
+    return new QueryCompiler(this, ...arguments);
+  },
+
+  columnCompiler() {
+    return new ColumnCompiler(this, ...arguments);
+  },
+
+  tableCompiler() {
+    return new TableCompiler(this, ...arguments);
+  },
+
+  ddl(compiler, pragma, connection) {
+    return new SQLite3_DDL(this, compiler, pragma, connection);
+  },
+
+  wrapIdentifierImpl(value) {
+    return value !== '*' ? `\`${value.replace(/`/g, '``')}\`` : '*';
+  },
+
+  // Get a raw connection from the database, returning a promise with the connection object.
+  acquireRawConnection() {
+    return new Promise((resolve, reject) => {
+      const db = new this.driver.Database(
+        this.connectionSettings.filename,
+        (err) => {
+          if (err) {
+            return reject(err);
+          }
+          resolve(db);
+        }
+      );
+    });
+  },
+
+  // Used to explicitly close a connection, called internally by the pool when
+  // a connection times out or the pool is shutdown.
+  async destroyRawConnection(connection) {
+    const close = promisify((cb) => connection.close(cb));
+    return close();
+  },
+
+  // Runs the query on the specified connection, providing the bindings and any
+  // other necessary prep work.
+  _query(connection, obj) {
+    const { method } = obj;
+    let callMethod;
+    switch (method) {
+      case 'insert':
+      case 'update':
+      case 'counter':
+      case 'del':
+        callMethod = 'run';
+        break;
+      default:
+        callMethod = 'all';
+    }
+    return new Promise(function (resolver, rejecter) {
+      if (!connection || !connection[callMethod]) {
+        return rejecter(
+          new Error(`Error calling ${callMethod} on connection.`)
+        );
+      }
+      connection[callMethod](obj.sql, obj.bindings, function (err, response) {
+        if (err) return rejecter(err);
+        obj.response = response;
+
+        // We need the context here, as it contains
+        // the "this.lastID" or "this.changes"
+        obj.context = this;
+        return resolver(obj);
+      });
+    });
+  },
+
+  _stream(connection, sql, stream) {
+    const client = this;
+    return new Promise(function (resolver, rejecter) {
+      stream.on('error', rejecter);
+      stream.on('end', resolver);
+      return client
+        ._query(connection, sql)
+        .then((obj) => obj.response)
+        .then((rows) => rows.forEach((row) => stream.write(row)))
+        .catch(function (err) {
+          stream.emit('error', err);
+        })
+        .then(function () {
+          stream.end();
+        });
+    });
+  },
+
+  // Ensures the response is returned in the same format as other clients.
+  processResponse(obj, runner) {
+    const ctx = obj.context;
+    let { response } = obj;
+    if (obj.output) return obj.output.call(runner, response);
+    switch (obj.method) {
+      case 'select':
+      case 'pluck':
+      case 'first':
+        if (obj.method === 'pluck') response = map(response, obj.pluck);
+        return obj.method === 'first' ? response[0] : response;
+      case 'insert':
+        return [ctx.lastID];
+      case 'del':
+      case 'update':
+      case 'counter':
+        return ctx.changes;
+      default:
+        return response;
+    }
+  },
+
+  poolDefaults() {
+    return defaults(
+      { min: 1, max: 1 },
+      Client.prototype.poolDefaults.call(this)
+    );
+  },
+
+  formatter() {
+    return new SQLite3_Formatter(this, ...arguments);
+  },
+});
+
+module.exports = Client_SQLite3;