@ditojs/server 2.0.5 → 2.1.0

package/src/query/QueryBuilder.js

@@ -1,7 +1,14 @@
 import objection from 'objection'
 import {
-  isObject, isPlainObject, isString, isArray, clone, mapKeys,
-  getValueAtDataPath, setValueAtDataPath, parseDataPath
+  isObject,
+  isPlainObject,
+  isString,
+  isArray,
+  clone,
+  mapKeys,
+  getValueAtDataPath,
+  setValueAtDataPath,
+  parseDataPath
 } from '@ditojs/utils'
 import { QueryParameters } from './QueryParameters.js'
 import { KnexHelper } from '../lib/index.js'
@@ -14,73 +21,32 @@ import { deprecate } from '../utils/deprecate.js'
 const SYMBOL_ALL = Symbol('all')
 
 export class QueryBuilder extends objection.QueryBuilder {
-  constructor(modelClass) {
-    super(modelClass)
-    this._ignoreGraph = false
-    this._graphAlgorithm = 'fetch'
-    this._allowFilters = null
-    this._allowScopes = null
-    this._ignoreScopes = {}
-    this._appliedScopes = {}
-    this._executeFirst = null // Part of a work-around for cyclic graphs
-    this._clearScopes(true)
-  }
+  #ignoreGraph = false
+  #graphAlgorithm = 'fetch'
+  #isJoinChildQuery = false
+  #scopes = { default: true } // Eager-apply the default scope
+  #allowScopes = null
+  #ignoreScopes = {}
+  #appliedScopes = {}
+  #allowFilters = null
+  #executeFirst = null // Part of a work-around for cyclic graphs
 
   // @override
   clone() {
     const copy = super.clone()
-    copy._ignoreGraph = this._ignoreGraph
-    copy._graphAlgorithm = this._graphAlgorithm
-    copy._appliedScopes = { ...this._appliedScopes }
-    copy._allowFilters = this._allowFilters ? { ...this._allowFilters } : null
-    copy._copyScopes(this)
+    copy.#ignoreGraph = this.#ignoreGraph
+    copy.#graphAlgorithm = this.#graphAlgorithm
+    copy.#appliedScopes = { ...this.#appliedScopes }
+    copy.#allowFilters = this.#allowFilters ? { ...this.#allowFilters } : null
+    copy.#copyScopes(this)
     return copy
   }
 
   // @override
   async execute() {
-    if (!this._ignoreScopes[SYMBOL_ALL]) {
-      // Only apply default scopes if this is a normal find query, meaning it
-      // does not define any write operations or special selects, e.g. `count`:
-      const isNormalFind = (
-        this.isFind() &&
-        !this.hasSpecialSelects()
-      )
-      // If this isn't a normal find query, ignore all graph operations,
-      // to not mess with special selects such as `count`, etc:
-      this._ignoreGraph = !isNormalFind
-      // All scopes in `_scopes` were already checked against `_allowScopes`.
-      // They themselves are allowed to apply / request other scopes that
-      // aren't listed, so clear `_applyScope` and restore again after:
-      const { _allowScopes } = this
-      this._allowScopes = null
-      const collectedScopes = {}
-      // Scopes can themselves request more scopes by calling `withScope()`
-      // In order to prevent that from causing problems while looping over
-      // `_scopes`, create a local copy of the entries, set `_scopes` to an
-      // empty object during iteration and check if there are new entries after
-      // one full loop. Keep doing this until there's nothing left, but keep
-      // track of all the applied scopes, so `_scopes` can be set to the the
-      // that in the end. This is needed for child queries, see `childQueryOf()`
-      let scopes = Object.entries(this._scopes)
-      while (scopes.length > 0) {
-        this._scopes = {}
-        for (const [scope, graph] of scopes) {
-          // Don't apply `default` scopes on anything else than a normal find
-          // query:
-          if (scope !== 'default' || isNormalFind) {
-            this._applyScope(scope, graph)
-            collectedScopes[scope] ||= graph
-          }
-        }
-        scopes = Object.entries(this._scopes)
-      }
-      this._scopes = collectedScopes
-      this._allowScopes = _allowScopes
-      this._ignoreGraph = false
-    }
+    this.#applyScopes()
     // In case of cyclic graphs, run `_executeFirst()` now:
-    await this._executeFirst?.()
+    await this.#executeFirst?.()
     return super.execute()
   }
 
@@ -100,13 +66,16 @@ export class QueryBuilder extends objection.QueryBuilder {
   // @override
   childQueryOf(query, options) {
     super.childQueryOf(query, options)
+    this.#isJoinChildQuery = query.#graphAlgorithm === 'join'
     if (this.isInternal()) {
       // Internal queries shouldn't apply or inherit any scopes, not even the
       // default scope.
-      this._clearScopes(false)
+      this.#clearScopes(false)
     } else {
       // Inherit the graph scopes from the parent query.
-      this._copyScopes(query, true)
+      this.#ignoreGraph = query.#ignoreGraph
+      this.#graphAlgorithm = query.#graphAlgorithm
+      this.#copyScopes(query, true)
     }
     return this
   }
@@ -122,12 +91,12 @@ export class QueryBuilder extends objection.QueryBuilder {
     for (const expr of scopes) {
       if (expr) {
         const { scope, graph } = getScope(expr)
-        if (this._allowScopes && !this._allowScopes[scope]) {
+        if (this.#allowScopes && !this.#allowScopes[scope]) {
           throw new QueryBuilderError(
             `Query scope '${scope}' is not allowed.`
           )
         }
-        this._scopes[scope] ||= graph
+        this.#scopes[scope] ||= graph
       }
     }
     return this
@@ -136,52 +105,53 @@ export class QueryBuilder extends objection.QueryBuilder {
   // Clear all scopes defined with `withScope()` statements, preserving the
   // default scope.
   clearWithScope() {
-    return this._clearScopes(true)
+    return this.#clearScopes(true)
   }
 
   ignoreScope(...scopes) {
-    if (!this._ignoreScopes[SYMBOL_ALL]) {
-      this._ignoreScopes = scopes.length > 0
-        ? {
-          ...this._ignoreScopes,
-          ...createLookup(scopes)
-        }
-        // Empty arguments = ignore all scopes
-        : {
-          [SYMBOL_ALL]: true
-        }
+    if (!this.#ignoreScopes[SYMBOL_ALL]) {
+      this.#ignoreScopes =
+        scopes.length > 0
+          ? {
+              ...this.#ignoreScopes,
+              ...createLookup(scopes)
+            }
+          : // Empty arguments = ignore all scopes
+            {
+              [SYMBOL_ALL]: true
+            }
     }
     return this
   }
 
   applyScope(...scopes) {
-    // When directly applying a scope, still merge it into `this._scopes`,
+    // When directly applying a scope, still merge it into `this.#scopes`,
     // so it can still be passed on to forked child queries. This also handles
     // the checks against `_allowScopes`.
     this.withScope(...scopes)
     for (const expr of scopes) {
       if (expr) {
         const { scope, graph } = getScope(expr)
-        this._applyScope(scope, graph)
+        this.#applyScope(scope, graph)
       }
     }
     return this
   }
 
   allowScope(...scopes) {
-    this._allowScopes ||= {
+    this.#allowScopes ||= {
       default: true // The default scope is always allowed.
     }
     for (const expr of scopes) {
       if (expr) {
         const { scope } = getScope(expr)
-        this._allowScopes[scope] = true
+        this.#allowScopes[scope] = true
       }
     }
   }
 
   clearAllowScope() {
-    this._allowScopes = null
+    this.#allowScopes = null
   }
 
   scope(...scopes) {
@@ -191,61 +161,111 @@ export class QueryBuilder extends objection.QueryBuilder {
   }
 
   mergeScope(...scopes) {
-    deprecate(`QueryBuilder#mergeScope() is deprecated. Use #withScope() instead.`)
+    deprecate(
+      `QueryBuilder#mergeScope() is deprecated. Use #withScope() instead.`
+    )
 
     return this.withScope(...scopes)
   }
 
   clearScope() {
-    deprecate(`QueryBuilder#clearScope() is deprecated. Use #clearWithScope() or #ignoreScope() instead.`)
+    deprecate(
+      `QueryBuilder#clearScope() is deprecated. Use #clearWithScope() or #ignoreScope() instead.`
+    )
 
     return this.clearWithScope()
   }
 
-  _clearScopes(addDefault) {
+  #clearScopes(addDefault) {
     // `_scopes` is an object where the keys are the scopes and the values
     // indicate if the scope should be eager-applied or not:
-    this._scopes = addDefault
-      ? { default: true } // eager-apply the default scope
+    this.#scopes = addDefault
+      ? { default: true } // Eager-apply the default scope
       : {}
     return this
   }
 
-  _copyScopes(query, isChildQuery = false) {
+  #copyScopes(query, isChildQuery = false) {
     const isSameModelClass = this.modelClass() === query.modelClass()
     // Only copy `_allowScopes` and `_ignoreScopes` if it's for the same model.
     if (isSameModelClass) {
-      this._allowScopes = query._allowScopes ? { ...query._allowScopes } : null
-      this._ignoreScopes = { ...query._ignoreScopes }
+      this.#allowScopes = query.#allowScopes ? { ...query.#allowScopes } : null
+      this.#ignoreScopes = { ...query.#ignoreScopes }
     }
     const scopes = isChildQuery
-      // When copying scopes for child-queries, we also need to take the already
-      // applied scopes into account and copy those too.
-      ? { ...query._appliedScopes, ...query._scopes }
-      : { ...query._scopes }
+      ? // When copying scopes for child-queries, we also need to take the
+        // already applied scopes into account and copy those too.
+        { ...query.#appliedScopes, ...query.#scopes }
+      : { ...query.#scopes }
     // If the target is a child query of a graph query, copy all scopes, graph
     // and non-graph. If it is a child query of a related or eager query,
     // copy only the graph scopes.
-    const copyAllScopes =
-      isSameModelClass && isChildQuery && query.has(/GraphAndFetch$/)
-    this._scopes = copyAllScopes
+    const copyAllScopes = (
+      isSameModelClass &&
+      isChildQuery &&
+      query.has(/GraphAndFetch$/)
+    )
+    this.#scopes = copyAllScopes
       ? scopes
       : filterScopes(scopes, (scope, graph) => graph) // copy graph-scopes only.
   }
 
-  _applyScope(scope, graph) {
-    if (!this._ignoreScopes[SYMBOL_ALL] && !this._ignoreScopes[scope]) {
+  #applyScopes() {
+    if (!this.#ignoreScopes[SYMBOL_ALL]) {
+      // Only apply default scopes if this is a normal find query, meaning it
+      // does not define any write operations or special selects, e.g. `count`:
+      const isNormalFind = (
+        this.isFind() &&
+        !this.hasSpecialSelects()
+      )
+      // If this isn't a normal find query, ignore all graph operations,
+      // to not mess with special selects such as `count`, etc:
+      this.#ignoreGraph = !isNormalFind
+      // All scopes in `_scopes` were already checked against `_allowScopes`.
+      // They themselves are allowed to apply / request other scopes that
+      // aren't listed, so clear `_allowScopes` and restore again after:
+      const allowScopes = this.#allowScopes
+      this.#allowScopes = null
+      const collectedScopes = {}
+      // Scopes can themselves request more scopes by calling `withScope()`
+      // In order to prevent that from causing problems while looping over
+      // `_scopes`, create a local copy of the entries, set `_scopes` to an
+      // empty object during iteration and check if there are new entries after
+      // one full loop. Keep doing this until there's nothing left, but keep
+      // track of all the applied scopes, so `_scopes` can be set to the the
+      // that in the end. This is needed for child queries, see `childQueryOf()`
+      let scopes = Object.entries(this.#scopes)
+      while (scopes.length > 0) {
+        this.#scopes = {}
+        for (const [scope, graph] of scopes) {
+          // Don't apply `default` scopes on anything else than a normal find
+          // query:
+          if (isNormalFind || scope !== 'default') {
+            this.#applyScope(scope, graph)
+            collectedScopes[scope] ||= graph
+          }
+        }
+        scopes = Object.entries(this.#scopes)
+      }
+      this.#scopes = collectedScopes
+      this.#allowScopes = allowScopes
+      this.#ignoreGraph = false
+    }
+  }
+
+  #applyScope(scope, graph) {
+    if (!this.#ignoreScopes[SYMBOL_ALL] && !this.#ignoreScopes[scope]) {
       // Prevent multiple application of scopes. This can easily occur
       // with the nesting and eager-application of graph-scopes, see below.
       // NOTE: The boolean values indicate the `graph` settings, not whether the
       // scopes were applied or not.
-      if (!(scope in this._appliedScopes)) {
+      if (!(scope in this.#appliedScopes)) {
         // Only apply graph-scopes that are actually defined on the model:
         const func = this.modelClass().getScope(scope)
         if (func) {
           func.call(this, this)
         }
-        this._appliedScopes[scope] = graph
+        this.#appliedScopes[scope] = graph
       }
       if (graph) {
         // Also bake the scope into any graph expression that may have been
@@ -258,7 +278,16 @@ export class QueryBuilder extends objection.QueryBuilder {
           // re-applies itself to the result.
           const name = `^${scope}`
           const modifiers = {
-            [name]: query => query.withScope(name)
+            [name]: query => {
+              query.withScope(name)
+              if (query.#isJoinChildQuery) {
+                // Join child queries are never executed, and need to apply
+                // their scopes manually. Note that it's OK to call this
+                // repeatedly, because `_appliedScopes` prevents multiple
+                // application of the same scope.
+                query.#applyScopes()
+              }
+            }
           }
           this.withGraph(
             addGraphScope(this.modelClass(), expr, [name], modifiers, true)
@@ -269,7 +298,7 @@ export class QueryBuilder extends objection.QueryBuilder {
   }
 
   applyFilter(name, ...args) {
-    if (this._allowFilters && !this._allowFilters[name]) {
+    if (this.#allowFilters && !this.#allowFilters[name]) {
       throw new QueryBuilderError(`Query filter '${name}' is not allowed.`)
     }
     const filter = this.modelClass().definition.filters[name]
@@ -281,9 +310,9 @@ export class QueryBuilder extends objection.QueryBuilder {
   }
 
   allowFilter(...filters) {
-    this._allowFilters ||= {}
+    this.#allowFilters ||= {}
     for (const filter of filters) {
-      this._allowFilters[filter] = true
+      this.#allowFilters[filter] = true
     }
   }
 
@@ -292,7 +321,7 @@ export class QueryBuilder extends objection.QueryBuilder {
   // `_ignoreGraph` and `_graphAlgorithm`:
   withGraph(expr, options = {}) {
     // To make merging easier, keep the current algorithm if none is specified:
-    const { algorithm = this._graphAlgorithm } = options
+    const { algorithm = this.#graphAlgorithm } = options
     const method = {
       fetch: 'withGraphFetched',
       join: 'withGraphJoined'
@@ -302,8 +331,8 @@ export class QueryBuilder extends objection.QueryBuilder {
         `Graph algorithm '${algorithm}' is unsupported.`
       )
     }
-    if (!this._ignoreGraph) {
-      this._graphAlgorithm = algorithm
+    if (!this.#ignoreGraph) {
+      this.#graphAlgorithm = algorithm
       super[method](expr, options)
     }
     return this
@@ -391,7 +420,8 @@ export class QueryBuilder extends objection.QueryBuilder {
       // Support `restart` and `cascade` in PostgreSQL truncate queries.
       return this.raw(
         `truncate table ??${
-          restart ? ' restart identity' : ''}${
+          restart ? ' restart identity' : ''
+        }${
           cascade ? ' cascade' : ''
         }`,
         this.modelClass().tableName
@@ -412,39 +442,39 @@ export class QueryBuilder extends objection.QueryBuilder {
   // https://github.com/Vincit/objection.js/issues/101#issuecomment-200363667
   upsert(data, options = {}) {
     let mainQuery
-    return this
-      .runBefore((result, builder) => {
-        if (!builder.context().isMainQuery) {
-          // At this point the builder should only contain a bunch of `where*`
-          // operations. Store this query for later use in runAfter(). Also mark
-          // the query with `isMainQuery: true` so we can skip all this when
-          // this function is called for the `mainQuery`.
-          mainQuery = builder.clone().context({ isMainQuery: true })
-          // Call update() on the original query, turning it into an update.
-          builder[options.update ? 'update' : 'patch'](data)
-        }
-        return result
-      })
-      .runAfter((result, builder) => {
-        if (!builder.context().isMainQuery) {
-          return result === 0
-            ? mainQuery[options.fetch ? 'insertAndFetch' : 'insert'](data)
-            // We can use the `mainQuery` we saved in runBefore() to fetch the
+    return this.runBefore((result, builder) => {
+      if (!builder.context().isMainQuery) {
+        // At this point the builder should only contain a bunch of `where*`
+        // operations. Store this query for later use in runAfter(). Also mark
+        // the query with `isMainQuery: true` so we can skip all this when
+        // this function is called for the `mainQuery`.
+        mainQuery = builder.clone().context({ isMainQuery: true })
+        // Call update() on the original query, turning it into an update.
+        builder[options.update ? 'update' : 'patch'](data)
+      }
+      return result
+    }).runAfter((result, builder) => {
+      if (!builder.context().isMainQuery) {
+        return result === 0
+          ? mainQuery[options.fetch ? 'insertAndFetch' : 'insert'](data)
+          : // We can use the `mainQuery` we saved in runBefore() to fetch the
             // inserted results. It is noteworthy that this query will return
             // the wrong results if the update changed any of the columns the
             // where operates with. This also returns all updated models.
-            : mainQuery.first()
-        }
-        return result
-      })
+            mainQuery.first()
+      }
+      return result
+    })
   }
 
   find(query, allowParam) {
     if (!query) return this
     const allowed = !allowParam
-      ? QueryParameters.allowed()
-      // If it's already a lookup object just use it, otherwise convert it:
-      : isPlainObject(allowParam) ? allowParam : createLookup(allowParam)
+      ? QueryParameters.getAllowed()
+      : // If it's already a lookup object just use it, otherwise convert it:
+        isPlainObject(allowParam)
+        ? allowParam
+        : createLookup(allowParam)
     for (const [key, value] of Object.entries(query)) {
       // Support array notation for multiple parameters, as sent by axios:
       const param = key.endsWith('[]') ? key.slice(0, -2) : key
@@ -454,7 +484,8 @@ export class QueryBuilder extends objection.QueryBuilder {
       const paramHandler = QueryParameters.get(param)
       if (!paramHandler) {
         throw new QueryBuilderError(
-          `Invalid query parameter '${param}' in '${key}=${value}'.`)
+          `Invalid query parameter '${param}' in '${key}=${value}'.`
+        )
       }
       paramHandler(this, key, value)
     }
@@ -500,18 +531,18 @@ export class QueryBuilder extends objection.QueryBuilder {
 
   patchAndFetch(data) {
     return isArray(data)
-      ? this._upsertAndFetch(data)
+      ? this.#upsertAndFetch(data)
       : super.patchAndFetch(data)
   }
 
   updateAndFetch(data) {
     return isArray(data)
-      ? this._upsertAndFetch(data, { update: true })
+      ? this.#upsertAndFetch(data, { update: true })
       : super.updateAndFetch(data)
   }
 
   upsertAndFetch(data) {
-    return this._upsertAndFetch(data, {
+    return this.#upsertAndFetch(data, {
       // Insert missing nodes only at root by allowing `insertMissing`,
       // but set `noInsert` for all relations:
       insertMissing: true,
@@ -519,7 +550,7 @@ export class QueryBuilder extends objection.QueryBuilder {
     })
   }
 
-  _upsertAndFetch(data, options) {
+  #upsertAndFetch(data, options) {
     return this.upsertGraphAndFetch(data, {
       fetchStrategy: 'OnlyNeeded',
       noInset: true,
@@ -531,70 +562,111 @@ export class QueryBuilder extends objection.QueryBuilder {
   }
 
   insertDitoGraph(data, options) {
-    return this._handleDitoGraph('insertGraph',
-      data, options, insertDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'insertGraph',
+      data,
+      options,
+      insertDitoGraphOptions
+    )
   }
 
   insertDitoGraphAndFetch(data, options) {
-    return this._handleDitoGraph('insertGraphAndFetch',
-      data, options, insertDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'insertGraphAndFetch',
+      data,
+      options,
+      insertDitoGraphOptions
+    )
   }
 
   upsertDitoGraph(data, options) {
-    return this._handleDitoGraph('upsertGraph',
-      data, options, upsertDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'upsertGraph',
+      data,
+      options,
+      upsertDitoGraphOptions
+    )
   }
 
   upsertDitoGraphAndFetch(data, options) {
-    return this._handleDitoGraph('upsertGraphAndFetch',
-      data, options, upsertDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'upsertGraphAndFetch',
+      data,
+      options,
+      upsertDitoGraphOptions
+    )
   }
 
   patchDitoGraph(data, options) {
-    return this._handleDitoGraph('upsertGraph',
-      data, options, patchDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'upsertGraph',
+      data,
+      options,
+      patchDitoGraphOptions
+    )
   }
 
   patchDitoGraphAndFetch(data, options) {
-    return this._handleDitoGraph('upsertGraphAndFetch',
-      data, options, patchDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'upsertGraphAndFetch',
+      data,
+      options,
+      patchDitoGraphOptions
+    )
   }
 
   updateDitoGraph(data, options) {
-    return this._handleDitoGraph('upsertGraph',
-      data, options, updateDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'upsertGraph',
+      data,
+      options,
+      updateDitoGraphOptions
+    )
   }
 
   updateDitoGraphAndFetch(data, options) {
-    return this._handleDitoGraph('upsertGraphAndFetch',
-      data, options, updateDitoGraphOptions)
+    return this.#handleDitoGraph(
+      'upsertGraphAndFetch',
+      data,
+      options,
+      updateDitoGraphOptions
+    )
   }
 
   upsertDitoGraphAndFetchById(id, data, options) {
     this.context({ byId: id })
-    return this.upsertDitoGraphAndFetch({
-      ...data,
-      ...this.modelClass().getReference(id)
-    }, options)
+    return this.upsertDitoGraphAndFetch(
+      {
+        ...data,
+        ...this.modelClass().getReference(id)
+      },
+      options
+    )
   }
 
   patchDitoGraphAndFetchById(id, data, options) {
     this.context({ byId: id })
-    return this.patchDitoGraphAndFetch({
-      ...data,
-      ...this.modelClass().getReference(id)
-    }, options)
+    return this.patchDitoGraphAndFetch(
+      {
+        ...data,
+        ...this.modelClass().getReference(id)
+      },
+      options
+    )
   }
 
   updateDitoGraphAndFetchById(id, data, options) {
     this.context({ byId: id })
-    return this.updateDitoGraphAndFetch({
-      ...data,
-      ...this.modelClass().getReference(id)
-    }, options)
+    return this.updateDitoGraphAndFetch(
+      {
+        ...data,
+        ...this.modelClass().getReference(id)
+      },
+      options
+    )
   }
 
-  _handleDitoGraph(method, data, options, defaultOptions) {
+  #handleDitoGraph(method, data, options, defaultOptions) {
     const handleGraph = data => {
       const graphProcessor = new DitoGraphProcessor(
         this.modelClass(),
@@ -615,10 +687,10 @@ export class QueryBuilder extends objection.QueryBuilder {
       // `_upsertCyclicDitoGraphAndFetch()` needs to run asynchronously,
       // but we can't do so here and `runBefore()` executes too late,
       // so use `_executeFirst()` to work around it.
-      this._executeFirst = async () => {
-        this._executeFirst = null
+      this.#executeFirst = async () => {
+        this.#executeFirst = null
         handleGraph(
-          await this.clone()._upsertCyclicDitoGraphAndFetch(data, options)
+          await this.clone().#upsertCyclicDitoGraphAndFetch(data, options)
         )
       }
     } else {
@@ -628,7 +700,7 @@ export class QueryBuilder extends objection.QueryBuilder {
     return this
   }
 
-  async _upsertCyclicDitoGraphAndFetch(data, options) {
+  async #upsertCyclicDitoGraphAndFetch(data, options) {
     // TODO: This is part of a workaround for the following Objection.js issue.
     // Replace with a normal `upsertGraphAndFetch()` once it is fixed:
     // https://github.com/Vincit/objection.js/issues/1482
@@ -697,7 +769,8 @@ export class QueryBuilder extends objection.QueryBuilder {
     for (const method of mixinMethods) {
       if (method in target) {
         console.warn(
-          `There is already a property named '${method}' on '${target}'`)
+          `There is already a property named '${method}' on '${target}'`
+        )
       } else {
         Object.defineProperty(target, method, {
           value(...args) {
@@ -713,23 +786,6 @@ export class QueryBuilder extends objection.QueryBuilder {
 
 KnexHelper.mixin(QueryBuilder.prototype)
 
-// Override all deprecated eager methods to respect the `_ignoreGraph` flag,
-// and also keep track of `_graphAlgorithm`, as required by `withGraph()`
-// TODO: Remove once we move to Objection 3.0
-for (const key of [
-  'eager', 'joinEager', 'naiveEager',
-  'mergeEager', 'mergeJoinEager', 'mergeNaiveEager'
-]) {
-  const method = QueryBuilder.prototype[key]
-  QueryBuilder.prototype[key] = function(...args) {
-    if (!this._ignoreGraph) {
-      this._graphAlgorithm = /join/i.test(key) ? 'join' : 'fetch'
-      method.call(this, ...args)
-    }
-    return this
-  }
-}
-
 // Add conversion of identifiers to all `where` statements, as well as to
 // `select` and `orderBy`, by detecting use of model properties and expanding
 // them to `${tableRefFor(modelClass}.${propertyName}`, for unambiguous
@@ -762,16 +818,17 @@ for (const key of [
   'groupBy', 'orderBy'
 ]) {
   const method = QueryBuilder.prototype[key]
-  QueryBuilder.prototype[key] = function(...args) {
+  QueryBuilder.prototype[key] = function (...args) {
     const modelClass = this.modelClass()
     const { properties } = modelClass.definition
 
     // Expands all identifiers known to the model to their extended versions.
     const expandIdentifier = identifier => {
       // Support expansion of identifiers with aliases, e.g. `name AS newName`
-      const alias =
+      const alias = (
         isString(identifier) &&
         identifier.match(/^\s*([a-z][\w_]+)(\s+AS\s+.*)$/i)
+      )
       return alias
         ? `${expandIdentifier(alias[1])}${alias[2]}`
         : identifier === '*' || identifier in properties
@@ -801,9 +858,11 @@ for (const key of [
 }
 
 function filterScopes(scopes, callback) {
-  return Object.fromEntries(Object.entries(scopes).filter(
-    ([scope, graph]) => callback(scope, graph)
-  ))
+  return Object.fromEntries(
+    Object.entries(scopes).filter(
+      ([scope, graph]) => callback(scope, graph)
+    )
+  )
 }
 
 // The default options for insertDitoGraph(), upsertDitoGraph(),
@@ -842,7 +901,7 @@ function addGraphScope(modelClass, expr, scopes, modifiers, isRoot = false) {
     // and if it's actually available in the model's list of modifiers.
     for (const scope of scopes) {
       if (
-        !expr.$modify?.includes(scope) && (
+        !expr.$modify.includes(scope) && (
           modelClass.hasScope(scope) ||
           modifiers[scope]
         )
@@ -899,8 +958,6 @@ const mixinMethods = [
   'clearWithScope',
 
   'clear',
-  'pick',
-  'omit',
   'select',
 
   'insert',