knex 2.2.0 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # 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:
+
+- PostgreSQL: Explicit jsonb support for custom pg clients #5201
+- SQLite: Support returning with sqlite3 and better-sqlite3 #5285
+- MSSQL: Implement mapBinding mssql dialect option #5292
+
+### Typings:
+
+- Update types for TS 4.8 #5279
+- Fix typo #5267
+- Fix WhereJsonObject withCompositeTableType #5306
+- Fix AnalyticFunction type #5304
+- Infer specific column value type in aggregations #5297
+
 # 2.2.0 - 19 July, 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/index.js

@@ -333,14 +333,24 @@ class Client_MSSQL extends Client {
   _typeForBinding(binding) {
     const Driver = this._driver();
 
+    if (
+      this.connectionSettings.options &&
+      this.connectionSettings.options.mapBinding
+    ) {
+      const result = this.connectionSettings.options.mapBinding(binding);
+      if (result) {
+        return [result.value, result.type];
+      }
+    }
+
     switch (typeof binding) {
       case 'string':
-        return Driver.TYPES.NVarChar;
+        return [binding, Driver.TYPES.NVarChar];
       case 'boolean':
-        return Driver.TYPES.Bit;
+        return [binding, Driver.TYPES.Bit];
       case 'number': {
         if (binding % 1 !== 0) {
-          return Driver.TYPES.Float;
+          return [binding, Driver.TYPES.Float];
         }
 
         if (binding < SQL_INT4.MIN || binding > SQL_INT4.MAX) {
@@ -350,25 +360,21 @@ class Client_MSSQL extends Client {
             );
           }
 
-          return Driver.TYPES.BigInt;
+          return [binding, Driver.TYPES.BigInt];
         }
 
-        return Driver.TYPES.Int;
+        return [binding, Driver.TYPES.Int];
       }
       default: {
-        // if (binding === null || typeof binding === 'undefined') {
-        //   return tedious.TYPES.Null;
-        // }
-
         if (binding instanceof Date) {
-          return Driver.TYPES.DateTime;
+          return [binding, Driver.TYPES.DateTime];
         }
 
         if (binding instanceof Buffer) {
-          return Driver.TYPES.VarBinary;
+          return [binding, Driver.TYPES.VarBinary];
         }
 
-        return Driver.TYPES.NVarChar;
+        return [binding, Driver.TYPES.NVarChar];
       }
     }
   }
@@ -401,8 +407,8 @@ class Client_MSSQL extends Client {
   }
 
   // sets a request input parameter. Detects bigints and decimals and sets type appropriately.
