objection 2.1.6 → 2.2.3

package/lib/model/Model.js

@@ -886,12 +886,24 @@ function getIdRelationProperty(modelClass) {
 }
 
 function getReadOnlyAttributes(modelClass) {
+  return [...new Set(getReadOnlyAttributesRecursively(modelClass))];
+}
+
+function getReadOnlyAttributesRecursively(modelClass) {
+  if (modelClass === Model) {
+    // Stop recursion to the model class.
+    return [];
+  }
+
   const propertyNames = Object.getOwnPropertyNames(modelClass.prototype);
 
-  return propertyNames.filter(propName => {
-    const desc = Object.getOwnPropertyDescriptor(modelClass.prototype, propName);
-    return (desc.get && !desc.set) || desc.writable === false || isFunction(desc.value);
-  });
+  return [
+    ...getReadOnlyAttributes(Object.getPrototypeOf(modelClass)),
+    ...propertyNames.filter(propName => {
+      const desc = Object.getOwnPropertyDescriptor(modelClass.prototype, propName);
+      return (desc.get && !desc.set) || desc.writable === false || isFunction(desc.value);
+    })
+  ];
 }
 
 function getRelationMappings(modelClass) {

package/lib/queryBuilder/InternalOptions.js

@@ -6,6 +6,7 @@ class InternalOptions {
     this.keepImplicitJoinProps = false;
     this.isInternalQuery = false;
     this.debug = false;
+    this.schema = undefined;
   }
 
   clone() {
@@ -15,6 +16,7 @@ class InternalOptions {
     copy.keepImplicitJoinProps = this.keepImplicitJoinProps;
     copy.isInternalQuery = this.isInternalQuery;
     copy.debug = this.debug;
+    copy.schema = this.schema;
 
     return copy;
   }

package/lib/queryBuilder/QueryBuilder.js

@@ -8,6 +8,8 @@ const { createModifier } = require('../utils/createModifier');
 const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
+const { assertIdNotUndefined } = require('../utils/assert');
+
 const { Selection } = require('./operations/select/Selection');
 
 const { QueryBuilderContext } = require('./QueryBuilderContext');
@@ -682,7 +684,7 @@ class QueryBuilder extends QueryBuilderBase {
       const result = await doExecute(builder);
       return await afterExecute(builder, result);
     } catch (error) {
-      await handleExecuteError(builder, error);
+      return await handleExecuteError(builder, error);
     }
   }
 
@@ -700,7 +702,7 @@ class QueryBuilder extends QueryBuilderBase {
     });
   }
 
