knex 3.0.1 → 3.1.0

package/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Master (Unreleased)
 
-# 3.0.0 - 6 October, 2023
+# 3.1.0 - 8 December, 2023
+
+### Bug fixes
+
+- andWhereNotJsonObject calling wrong function (#5683)
+- PostgreSQL: fix error when setting query_timeout (#5673)
+- MySQL: Missing comments on delete, update and insert (#5738)
+- MySQL: Fixed issue with bigincrements not working with composite primary key - #5341 (#5343)
+
+### Types
+
+- Add type definitions for orHavingNull and orHavingNotNull (#5669)
+- Import knex as type in TS migration template (#5741)
+- Fix conditional constraint error (#5747)
+- PostgreSQL: Fix typing to reflect pg typing change (#5647)
+
+### New features
+
+- Add transactor.parentTransaction (#5567)
+- MySQL: Added implementation for upsert (#5743)
+- Oracle: Support Object Names Greater than 30 Characters for Oracle DB Versions 12.2 and Greater (#5197)
+
+# 3.0.1 - 6 October, 2023
 
 - Build fix
 

package/lib/dialects/mysql/index.js

@@ -6,6 +6,7 @@ const { promisify } = require('util');
 const Client = require('../../client');
 
 const Transaction = require('./transaction');
+const QueryBuilder = require('./query/mysql-querybuilder');
 const QueryCompiler = require('./query/mysql-querycompiler');
 const SchemaCompiler = require('./schema/mysql-compiler');
 const TableCompiler = require('./schema/mysql-tablecompiler');
@@ -23,6 +24,10 @@ class Client_MySQL extends Client {
     return require('mysql');
   }
 
+  queryBuilder() {
+    return new QueryBuilder(this);
+  }
+
   queryCompiler(builder, formatter) {
     return new QueryCompiler(this, builder, formatter);
   }

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

@@ -0,0 +1,14 @@
+const QueryBuilder = require('../../../query/querybuilder');
+const isEmpty = require('lodash/isEmpty');
+
+module.exports = class QueryBuilder_MySQL extends QueryBuilder {
+  upsert(values, returning, options) {
+    this._method = 'upsert';
+    if (!isEmpty(returning)) {
+      this.returning(returning, options);
+    }
+
+    this._single.upsert = values;
+    return this;
+  }
+};

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

@@ -27,12 +27,21 @@ class QueryCompiler_MySQL extends QueryCompiler {
 
     this._emptyInsertValue = '() values ()';
   }
+  // Compiles an `delete` allowing comments
+  del() {
+    const sql = super.del();
+    if (sql === '') return sql;
+    const comments = this.comments();
+    return (comments === '' ? '' : comments + ' ') + sql;
+  }
 
   // Compiles an `insert` query, allowing for multiple
   // inserts using a single query statement.
   insert() {
     let sql = super.insert();
     if (sql === '') return sql;
+    const comments = this.comments();
+    sql = (comments === '' ? '' : comments + ' ') + sql;
 
     const { ignore, merge, insert } = this.single;
     if (ignore) sql = sql.replace('insert into', 'insert ignore into');
@@ -49,6 +58,13 @@ class QueryCompiler_MySQL extends QueryCompiler {
     return sql;
   }
 
+  upsert() {
+    const upsertValues = this.single.upsert || [];
+    const sql = this.with() + `replace into ${this.tableName} `;
+    const body = this._insertBody(upsertValues);
+    return body === '' ? '' : sql + body;
+  }
+
   // Compiles merge for onConflict, allowing for different merge strategies
   _merge(updates, insert) {
     const sql = ' on duplicate key update ';
@@ -86,6 +102,7 @@ class QueryCompiler_MySQL extends QueryCompiler {
 
   // Update method, including joins, wheres, order & limits.
   update() {
+    const comments = this.comments();
     const withSQL = this.with();
     const join = this.join();
     const updates = this._prepUpdate(this.single.update);
@@ -93,6 +110,7 @@ class QueryCompiler_MySQL extends QueryCompiler {
     const order = this.order();
     const limit = this.limit();
     return (
+      (comments === '' ? '' : comments + ' ') +
       withSQL +
       `update ${this.tableName}` +
       (join ? ` ${join}` : '') +

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

@@ -160,6 +160,14 @@ class TableCompiler_MySQL extends TableCompiler {
             }
           });
         }
+        const bigIncrementsCols = this._getBigIncrementsColumnNames();
+        if (bigIncrementsCols.length) {
+          bigIncrementsCols.forEach((c) => {
+            if (!columns.includes(c)) {
+              columns.unshift(c);
+            }
+          });
+        }
       }
 
       return `,${constraintName} primary key (${this.formatter.columnize(
@@ -292,6 +300,7 @@ class TableCompiler_MySQL extends TableCompiler {
 
     const primaryCols = columns;
     let incrementsCols = [];
+    let bigIncrementsCols = [];
     if (this.grouped.columns) {
       incrementsCols = this._getIncrementsColumnNames();
       if (incrementsCols) {
@@ -301,6 +310,14 @@ class TableCompiler_MySQL extends TableCompiler {
           }
         });
       }
+      bigIncrementsCols = this._getBigIncrementsColumnNames();
+      if (bigIncrementsCols) {
+        bigIncrementsCols.forEach((c) => {
+          if (!primaryCols.includes(c)) {
+            primaryCols.unshift(c);
+          }
+        });
+      }
     }
     if (this.method !== 'create' && this.method !== 'createIfNot') {
       this.pushQuery(
@@ -316,6 +333,13 @@ class TableCompiler_MySQL extends TableCompiler {
         )} int unsigned not null auto_increment`
       );
     }
+    if (bigIncrementsCols.length) {
+      this.pushQuery(
+        `alter table ${this.tableName()} modify column ${this.formatter.columnize(
+          bigIncrementsCols
+        )} bigint unsigned not null auto_increment`
+      );
+    }
   }
 
   unique(columns, indexName) {

package/lib/dialects/oracle/schema/internal/incrementUtils.js

@@ -2,11 +2,13 @@ const Trigger = require('./trigger');
 
 // helper function for pushAdditional in increments() and bigincrements()
 function createAutoIncrementTriggerAndSequence(columnCompiler) {
+  const trigger = new Trigger(columnCompiler.client.version);
+
   // TODO Add warning that sequence etc is created
   columnCompiler.pushAdditional(function () {
     const tableName = this.tableCompiler.tableNameRaw;
     const schemaName = this.tableCompiler.schemaNameRaw;
-    const createTriggerSQL = Trigger.createAutoIncrementTrigger(
+    const createTriggerSQL = trigger.createAutoIncrementTrigger(
       this.client.logger,
       tableName,
       schemaName

package/lib/dialects/oracle/schema/internal/trigger.js

@@ -1,13 +1,21 @@
-const utils = require('../../utils');
+const { NameHelper } = require('../../utils');
 
-const trigger = {
-  renameColumnTrigger: function (logger, tableName, columnName, to) {
-    const triggerName = utils.generateCombinedName(
+class Trigger {
+  constructor(oracleVersion) {
+    this.nameHelper = new NameHelper(oracleVersion);
+  }
+
+  renameColumnTrigger(logger, tableName, columnName, to) {
+    const triggerName = this.nameHelper.generateCombinedName(
       logger,
       'autoinc_trg',
       tableName
     );
-    const sequenceName = utils.generateCombinedName(logger, 'seq', tableName);
+    const sequenceName = this.nameHelper.generateCombinedName(
+      logger,
+      'seq',
+      tableName
+    );
     return (
       `DECLARE ` +
       `PK_NAME VARCHAR(200); ` +
@@ -41,19 +49,19 @@ const trigger = {
       `  end if;` +
       `END;`
     );
-  },
+  }
 
-  createAutoIncrementTrigger: function (logger, tableName, schemaName) {
+  createAutoIncrementTrigger(logger, tableName, schemaName) {
     const tableQuoted = `"${tableName}"`;
     const tableUnquoted = tableName;
     const schemaQuoted = schemaName ? `"${schemaName}".` : '';
     const constraintOwner = schemaName ? `'${schemaName}'` : 'cols.owner';
-    const triggerName = utils.generateCombinedName(
+    const triggerName = this.nameHelper.generateCombinedName(
       logger,
       'autoinc_trg',
       tableName
     );
-    const sequenceNameUnquoted = utils.generateCombinedName(
+    const sequenceNameUnquoted = this.nameHelper.generateCombinedName(
       logger,
       'seq',
       tableName
@@ -86,17 +94,29 @@ const trigger = {
       `  end;'); ` +
       `END;`
     );
-  },
+  }
 
-  renameTableAndAutoIncrementTrigger: function (logger, tableName, to) {
-    const triggerName = utils.generateCombinedName(
+  renameTableAndAutoIncrementTrigger(logger, tableName, to) {
+    const triggerName = this.nameHelper.generateCombinedName(
       logger,
       'autoinc_trg',
       tableName
     );
-    const sequenceName = utils.generateCombinedName(logger, 'seq', tableName);
-    const toTriggerName = utils.generateCombinedName(logger, 'autoinc_trg', to);
-    const toSequenceName = utils.generateCombinedName(logger, 'seq', to);
+    const sequenceName = this.nameHelper.generateCombinedName(
+      logger,
+      'seq',
+      tableName
+    );
+    const toTriggerName = this.nameHelper.generateCombinedName(
+      logger,
+      'autoinc_trg',
+      to
+    );
+    const toSequenceName = this.nameHelper.generateCombinedName(
+      logger,
+      'seq',
+      to
+    );
     return (
       `DECLARE ` +
       `PK_NAME VARCHAR(200); ` +
@@ -129,7 +149,7 @@ const trigger = {
       `  end if;` +
       `END;`
     );
-  },
-};
+  }
+}
 
-module.exports = trigger;
+module.exports = Trigger;

package/lib/dialects/oracle/schema/oracle-compiler.js

@@ -11,7 +11,8 @@ class SchemaCompiler_Oracle extends SchemaCompiler {
 
   // Rename a table on the schema.
   renameTable(tableName, to) {
-    const renameTable = Trigger.renameTableAndAutoIncrementTrigger(
+    const trigger = new Trigger(this.client.version);
+    const renameTable = trigger.renameTableAndAutoIncrementTrigger(
       this.client.logger,
       tableName,
       to
@@ -60,7 +61,8 @@ class SchemaCompiler_Oracle extends SchemaCompiler {
 
   _dropRelatedSequenceIfExists(tableName) {
     // removing the sequence that was possibly generated by increments() column
-    const sequenceName = utils.generateCombinedName(
+    const nameHelper = new utils.NameHelper(this.client.version);
+    const sequenceName = nameHelper.generateCombinedName(
       this.client.logger,
       'seq',
       tableName

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

@@ -39,8 +39,9 @@ class TableCompiler_Oracle extends TableCompiler {
   renameColumn(from, to) {
     // Remove quotes around tableName
     const tableName = this.tableName().slice(1, -1);
+    const trigger = new Trigger(this.client.version);
     return this.pushQuery(
-      Trigger.renameColumnTrigger(this.client.logger, tableName, from, to)
+      trigger.renameColumnTrigger(this.client.logger, tableName, from, to)
     );
   }
 
@@ -86,8 +87,14 @@ class TableCompiler_Oracle extends TableCompiler {
   }
 
   _indexCommand(type, tableName, columns) {
+    const nameHelper = new utils.NameHelper(this.client.version);
     return this.formatter.wrap(
-      utils.generateCombinedName(this.client.logger, type, tableName, columns)
+      nameHelper.generateCombinedName(
+        this.client.logger,
+        type,
+        tableName,
+        columns
+      )
     );
   }
 

package/lib/dialects/oracle/utils.js

@@ -1,25 +1,44 @@
-function generateCombinedName(logger, postfix, name, subNames) {
-  const crypto = require('crypto');
-  const limit = 30;
-  if (!Array.isArray(subNames)) subNames = subNames ? [subNames] : [];
-  const table = name.replace(/\.|-/g, '_');
-  const subNamesPart = subNames.join('_');
-  let result = `${table}_${
-    subNamesPart.length ? subNamesPart + '_' : ''
-  }${postfix}`.toLowerCase();
-  if (result.length > limit) {
-    logger.warn(
-      `Automatically generated name "${result}" exceeds ${limit} character ` +
-        `limit for Oracle. Using base64 encoded sha1 of that name instead.`
-    );
-    // generates the sha1 of the name and encode it with base64
-    result = crypto
-      .createHash('sha1')
-      .update(result)
-      .digest('base64')
-      .replace('=', '');
+class NameHelper {
+  constructor(oracleVersion) {
+    this.oracleVersion = oracleVersion;
+
+    // In oracle versions prior to 12.2, the maximum length for a database
+    // object name was 30 characters. 12.2 extended this to 128.
+    const versionParts = oracleVersion
+      .split('.')
+      .map((versionPart) => parseInt(versionPart));
+    if (
+      versionParts[0] > 12 ||
+      (versionParts[0] === 12 && versionParts[1] >= 2)
+    ) {
+      this.limit = 128;
+    } else {
+      this.limit = 30;
+    }
+  }
+
+  generateCombinedName(logger, postfix, name, subNames) {
+    const crypto = require('crypto');
+    if (!Array.isArray(subNames)) subNames = subNames ? [subNames] : [];
+    const table = name.replace(/\.|-/g, '_');
+    const subNamesPart = subNames.join('_');
+    let result = `${table}_${
+      subNamesPart.length ? subNamesPart + '_' : ''
+    }${postfix}`.toLowerCase();
+    if (result.length > this.limit) {
+      logger.warn(
+        `Automatically generated name "${result}" exceeds ${this.limit} character ` +
+          `limit for Oracle Database ${this.oracleVersion}. Using base64 encoded sha1 of that name instead.`
+      );
+      // generates the sha1 of the name and encode it with base64
+      result = crypto
+        .createHash('sha1')
+        .update(result)
+        .digest('base64')
+        .replace('=', '');
+    }
+    return result;
   }
-  return result;
 }
 
 function wrapSqlWithCatch(sql, errorNumberToCatch) {
@@ -80,7 +99,7 @@ function isConnectionError(err) {
 }
 
 module.exports = {
-  generateCombinedName,
+  NameHelper,
   isConnectionError,
   wrapSqlWithCatch,
   ReturningHelper,

package/lib/dialects/oracledb/index.js

@@ -25,6 +25,13 @@ const { compileCallback } = require('../../formatter/formatterUtils');
 class Client_Oracledb extends Client_Oracle {
   constructor(config) {
     super(config);
+
+    if (this.version) {
+      // Normalize version format; null bad format
+      // to trigger fallback to auto-detect.
+      this.version = parseVersion(this.version);
+    }
+
     if (this.driver) {
       process.env.UV_THREADPOOL_SIZE = process.env.UV_THREADPOOL_SIZE || 1;
       process.env.UV_THREADPOOL_SIZE =
@@ -120,43 +127,40 @@ class Client_Oracledb extends Client_Oracle {
   // Get a raw connection, called by the `pool` whenever a new
   // connection needs to be added to the pool.
   acquireRawConnection() {
-    const client = this;
-    const asyncConnection = new Promise(function (resolver, rejecter) {
+    return new Promise((resolver, rejecter) => {
       // If external authentication don't have to worry about username/password and
       // if not need to set the username and password
-      const oracleDbConfig = client.connectionSettings.externalAuth
-        ? { externalAuth: client.connectionSettings.externalAuth }
+      const oracleDbConfig = this.connectionSettings.externalAuth
+        ? { externalAuth: this.connectionSettings.externalAuth }
         : {
-            user: client.connectionSettings.user,
-            password: client.connectionSettings.password,
+            user: this.connectionSettings.user,
+            password: this.connectionSettings.password,
           };
 
       // In the case of external authentication connection string will be given
       oracleDbConfig.connectString = resolveConnectString(
-        client.connectionSettings
+        this.connectionSettings
       );
 
-      if (client.connectionSettings.prefetchRowCount) {
-        oracleDbConfig.prefetchRows =
-          client.connectionSettings.prefetchRowCount;
+      if (this.connectionSettings.prefetchRowCount) {
+        oracleDbConfig.prefetchRows = this.connectionSettings.prefetchRowCount;
       }
 
-      if (client.connectionSettings.stmtCacheSize !== undefined) {
-        oracleDbConfig.stmtCacheSize = client.connectionSettings.stmtCacheSize;
+      if (this.connectionSettings.stmtCacheSize !== undefined) {
+        oracleDbConfig.stmtCacheSize = this.connectionSettings.stmtCacheSize;
       }
 
-      client.driver.fetchAsString = client.fetchAsString;
+      this.driver.fetchAsString = this.fetchAsString;
 
-      client.driver.getConnection(oracleDbConfig, function (err, connection) {
+      this.driver.getConnection(oracleDbConfig, (err, connection) => {
         if (err) {
           return rejecter(err);
         }
-        monkeyPatchConnection(connection, client);
+        monkeyPatchConnection(connection, this);
 
         resolver(connection);
       });
     });
-    return asyncConnection;
   }
 
   // Used to explicitly close a connection, called internally by the pool
@@ -165,6 +169,39 @@ class Client_Oracledb extends Client_Oracle {
     return connection.release();
   }
 
+  // Handle oracle version resolution on acquiring connection from pool instead of connection creation.
+  // Must do this here since only the client used to create a connection would be updated with version
+  // information on creation. Poses a problem when knex instance is cloned since instances share the
+  // connection pool while having their own client instances.
+  async acquireConnection() {
+    const connection = await super.acquireConnection();
+    this.checkVersion(connection);
+    return connection;
+  }
+
+  // In Oracle, we need to check the version to dynamically determine
+  // certain limits. If user did not specify a version, get it from the connection.
+  checkVersion(connection) {
+    // Already determined version before?
+    if (this.version) {
+      return this.version;
+    }
+
+    const detectedVersion = parseVersion(connection.oracleServerVersionString);
+    if (!detectedVersion) {
+      // When original version is set to null, user-provided version was invalid and we fell-back to auto-detect.
+      // Otherwise, we couldn't auto-detect at all. Set error message accordingly.
+      throw new Error(
+        this.version === null
+          ? 'Invalid Oracledb version number format passed to knex. Unable to successfully auto-detect as fallback. Please specify a valid oracledb version.'
+          : 'Unable to detect Oracledb version number automatically. Please specify the version in knex configuration.'
+      );
+    }
+
+    this.version = detectedVersion;
+    return detectedVersion;
+  }
+
   // Runs the query on the specified connection, providing the bindings
   // and any other necessary prep work.
   _query(connection, obj) {
@@ -300,12 +337,29 @@ class Client_Oracledb extends Client_Oracle {
   }
 
   processPassedConnection(connection) {
+    this.checkVersion(connection);
     monkeyPatchConnection(connection, this);
   }
 }
 
 Client_Oracledb.prototype.driverName = 'oracledb';
 
+function parseVersion(versionString) {
+  try {
+    // We only care about first two version components at most
+    const versionParts = versionString.split('.').slice(0, 2);
+    // Strip off any character suffixes in version number (ex. 12c => 12, 12.2c => 12.2)
+    versionParts.forEach((versionPart, idx) => {
+      versionParts[idx] = versionPart.replace(/\D$/, '');
+    });
+    const version = versionParts.join('.');
+    return version.match(/^\d+\.?\d*$/) ? version : null;
+  } catch (err) {
+    // Non-string versionString passed in.
+    return null;
+  }
+}
+
 function resolveConnectString(connectionSettings) {
   if (connectionSettings.connectString) {
     return connectionSettings.connectString;

package/lib/dialects/postgres/index.js

@@ -194,7 +194,10 @@ class Client_PG extends Client {
 
     return new Promise(function (resolver, rejecter) {
       const queryStream = connection.query(
-        new PGQueryStream(sql, obj.bindings, options)
+        new PGQueryStream(sql, obj.bindings, options),
+        (err) => {
+          rejecter(err);
+        }
       );
 
       queryStream.on('error', function (error) {

package/lib/execution/transaction.js

@@ -219,6 +219,10 @@ class Transaction extends EventEmitter {
           return makeTransactor(this, connection, trxClient);
         })
         .then((transactor) => {
+          this.transactor = transactor;
+          if (this.outerTx) {
+            transactor.parentTransaction = this.outerTx.transactor;
+          }
           transactor.executionPromise = executionPromise;
 
           // If we've returned a "thenable" from the transaction container, assume

package/lib/migrations/migrate/stub/ts.stub

@@ -1,4 +1,4 @@
-import { Knex } from "knex";
+import type { Knex } from "knex";
 
 <% if (d.tableName) { %>
 export async function up(knex: Knex): Promise<Knex.SchemaBuilder> {

package/lib/query/querybuilder.js

@@ -1730,7 +1730,7 @@ Builder.prototype.andWhereRaw = Builder.prototype.whereRaw;
 Builder.prototype.andWhereBetween = Builder.prototype.whereBetween;
 Builder.prototype.andWhereNotBetween = Builder.prototype.whereNotBetween;
 Builder.prototype.andWhereJsonObject = Builder.prototype.whereJsonObject;
-Builder.prototype.andWhereNotJsonObject = Builder.prototype.whereJsonObject;
+Builder.prototype.andWhereNotJsonObject = Builder.prototype.whereNotJsonObject;
 Builder.prototype.andWhereJsonPath = Builder.prototype.whereJsonPath;
 Builder.prototype.andWhereLike = Builder.prototype.whereLike;
 Builder.prototype.andWhereILike = Builder.prototype.whereILike;

package/lib/schema/tablecompiler.js

@@ -418,6 +418,12 @@ class TableCompiler {
       .filter((c) => c.builder._type === 'increments')
       .map((c) => c.builder._args[0]);
   }
+
+  _getBigIncrementsColumnNames() {
+    return this.grouped.columns
+      .filter((c) => c.builder._type === 'bigincrements')
+      .map((c) => c.builder._args[0]);
+  }
 }
 
 TableCompiler.prototype.pushQuery = pushQuery;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "A batteries-included SQL query & schema builder for PostgresSQL, MySQL, CockroachDB, MSSQL and SQLite3",
   "main": "knex",
   "types": "types/index.d.ts",
@@ -17,9 +17,10 @@
     "debug:test": "mocha --inspect-brk --exit -t 0 test/all-tests-suite.js",
     "debug:tape": "node --inspect-brk test/tape/index.js",
     "coveralls": "nyc report --reporter=lcov",
-    "lint": "eslint --cache **/*.js",
-    "lint:fix": "eslint --cache --fix '**/*.js'",
-    "lint:types": "tsd && dtslint types",
+    "lint": "eslint --cache .",
+    "lint:fix": "eslint --cache --fix .",
+    "lint:types": "tsd",
+    "lint:types:legacy": "dtslint types",
     "lint:everything": "npm run lint && npm run lint:types",
     "lint:fix:everything": "npm run lint:fix && npm run lint:types",
     "test:unit": "npm run test:unit-only && npm run test:cli",
@@ -70,7 +71,7 @@
     "getopts": "2.3.0",
     "interpret": "^2.2.0",
     "lodash": "^4.17.21",
-    "pg-connection-string": "2.6.1",
+    "pg-connection-string": "2.6.2",
     "rechoir": "^0.8.0",
     "resolve-from": "^5.0.0",
     "tarn": "^3.0.2",
@@ -106,7 +107,7 @@
   "devDependencies": {
     "@tsconfig/recommended": "^1.0.1",
     "@types/node": "^20.4.0",
-    "better-sqlite3": "^7.6.2",
+    "better-sqlite3": "^9.1.1",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "chai-subset-in-order": "^3.1.0",
@@ -114,9 +115,9 @@
     "coveralls": "^3.1.1",
     "cross-env": "^7.0.3",
     "dtslint": "4.2.1",
-    "eslint": "^8.32.0",
+    "eslint": "^8.54.0",
     "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-mocha-no-only": "^1.1.1",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.1",
@@ -132,14 +133,14 @@
     "pg": "^8.8.0",
     "pg-query-stream": "^4.2.4",
     "prettier": "2.8.7",
-    "rimraf": "^3.0.2",
+    "rimraf": "^5.0.5",
     "sinon": "^15.0.1",
     "sinon-chai": "^3.7.0",
     "source-map-support": "^0.5.21",
     "sqlite3": "^5.0.11",
     "tap-spec": "^5.0.0",
     "tape": "^5.6.0",
-    "tedious": "^14.4.0",
+    "tedious": "^16.6.1",
     "toxiproxy-node-client": "^2.0.6",
     "ts-node": "^10.9.1",
     "tsd": "^0.28.1",

package/types/index.d.ts

@@ -561,7 +561,7 @@ declare namespace Knex {
   type ResolveTableType<
     TCompositeTableType,
     TScope extends TableInterfaceScope = 'base'
-  > = TCompositeTableType extends CompositeTableType<unknown>
+  > = TCompositeTableType extends CompositeTableType<{}>
     ? TCompositeTableType[TScope]
     : TCompositeTableType;
 
@@ -734,6 +734,8 @@ declare namespace Knex {
     orHavingNotIn: HavingRange<TRecord, TResult>;
     havingNull: HavingNull<TRecord, TResult>;
     havingNotNull: HavingNull<TRecord, TResult>;
+    orHavingNull: HavingNull<TRecord, TResult>;
+    orHavingNotNull: HavingNull<TRecord, TResult>;
 
     // Clear
     clearSelect(): QueryBuilder<
@@ -2321,6 +2323,7 @@ declare namespace Knex {
   interface Transaction<TRecord extends {} = any, TResult = any[]>
     extends Knex<TRecord, TResult> {
     executionPromise: Promise<TResult>;
+    parentTransaction?: Transaction;
     isCompleted: () => boolean;
 
     query<TRecord extends {} = any, TResult = void>(
@@ -3043,7 +3046,7 @@ declare namespace Knex {
     host?: string;
     connectionString?: string;
     keepAlive?: boolean;
-    stream?: stream.Duplex;
+    stream?: () => stream.Duplex | stream.Duplex | undefined;
     statement_timeout?: false | number;
     parseInputDatesAsUTC?: boolean;
     ssl?: boolean | ConnectionOptions;