knex 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Master (Unreleased)
 
+# 2.4.0 - 06 January, 2022
+
+### New features:
+
+- Support partial unique indexes #5316
+- Make compiling SQL in error message optional #5282
+
+### Bug fixes
+
+- Insert array into json column #5321
+- Fix unexpected max acquire-timeout #5377
+- Fix: orWhereJson #5361
+- MySQL: Add assertion for basic where clause not to be object or array #1227
+- SQLite: Fix changing the default value of a boolean column in SQLite #5319
+
+### Typings:
+
+- add missing type for 'expirationChecker' on PgConnectionConfig #5334
+
 # 2.3.0 - 31 August, 2022
 
 ### New features:

package/lib/client.js

@@ -213,11 +213,16 @@ class Client extends EventEmitter {
       }
     });
 
+    const DEFAULT_ACQUIRE_TIMEOUT = 60000;
     const timeouts = [
-      this.config.acquireConnectionTimeout || 60000,
-      poolConfig.acquireTimeoutMillis,
+      this.config.acquireConnectionTimeout,
+      poolConfig.acquireTimeoutMillis
     ].filter((timeout) => timeout !== undefined);
 
+    if (!timeouts.length) {
+      timeouts.push(DEFAULT_ACQUIRE_TIMEOUT)
+    }
+
     // acquire connection timeout can be set on config or config.pool
     // choose the smallest, positive timeout setting and set on poolConfig
     poolConfig.acquireTimeoutMillis = Math.min(...timeouts);
@@ -396,7 +401,7 @@ class Client extends EventEmitter {
       if (i > 0) str += ', ';
       let value = values[i];
       // json columns can have object in values.
-      if (isPlainObject(value)) {
+      if (isPlainObject(value) || Array.isArray(value)) {
         value = JSON.stringify(value);
       }
       str += this.parameter(

package/lib/dialects/mssql/schema/mssql-tablecompiler.js

@@ -280,20 +280,24 @@ class TableCompiler_MSSQL extends TableCompiler {
    * Create a unique index.
    *
    * @param {string | string[]} columns
-   * @param {string | {indexName: undefined | string, deferrable?: 'not deferrable'|'deferred'|'immediate', useConstraint?: true|false }} indexName
+   * @param {string | {indexName: undefined | string, deferrable?: 'not deferrable'|'deferred'|'immediate', useConstraint?: true|false, predicate?: QueryBuilder }} indexName
    */
   unique(columns, indexName) {
     /** @type {string | undefined} */
     let deferrable;
     let useConstraint = false;
+    let predicate;
     if (isObject(indexName)) {
-      ({ indexName, deferrable, useConstraint } = indexName);
+      ({ indexName, deferrable, useConstraint, predicate } = indexName);
     }
     if (deferrable && deferrable !== 'not deferrable') {
       this.client.logger.warn(
         `mssql: unique index [${indexName}] will not be deferrable ${deferrable} because mssql does not support deferred constraints.`
       );
     }
+    if (useConstraint && predicate) {
+      throw new Error('mssql cannot create constraint with predicate');
+    }
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('unique', this.tableNameRaw, columns);
@@ -302,10 +306,6 @@ class TableCompiler_MSSQL extends TableCompiler {
       columns = [columns];
     }
 
-    const whereAllTheColumnsAreNotNull = columns
-      .map((column) => this.formatter.columnize(column) + ' IS NOT NULL')
-      .join(' AND ');
-
     if (useConstraint) {
       // mssql supports unique indexes and unique constraints.
       // unique indexes cannot be used with foreign key relationships hence unique constraints are used instead.
@@ -315,12 +315,18 @@ class TableCompiler_MSSQL extends TableCompiler {
         )})`
       );
     } else {
-      // make unique constraint that allows null https://stackoverflow.com/a/767702/360060
+      // default to making unique index that allows null https://stackoverflow.com/a/767702/360060
       // to be more or less compatible with other DBs (if any of the columns is NULL then "duplicates" are allowed)
+      const predicateQuery = predicate
+        ? ' ' + this.client.queryCompiler(predicate).where()
+        : ' WHERE ' +
+          columns
+            .map((column) => this.formatter.columnize(column) + ' IS NOT NULL')
+            .join(' AND ');
       this.pushQuery(
         `CREATE UNIQUE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
           columns
-        )}) WHERE ${whereAllTheColumnsAreNotNull}`
+        )})${predicateQuery}`
       );
     }
   }

package/lib/dialects/mysql/query/mysql-querycompiler.js

@@ -1,6 +1,9 @@
 // MySQL Query Compiler
 // ------
+const assert = require('assert');
 const identity = require('lodash/identity');
+const isPlainObject = require('lodash/isPlainObject');
+const isEmpty = require('lodash/isEmpty');
 const QueryCompiler = require('../../../query/querycompiler');
 const { wrapAsIdentifier } = require('../../../formatter/formatterUtils');
 const {
@@ -8,6 +11,9 @@ const {
   wrap: wrap_,
 } = require('../../../formatter/wrappingFormatter');
 
+const isPlainObjectOrArray = (value) =>
+  isPlainObject(value) || Array.isArray(value);
+
 class QueryCompiler_MySQL extends QueryCompiler {
   constructor(client, builder, formatter) {
     super(client, builder, formatter);
@@ -131,7 +137,8 @@ class QueryCompiler_MySQL extends QueryCompiler {
       output(resp) {
         const out = resp.reduce(function (columns, val) {
           columns[val.COLUMN_NAME] = {
-            defaultValue: val.COLUMN_DEFAULT === 'NULL' ? null : val.COLUMN_DEFAULT,
+            defaultValue:
+              val.COLUMN_DEFAULT === 'NULL' ? null : val.COLUMN_DEFAULT,
             type: val.DATA_TYPE,
             maxLength: val.CHARACTER_MAXIMUM_LENGTH,
             nullable: val.IS_NULLABLE === 'YES',
@@ -156,6 +163,25 @@ class QueryCompiler_MySQL extends QueryCompiler {
     return `limit ${limit}`;
   }
 
+  whereBasic(statement) {
+    assert(
+      !isPlainObjectOrArray(statement.value),
+      'The values in where clause must not be object or array.'
+    );
+
+    return super.whereBasic(statement);
+  }
+
+  whereRaw(statement) {
+    assert(
+      isEmpty(statement.value.bindings) ||
+        !Object.values(statement.value.bindings).some(isPlainObjectOrArray),
+      'The values in where clause must not be object or array.'
+    );
+
+    return super.whereRaw(statement);
+  }
+
   whereLike(statement) {
     return `${this._columnClause(statement)} ${this._not(
       statement,

package/lib/dialects/postgres/schema/pg-tablecompiler.js

@@ -189,20 +189,44 @@ class TableCompiler_PG extends TableCompiler {
 
   unique(columns, indexName) {
     let deferrable;
+    let useConstraint = true;
+    let predicate;
     if (isObject(indexName)) {
-      ({ indexName, deferrable } = indexName);
+      ({ indexName, deferrable, useConstraint, predicate } = indexName);
+      if (useConstraint === undefined) {
+        useConstraint = !!deferrable || !predicate;
+      }
+    }
+    if (!useConstraint && deferrable && deferrable !== 'not deferrable') {
+      throw new Error('postgres cannot create deferrable index');
+    }
+    if (useConstraint && predicate) {
+      throw new Error('postgres cannot create constraint with predicate');
     }
     deferrable = deferrable ? ` deferrable initially ${deferrable}` : '';
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('unique', this.tableNameRaw, columns);
-    this.pushQuery(
-      `alter table ${this.tableName()} add constraint ${indexName}` +
-        ' unique (' +
-        this.formatter.columnize(columns) +
-        ')' +
-        deferrable
-    );
+
+    if (useConstraint) {
+      this.pushQuery(
+        `alter table ${this.tableName()} add constraint ${indexName}` +
+          ' unique (' +
+          this.formatter.columnize(columns) +
+          ')' +
+          deferrable
+      );
+    } else {
+      const predicateQuery = predicate
+        ? ' ' + this.client.queryCompiler(predicate).where()
+        : '';
+
+      this.pushQuery(
+        `create unique index ${indexName} on ${this.tableName()} (${this.formatter.columnize(
+          columns
+        )})${predicateQuery}`
+      );
+    }
   }
 
   index(columns, indexName, options) {

package/lib/dialects/sqlite3/schema/sqlite-tablecompiler.js

@@ -51,7 +51,7 @@ class TableCompiler_SQLite3 extends TableCompiler {
         const type = col.getColumnType();
 
         const defaultTo = col.modified['defaultTo']
-          ? formatDefault(col.modified['defaultTo'][0], type, this.client)
+          ? formatDefault(col.modified['defaultTo'][0], col.type, this.client)
           : null;
 
         const notNull =
@@ -132,8 +132,9 @@ class TableCompiler_SQLite3 extends TableCompiler {
   // Compile a unique key command.
   unique(columns, indexName) {
     let deferrable;
+    let predicate;
     if (isObject(indexName)) {
-      ({ indexName, deferrable } = indexName);
+      ({ indexName, deferrable, predicate } = indexName);
     }
     if (deferrable && deferrable !== 'not deferrable') {
       this.client.logger.warn(
@@ -144,8 +145,13 @@ class TableCompiler_SQLite3 extends TableCompiler {
       ? this.formatter.wrap(indexName)
       : this._indexCommand('unique', this.tableNameRaw, columns);
     columns = this.formatter.columnize(columns);
+
+    const predicateQuery = predicate
+      ? ' ' + this.client.queryCompiler(predicate).where()
+      : '';
+
     this.pushQuery(
-      `create unique index ${indexName} on ${this.tableName()} (${columns})`
+      `create unique index ${indexName} on ${this.tableName()} (${columns})${predicateQuery}`
     );
   }
 

package/lib/execution/internal/query-executioner.js

@@ -35,10 +35,14 @@ function enrichQueryObject(connection, queryParam, client) {
 
 function executeQuery(connection, queryObject, client) {
   return client._query(connection, queryObject).catch((err) => {
-    err.message =
-      formatQuery(queryObject.sql, queryObject.bindings, undefined, client) +
-      ' - ' +
-      err.message;
+    if (client.config && client.config.compileSqlOnError === false) {
+      err.message = queryObject.sql + ' - ' + err.message;
+    } else {
+      err.message =
+        formatQuery(queryObject.sql, queryObject.bindings, undefined, client) +
+        ' - ' +
+        err.message;
+    }
     client.emit(
       'query-error',
       err,

package/lib/migrations/migrate/stub/mjs.stub

@@ -1,4 +1,8 @@
 
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
 export const up = async (knex) => {
   <% if (d.tableName) { %>
   await knex.schema.createTable("<%= d.tableName %>", function(t) {
@@ -8,6 +12,10 @@ export const up = async (knex) => {
   <% } %>
 };
 
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
 export const down = async (knex) => {
   <% if (d.tableName) { %>
   await knex.schema.dropTable("<%= d.tableName %>");

package/lib/query/querybuilder.js

@@ -527,6 +527,7 @@ class Builder extends EventEmitter {
   // Adds a raw `where` clause to the query.
   whereRaw(sql, bindings) {
     const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
+
     this._statements.push({
       grouping: 'where',
       type: 'whereRaw',
@@ -1501,17 +1502,16 @@ class Builder extends EventEmitter {
     return this;
   }
 
-  orWhereJsonObject(column, operator, value) {
-    return this._bool('or').whereJsonObject(column, operator, value);
+  orWhereJsonObject(column, value) {
+    return this._bool('or').whereJsonObject(column, value);
   }
 
   whereNotJsonObject(column, value) {
-    this._not(true)._whereJsonWrappedValue('whereJsonObject', column, value);
-    return this;
+    return this._not(true).whereJsonObject(column, value);
   }
 
-  orWhereNotJsonObject(column, operator, value) {
-    return this._not(true)._bool('or').whereJsonObject(column, operator, value);
+  orWhereNotJsonObject(column, value) {
+    return this._bool('or').whereNotJsonObject(column, value);
   }
 
   whereJsonPath(column, path, operator, value) {
@@ -1530,18 +1530,15 @@ class Builder extends EventEmitter {
   }
 
   whereJsonNotSupersetOf(column, value) {
-    this._not(true).whereJsonSupersetOf(column, value);
-    return this;
+    return this._not(true).whereJsonSupersetOf(column, value);
   }
 
   orWhereJsonSupersetOf(column, value) {
-    this._whereJsonWrappedValue('whereJsonSupersetOf', column, value);
-    return this;
+    return this._bool('or').whereJsonSupersetOf(column, value);
   }
 
   orWhereJsonNotSupersetOf(column, value) {
-    this._not(true)._bool('or').whereJsonSupersetOf(column, value);
-    return this;
+    return this._bool('or').whereJsonNotSupersetOf(column, value);
   }
 
   // Json subset wheres
@@ -1551,18 +1548,15 @@ class Builder extends EventEmitter {
   }
 
   whereJsonNotSubsetOf(column, value) {
-    this._not(true).whereJsonSubsetOf(column, value);
-    return this;
+    return this._not(true).whereJsonSubsetOf(column, value);
   }
 
   orWhereJsonSubsetOf(column, value) {
-    this._whereJsonWrappedValue('whereJsonSubsetOf', column, value);
-    return this;
+    return this._bool('or').whereJsonSubsetOf(column, value);
   }
 
   orWhereJsonNotSubsetOf(column, value) {
-    this._not(true)._bool('or').whereJsonSubsetOf(column, value);
-    return this;
+    return this._bool('or').whereJsonNotSubsetOf(column, value);
   }
 
   whereJsonHasNone(column, values) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "A batteries-included SQL query & schema builder for PostgresSQL, MySQL, CockroachDB, MSSQL and SQLite3",
   "main": "knex",
   "types": "types/index.d.ts",
@@ -132,7 +132,7 @@
     "pg-query-stream": "^4.2.4",
     "prettier": "2.6.2",
     "rimraf": "^3.0.2",
-    "sinon": "^14.0.0",
+    "sinon": "^15.0.1",
     "sinon-chai": "^3.7.0",
     "source-map-support": "^0.5.21",
     "sqlite3": "^5.0.11",
@@ -141,8 +141,8 @@
     "tedious": "^14.4.0",
     "toxiproxy-node-client": "^2.0.6",
     "ts-node": "^10.9.1",
-    "tsd": "^0.23.0",
-    "typescript": "4.8.2"
+    "tsd": "^0.25.0",
+    "typescript": "4.8.3"
   },
   "buildDependencies": [
     "rimraf"

package/scripts/update_gitignore_for_tsc_output.js

@@ -64,7 +64,8 @@ function main(cliCommand) {
       const relativeTsPath = filepath.slice(libDirectory.length + 1)
       // Swaps .ts for .js file ending
       const relativeJsPath = relativeTsPath.slice(0, relativeTsPath.length - 3) + '.js'
-      return relativeJsPath
+      // Always use POSIX-style path separators - .gitignore requires it
+      return relativeJsPath.split(path.sep).join(path.posix.sep);
     })
     const jsFilesToIgnoreString = jsFilesToIgnore.join('\n')
     const libGitignorePath = path.join(libDirectory, '.gitignore')

package/types/index.d.ts

@@ -2513,6 +2513,7 @@ export declare namespace Knex {
         storageEngineIndexType?: string;
         deferrable?: deferrableType;
         useConstraint?: boolean;
+        predicate?: QueryBuilder;
       }>
     ): TableBuilder;
     /** @deprecated */
@@ -2716,6 +2717,7 @@ export declare namespace Knex {
     searchPath?: string | readonly string[];
     asyncStackTraces?: boolean;
     log?: Logger;
+    compileSqlOnError?: boolean;
   }
 
   type StaticConnectionConfig =
@@ -3023,6 +3025,7 @@ export declare namespace Knex {
     connectionTimeoutMillis?: number;
     types?: PgCustomTypesConfig;
     options?: string;
+    expirationChecker?(): boolean;
   }
 
   type PgGetTypeParser = (oid: number, format: string) => any;