-  _setReqInput(req, i, binding) {
-    const tediousType = this._typeForBinding(binding);
+  _setReqInput(req, i, inputBinding) {
+    const [binding, tediousType] = this._typeForBinding(inputBinding);
     const bindingName = 'p'.concat(i);
     let options;
 

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-columncompiler.js

@@ -145,6 +145,7 @@ function jsonColumn(client, jsonb) {
   if (
     !client.version ||
     client.config.client === 'cockroachdb' ||
+    client.config.jsonbSupport === true ||
     parseFloat(client.version) >= 9.2
   ) {
     return jsonb ? 'jsonb' : 'json';

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/index.js

@@ -126,6 +126,8 @@ class Client_SQLite3 extends Client {
     switch (method) {
       case 'insert':
       case 'update':
+        callMethod = obj.returning ? 'all' : 'run';
+        break;
       case 'counter':
       case 'del':
         callMethod = 'run';
@@ -190,16 +192,18 @@ class Client_SQLite3 extends Client {
           if (response) {
             return response;
           }
-
-          // ToDo Implement after https://github.com/microsoft/vscode-node-sqlite3/issues/15 is resolved
-          this.logger.warn(
-            'node-sqlite3 does not currently support RETURNING clause'
-          );
         }
         return [ctx.lastID];
       }
+      case 'update': {
+        if (returning) {
+          if (response) {
+            return response;
+          }
+        }
+        return ctx.changes;
+      }
       case 'del':
-      case 'update':
       case 'counter':
         return ctx.changes;
       default: {

package/lib/dialects/sqlite3/query/sqlite-querycompiler.js

@@ -149,6 +149,23 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
     };
   }
 
+  // Compiles an `update` query, allowing for a return value.
+  update() {
+    const withSQL = this.with();
+    const updateData = this._prepUpdate(this.single.update);
+    const wheres = this.where();
+    const { returning } = this.single;
+    return {
+      sql:
+        withSQL +
+        `update ${this.single.only ? 'only ' : ''}${this.tableName} ` +
+        `set ${updateData.join(', ')}` +
+        (wheres ? ` ${wheres}` : '') +
+        this._returning(returning),
+      returning,
+    };
+  }
+
   _ignore(columns) {
     if (columns === true) {
       return ' on conflict do nothing';

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/formatter/wrappingFormatter.js

@@ -225,8 +225,7 @@ function rawOrFn(value, method, builder, client, bindingHolder) {
       compileCallback(value, method, client, bindingHolder),
       undefined,
       builder,
-      client,
-      bindingHolder
+      client
     );
   }
   return unwrapRaw(value, undefined, builder, client, bindingHolder) || '';

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.2.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",
@@ -105,8 +105,8 @@
   },
   "devDependencies": {
     "@tsconfig/recommended": "^1.0.1",
-    "@types/node": "^18.0.4",
-    "better-sqlite3": "^7.5.1",
+    "@types/node": "^18.7.14",
+    "better-sqlite3": "^7.6.2",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "chai-subset-in-order": "^3.1.0",
@@ -123,26 +123,26 @@
     "JSONStream": "^1.3.5",
     "lint-staged": "^13.0.0",
     "mocha": "^10.0.0",
-    "mock-fs": "^5.1.2",
+    "mock-fs": "^5.1.4",
     "mysql": "^2.18.1",
     "mysql2": "^2.3.3",
     "nyc": "^15.1.0",
-    "oracledb": "^5.3.0",
-    "pg": "^8.7.3",
-    "pg-query-stream": "^4.2.1",
+    "oracledb": "^5.4.0",
+    "pg": "^8.8.0",
+    "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.4",
+    "sqlite3": "^5.0.11",
     "tap-spec": "^5.0.0",
-    "tape": "^5.5.3",
+    "tape": "^5.6.0",
     "tedious": "^14.4.0",
     "toxiproxy-node-client": "^2.0.6",
-    "ts-node": "^10.7.0",
-    "tsd": "^0.22.0",
-    "typescript": "4.7.4"
+    "ts-node": "^10.9.1",
+    "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

@@ -444,7 +444,7 @@ export declare namespace knex {
   class QueryBuilder {
     static extend(
       methodName: string,
-      fn: <TRecord extends {} = any, TResult = unknown[]>(
+      fn: <TRecord extends {} = any, TResult extends {} = unknown[]>(
         this: Knex.QueryBuilder<TRecord, TResult>,
         ...args: any[]
       ) =>
@@ -1760,12 +1760,12 @@ export declare namespace Knex {
   }
 
   interface WhereJsonObject<TRecord extends {} = any, TResult = unknown[]> {
-    (columnName: keyof TRecord, value: any): QueryBuilder<TRecord, TResult>;
+    (columnName: keyof ResolveTableType<TRecord>, value: any): QueryBuilder<TRecord, TResult>;
   }
 
   interface WhereJsonPath<TRecord extends {} = any, TResult = unknown[]> {
     (
-      columnName: keyof TRecord,
+      columnName: keyof ResolveTableType<TRecord>,
       jsonPath: string,
       operator: string,
       value: any
@@ -1864,7 +1864,7 @@ export declare namespace Knex {
         }
       >
     >(
-      columnName: Readonly<TKey>,
+      columnName: TKey,
       options: Readonly<TOptions>
     ): QueryBuilder<TRecord, TResult2>;
     <
@@ -1918,11 +1918,11 @@ export declare namespace Knex {
         | TKey
         | TKey[]
         | {
-            columnName: TKey;
+            column: TKey;
             order?: 'asc' | 'desc';
             nulls?: 'first' | 'last';
           },
-      partitionBy?: TKey | TKey[] | { columnName: TKey; order?: 'asc' | 'desc' }
+      partitionBy?: TKey | TKey[] | { column: TKey; order?: 'asc' | 'desc' }
     ): QueryBuilder<TRecord, TResult2>;
   }
 
@@ -2513,6 +2513,7 @@ export declare namespace Knex {
         storageEngineIndexType?: string;
         deferrable?: deferrableType;
         useConstraint?: boolean;
+        predicate?: QueryBuilder;
       }>
     ): TableBuilder;
     /** @deprecated */
@@ -2699,6 +2700,7 @@ export declare namespace Knex {
     debug?: boolean;
     client?: string | typeof Client;
     dialect?: string;
+    jsonbSupport?: boolean;
     version?: string;
     connection?: string | StaticConnectionConfig | ConnectionConfigProvider;
     pool?: PoolConfig;
@@ -2715,6 +2717,7 @@ export declare namespace Knex {
     searchPath?: string | readonly string[];
     asyncStackTraces?: boolean;
     log?: Logger;
+    compileSqlOnError?: boolean;
   }
 
   type StaticConnectionConfig =
@@ -2887,6 +2890,7 @@ export declare namespace Knex {
       multiSubnetFailover?: boolean;
       packetSize?: number;
       trustServerCertificate?: boolean;
+      mapBinding?: (value: any) => ({ value: any, type: any } | undefined);
     }>;
     pool?: Readonly<{
       min?: number;
@@ -3021,6 +3025,7 @@ export declare namespace Knex {
     connectionTimeoutMillis?: number;
     types?: PgCustomTypesConfig;
     options?: string;
+    expirationChecker?(): boolean;
   }
 
   type PgGetTypeParser = (oid: number, format: string) => any;
@@ -3081,7 +3086,7 @@ export declare namespace Knex {
 
   interface Migration {
     up: (knex: Knex) => PromiseLike<any>;
-    down?: (kenx: Knex) => PromiseLike<any>;
+    down?: (knex: Knex) => PromiseLike<any>;
   }
 
   interface MigrationSource<TMigrationSpec> {