knex 0.95.14 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,94 @@
 # Master (Unreleased)
 
+# 1.0.2 - 02 February, 2022
+
+### New features:
+
+- Support of MATERIALIZED and NOT MATERIALIZED with WITH/CTE #4940
+- Add raw support in onConflict clause #4960
+- Alter nullable constraint when alterNullable is set to true #4730
+- Add alterType parameter for alter function #4967
+- Support string json in json values #4988
+- MySQL: add with clause #4508
+
+### Bug fixes:
+
+- Fix error message for missing migration files #4937
+- Move deferrable to after on update/on delete #4976
+- Do not use sys.tables to find if a table exists #2328
+- PostgreSQL: Fix Order nulls #4989
+- MySQL: Fix collation when renaming column #2666
+- SQLite: Same boolean handling in better-sqlite3 as in sqlite3 #4982
+
+### Typings:
+
+- WhereILike - fix typo #4941
+
+# 1.0.1 - 16 January, 2022
+
+### Bug fixes:
+
+- Fix package.json metadata
+
+# 1.0.0 - 16 January, 2022
+
+### Breaking changes
+
+- Dropped support for Node 10;
+- Replaced unsupported `sqlite3` driver with `@vscode/sqlite3`;
+- Changed data structure from `RETURNING` operation to be consistent with `SELECT`;
+- Changed Migrator to return list of migrations as objects consistently.
+
+### New features:
+
+- Support fromRaw #4781
+- Support zero precision in timestamp/datetime #4784
+- Support whereLike and whereILike #4779
+- Add JSDoc (TS flavor) to stub files #4809
+- Allow skip binding in limit and offset #4811
+- Support creating a new table in the database based on another table #4821
+- Accept Raw on onIn joins #4830
+- Implement support for custom seed sources #4842
+- Add binary uuid option #4836
+- ForUpdate array parameter #4882
+- Add camel case to timestamps method #4803
+- Advanced JSON support #4859
+- Add type to TypeScript knexfile #4909
+- Checks Constraints Support #4874
+- Support creating multiple PKs with increments #4903
+- Enable wrapIdentifier for SQLite .hasTable #4915
+- MSSQL: Add support for unique constraint #4887
+- SQLite: New dialect, using better-sqlite3 driver #4871
+- SQLite: Switch to @vscode/sqlite3 #4866
+- SQLite: Support createViewOrReplace #4856
+- SQLite: Support RETURNING statements for better-sqlite3 driver #4934
+- PostgreSQL: Support JOIN and USING syntax for Delete Statement #4800
+
+### Bug fixes:
+
+- Fix overzealous warning on use of whereNot with "in" or "between" #4780
+- Fix Union all + first syntax error #4799
+- Make view columns optional in create view like #4829
+- Insert lock row fix during migration #4865
+- Fix for createViewOrReplace #4856
+- SQLite: Fix foreign key constraints when altering a table #4189
+- MySQL: Validate connection fix #4794
+- MySQL: Set comment size warning limit to 1024 #4867
+
+### Typings:
+
+- Allow string indexType in index creation #4791
+- Add missing ints typings #4832
+- Returning method types #4881
+- Improve columnInfo type #4868
+
+# 0.95.15 - 22 December, 2021
+
+### Bug fixes:
+
+- Oracle:
+- MariaDB: lock row fix during migration in MariaDB and Oracle #4865
+
 # 0.95.14 - 09 November, 2021
 
 ### Bug fixes:
@@ -11,7 +100,7 @@
 ### Bug fixes:
 
 - PostgreSQL: Support zero precision in timestamp/datetime #4784
-   
+
 ### Typings:
 
 - Allow string indexType in index creation #4791

package/README.md