-  throwIfNotFound() {
+  throwIfNotFound(data = {}) {
     return this.runAfter(result => {
       if (
         (Array.isArray(result) && result.length === 0) ||
@@ -708,7 +710,7 @@ class QueryBuilder extends QueryBuilderBase {
         result === undefined ||
         result === 0
       ) {
-        throw this.modelClass().createNotFoundError(this.context());
+        throw this.modelClass().createNotFoundError(this.context(), data);
       } else {
         return result;
       }
@@ -842,8 +844,11 @@ class QueryBuilder extends QueryBuilderBase {
     const knex = this.knex();
     const tableParts = table.split('.');
     const columnInfoQuery = knex(last(tableParts)).columnInfo();
+    const schema = this.internalOptions().schema;
 
-    if (tableParts.length > 1) {
+    if (schema) {
+      columnInfoQuery.withSchema(schema);
+    } else if (tableParts.length > 1) {
       columnInfoQuery.withSchema(tableParts[0]);
     }
 
@@ -855,6 +860,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   withSchema(schema) {
+    this.internalOptions().schema = schema;
     this.internalContext().onBuild.push(builder => {
       if (!builder.has(/withSchema/)) {
         // Need to push this operation to the front because knex doesn't use the
@@ -1245,8 +1251,14 @@ class QueryBuilder extends QueryBuilderBase {
     return this.rightOuterJoinRelated(...args);
   }
 
-  deleteById(...args) {
-    return this.findById(...args).delete();
+  deleteById(id) {
+    return this.findById(id)
+      .delete()
+      .runBefore((_, builder) => {
+        if (!builder.internalOptions().skipUndefined) {
+          assertIdNotUndefined(id, `undefined was passed to deleteById`);
+        }
+      });
   }
 
   findById(...args) {

package/lib/queryBuilder/QueryBuilderBase.js

@@ -172,6 +172,10 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
     return this.addOperation(new KnexOperation('whereNot'), args);
   }
 
+  andWhereNot(...args) {
+    return this.addOperation(new KnexOperation('andWhereNot'), args);
+  }
+
   orWhereNot(...args) {
     return this.addOperation(new KnexOperation('orWhereNot'), args);
   }

package/lib/queryBuilder/graph/insert/GraphInsertAction.js

@@ -96,9 +96,9 @@ class GraphInsertAction extends GraphAction {
 
     this._resolveReferences(dependencyNode);
 
-    for (let i = 0, l = targetProp.size; i < l; ++i) {
+    targetProp.forEach(i => {
       targetProp.setProp(dependentNode.obj, i, sourceProp.getProp(dependencyNode.obj, i));
-    }
+    });
   }
 
   _resolvePropertyReferenceNode(dependencyNode, edge) {
@@ -152,15 +152,15 @@ class GraphInsertAction extends GraphAction {
 
         const prop = edge.isOwnerNode(node) ? edge.relation.ownerProp : edge.relation.relatedProp;
 
-        for (let i = 0, l = prop.size; i < l; ++i) {
+        prop.forEach(i => {
           const value = prop.getProp(node.obj, i);
 
           if (value !== undefined) {
-            continue;
+            return;
           }
 
           prop.setProp(node.obj, i, prop.getProp(currentNode.obj, i));
-        }
+        });
       }
     }
   }

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -93,7 +93,7 @@ class GraphPatchAction extends GraphAction {
       ) {
         const { relation } = edge;
 
-        for (let i = 0, l = relation.ownerProp.size; i < l; ++i) {
+        relation.ownerProp.forEach(i => {
           const currentValue = currentNode && relation.ownerProp.getProp(currentNode.obj, i);
           const relatedValue = relation.relatedProp.getProp(edge.relatedNode.obj, i);
 
@@ -101,7 +101,7 @@ class GraphPatchAction extends GraphAction {
             relation.ownerProp.setProp(node.obj, i, relatedValue);
             updatedProps.push(relation.ownerProp.props[i]);
           }
-        }
+        });
       }
     }
 
@@ -125,14 +125,14 @@ class GraphPatchAction extends GraphAction {
       ) {
         const { relation } = edge;
 
-        for (let i = 0, l = relation.ownerProp.size; i < l; ++i) {
+        relation.ownerProp.forEach(i => {
           const currentValue = relation.ownerProp.getProp(currentNode.obj, i);
 
           if (currentValue != null) {
             relation.ownerProp.setProp(node.obj, i, null);
             updatedProps.push(relation.ownerProp.props[i]);
           }
-        }
+        });
       }
     }
 

package/lib/queryBuilder/operations/FindByIdOperation.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { assertIdNotUndefined } = require('../../utils/assert');
 
 class FindByIdOperation extends QueryBuilderOperation {
   constructor(name, opt) {
@@ -14,6 +15,10 @@ class FindByIdOperation extends QueryBuilderOperation {
   }
 
   onBuild(builder) {
+    if (!builder.internalOptions().skipUndefined) {
+      assertIdNotUndefined(this.id, `undefined was passed to ${this.name}`);
+    }
+
     builder.whereComposite(builder.fullIdColumn(), this.id);
   }
 

package/lib/queryBuilder/operations/eager/WhereInEagerOperation.js

@@ -109,7 +109,7 @@ class WhereInEagerOperation extends EagerOperation {
   }
 
   fetchRelationBatch(builder, models, relation, expr) {
-    if (this.shouldSkipFetched(models, expr)) {
+    if (this.shouldSkipFetched(models, relation, expr)) {
       return this.createSkippedQuery(builder, models, relation, expr);
     }
 
@@ -148,7 +148,7 @@ class WhereInEagerOperation extends EagerOperation {
     return queryBuilder;
   }
 
-  shouldSkipFetched(models, expr) {
+  shouldSkipFetched(models, relation, expr) {
     if (!this.graphOptions.skipFetched) {
       return false;
     }
@@ -157,7 +157,7 @@ class WhereInEagerOperation extends EagerOperation {
       return false;
     }
 
-    const relationsToFetch = findRelationsToFetch(models[0].constructor, expr);
+    const relationsToFetch = findRelationsToFetch(relation.relatedModelClass, expr);
     const childModels = getRelatedModels(models, expr);
 
     // We can only skip fetching a relation if all already fetched models
@@ -170,7 +170,7 @@ class WhereInEagerOperation extends EagerOperation {
         const prop = ownerProp.props[c];
 
         for (const model of childModels) {
-          if (model[prop] === null || model[prop] === undefined) {
+          if (model[prop] === undefined) {
             return false;
           }
         }

package/lib/relations/Relation.js

@@ -153,12 +153,12 @@ class Relation {
       const relatedProp = this.relatedProp;
       const ownerProp = this.ownerProp;
 
-      for (let i = 0, l = relatedProp.size; i < l; ++i) {
+      relatedProp.forEach(i => {
         const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
         const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
 
         join.on(relatedRef, ownerRef);
-      }
+      });
     });
   }
 
@@ -211,9 +211,9 @@ class Relation {
   }
 
   setRelateProp(model, values) {
-    for (let i = 0, l = this.relatedProp.size; i < l; ++i) {
+    this.relatedProp.forEach(i => {
       this.relatedProp.setProp(model, i, values[i]);
-    }
+    });
   }
 
   executeBeforeInsert(models, queryContext, result) {

package/lib/relations/RelationProperty.js

@@ -79,6 +79,12 @@ class RelationProperty {
     return this._cols;
   }
 
+  forEach(callback) {
+    for (let i = 0, l = this.size; i < l; ++i) {
+      callback(i);
+    }
+  }
+
   // Creates a concatenated string from the property values of the given object.
   propKey(obj) {
     const size = this.size;

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -8,9 +8,9 @@ class BelongsToOneDeleteOperation extends RelationDeleteOperation {
       const ownerProp = this.relation.ownerProp;
 
       for (const owner of this.owner.modelArray) {
-        for (let i = 0, l = ownerProp.size; i < l; ++i) {
+        ownerProp.forEach(i => {
           ownerProp.setProp(owner, i, null);
-        }
+        });
       }
     }
 

package/lib/relations/belongsToOne/BelongsToOneRelateOperation.js

@@ -16,7 +16,7 @@ class BelongsToOneRelateOperation extends RelateOperation {
     const patch = {};
     const ownerProp = this.relation.ownerProp;
 
-    for (let i = 0, l = ownerProp.size; i < l; ++i) {
+    ownerProp.forEach(i => {
       const relatedValue = this.ids[0][i];
 
       if (this.owner.isModels) {
@@ -26,7 +26,7 @@ class BelongsToOneRelateOperation extends RelateOperation {
       }
 
       ownerProp.patch(patch, i, relatedValue);
-    }
+    });
 
     const ownerIdProp = this.relation.ownerModelClass.getIdRelationProperty();
     const ownerIds = this.owner.getProps(this.relation, ownerIdProp);

package/lib/relations/belongsToOne/BelongsToOneUnrelateOperation.js

@@ -6,9 +6,9 @@ class BelongsToOneUnrelateOperation extends UnrelateOperation {
   onAdd() {
     const ids = new Array(this.relation.ownerProp.size);
 
-    for (let i = 0, l = this.relation.ownerProp.size; i < l; ++i) {
+    this.relation.ownerProp.forEach(i => {
       ids[i] = null;
-    }
+    });
 
     this.ids = [ids];
     return true;
@@ -18,7 +18,7 @@ class BelongsToOneUnrelateOperation extends UnrelateOperation {
     const patch = {};
     const ownerProp = this.relation.ownerProp;
 
-    for (let i = 0, l = ownerProp.size; i < l; ++i) {
+    ownerProp.forEach(i => {
       const relatedValue = this.ids[0][i];
 
       if (this.owner.isModels) {
@@ -28,7 +28,7 @@ class BelongsToOneUnrelateOperation extends UnrelateOperation {
       }
 
       ownerProp.patch(patch, i, relatedValue);
-    }
+    });
 
     const ownerIdProp = this.relation.ownerModelClass.getIdRelationProperty();
     const ownerRefs = ownerIdProp.refs(builder);

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -20,9 +20,9 @@ class HasManyRelateOperation extends RelateOperation {
     const relatedProp = this.relation.relatedProp;
     const ownerValues = this.owner.getSplitProps(builder, this.relation);
 
-    for (let i = 0, l = relatedProp.size; i < l; ++i) {
+    relatedProp.forEach(i => {
       relatedProp.patch(patch, i, ownerValues[0][i]);
-    }
+    });
 
     return this.relation.relatedModelClass
       .query()

package/lib/relations/hasMany/HasManyUnrelateOperation.js

@@ -9,9 +9,9 @@ class HasManyUnrelateOperation extends UnrelateOperation {
     const ownerValues = this.owner.getProps(this.relation);
     const relatedRefs = relatedProp.refs(builder);
 
-    for (let i = 0, l = relatedProp.size; i < l; ++i) {
+    relatedProp.forEach(i => {
       relatedProp.patch(patch, i, null);
-    }
+    });
 
     return this.relation.relatedModelClass
       .query()

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -4,11 +4,11 @@ const getModel = () => require('../../model/Model').Model;
 const { Relation } = require('../Relation');
 const { RelationProperty } = require('../RelationProperty');
 
-const { isSqlite, isMySql } = require('../../utils/knexUtils');
+const { isSqlite } = require('../../utils/knexUtils');
 const { inheritModel } = require('../../model/inheritModel');
 const { resolveModel } = require('../../utils/resolveModel');
 const { mapAfterAllReturn } = require('../../utils/promiseUtils');
-const { isFunction, isObject } = require('../../utils/objectUtils');
+const { isFunction, isObject, isString } = require('../../utils/objectUtils');
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
@@ -71,12 +71,12 @@ class ManyToManyRelation extends Relation {
     const joinTableAlias = builder.tableRefFor(this.joinTable);
 
     builder.join(aliasedTableName(joinTable, joinTableAlias), join => {
-      for (let i = 0, l = this.relatedProp.size; i < l; ++i) {
+      this.relatedProp.forEach(i => {
         const relatedRef = this.relatedProp.ref(builder, i);
         const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i);
 
         join.on(relatedRef, joinTableRelatedRef);
-      }
+      });
     });
 
     owner.buildFindQuery(builder, this, joinTableOwnerRefs);
@@ -105,22 +105,22 @@ class ManyToManyRelation extends Relation {
       const ownerProp = this.ownerProp;
       const joinTableOwnerProp = this.joinTableOwnerProp;
 
-      for (let i = 0, l = ownerProp.size; i < l; ++i) {
+      ownerProp.forEach(i => {
         const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i).table(joinTableAlias);
         const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
 
         join.on(joinTableOwnerRef, ownerRef);
-      }
+      });
     })[joinOperation](relatedJoinSelect, join => {
       const relatedProp = this.relatedProp;
       const joinTableRelatedProp = this.joinTableRelatedProp;
 
-      for (let i = 0, l = relatedProp.size; i < l; ++i) {
+      relatedProp.forEach(i => {
         const joinTableRelatedRef = joinTableRelatedProp.ref(builder, i).table(joinTableAlias);
         const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
 
         join.on(joinTableRelatedRef, relatedRef);
-      }
+      });
     });
   }
 
@@ -417,7 +417,11 @@ function parseExtras(ctx) {
     return ctx;
   }
 
-  if (Array.isArray(extraDef)) {
+  if (isString(extraDef)) {
+    extraDef = {
+      [extraDef]: extraDef
+    };
+  } else if (Array.isArray(extraDef)) {
     extraDef = extraDef.reduce((extraDef, col) => {
       extraDef[col] = col;
       return extraDef;

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -87,14 +87,14 @@ class ManyToManyFindOperation extends RelationFindOperation {
 
     // We must select the owner join columns so that we know for which owner model the related
     // models belong to after the requests.
-    for (let i = 0, l = joinTableOwnerProp.size; i < l; ++i) {
+    joinTableOwnerProp.forEach(i => {
       const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
       // Mark them to be omitted later.
       this.omitProps.push(propName);
-    }
+    });
 
     super.selectMissingJoinColumns(builder);
   }

package/lib/utils/assert.js

@@ -11,6 +11,15 @@ function assertHasId(model) {
   }
 }
 
+function assertIdNotUndefined(id, message) {
+  if (Array.isArray(id)) {
+    id.forEach(id => assertIdNotUndefined(id, message));
+  } else if (id === undefined) {
+    throw Error(message);
+  }
+}
+
 module.exports = {
-  assertHasId
+  assertHasId,
+  assertIdNotUndefined
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "2.1.6",
+  "version": "2.2.3",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",
@@ -16,7 +16,7 @@
     "perf": "mocha --slow 60000 --timeout 60000 --reporter spec --recursive perf",
     "perf-debug": "mocha --slow 60000 --timeout 60000 --reporter spec --inspect-brk perf",
     "perf-opt": "mocha --slow 60000 --timeout 60000 --reporter spec --recursive perf --trace_opt --trace_deopt",
-    "prettier": "prettier --write \"{examples,lib,tests,typings,doc}/**/*.{js,ts,md}\"",
+    "prettier": "prettier --write \"{examples,lib,tests,typings,doc}/**/*.{js,ts}\"",
     "eslint": "eslint --format codeframe \"examples/**/*.js\" \"lib/**/*.js\" \"tests/**/*.js\"",
     "docs:dev": "vuepress dev doc",
     "docs:build": "vuepress build doc"
@@ -115,7 +115,7 @@
       "eslint --fix",
       "git add"
     ],
-    "*.{md,yml,ts}": [
+    "*.{yml,ts}": [
       "prettier --write",
       "git add"
     ]

package/typings/objection/index.d.ts

@@ -14,8 +14,7 @@
 
 import * as ajv from 'ajv';
 import * as dbErrors from 'db-errors';
-import * as knex from 'knex';
-import Knex = require('knex');
+import * as Knex from 'knex';
 
 // Export the entire Objection namespace.
 export = Objection;
@@ -118,10 +117,10 @@ declare namespace Objection {
     castTo(sqlType: string): this;
   }
 
-  type Raw = RawBuilder | knex.Raw;
+  type Raw = RawBuilder | Knex.Raw;
   type Operator = string;
   type ColumnRef = string | Raw | ReferenceBuilder;
-  type TableRef = ColumnRef | AnyQueryBuilder;
+  type TableRef<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
 
   type PrimitiveValue =
     | string
@@ -189,7 +188,7 @@ declare namespace Objection {
    * A Pojo version of model.
    */
   type ModelObject<T extends Model> = {
-    [K in NonFunctionPropertyNames<T>]: T[K];
+    [K in Exclude<NonFunctionPropertyNames<T>, 'QueryBuilderType'>]: T[K];
   };
 
   /**
@@ -350,10 +349,7 @@ declare namespace Objection {
   }
 
   interface FromMethod<QB extends AnyQueryBuilder> {
-    (table: string): QB;
-    (cb: CallbackVoid<QB>): QB;
-    (raw: Raw): QB;
-    <QBP extends AnyQueryBuilder>(qb: QBP): QB;
+    (table: TableRef<QB>): QB;
   }
 
   interface WhereMethod<QB extends AnyQueryBuilder> {
@@ -524,10 +520,10 @@ declare namespace Objection {
   }
 
   interface JoinMethod<QB extends AnyQueryBuilder> {
-    (table: TableRef, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
-    (table: TableRef, leftCol: ColumnRef, rightCol: ColumnRef): QB;
-    (table: TableRef, cb: CallbackVoid<knex.JoinClause>): QB;
-    (table: TableRef, raw: Raw): QB;
+    (table: TableRef<QB>, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, leftCol: ColumnRef, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, cb: CallbackVoid<Knex.JoinClause>): QB;
+    (table: TableRef<QB>, raw: Raw): QB;
     (raw: Raw): QB;
   }
 
@@ -591,6 +587,10 @@ declare namespace Objection {
     (arg: T): QB;
   }
 
+  interface OptionalOneArgMethod<T, QB extends AnyQueryBuilder> {
+    (arg?: T): QB;
+  }
+
   interface StringReturningMethod {
     (): string;
   }
@@ -608,7 +608,7 @@ declare namespace Objection {
   }
 
   interface ColumnInfoMethod<QB extends AnyQueryBuilder> {
-    (): Promise<knex.ColumnInfo>;
+    (): Promise<Knex.ColumnInfo>;
   }
 
   interface TableRefForMethod {
@@ -667,7 +667,7 @@ declare namespace Objection {
   }
 
   interface OnBuildKnexCallback<QB extends AnyQueryBuilder> {
-    (this: QB, knexQuery: knex.QueryBuilder, query: QB): void;
+    (this: QB, knexQuery: Knex.QueryBuilder, query: QB): void;
   }
 
   interface OnBuildKnexMethod<QB extends AnyQueryBuilder> {
@@ -876,24 +876,29 @@ declare namespace Objection {
     having: WhereMethod<this>;
     andHaving: WhereMethod<this>;
     orHaving: WhereMethod<this>;
-    havingRaw: WhereMethod<this>;
-    orHavingRaw: WhereMethod<this>;
-    havingIn: WhereMethod<this>;
-    orHavingIn: WhereMethod<this>;
-    havingNotIn: WhereMethod<this>;
-    orHavingNotIn: WhereMethod<this>;
-    havingNull: WhereMethod<this>;
-    orHavingNull: WhereMethod<this>;
-    havingNotNull: WhereMethod<this>;
-    orHavingNotNull: WhereMethod<this>;
-    havingExists: WhereMethod<this>;
-    orHavingExists: WhereMethod<this>;
-    havingNotExists: WhereMethod<this>;
-    orHavingNotExists: WhereMethod<this>;
-    havingBetween: WhereMethod<this>;
-    orHavingBetween: WhereMethod<this>;
-    havingNotBetween: WhereMethod<this>;
-    orHavingNotBetween: WhereMethod<this>;
+
+    havingRaw: WhereRawMethod<this>;
+    orHavingRaw: WhereRawMethod<this>;
+
+    havingIn: WhereInMethod<this>;
+    orHavingIn: WhereInMethod<this>;
+    havingNotIn: WhereInMethod<this>;
+    orHavingNotIn: WhereInMethod<this>;
+
+    havingNull: WhereNullMethod<this>;
+    orHavingNull: WhereNullMethod<this>;
+    havingNotNull: WhereNullMethod<this>;
+    orHavingNotNull: WhereNullMethod<this>;
+
+    havingExists: WhereExistsMethod<this>;
+    orHavingExists: WhereExistsMethod<this>;
+    havingNotExists: WhereExistsMethod<this>;
+    orHavingNotExists: WhereExistsMethod<this>;
+
+    havingBetween: WhereBetweenMethod<this>;
+    orHavingBetween: WhereBetweenMethod<this>;
+    havingNotBetween: WhereBetweenMethod<this>;
+    orHavingNotBetween: WhereBetweenMethod<this>;
 
     whereComposite: WhereCompositeMethod<this>;
     whereInComposite: WhereInCompositeMethod<this>;
@@ -1034,7 +1039,7 @@ declare namespace Objection {
     // Deprecated
     allowUpsert: AllowGraphMethod<this>;
 
-    throwIfNotFound: IdentityMethod<this>;
+    throwIfNotFound: OptionalOneArgMethod<object, this>;
     returning: ReturningMethod;
     forUpdate: IdentityMethod<this>;
     forShare: IdentityMethod<this>;
@@ -1066,10 +1071,11 @@ declare namespace Objection {
     omit(modelClass: typeof Model, properties: string[]): this;
     // Deprecated
     omit(properties: string[]): this;
-    // Deprecated
+
     traverse(filterConstructor: typeof Model, traverser: TraverserFunction): R;
-    // Deprecated
     traverse(traverser: TraverserFunction): R;
+    traverseAsync(filterConstructor: typeof Model, traverser: TraverserFunction): Promise<R>;
+    traverseAsync(traverser: TraverserFunction): Promise<R>;
 
     page(page: number, pageSize: number): PageQueryBuilder<this>;
     range(): PageQueryBuilder<this>;
@@ -1173,8 +1179,8 @@ declare namespace Objection {
     result?: R;
   }
 
-  export type Transaction = knex.Transaction;
-  export type TransactionOrKnex = Transaction | knex;
+  export type Transaction = Knex.Transaction;
+  export type TransactionOrKnex = Transaction | Knex;
 
   export interface RelationMappings {
     [relationName: string]: RelationMapping<any>;
@@ -1209,7 +1215,7 @@ declare namespace Objection {
   export interface RelationThrough<M extends Model> {
     from: RelationMappingColumnRef;
     to: RelationMappingColumnRef;
-    extra?: string[] | Record<string, string>;
+    extra?: string | string[] | Record<string, string>;
     modelClass?: ModelClassSpecifier;
     beforeInsert?: RelationMappingHook<M>;
   }
@@ -1359,7 +1365,7 @@ declare namespace Objection {
   }
 
   export interface FetchTableMetadataOptions {
-    knex?: knex;
+    knex?: Knex;
     force?: boolean;
     table?: string;
   }
@@ -1435,8 +1441,8 @@ declare namespace Objection {
     tableMetadata(opt?: TableMetadataOptions): TableMetadata;
     fetchTableMetadata(opt?: FetchTableMetadataOptions): Promise<TableMetadata>;
 
-    knex(knex?: knex): knex;
-    knexQuery(): knex.QueryBuilder;
+    knex(knex?: Knex): Knex;
+    knexQuery(): Knex.QueryBuilder;
     startTransaction(knexOrTransaction?: TransactionOrKnex): Promise<Transaction>;
 
     transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<T>;
@@ -1565,8 +1571,8 @@ declare namespace Objection {
     static tableMetadata(opt?: TableMetadataOptions): TableMetadata;
     static fetchTableMetadata(opt?: FetchTableMetadataOptions): Promise<TableMetadata>;
 
-    static knex(knex?: knex): knex;
-    static knexQuery(): knex.QueryBuilder;
+    static knex(knex?: Knex): Knex;
+    static knexQuery(): Knex.QueryBuilder;
     static startTransaction(knexOrTransaction?: TransactionOrKnex): Promise<Transaction>;
 
     static transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<T>;
@@ -1675,8 +1681,8 @@ declare namespace Objection {
     $afterDelete(queryContext: QueryContext): Promise<any> | void;
 
     $toDatabaseJson(): Pojo;
-    $toJson(opt?: ToJsonOptions): Pojo;
-    toJSON(opt?: ToJsonOptions): Pojo;
+    $toJson(opt?: ToJsonOptions): ModelObject<this>;
+    toJSON(opt?: ToJsonOptions): ModelObject<this>;
 
     $setJson(json: object, opt?: ModelOptions): this;
     $setDatabaseJson(json: object): this;
@@ -1697,9 +1703,11 @@ declare namespace Objection {
     $clone(opt?: CloneOptions): this;
     $traverse(filterConstructor: typeof Model, traverser: TraverserFunction): this;
     $traverse(traverser: TraverserFunction): this;
+    $traverseAsync(filterConstructor: typeof Model, traverser: TraverserFunction): Promise<this>;
+    $traverseAsync(traverser: TraverserFunction): Promise<this>;
 
-    $knex(): knex;
-    $transaction(): knex;
+    $knex(): Knex;
+    $transaction(): Knex;
 
     QueryBuilderType: QueryBuilder<this, this[]>;
   }
@@ -1713,7 +1721,7 @@ declare namespace Objection {
    * @tutorial https://vincit.github.io/objection.js/guide/transactions.html#creating-a-transaction
    */
   export interface transaction {
-    start(knexOrModel: knex | AnyModelConstructor): Promise<Transaction>;
+    start(knexOrModel: Knex | AnyModelConstructor): Promise<Transaction>;
 
     <MC1 extends AnyModelConstructor, ReturnValue>(
       modelClass1: MC1,
@@ -1790,7 +1798,7 @@ declare namespace Objection {
       ) => Promise<ReturnValue>
     ): Promise<ReturnValue>;
 
-    <ReturnValue>(knex: knex, callback: (trx: Transaction) => Promise<ReturnValue>): Promise<
+    <ReturnValue>(knex: Knex, callback: (trx: Transaction) => Promise<ReturnValue>): Promise<
       ReturnValue
     >;
   }