knex 0.21.13 → 0.21.17

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Master (Unreleased)
 
+# 0.21.17 - 30 January, 2021
+
+### Bug fixes:
+
+- SQLite: Fix SQLite foreign on delete when altering a table #4261
+
+### New features:
+
+- Add support for optimizer hints (see https://github.com/knex/documentation/pull/306 for documentation) #4243
+
+# 0.21.16 - 17 January, 2021
+
+### Bug fixes:
+
+- MSSQL: Avoid passing unsupported pool param. Fixes node-mssql 7+ support #4236
+
+# 0.21.15 - 26 December, 2020
+
+### New features:
+
+- SQLite: Add primary/foreign support on alterTable #4162
+- SQLite: Add dropPrimary/dropForeign support on alterTable #4162
+
+### Typings:
+
+- Add "after" and "first" to columnBuilder types #3549 #4169
+
+### Test / internal changes:
+
+- Extract knex config resolution logic #4166
+- Run CI using GitHub Actions #4168
+- Add Node.js 15 to CI matrix #4173
+
+# 0.21.14 - 18 December, 2020
+
+### New features:
+
+- MSSQL: support "returning" on inserts, updates and deletes on tables with triggers #4152
+- Use esm import if package.json type is "module" #4158
+
+### Bug fixes:
+
+- Make sure query-response and query-error events contain _knexTxId #4160
+
+### Test / internal changes:
+
+- Improved integration test framework #4161
+
 # 0.21.13 - 12 December, 2020
 
 ### New features:

package/README.md

@@ -2,8 +2,8 @@
 
 [![npm version](http://img.shields.io/npm/v/knex.svg)](https://npmjs.org/package/knex)
 [![npm downloads](https://img.shields.io/npm/dm/knex.svg)](https://npmjs.org/package/knex)
-[![Build Status](https://travis-ci.org/knex/knex.svg?branch=master)](https://travis-ci.org/knex/knex)
-[![Coverage Status](https://coveralls.io/repos/tgriesser/knex/badge.svg?branch=master)](https://coveralls.io/r/tgriesser/knex?branch=master)
+![](https://github.com/knex/knex/workflows/CI/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/knex/knex/badge.svg?branch=master)](https://coveralls.io/r/knex/knex?branch=master)
 [![Dependencies Status](https://david-dm.org/knex/knex.svg)](https://david-dm.org/knex/knex)
 [![Gitter chat](https://badges.gitter.im/tgriesser/knex.svg)](https://gitter.im/tgriesser/knex)
 [![Language Grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/knex/knex.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/knex/knex/context:javascript)

package/bin/cli.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-/* eslint no-console:0, no-var:0 */
 const Liftoff = require('liftoff');
 const interpret = require('interpret');
 const path = require('path');

package/lib/config-resolver.js

@@ -0,0 +1,61 @@
+const Client = require('./client');
+const { SUPPORTED_CLIENTS } = require('./constants');
+
+const parseConnection = require('./util/parse-connection');
+const { resolveClientNameWithAliases } = require('./helpers');
+
+function resolveConfig(config) {
+  let Dialect;
+  let resolvedConfig;
+
+  // If config is a string, try to parse it
+  const parsedConfig =
+    typeof config === 'string'
+      ? Object.assign(parseConnection(config), arguments[2])
+      : config;
+
+  // If user provided no relevant parameters, use generic client
+  if (
+    arguments.length === 0 ||
+    (!parsedConfig.client && !parsedConfig.dialect)
+  ) {
+    Dialect = Client;
+  }
+  // If user provided Client constructor as a parameter, use it
+  else if (
+    typeof parsedConfig.client === 'function' &&
+    parsedConfig.client.prototype instanceof Client
+  ) {
+    Dialect = parsedConfig.client;
+  }
+  // If neither applies, let's assume user specified name of a client or dialect as a string
+  else {
+    const clientName = parsedConfig.client || parsedConfig.dialect;
+    if (!SUPPORTED_CLIENTS.includes(clientName)) {
+      throw new Error(
+        `knex: Unknown configuration option 'client' value ${clientName}. Note that it is case-sensitive, check documentation for supported values.`
+      );
+    }
+
+    const resolvedClientName = resolveClientNameWithAliases(clientName);
+    Dialect = require(`./dialects/${resolvedClientName}/index.js`);
+  }
+
+  // If config connection parameter is passed as string, try to parse it
+  if (typeof parsedConfig.connection === 'string') {
+    resolvedConfig = Object.assign({}, parsedConfig, {
+      connection: parseConnection(parsedConfig.connection).connection,
+    });
+  } else {
+    resolvedConfig = Object.assign({}, parsedConfig);
+  }
+
+  return {
+    resolvedConfig,
+    Dialect,
+  };
+}
+
+module.exports = {
+  resolveConfig,
+};

package/lib/constants.js

@@ -29,8 +29,16 @@ const POOL_CONFIG_OPTIONS = Object.freeze([
   'Promise',
 ]);
 
+/**
+ * Regex that only matches comma's in strings that aren't wrapped in parentheses. Can be used to
+ * safely split strings like `id int, name string, body text, primary key (id, name)` into definition
+ * rows
+ */
+const COMMA_NO_PAREN_REGEX = /,[\s](?![^(]*\))/g;
+
 module.exports = {
   CLIENT_ALIASES,
   SUPPORTED_CLIENTS,
   POOL_CONFIG_OPTIONS,
+  COMMA_NO_PAREN_REGEX,
 };

package/lib/dialects/mssql/index.js

@@ -31,7 +31,6 @@ function Client_MSSQL(config = {}) {
     min: 1,
     max: 1,
     idleTimeoutMillis: Number.MAX_SAFE_INTEGER,
-    evictionRunIntervalMillis: 0,
   };
 
   Client.call(this, config);

package/lib/dialects/mssql/query/compiler.js

@@ -37,9 +37,70 @@ class QueryCompiler_MSSQL extends QueryCompiler {
     return sql + compact(statements).join(' ');
   }
 
+  //#region Insert
   // Compiles an "insert" query, allowing for multiple
   // inserts using a single query statement.
   insert() {
+    if (this.single.options && this.single.options.includeTriggerModifications) {
+      return this.insertWithTriggers();
+    } else {
+      return this.standardInsert();
+    }
+  }
+
+  insertWithTriggers() {
+    const insertValues = this.single.insert || [];
+    const { returning } = this.single;
+    let sql = this.with() + `${this._buildTempTable(returning)}insert into ${this.tableName} `;
+    const returningSql = returning
+      ? this._returning('insert', returning, true) + ' '
+      : '';
+
+    if (Array.isArray(insertValues)) {
+      if (insertValues.length === 0) {
+        return '';
+      }
+    } else if (typeof insertValues === 'object' && isEmpty(insertValues)) {
+      return {
+        sql: sql + returningSql + this._emptyInsertValue + this._buildReturningSelect(returning),
+        returning,
+      };
+    }
+
+    const insertData = this._prepInsert(insertValues);
+    if (typeof insertData === 'string') {
+      sql += insertData;
+    } else {
+      if (insertData.columns.length) {
+        sql += `(${this.formatter.columnize(insertData.columns)}`;
+        sql += `) ${returningSql}values (`;
+        let i = -1;
+        while (++i < insertData.values.length) {
+          if (i !== 0) sql += '), (';
+          sql += this.formatter.parameterize(
+            insertData.values[i],
+            this.client.valueForUndefined
+          );
+        }
+        sql += ')';
+      } else if (insertValues.length === 1 && insertValues[0]) {
+        sql += returningSql + this._emptyInsertValue;
+      } else {
+        sql = '';
+      }
+    }
+
+    if (returning) {
+      sql += this._buildReturningSelect(returning);
+    }
+
+    return {
+      sql,
+      returning,
+    };
+  }
+
+  standardInsert() {
     const insertValues = this.single.insert || [];
     let sql = this.with() + `insert into ${this.tableName} `;
     const { returning } = this.single;
@@ -80,14 +141,52 @@ class QueryCompiler_MSSQL extends QueryCompiler {
         sql = '';
       }
     }
+
     return {
       sql,
       returning,
     };
   }
+  //#endregion
 
+  //#region Update
   // Compiles an `update` query, allowing for a return value.
   update() {
+    if (this.single.options && this.single.options.includeTriggerModifications) {
+      return this.updateWithTriggers();
+    } else {
+      return this.standardUpdate();
+    }
+  }
+
+  updateWithTriggers() {
+    const top = this.top();
+    const withSQL = this.with();
+    const updates = this._prepUpdate(this.single.update);
+    const join = this.join();
+    const where = this.where();
+    const order = this.order();
+    const { returning } = this.single;
+    const declaredTemp = this._buildTempTable(returning);
+    return {
+      sql:
+        withSQL +
+        declaredTemp +
+        `update ${top ? top + ' ' : ''}${this.tableName}` +
+        ' set ' +
+        updates.join(', ') +
+        (returning ? ` ${this._returning('update', returning, true)}` : '') +
+        (join ? ` from ${this.tableName} ${join}` : '') +
+        (where ? ` ${where}` : '') +
+        (order ? ` ${order}` : '') +
+        (!returning
+          ? this._returning('rowcount', '@@rowcount')
+          : this._buildReturningSelect(returning)),
+      returning: returning || '@@rowcount',
+    };
+  }
+
+  standardUpdate() {
     const top = this.top();
     const withSQL = this.with();
     const updates = this._prepUpdate(this.single.update);
@@ -105,13 +204,42 @@ class QueryCompiler_MSSQL extends QueryCompiler {
         (join ? ` from ${this.tableName} ${join}` : '') +
         (where ? ` ${where}` : '') +
         (order ? ` ${order}` : '') +
-        (!returning ? this._returning('rowcount', '@@rowcount') : ''),
+        (!returning
+          ? this._returning('rowcount', '@@rowcount')
+          : ""),
       returning: returning || '@@rowcount',
     };
   }
+  //#endregion
 
+  //#region Delete
   // Compiles a `delete` query.
   del() {
+    if (this.single.options && this.single.options.includeTriggerModifications) {
+      return this.deleteWithTriggers();
+    } else {
+      return this.standardDelete();
+    }
+  }
+
+  deleteWithTriggers() {
+    // Make sure tableName is processed by the formatter first.
+    const withSQL = this.with();
+    const { tableName } = this;
+    const wheres = this.where();
+    const { returning } = this.single;
+    return {
+      sql:
+        withSQL +
+        `${this._buildTempTable(returning)}delete from ${tableName}` +
+        (returning ? ` ${this._returning('del', returning, true)}` : '') +
+        (wheres ? ` ${wheres}` : '') +
+        (!returning ? this._returning('rowcount', '@@rowcount') : this._buildReturningSelect(returning)),
+      returning: returning || '@@rowcount',
+    };
+  }
+
+  standardDelete() {
     // Make sure tableName is processed by the formatter first.
     const withSQL = this.with();
     const { tableName } = this;
@@ -123,16 +251,18 @@ class QueryCompiler_MSSQL extends QueryCompiler {
         `delete from ${tableName}` +
         (returning ? ` ${this._returning('del', returning)}` : '') +
         (wheres ? ` ${wheres}` : '') +
-        (!returning ? this._returning('rowcount', '@@rowcount') : ''),
+        (!returning ? this._returning('rowcount', '@@rowcount') : ""),
       returning: returning || '@@rowcount',
     };
   }
+  //#endregion
 
   // Compiles the columns in the query, specifying if an item was distinct.
   columns() {
     let distinctClause = '';
     if (this.onlyUnions()) return '';
     const top = this.top();
+    const hints = this._hintComments()
     const columns = this.grouped.columns || [];
     let i = -1,
       sql = [];
@@ -156,29 +286,75 @@ class QueryCompiler_MSSQL extends QueryCompiler {
     if (sql.length === 0) sql = ['*'];
 
     return (
-      `select ${distinctClause}` +
+      `select ${hints}${distinctClause}` +
       (top ? top + ' ' : '') +
       sql.join(', ') +
       (this.tableName ? ` from ${this.tableName}` : '')
     );
   }
 
-  _returning(method, value) {
+  _returning(method, value, withTrigger) {
     switch (method) {
       case 'update':
       case 'insert':
         return value
-          ? `output ${this.formatter.columnizeWithPrefix('inserted.', value)}`
+          ? `output ${this.formatter.columnizeWithPrefix('inserted.', value)}${withTrigger ? " into #out" : ""}`
           : '';
       case 'del':
         return value
-          ? `output ${this.formatter.columnizeWithPrefix('deleted.', value)}`
+          ? `output ${this.formatter.columnizeWithPrefix('deleted.', value)}${withTrigger ? " into #out" : ""}`
           : '';
       case 'rowcount':
         return value ? ';select @@rowcount' : '';
     }
   }
 
+  _buildTempTable(values) {
+    // If value is nothing then return an empty string
+    if (values && values.length > 0) {
+      let selections = "";
+
+      // Build values that will be returned from this procedure
+      if (Array.isArray(values)) {
+        selections = values.map(value => `[t].${this.formatter.columnize(value)}`).join(",");
+      } else {
+        selections = `[t].${this.formatter.columnize(values)}`;
+      }
+
+      // Force #out to be correctly populated with the correct column structure.
+      let sql = `select top(0) ${selections} into #out `;
+      sql += `from ${this.tableName} as t `;
+      sql += `left join ${this.tableName} on 0=1;`;
+
+      return sql;
+    }
+
+    return '';
+  }
+
+  _buildReturningSelect(values) {
+    // If value is nothing then return an empty string
+    if (values && values.length > 0) {
+      let selections = "";
+
+      // Build columns to return
+      if (Array.isArray(values)) {
+        selections = values.map(value => `${this.formatter.columnize(value)}`).join(",");
+      } else {
+        selections = this.formatter.columnize(values);
+      }
+
+      // Get the returned values
+      let sql = `; select ${selections} from #out; `
+      // Drop the temp table to prevent memory leaks
+      sql += `drop table #out;`;
+
+      return sql;
+    }
+
+    return '';
+  }
+
   // Compiles a `truncate` query.
   truncate() {
     return `truncate table ${this.tableName}`;
@@ -252,9 +428,8 @@ class QueryCompiler_MSSQL extends QueryCompiler {
     const noLimit = !this.single.limit && this.single.limit !== 0;
     const noOffset = !this.single.offset;
     if (noOffset) return '';
-    let offset = `offset ${
-      noOffset ? '0' : this.formatter.parameter(this.single.offset)
-    } rows`;
+    let offset = `offset ${noOffset ? '0' : this.formatter.parameter(this.single.offset)
+      } rows`;
     if (!noLimit) {
       offset += ` fetch next ${this.formatter.parameter(
         this.single.limit

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

@@ -1,4 +1,4 @@
-/* eslint max-len:0 no-console:0*/
+/* eslint max-len:0*/
 
 // MySQL Table Builder & Compiler
 // -------

package/lib/dialects/sqlite3/schema/ddl.js

@@ -14,6 +14,7 @@ const isEmpty = require('lodash/isEmpty');
 const negate = require('lodash/negate');
 const omit = require('lodash/omit');
 const uniqueId = require('lodash/uniqueId');
+const { COMMA_NO_PAREN_REGEX } = require('../../../constants');
 
 // So altering the schema in SQLite3 is a major pain.
 // We have our own object to deal with the renaming and altering the types
@@ -328,7 +329,7 @@ assign(SQLite3_DDL.prototype, {
         }
 
         const updatedDefs = defs
-          .split(',')
+          .split(COMMA_NO_PAREN_REGEX)
           .map((line) => line.trim())
           .filter((defLine) => {
             if (
@@ -359,6 +360,157 @@ assign(SQLite3_DDL.prototype, {
     );
   },
 
+  dropPrimary: async function (constraintName) {
+    return this.client.transaction(
+      async (trx) => {
+        this.trx = trx;
+
+        const sql = await this.getTableSql();
+
+        const createTable = sql[0];
+
+        const oneLineSql = createTable.sql.replace(/\s+/g, ' ');
+        const matched = oneLineSql.match(/^CREATE TABLE\s+(\S+)\s*\((.*)\)/);
+
+        const defs = matched[2];
+
+        if (!defs) {
+          throw new Error('No column definitions in this statement!');
+        }
+
+        const updatedDefs = defs
+          .split(COMMA_NO_PAREN_REGEX)
+          .map((line) => line.trim())
+          .filter((defLine) => {
+            if (
+              defLine.startsWith('constraint') === false &&
+              defLine.includes('primary key') === false
+            )
+              return true;
+
+            if (constraintName) {
+              if (defLine.includes(constraintName)) return false;
+              return true;
+            } else {
+              return true;
+            }
+          })
+          .join(', ');
+
+        const newSql = oneLineSql.replace(defs, updatedDefs);
+
+        return this.reinsertMapped(createTable, newSql, (row) => {
+          return row;
+        });
+      },
+      { connection: this.connection }
+    );
+  },
+
+  primary: async function (columns, constraintName) {
+    return this.client.transaction(
+      async (trx) => {
+        this.trx = trx;
+
+        const tableInfo = (await this.getTableSql())[0];
+        const currentSQL = tableInfo.sql;
+
+        const oneLineSQL = currentSQL.replace(/\s+/g, ' ');
+        const matched = oneLineSQL.match(/^CREATE TABLE\s+(\S+)\s*\((.*)\)/);
+
+        const columnDefinitions = matched[2];
+
+        if (!columnDefinitions) {
+          throw new Error('No column definitions in this statement!');
+        }
+
+        const primaryKeyDef = `primary key(${columns.join(',')})`;
+        const constraintDef = constraintName
+          ? `constraint ${constraintName} ${primaryKeyDef}`
+          : primaryKeyDef;
+
+        const newColumnDefinitions = [
+          ...columnDefinitions
+            .split(COMMA_NO_PAREN_REGEX)
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith('primary') === false)
+            .map((line) => line.replace(/primary key/i, '')),
+          constraintDef,
+        ].join(', ');
+
+        const newSQL = oneLineSQL.replace(
+          columnDefinitions,
+          newColumnDefinitions
+        );
+
+        return this.reinsertMapped(tableInfo, newSQL, (row) => {
+          return row;
+        });
+      },
+      { connection: this.connection }
+    );
+  },
+
+  foreign: async function (foreignInfo) {
+    return this.client.transaction(
+      async (trx) => {
+        this.trx = trx;
+
+        const tableInfo = (await this.getTableSql())[0];
+        const currentSQL = tableInfo.sql;
+
+        const oneLineSQL = currentSQL.replace(/\s+/g, ' ');
+        const matched = oneLineSQL.match(/^CREATE TABLE\s+(\S+)\s*\((.*)\)/);
+
+        const columnDefinitions = matched[2];
+
+        if (!columnDefinitions) {
+          throw new Error('No column definitions in this statement!');
+        }
+
+        const newColumnDefinitions = columnDefinitions
+          .split(COMMA_NO_PAREN_REGEX)
+          .map((line) => line.trim());
+
+        let newForeignSQL = '';
+
+        if (foreignInfo.keyName) {
+          newForeignSQL += `CONSTRAINT ${foreignInfo.keyName}`;
+        }
+
+        newForeignSQL += ` FOREIGN KEY (${foreignInfo.column.join(', ')}) `;
+        newForeignSQL += ` REFERENCES ${foreignInfo.inTable} (${foreignInfo.references})`;
+
+        if (foreignInfo.onUpdate) {
+          newForeignSQL += ` ON UPDATE ${foreignInfo.onUpdate}`;
+        }
+
+        if (foreignInfo.onDelete) {
+          newForeignSQL += ` ON DELETE ${foreignInfo.onDelete}`;
+        }
+
+        newColumnDefinitions.push(newForeignSQL);
+
+        const newSQL = oneLineSQL.replace(
+          columnDefinitions,
+          newColumnDefinitions.join(', ')
+        );
+
+        return this.reinsertMapped(tableInfo, newSQL, (row) => {
+          return row;
+        });
+      },
+      { connection: this.connection }
+    );
+  },
+
+  /**
+   * @fixme
+   *
+   * There's a bunch of overlap between renameColumn/dropColumn/dropForeign/primary/foreign.
+   * It'll be helpful to refactor this file heavily to combine/optimize some of these calls
+   */
+
   reinsertMapped(createTable, newSql, mapRow) {
     return Promise.resolve()
       .then(() => this.createTempTable(createTable))