@@ -19,7 +19,7 @@ Node.js, featuring:
 - both a [promise](https://knexjs.org/#Interfaces-Promises) and [callback](https://knexjs.org/#Interfaces-Callbacks) API
 - a [thorough test suite](https://github.com/knex/knex/actions)
 
-Node.js versions 10+ are supported.
+Node.js versions 12+ are supported.
 
 * Take a look at the [full documentation](https://knexjs.org) to get started!
 * Browse the [list of plugins and tools](https://github.com/knex/knex/blob/master/ECOSYSTEM.md) built for knex

package/UPGRADING.md

@@ -1,5 +1,12 @@
 ## Upgrading to new knex.js versions
 
+### Upgrading to version 1.0.0+
+
+* Node.js older than 12 is no longer supported, make sure to update your environment;
+* If you are using `sqlite3` driver dependency, please replace it with `@vscode/sqlite3` in your `package.json`;
+* `RETURNING` operations now always return an object with column names;
+* Migrator now returns list of migrations as objects.
+
 ### Upgrading to version 0.95.0+
 
 * TypeScript type exports changed significantly. While `import Knex from 'knex';` used to import the knex instantiation function, the namespace and the interface for the knex instantiation function/object, there is now a clear distinction between them:

package/lib/client.js

@@ -30,6 +30,7 @@ const Logger = require('./logger');
 const { POOL_CONFIG_OPTIONS } = require('./constants');
 const ViewBuilder = require('./schema/viewbuilder.js');
 const ViewCompiler = require('./schema/viewcompiler.js');
+const isPlainObject = require('lodash/isPlainObject');
 
 const debug = require('debug')('knex:client');
 
@@ -51,6 +52,7 @@ class Client extends EventEmitter {
         `Using 'this.dialect' to identify the client is deprecated and support for it will be removed in the future. Please use configuration option 'client' instead.`
       );
     }
+
     const dbClient = this.config.client || this.dialect;
     if (!dbClient) {
       throw new Error(
@@ -392,8 +394,13 @@ class Client extends EventEmitter {
       i = -1;
     while (++i < values.length) {
       if (i > 0) str += ', ';
+      let value = values[i];
+      // json columns can have object in values.
+      if (isPlainObject(value)) {
+        value = JSON.stringify(value);
+      }
       str += this.parameter(
-        values[i] === undefined ? notSetValue : values[i],
+        value === undefined ? notSetValue : value,
         builder,
         bindingsHolder
       );
@@ -442,6 +449,12 @@ class Client extends EventEmitter {
   processPassedConnection(connection) {
     // Default implementation is noop
   }
+
+  toPathForJson(jsonPath) {
+    // By default, we want a json path, so if this function is not overriden,
+    // we return the path.
+    return jsonPath;
+  }
 }
 
 Object.assign(Client.prototype, {

package/lib/constants.js

@@ -16,6 +16,7 @@ const SUPPORTED_CLIENTS = Object.freeze(
     'redshift',
     'sqlite3',
     'cockroachdb',
+    'better-sqlite3',
   ].concat(Object.keys(CLIENT_ALIASES))
 );
 
@@ -29,6 +30,7 @@ const DRIVER_NAMES = Object.freeze({
   Redshift: 'pg-redshift',
   SQLite: 'sqlite3',
   CockroachDB: 'cockroachdb',
+  BetterSQLite3: 'better-sqlite3',
 });
 
 const POOL_CONFIG_OPTIONS = Object.freeze([

package/lib/dialects/better-sqlite3/index.js

@@ -0,0 +1,72 @@
+// better-sqlite3 Client
+// -------
+const Client_SQLite3 = require('../sqlite3');
+
+class Client_BetterSQLite3 extends Client_SQLite3 {
+  _driver() {
+    return require('better-sqlite3');
+  }
+
+  // Get a raw connection from the database, returning a promise with the connection object.
+  async acquireRawConnection() {
+    return new this.driver(this.connectionSettings.filename);
+  }
+
+  // Used to explicitly close a connection, called internally by the pool when
+  // a connection times out or the pool is shutdown.
+  async destroyRawConnection(connection) {
+    return connection.close();
+  }
+
+  // Runs the query on the specified connection, providing the bindings and any
+  // other necessary prep work.
+  async _query(connection, obj) {
+    if (!obj.sql) throw new Error('The query is empty');
+
+    if (!connection) {
+      throw new Error('No connection provided');
+    }
+
+    const statement = connection.prepare(obj.sql);
+    const bindings = this._formatBindings(obj.bindings);
+
+    if (statement.reader) {
+      const response = await statement.all(bindings);
+      obj.response = response;
+      return obj;
+    }
+
+    const response = await statement.run(bindings);
+    obj.response = response;
+    obj.context = {
+      lastID: response.lastInsertRowid,
+      changes: response.changes,
+    };
+
+    return obj;
+  }
+
+  _formatBindings(bindings) {
+    if (!bindings) {
+      return [];
+    }
+    return bindings.map((binding) => {
+      if (binding instanceof Date) {
+        return binding.valueOf();
+      }
+
+      if (typeof binding === 'boolean') {
+        return Number(binding);
+      }
+
+      return binding;
+    });
+  }
+}
+
+Object.assign(Client_BetterSQLite3.prototype, {
+  // The "dialect", for reference .
+  driverName: 'better-sqlite3',
+});
+
+module.exports = Client_BetterSQLite3;

package/lib/dialects/cockroachdb/crdb-querycompiler.js

@@ -1,6 +1,9 @@
 const QueryCompiler_PG = require('../postgres/query/pg-querycompiler');
-const isEmpty = require('lodash/isEmpty');
-const { columnize: columnize_ } = require('../../formatter/wrappingFormatter');
+const {
+  columnize: columnize_,
+  wrap: wrap_,
+  operator: operator_,
+} = require('../../formatter/wrappingFormatter');
 
 class QueryCompiler_CRDB extends QueryCompiler_PG {
   truncate() {
@@ -20,43 +23,99 @@ class QueryCompiler_CRDB extends QueryCompiler_PG {
 
   _upsert() {
     const upsertValues = this.single.upsert || [];
-    let sql = this.with() + `upsert into ${this.tableName} `;
-    if (Array.isArray(upsertValues)) {
-      if (upsertValues.length === 0) return '';
-    } else if (typeof upsertValues === 'object' && isEmpty(upsertValues)) {
-      return sql + this._emptyInsertValue;
+    const sql = this.with() + `upsert into ${this.tableName} `;
+    const body = this._insertBody(upsertValues);
+    return body === '' ? '' : sql + body;
+  }
+
+  _groupOrder(item, type) {
+    // CockroachDB don't support PostgreSQL order nulls first/last syntax, we take the generic one.
+    return this._basicGroupOrder(item, type);
+  }
+
+  whereJsonPath(statement) {
+    let castValue = '';
+    if (parseInt(statement.value)) {
+      castValue = '::int';
+    } else if (parseFloat(statement.value)) {
+      castValue = '::float';
+    } else {
+      castValue = " #>> '{}'";
     }
+    return `json_extract_path(${this._columnClause(
+      statement
+    )}, ${this.client.toArrayPathFromJsonPath(
+      statement.jsonPath,
+      this.builder,
+      this.bindingsHolder
+    )})${castValue} ${operator_(
+      statement.operator,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )} ${this._jsonValueClause(statement)}`;
+  }
 
-    const upsertData = this._prepInsert(upsertValues);
-    if (typeof upsertData === 'string') {
-      sql += upsertData;
+  // Json common functions
+  _jsonExtract(nameFunction, params) {
+    let extractions;
+    if (Array.isArray(params.column)) {
+      extractions = params.column;
     } else {
-      if (upsertData.columns.length) {
-        sql += `(${columnize_(
-          upsertData.columns,
+      extractions = [params];
+    }
+    return extractions
+      .map((extraction) => {
+        const jsonCol = `json_extract_path(${columnize_(
+          extraction.column || extraction[0],
           this.builder,
           this.client,
           this.bindingsHolder
-        )}`;
-        sql += ') values (';
-        let i = -1;
-        while (++i < upsertData.values.length) {
-          if (i !== 0) sql += '), (';
-          sql += this.client.parameterize(
-            upsertData.values[i],
-            this.client.valueForUndefined,
-            this.builder,
-            this.bindingsHolder
-          );
-        }
-        sql += ')';
-      } else if (upsertValues.length === 1 && upsertValues[0]) {
-        sql += this._emptyInsertValue;
-      } else {
-        sql = '';
-      }
-    }
-    return sql;
+        )}, ${this.client.toArrayPathFromJsonPath(
+          extraction.path || extraction[1],
+          this.builder,
+          this.bindingsHolder
+        )})`;
+        const alias = extraction.alias || extraction[2];
+        return alias
+          ? this.client.alias(jsonCol, this.formatter.wrap(alias))
+          : jsonCol;
+      })
+      .join(', ');
+  }
+
+  _onJsonPathEquals(nameJoinFunction, clause) {
+    return (
+      'json_extract_path(' +
+      wrap_(
+        clause.columnFirst,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.toArrayPathFromJsonPath(
+        clause.jsonPathFirst,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ') = json_extract_path(' +
+      wrap_(
+        clause.columnSecond,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.toArrayPathFromJsonPath(
+        clause.jsonPathSecond,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ')'
+    );
   }
 }
 

package/lib/dialects/cockroachdb/crdb-tablecompiler.js

@@ -7,6 +7,25 @@ class TableCompiler_CRDB extends TableCompiler {
     super(client, tableBuilder);
   }
 
+  addColumns(columns, prefix, colCompilers) {
+    if (prefix === this.alterColumnsPrefix) {
+      // alter columns
+      for (const col of colCompilers) {
+        this.client.logger.warn(
+          'Experimental alter column in use, see issue: https://github.com/cockroachdb/cockroach/issues/49329'
+        );
+        this.pushQuery({
+          sql: 'SET enable_experimental_alter_column_type_general = true',
+          bindings: [],
+        });
+        super._addColumn(col);
+      }
+    } else {
+      // base class implementation for normal add
+      super.addColumns(columns, prefix);
+    }
+  }
+
   dropUnique(columns, indexName) {
     indexName = indexName
       ? this.formatter.wrap(indexName)

package/lib/dialects/cockroachdb/index.js

@@ -58,6 +58,19 @@ class Client_CockroachDB extends Client_PostgreSQL {
       connectionToKill.activeQuery
     );
   }
+
+  toArrayPathFromJsonPath(jsonPath, builder, bindingsHolder) {
+    return jsonPath
+      .replace(/^(\$\.)/, '') // remove the first dollar
+      .replace(/\[([0-9]+)]/, '.$1')
+      .split('.')
+      .map(
+        function (v) {
+          return this.parameter(v, builder, bindingsHolder);
+        }.bind(this)
+      )
+      .join(', ');
+  }
 }
 
 Object.assign(Client_CockroachDB.prototype, {

package/lib/dialects/mssql/index.js

@@ -1,8 +1,6 @@
 // MSSQL Client
 // -------
-const flatten = require('lodash/flatten');
 const map = require('lodash/map');
-const values = require('lodash/values');
 const isNil = require('lodash/isNil');
 
 const Client = require('../../client');
@@ -472,15 +470,6 @@ class Client_MSSQL extends Client {
           if (query.returning === '@@rowcount') {
             return response[0][''];
           }
-
-          if (
-            (Array.isArray(query.returning) && query.returning.length > 1) ||
-            query.returning[0] === '*'
-          ) {
-            return response;
-          }
-          // return an array with values if only one returning value was specified
-          return flatten(map(response, values));
         }
         return response;
       default: