knex 1.0.4 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Master (Unreleased)
 
+# 1.0.5 - 05 March, 2022
+
+### New features:
+
+- Override knexfile options with CLI options #4047
+
+### Bug fixes:
+
+- Stringify json value in update #5063
+- Fix isModuleType() for yarn #4447
+- Wrapped Unions Fixes #5072
+- SQLite: Fix @vscode-sqlite3 error message #5081
+- CLI: Fix completed migration listing #5060
+
+### Typings:
+
+- Make default generic parameters of `Knex` match the generic parameter types of `knex` #5021
+- Update knex types for TS 4.7 #5095
+
 # 1.0.4 - 13 March, 2022
 
 ### New features:

package/bin/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 const rechoir = require('rechoir');
+const merge = require('lodash/merge');
 const interpret = require('interpret');
 const resolveFrom = require('resolve-from');
 const path = require('path');
@@ -9,6 +10,7 @@ const color = require('colorette');
 const argv = require('getopts')(process.argv.slice(2));
 const cliPkg = require('../package');
 const {
+  parseConfigObj,
   mkConfigObj,
   resolveEnvironmentConfig,
   exit,
@@ -59,8 +61,17 @@ async function initKnex(env, opts) {
     env.configuration,
     env.configPath
   );
+
+  const optionsConfig = parseConfigObj(opts);
+  const config = merge(resolvedConfig, optionsConfig);
+
+  // Migrations directory gets defaulted if it is undefined.
+  if (!env.configPath && !config.migrations.directory) {
+    config.migrations.directory = null;
+  }
+
   const knex = require(env.modulePath);
-  return knex(resolvedConfig);
+  return knex(config);
 }
 
 function invoke() {
@@ -138,16 +149,10 @@ function invoke() {
     .option('--knexfile [path]', 'Specify the knexfile path.')
     .option('--knexpath [path]', 'Specify the path to knex instance.')
     .option('--cwd [path]', 'Specify the working directory.')
-    .option('--client [name]', 'Set DB client without a knexfile.')
-    .option('--connection [address]', 'Set DB connection without a knexfile.')
-    .option(
-      '--migrations-directory [path]',
-      'Set migrations directory without a knexfile.'
-    )
-    .option(
-      '--migrations-table-name [path]',
-      'Set migrations table name without a knexfile.'
-    )
+    .option('--client [name]', 'Set DB client.')
+    .option('--connection [address]', 'Set DB connection.')
+    .option('--migrations-directory [path]', 'Set migrations directory.')
+    .option('--migrations-table-name [path]', 'Set migrations table name.')
     .option(
       '--env [name]',
       'environment, default: process.env.NODE_ENV || development'

package/bin/utils/cli-config-utils.js

@@ -1,12 +1,39 @@
 const { DEFAULT_EXT, DEFAULT_TABLE_NAME } = require('./constants');
 const { resolveClientNameWithAliases } = require('../../lib/util/helpers');
-const fs = require('fs');
 const path = require('path');
 const escalade = require('escalade/sync');
 const tildify = require('tildify');
 const color = require('colorette');
 const argv = require('getopts')(process.argv.slice(2));
 
+function findCaseInsensitiveProperty(propertyName, object) {
+  return Object.keys(object).find(
+    (key) => key.toLowerCase() === propertyName.toLowerCase()
+  );
+}
+
+function parseConfigObj(opts) {
+  const config = { migrations: {} };
+
+  if (opts.client) {
+    config.client = opts.client;
+  }
+
+  if (opts.connection) {
+    config.connection = opts.connection;
+  }
+
+  if (opts.migrationsDirectory) {
+    config.migrations.directory = opts.migrationsDirectory;
+  }
+
+  if (opts.migrationsTableName) {
+    config.migrations.tableName = opts.migrationsTableName;
+  }
+
+  return config;
+}
+
 function mkConfigObj(opts) {
   if (!opts.client) {
     throw new Error(
@@ -17,16 +44,14 @@ function mkConfigObj(opts) {
   const envName = opts.env || process.env.NODE_ENV || 'development';
   const resolvedClientName = resolveClientNameWithAliases(opts.client);
   const useNullAsDefault = resolvedClientName === 'sqlite3';
+  const parsedConfig = parseConfigObj(opts);
+
   return {
     ext: DEFAULT_EXT,
     [envName]: {
+      ...parsedConfig,
       useNullAsDefault,
-      client: opts.client,
-      connection: opts.connection,
-      migrations: {
-        directory: opts.migrationsDirectory,
-        tableName: opts.migrationsTableName || DEFAULT_TABLE_NAME,
-      },
+      tableName: parsedConfig.tableName || DEFAULT_TABLE_NAME,
     },
   };
 }
@@ -174,6 +199,7 @@ function findUpConfig(cwd, name, extensions) {
 }
 
 module.exports = {
+  parseConfigObj,
   mkConfigObj,
   resolveEnvironmentConfig,
   exit,

package/bin/utils/migrationsLister.js

@@ -6,7 +6,7 @@ function listMigrations(completed, newMigrations) {
   let message = '';
 
   if (completed.length === 0) {
-    message += color.red('No Completed Migration files Found. \n');
+    message += color.red('No Completed Migration files Found.\n');
   } else {
     message = color.green(
       `Found ${completed.length} Completed Migration file/files.\n`
@@ -14,7 +14,7 @@ function listMigrations(completed, newMigrations) {
 
     for (let i = 0; i < completed.length; i++) {
       const file = completed[i];
-      message += color.cyan(`${file} \n`);
+      message += color.cyan(`${file.name}\n`);
     }
   }
 
@@ -27,7 +27,7 @@ function listMigrations(completed, newMigrations) {
 
     for (let i = 0; i < newMigrations.length; i++) {
       const file = newMigrations[i];
-      message += color.cyan(`${file.file} \n`);
+      message += color.cyan(`${file.file}\n`);
     }
   }
 

package/lib/client.js

@@ -189,7 +189,10 @@ class Client extends EventEmitter {
     try {
       this.driver = this._driver();
     } catch (e) {
-      const message = `Knex: run\n$ npm install ${this.driverName} --save`;
+      const driverName = this.aliasDriverName
+        ? this.aliasDriverName
+        : this.driverName;
+      const message = `Knex: run\n$ npm install ${driverName} --save`;
       this.logger.error(`${message}\n${e.message}\n${e.stack}`);
       throw new Error(`${message}\n${e.message}`);
     }

package/lib/dialects/sqlite3/index.js

@@ -232,6 +232,8 @@ Object.assign(Client_SQLite3.prototype, {
   dialect: 'sqlite3',
 
   driverName: 'sqlite3',
+  // SqlLite3 driver package name is different from driver name.
+  aliasDriverName: '@vscode/sqlite3',
 });
 
 module.exports = Client_SQLite3;

package/lib/migrations/util/is-module-type.js

@@ -1,14 +1,9 @@
-const { readFile } = require('./fs');
+const getPackageType = require('get-package-type');
 
 module.exports = async function isModuleType(filepath) {
-  if (process.env.npm_package_json) {
-    // npm >= 7.0.0
-    const packageJson = JSON.parse(
-      await readFile(process.env.npm_package_json, 'utf-8')
-    );
-    if (packageJson.type === 'module') {
-      return true;
-    }
-  }
-  return process.env.npm_package_type === 'module' || filepath.endsWith('.mjs');
+  return (
+    filepath.endsWith('.mjs') ||
+    (!filepath.endsWith('.cjs') &&
+      (await getPackageType(filepath)) === 'module')
+  );
 };

package/lib/query/querybuilder.js

@@ -1236,7 +1236,11 @@ class Builder extends EventEmitter {
     const obj = this._single.update || {};
     this._method = 'update';
     if (isString(values)) {
-      obj[values] = returning;
+      if (isPlainObject(returning)) {
+        obj[values] = JSON.stringify(returning);
+      } else {
+        obj[values] = returning;
+      }
       if (arguments.length > 2) {
         ret = arguments[2];
       }

package/lib/query/querycompiler.js

@@ -125,16 +125,27 @@ class QueryCompiler {
     let sql = this.with();
 
     let unionStatement = '';
-    // Compute all statements to main query
-    const statements = components.map((component) => {
+
+    const firstStatements = [];
+    const endStatements = [];
+
+    components.forEach((component) => {
       const statement = this[component](this);
       // We store the 'union' statement to append it at the end.
       // We still need to call the component sequentially because of
       // order of bindings.
-      if (component === 'union') {
-        unionStatement = statement;
-      } else {
-        return statement;
+      switch (component) {
+        case 'union':
+          unionStatement = statement;
+          break;
+        case 'columns':
+        case 'join':
+        case 'where':
+          firstStatements.push(statement);
+          break;
+        default:
+          endStatements.push(statement);
+          break;
       }
     });
 
@@ -144,15 +155,22 @@ class QueryCompiler {
     const wrapMainQuery =
       this.grouped.union &&
       this.grouped.union.map((u) => u.wrap).some((u) => u);
-    const allStatements =
-      (wrapMainQuery ? '(' : '') +
-      compact(statements).join(' ') +
-      (wrapMainQuery ? ')' : '');
 
     if (this.onlyUnions()) {
-      sql += unionStatement + ' ' + allStatements;
+      const statements = compact(firstStatements.concat(endStatements)).join(
+        ' '
+      );
+      sql += unionStatement + (statements ? ' ' + statements : '');
     } else {
-      sql += allStatements + (unionStatement ? ' ' + unionStatement : '');
+      const allStatements =
+        (wrapMainQuery ? '(' : '') +
+        compact(firstStatements).join(' ') +
+        (wrapMainQuery ? ')' : '');
+      const endStat = compact(endStatements).join(' ');
+      sql +=
+        allStatements +
+        (unionStatement ? ' ' + unionStatement : '') +
+        (endStat ? ' ' + endStat : endStat);
     }
     return sql;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A batteries-included SQL query & schema builder for PostgresSQL, MySQL, CockroachDB, MSSQL and SQLite3",
   "main": "knex",
   "types": "types/index.d.ts",
@@ -55,10 +55,11 @@
   },
   "dependencies": {
     "colorette": "2.0.16",
-    "commander": "^8.3.0",
-    "debug": "4.3.3",
+    "commander": "^9.1.0",
+    "debug": "4.3.4",
     "escalade": "^3.1.1",
     "esm": "^3.2.25",
+    "get-package-type": "^0.1.0",
     "getopts": "2.3.0",
     "interpret": "^2.2.0",
     "lodash": "^4.17.21",
@@ -111,6 +112,7 @@
     "eslint": "^8.8.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-mocha-no-only": "^1.1.1",
     "husky": "^4.3.8",
     "jake": "^8.1.1",
     "JSONStream": "^1.3.5",
@@ -123,17 +125,17 @@
     "oracledb": "^5.3.0",
     "pg": "^8.7.1",
     "pg-query-stream": "^4.2.1",
-    "prettier": "2.5.1",
+    "prettier": "2.6.2",
     "rimraf": "^3.0.2",
     "sinon": "^13.0.1",
     "sinon-chai": "^3.7.0",
     "source-map-support": "^0.5.21",
     "tap-spec": "^5.0.0",
     "tape": "^5.5.0",
-    "tedious": "^12.3.0",
+    "tedious": "^14.3.0",
     "toxiproxy-node-client": "^2.0.6",
     "ts-node": "^10.4.0",
-    "tsd": "^0.19.1",
+    "tsd": "^0.20.0",
     "typescript": "4.5.5"
   },
   "buildDependencies": [

package/types/index.d.ts

@@ -30,6 +30,11 @@ type StrKey<T> = string & keyof T;
 
 // If T is unknown then convert to any, else retain original
 type UnknownToAny<T> = unknown extends T ? any : T;
+type CurlyCurlyToAny<T> = T extends unknown ? // distribute
+  (<U>() => U extends T ? 0 : 1) extends
+  (<U>() => U extends {} ? 0 : 1) ? any : T
+  : never;
+type UnknownOrCurlyCurlyToAny<T> = [UnknownToAny<T> | CurlyCurlyToAny<T>][0];
 type AnyToUnknown<T> = unknown extends T ? unknown : T;
 type AnyOrUnknownToOther<T1, T2> = unknown extends T1 ? T2 : T1;
 
@@ -193,7 +198,7 @@ declare namespace DeferredKeySelection {
     ? DeferredKeySelection<TBase, TKeys | TKey, true, TAliasMapping, TSingle, TIntersectProps, TUnionProps>
     : DeferredKeySelection<unknown, TKey, true>;
 
-  type AddAliases<TSelection, T> = TSelection extends DeferredKeySelection<
+  type AddAliases<TSelection, T extends {}> = TSelection extends DeferredKeySelection<
     infer TBase,
     infer TKeys,
     infer THasSelect,
@@ -219,7 +224,7 @@ declare namespace DeferredKeySelection {
 
   // Convenience utility to set base, keys and aliases in a single type
   // application
-  type Augment<T, TBase, TKey extends string, TAliasMapping = {}> = AddAliases<
+  type Augment<T, TBase, TKey extends string, TAliasMapping extends {} = {}> = AddAliases<
     AddKey<SetBase<T, TBase>, TKey>,
     TAliasMapping
   >;
@@ -234,7 +239,7 @@ declare namespace DeferredKeySelection {
     infer TIntersectProps,
     infer TUnionProps
   >
-    ? UnknownToAny<
+    ? UnknownOrCurlyCurlyToAny<
       // ^ We convert final result to any if it is unknown for backward compatibility.
       //   Historically knex typings have been liberal with returning any and changing
       //   default return type to unknown would be a major breaking change for users.
@@ -263,11 +268,11 @@ declare namespace DeferredKeySelection {
     : TSelection extends DeferredKeySelection.Any[]
     ? Knex.ResolveTableType<ResolveOne<TSelection[0]>>[]
     : TSelection extends (infer I)[]
-    ? UnknownToAny<Knex.ResolveTableType<I>>[]
-    : UnknownToAny<Knex.ResolveTableType<TSelection>>;
+    ? UnknownOrCurlyCurlyToAny<Knex.ResolveTableType<I>>[]
+    : UnknownOrCurlyCurlyToAny<Knex.ResolveTableType<TSelection>>;
 }
 
-type AggregationQueryResult<TResult, TIntersectProps2> = ArrayIfAlready<
+type AggregationQueryResult<TResult, TIntersectProps2 extends {}> = ArrayIfAlready<
   TResult,
   UnwrapArrayMember<TResult> extends DeferredKeySelection<
     infer TBase,
@@ -307,13 +312,13 @@ interface DMLOptions {
   includeTriggerModifications?: boolean;
 }
 
-export interface Knex<TRecord extends {} = any, TResult = Record<string, any>[]>
+export interface Knex<TRecord extends {} = any, TResult = any[]>
   extends Knex.QueryInterface<TRecord, TResult>, events.EventEmitter {
   <TTable extends Knex.TableNames>(
     tableName: TTable,
     options?: TableOptions
   ): Knex.QueryBuilder<Knex.TableType<TTable>, DeferredKeySelection<Knex.ResolveTableType<Knex.TableType<TTable>>, never>[]>;
-  <TRecord2 = TRecord, TResult2 = DeferredKeySelection<TRecord2, never>[]>(
+  <TRecord2 extends {} = TRecord, TResult2 = DeferredKeySelection<TRecord2, never>[]>(
     tableName?: Knex.TableDescriptor | Knex.AliasDict,
     options?: TableOptions
   ): Knex.QueryBuilder<TRecord2, TResult2>;
@@ -340,7 +345,7 @@ export interface Knex<TRecord extends {} = any, TResult = Record<string, any>[]>
   destroy(callback: Function): void;
   destroy(): Promise<void>;
 
-  batchInsert<TRecord2 = TRecord, TResult2 = number[]>(
+  batchInsert<TRecord2 extends {} = TRecord, TResult2 = number[]>(
     tableName: Knex.TableDescriptor,
     data: TRecord2 extends Knex.CompositeTableType<unknown>
       ? ReadonlyArray<Knex.ResolveTableType<TRecord2, 'insert'>>
@@ -349,7 +354,7 @@ export interface Knex<TRecord extends {} = any, TResult = Record<string, any>[]>
   ): Knex.BatchInsertBuilder<TRecord2, TResult2>;
 
   schema: Knex.SchemaBuilder;
-  queryBuilder<TRecord2 = TRecord, TResult2 = TResult>(): Knex.QueryBuilder<
+  queryBuilder<TRecord2 extends {} = TRecord, TResult2 = TResult>(): Knex.QueryBuilder<
     TRecord2,
     TResult2
   >;
@@ -405,7 +410,7 @@ export declare namespace Knex {
   interface ValueDict extends Dict<Value | Knex.QueryBuilder> {}
   interface AliasDict extends Dict<string> {}
 
-  type ColumnDescriptor<TRecord, TResult> =
+  type ColumnDescriptor<TRecord extends {}, TResult> =
     | string
     | Knex.Raw
     | Knex.QueryBuilder<TRecord, TResult>
@@ -452,7 +457,7 @@ export declare namespace Knex {
     ? TCompositeTableType[TScope]
     : TCompositeTableType;
 
-  interface OnConflictQueryBuilder<TRecord, TResult> {
+  interface OnConflictQueryBuilder<TRecord extends {}, TResult> {
     ignore(): QueryBuilder<TRecord, TResult>;
     merge(mergeColumns?: (keyof TRecord)[]): QueryBuilder<TRecord, TResult>;
     merge(data?: Extract<DbRecord<ResolveTableType<TRecord, 'update'>>, object>): QueryBuilder<TRecord, TResult>;
@@ -1026,7 +1031,7 @@ export declare namespace Knex {
     truncate(): QueryBuilder<TRecord, void>;
   }
 
-  interface As<TRecord, TResult> {
+  interface As<TRecord extends {}, TResult> {
     (columnName: keyof TRecord): QueryBuilder<TRecord, TResult>;
     (columnName: string): QueryBuilder<TRecord, TResult>;
   }
@@ -1042,7 +1047,7 @@ export declare namespace Knex {
         Dict,
         {}
       >
-    >;
+    > & {}; // filters out `null` and `undefined`
 
   interface AliasQueryBuilder<TRecord extends {} = any, TResult = unknown[]> {
     <
@@ -1099,11 +1104,11 @@ export declare namespace Knex {
     ColumnNameQueryBuilder<TRecord, TResult> {
     (): QueryBuilder<TRecord, TResult>;
 
-    <TResult2 = ArrayIfAlready<TResult, any>, TInnerRecord = any, TInnerResult = any>(
+    <TResult2 = ArrayIfAlready<TResult, any>, TInnerRecord extends {} = any, TInnerResult = any>(
       ...subQueryBuilders: readonly QueryBuilder<TInnerRecord, TInnerResult>[]
     ): QueryBuilder<TRecord, TResult2>;
 
-    <TResult2 = ArrayIfAlready<TResult, any>, TInnerRecord = any, TInnerResult = any>(
+    <TResult2 = ArrayIfAlready<TResult, any>, TInnerRecord extends {} = any, TInnerResult = any>(
       subQueryBuilders: readonly QueryBuilder<TInnerRecord, TInnerResult>[]
     ): QueryBuilder<TRecord, TResult2>;
   }
@@ -1115,53 +1120,53 @@ export declare namespace Knex {
     singleValue?: boolean;
   }
 
-  interface JsonExtract<TRecord extends {} = any, TResult extends {} = any> {
+  interface JsonExtract<TRecord extends {} = any, TResult = any> {
     (column: string | Raw | QueryBuilder, path: string, alias?: string, singleValue?: boolean): QueryBuilder<TRecord, TResult>;
     (column: JsonExtraction[] | any[][], singleValue?: boolean): QueryBuilder<TRecord, TResult>;
   }
 
-  interface JsonSet<TRecord extends {} = any, TResult extends {} = any> {
+  interface JsonSet<TRecord extends {} = any, TResult = any> {
     (column: string | Raw | QueryBuilder, path: string, value: any, alias?: string): QueryBuilder<TRecord, TResult>;
   }
 
-  interface JsonInsert<TRecord extends {} = any, TResult extends {} = any> {
+  interface JsonInsert<TRecord extends {} = any, TResult = any> {
     (column: string | Raw | QueryBuilder, path: string, value: any, alias?: string): QueryBuilder<TRecord, TResult>;
   }
 
-  interface JsonRemove<TRecord extends {} = any, TResult extends {} = any> {
+  interface JsonRemove<TRecord extends {} = any, TResult = any> {
     (column: string | Raw | QueryBuilder, path: string, alias?: string): QueryBuilder<TRecord, TResult>;
   }
 
-  interface HintComment<TRecord extends {} = any, TResult extends {} = any> {
+  interface HintComment<TRecord extends {} = any, TResult = any> {
     (hint: string): QueryBuilder<TRecord, TResult>;
     (hints: readonly string[]): QueryBuilder<TRecord, TResult>;
   }
 
-  interface Table<TRecord extends {} = any, TResult extends {} = any> {
+  interface Table<TRecord extends {} = any, TResult = any> {
     <
       TTable extends TableNames,
-      TRecord2 = TableType<TTable>,
+      TRecord2 extends {} = TableType<TTable>,
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, ResolveTableType<TRecord2>>
       >(
       tableName: TTable,
       options?: TableOptions
     ): QueryBuilder<TRecord2, TResult2>;
     <
-      TRecord2 = unknown,
+      TRecord2 extends {} = {},
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       tableName: TableDescriptor | AliasDict,
       options?: TableOptions
     ): QueryBuilder<TRecord2, TResult2>;
     <
-      TRecord2 = unknown,
+      TRecord2 extends {} = {},
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       callback: Function,
       options?: TableOptions
     ): QueryBuilder<TRecord2, TResult2>;
     <
-      TRecord2 = unknown,
+      TRecord2 extends {} = {},
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       raw: Raw,
@@ -1199,7 +1204,7 @@ export declare namespace Knex {
     ): QueryBuilder<TRecord2, TResult2>;
     <
       TTable extends TableNames,
-      TRecord2 = ResolveTableType<TRecord> &
+      TRecord2 extends {} = ResolveTableType<TRecord> &
       ResolveTableType<TableType<TTable>>,
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
@@ -1236,7 +1241,7 @@ export declare namespace Knex {
       TKey1 extends StrKey<ResolveTableType<TableType<TTable1>>> & StrKey<TRecord1>,
       TKey2 extends StrKey<ResolveTableType<TableType<TTable2>>>,
       TRecord1 = ResolveTableType<TRecord>,
-      TRecord2 = TRecord1 & ResolveTableType<TableType<TTable2>>,
+      TRecord2 extends {} = TRecord1 & ResolveTableType<TableType<TTable2>>,
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       tableName: TTable2,
@@ -1249,7 +1254,7 @@ export declare namespace Knex {
       TKey1 extends StrKey<ResolveTableType<TableType<TTable1>>> & StrKey<TRecord1>,
       TKey2 extends StrKey<ResolveTableType<TableType<TTable2>>>,
       TRecord1 = ResolveTableType<TRecord>,
-      TRecord2 = TRecord1 & ResolveTableType<TableType<TTable2>>,
+      TRecord2 extends {} = TRecord1 & ResolveTableType<TableType<TTable2>>,
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       tableName: TTable2,
@@ -1280,7 +1285,7 @@ export declare namespace Knex {
       TKey1 extends StrKey<ResolveTableType<TableType<TTable1>>> & StrKey<TRecord1>,
       TKey2 extends StrKey<ResolveTableType<TableType<TTable2>>>,
       TRecord1 = ResolveTableType<TRecord>,
-      TRecord2 = TRecord1 & ResolveTableType<TableType<TTable2>>,
+      TRecord2 extends {} = TRecord1 & ResolveTableType<TableType<TTable2>>,
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       tableName: TTable2,
@@ -1294,7 +1299,7 @@ export declare namespace Knex {
       TKey1 extends StrKey<ResolveTableType<TableType<TTable1>>> & StrKey<TRecord1>,
       TKey2 extends StrKey<ResolveTableType<TableType<TTable2>>>,
       TRecord1 = ResolveTableType<TRecord>,
-      TRecord2 = TRecord1 & ResolveTableType<TableType<TTable2>>,
+      TRecord2 extends {} = TRecord1 & ResolveTableType<TableType<TTable2>>,
       TResult2 = DeferredKeySelection.ReplaceBase<TResult, TRecord2>
       >(
       tableName: TTable2,
@@ -1371,22 +1376,22 @@ export declare namespace Knex {
     type(type: string): JoinClause;
   }
 
-  interface JoinRaw<TRecord = any, TResult = unknown[]> {
+  interface JoinRaw<TRecord extends {} = any, TResult = unknown[]> {
     (tableName: string, binding?: Value | Value[] | ValueDict): QueryBuilder<
       TRecord,
       TResult
     >;
   }
 
-  interface Using<TRecord = any, TResult = unknown[]> {
+  interface Using<TRecord extends {} = any, TResult = unknown[]> {
     (tables: string[]): QueryBuilder<TRecord, TResult>;
   }
 
-  interface With<TRecord = any, TResult = unknown[]>
+  interface With<TRecord extends {} = any, TResult = unknown[]>
     extends WithRaw<TRecord, TResult>,
     WithWrapped<TRecord, TResult> {}
 
-  interface WithRaw<TRecord = any, TResult = unknown[]> {
+  interface WithRaw<TRecord extends {} = any, TResult = unknown[]> {
     (alias: string, raw: Raw | QueryBuilder): QueryBuilder<TRecord, TResult>;
     (alias: string, sql: string, bindings?: readonly Value[] | Object): QueryBuilder<
       TRecord,
@@ -1399,11 +1404,11 @@ export declare namespace Knex {
     >;
   }
 
-  interface WithSchema<TRecord = any, TResult = unknown[]> {
+  interface WithSchema<TRecord extends {} = any, TResult = unknown[]> {
     (schema: string): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WithWrapped<TRecord = any, TResult = unknown[]> {
+  interface WithWrapped<TRecord extends {} = any, TResult = unknown[]> {
     (alias: string, queryBuilder: QueryBuilder): QueryBuilder<TRecord, TResult>;
     (
       alias: string,
@@ -1417,7 +1422,7 @@ export declare namespace Knex {
     ): QueryBuilder<TRecord, TResult>;
   }
 
-  interface Where<TRecord = any, TResult = unknown>
+  interface Where<TRecord extends {} = any, TResult = unknown>
     extends WhereRaw<TRecord, TResult>,
     WhereWrapped<TRecord, TResult>,
     WhereNull<TRecord, TResult> {
@@ -1447,13 +1452,13 @@ export declare namespace Knex {
       TResult
     >;
 
-    <T extends keyof ResolveTableType<TRecord>, TRecordInner, TResultInner>(
+    <T extends keyof ResolveTableType<TRecord>, TRecordInner extends {}, TResultInner>(
       columnName: T,
       operator: ComparisonOperator,
       value: QueryBuilder<TRecordInner, TResultInner>
     ): QueryBuilder<TRecord, TResult>;
 
-    <TRecordInner, TResultInner>(
+    <TRecordInner extends {}, TResultInner>(
       columnName: string,
       operator: string,
       value: QueryBuilder<TRecordInner, TResultInner>
@@ -1464,28 +1469,28 @@ export declare namespace Knex {
       TResult
     >;
 
-    <TRecordInner, TResultInner>(
+    <TRecordInner extends {}, TResultInner>(
       left: Raw,
       operator: string,
       right: QueryBuilder<TRecordInner, TResultInner>
     ): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereRaw<TRecord = any, TResult = unknown[]>
+  interface WhereRaw<TRecord extends {} = any, TResult = unknown[]>
     extends RawQueryBuilder<TRecord, TResult> {
     (condition: boolean): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereWrapped<TRecord = any, TResult = unknown[]> {
+  interface WhereWrapped<TRecord extends {} = any, TResult = unknown[]> {
     (callback: QueryCallback<TRecord, TResult>): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereNull<TRecord = any, TResult = unknown[]> {
+  interface WhereNull<TRecord extends {} = any, TResult = unknown[]> {
     (columnName: keyof TRecord): QueryBuilder<TRecord, TResult>;
     (columnName: string): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereBetween<TRecord = any, TResult = unknown[]> {
+  interface WhereBetween<TRecord extends {} = any, TResult = unknown[]> {
     <K extends keyof TRecord>(
       columnName: K,
       range: readonly [DbColumn<TRecord[K]>, DbColumn<TRecord[K]>]
@@ -1493,22 +1498,22 @@ export declare namespace Knex {
     (columnName: string, range: readonly [Value, Value]): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereExists<TRecord = any, TResult = unknown[]> {
+  interface WhereExists<TRecord extends {} = any, TResult = unknown[]> {
     (callback: QueryCallback<TRecord, TResult>): QueryBuilder<TRecord, TResult>;
-    <TRecordInner, TResultInner>(
+    <TRecordInner extends {}, TResultInner>(
       query: QueryBuilder<TRecordInner, TResultInner>
     ): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereJsonObject<TRecord = any, TResult = unknown[]> {
+  interface WhereJsonObject<TRecord extends {} = any, TResult = unknown[]> {
     (columnName: keyof TRecord, value: any): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereJsonPath<TRecord = any, TResult = unknown[]> {
+  interface WhereJsonPath<TRecord extends {} = any, TResult = unknown[]> {
     (columnName: keyof TRecord, jsonPath: string, operator: string, value: any): QueryBuilder<TRecord, TResult>;
   }
 
-  interface WhereIn<TRecord = any, TResult = unknown[]> {
+  interface WhereIn<TRecord extends {} = any, TResult = unknown[]> {
     <K extends keyof ResolveTableType<TRecord>>(
       columnName: K,
       values: readonly DbColumn<ResolveTableType<TRecord>[K]>[] | QueryCallback
@@ -1525,19 +1530,19 @@ export declare namespace Knex {
       TRecord,
       TResult
     >;
-    <K extends keyof TRecord, TRecordInner, TResultInner>(
+    <K extends keyof TRecord, TRecordInner extends {}, TResultInner>(
       columnName: K,
       values: QueryBuilder<TRecordInner, TRecord[K]>
     ): QueryBuilder<TRecord, TResult>;
-    <TRecordInner, TResultInner>(
+    <TRecordInner extends {}, TResultInner>(
       columnName: string,
       values: Value[] | QueryBuilder<TRecordInner, TResultInner>
     ): QueryBuilder<TRecord, TResult>;
-    <K extends keyof TRecord, TRecordInner, TResultInner>(
+    <K extends keyof TRecord, TRecordInner extends {}, TResultInner>(
       columnNames: readonly K[],
       values: QueryBuilder<TRecordInner, TRecord[K]>
     ): QueryBuilder<TRecord, TResult>;
-    <TRecordInner, TResultInner>(
+    <TRecordInner extends {}, TResultInner>(
       columnNames: readonly string[],
       values: QueryBuilder<TRecordInner, TResultInner>
     ): QueryBuilder<TRecord, TResult>;
@@ -1547,7 +1552,7 @@ export declare namespace Knex {
   // by extracting out a common base interface will not work because order of overloads
   // is significant.
 
-  interface AsymmetricAggregation<TRecord = any, TResult = unknown[], TValue = any> {
+  interface AsymmetricAggregation<TRecord extends {} = any, TResult = unknown[], TValue = any> {
     <
       TOptions extends { "as": string },
       TResult2 = AggregationQueryResult<TResult, {[k in TOptions["as"]]: TValue}>
@@ -1567,7 +1572,7 @@ export declare namespace Knex {
     ): QueryBuilder<TRecord, TResult2>;
   }
 
-  interface TypePreservingAggregation<TRecord = any, TResult = unknown[], TValue = any> {
+  interface TypePreservingAggregation<TRecord extends {} = any, TResult = unknown[], TValue = any> {
     <
       TKey extends keyof ResolveTableType<TRecord>,
       TOptions extends { "as": string },
@@ -1599,7 +1604,7 @@ export declare namespace Knex {
     ): QueryBuilder<TRecord, TResult2>;
   }
 
-  interface AnalyticFunction<TRecord = any, TResult = unknown[]> {
+  interface AnalyticFunction<TRecord extends {} = any, TResult = unknown[]> {
     <
       TAlias extends string,
       TResult2 = AggregationQueryResult<TResult, {[x in TAlias]: number}>
@@ -1617,11 +1622,11 @@ export declare namespace Knex {
       >;
   }
 
-  interface GroupBy<TRecord = any, TResult = unknown[]>
+  interface GroupBy<TRecord extends {} = any, TResult = unknown[]>
     extends RawQueryBuilder<TRecord, TResult>,
     ColumnNameQueryBuilder<TRecord, TResult> {}
 
-  interface OrderBy<TRecord = any, TResult = unknown[]> {
+  interface OrderBy<TRecord extends {} = any, TResult = unknown[]> {
     (columnName: keyof TRecord | QueryBuilder, order?: 'asc' | 'desc', nulls?: 'first' | 'last'): QueryBuilder<
       TRecord,
       TResult
@@ -1645,10 +1650,10 @@ export declare namespace Knex {
     ): QueryBuilder<TRecord, TResult>;
   }
 
-  interface PartitionBy<TRecord = any, TResult = unknown[]>
+  interface PartitionBy<TRecord extends {} = any, TResult = unknown[]>
     extends OrderBy<TRecord, TResult> {}
 
-  interface Intersect<TRecord = any, TResult = unknown[]> {
+  interface Intersect<TRecord extends {} = any, TResult = unknown[]> {
     (
       callback: MaybeArray<QueryCallback | QueryBuilder<TRecord> | Raw>,
       wrap?: boolean
@@ -1658,10 +1663,10 @@ export declare namespace Knex {
     ): QueryBuilder<TRecord, TResult>;
   }
 
-  interface Union<TRecord = any, TResult = unknown[]>
+  interface Union<TRecord extends {} = any, TResult = unknown[]>
     extends Intersect<TRecord, TResult> {}
 
-  interface Having<TRecord = any, TResult = unknown[]>
+  interface Having<TRecord extends {} = any, TResult = unknown[]>
     extends WhereWrapped<TRecord, TResult> {
     <K extends keyof TRecord>(
       column: K,
@@ -1681,7 +1686,7 @@ export declare namespace Knex {
     >;
   }
 
-  interface HavingRange<TRecord = any, TResult = unknown[]> {
+  interface HavingRange<TRecord extends {} = any, TResult = unknown[]> {
     <K extends keyof TRecord>(
       columnName: K,
       values: readonly DbColumn<TRecord[K]>[]
@@ -1691,7 +1696,7 @@ export declare namespace Knex {
 
   // commons
 
-  interface ColumnNameQueryBuilder<TRecord = any, TResult = unknown[]> {
+  interface ColumnNameQueryBuilder<TRecord extends {} = any, TResult = unknown[]> {
     // When all columns are known to be keys of original record,
     // we can extend our selection by these columns
     (columnName: '*'): QueryBuilder<
@@ -1746,7 +1751,7 @@ export declare namespace Knex {
 
   type RawBinding = Value | QueryBuilder;
 
-  interface RawQueryBuilder<TRecord = any, TResult = unknown[]> {
+  interface RawQueryBuilder<TRecord extends {} = any, TResult = unknown[]> {
     <TResult2 = TResult>(
       sql: string,
       bindings?: readonly RawBinding[] | ValueDict | RawBinding
@@ -1834,12 +1839,12 @@ export declare namespace Knex {
   // QueryBuilder
   //
 
-  type QueryCallback<TRecord = any, TResult = unknown[]> = (
+  type QueryCallback<TRecord extends {} = any, TResult = unknown[]> = (
     this: QueryBuilder<TRecord, TResult>,
     builder: QueryBuilder<TRecord, TResult>
   ) => void;
 
-  type QueryCallbackWithArgs<TRecord = any, TResult = unknown[]> = (
+  type QueryCallbackWithArgs<TRecord extends {} = any, TResult = unknown[]> = (
     this: QueryBuilder<TRecord, TResult>,
     builder: QueryBuilder<TRecord, TResult>,
     ...args: any[]