objection 3.8.0 → 3.9.0

package/lib/queryBuilder/operations/LimitPerParentOperation.js

@@ -5,6 +5,7 @@ const { RangeOperation } = require('./RangeOperation');
 const { FirstOperation } = require('./FirstOperation');
 const { isString, isNumber } = require('../../utils/objectUtils');
 const { hasWindowFunctions, isKnexRaw } = require('../../utils/knexUtils');
+const { Selection, isSameTable, withoutSchema } = require('./select/Selection');
 
 // Without underscores, so that column name mappers don't change it.
 const rowNumberColumn = 'objectiontmprownum';
@@ -55,23 +56,18 @@ class LimitPerParentOperation extends QueryBuilderOperation {
       // table, so that the order can refer to the selected columns and their
       // aliases as in the query itself, e.g. to `id` when a joined table has
       // an `id` too. The order moves into the window function, as SQL Server
-      // doesn't allow it in subqueries.
+      // doesn't allow it in subqueries. An alias can't have a schema.
+      const table = withoutSchema(builder.tableRef());
+      // knex only accepts raw partitions wrapped in objects:
+      const partition = this.findOperation.ownerKeys(builder, table).map((column) => ({ column }));
       const numberedQuery = knex
         .queryBuilder()
         .select('*')
         .rowNumber(rowNumberColumn, (window) =>
-          window
-            .orderBy(getWindowOrder(builder, knex))
-            .partitionBy(this.findOperation.ownerKeyColumns()),
+          window.orderBy(getWindowOrder(builder, knex, table)).partitionBy(partition),
         )
         .from(
-          knexBuilder
-            .clone()
-            .clear('with')
-            .clear('limit')
-            .clear('offset')
-            .clear('order')
-            .as(builder.tableRef()),
+          knexBuilder.clone().clear('with').clear('limit').clear('offset').clear('order').as(table),
         );
 
       // Select the rows in range with the query itself, to keep its settings
@@ -103,9 +99,18 @@ class LimitPerParentOperation extends QueryBuilderOperation {
 }
 
 // Convert the `orderBy()` and `orderByRaw()` calls of the query to the order
-// of knex's window functions.
-function getWindowOrder(builder, knex) {
+// of knex's window functions, which can only refer to the related table by its
+// alias `table`.
+function getWindowOrder(builder, knex, table) {
   const order = [];
+  const tableRef = builder.tableRef();
+
+  const getAliasedColumn = (column) => {
+    const selection = isString(column) && Selection.create(column);
+    return selection?.table && isSameTable(builder, selection.table, tableRef)
+      ? `${table}.${selection.column}`
+      : column;
+  };
 
   builder.forEachOperation(builder.constructor.OrderBySelector, (op) => {
     const args = op.getKnexArgs(builder);
@@ -120,18 +125,20 @@ function getWindowOrder(builder, knex) {
         : [{ column, order: direction, nulls }];
 
       for (const item of items) {
+        const aliasedColumn = getAliasedColumn(item.column);
+
         if (item.nulls) {
           // Not all databases support `nulls first` and `nulls last`:
           order.push({
             column: knex.raw('(case when ? is null then 0 else 1 end)', [
-              isString(item.column) ? knex.ref(item.column) : item.column,
+              isString(aliasedColumn) ? knex.ref(aliasedColumn) : aliasedColumn,
             ]),
             order: item.nulls === 'first' ? 'asc' : 'desc',
           });
         }
 
         // Unlike in `orderBy()`, knex adds the direction to the window as it is:
-        order.push({ column: item.column, order: /^desc$/i.test(item.order) ? 'desc' : 'asc' });
+        order.push({ column: aliasedColumn, order: /^desc$/i.test(item.order) ? 'desc' : 'asc' });
       }
     }
   });

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -10,6 +10,7 @@ const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
 const { StaticHookArguments } = require('../StaticHookArguments');
+const { ValidationErrorType } = require('../../model/ValidationError');
 
 class UpdateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
@@ -110,7 +111,8 @@ async function callStaticAfterUpdate(builder, result) {
 
 function convertFieldExpressionsToRaw(builder, model, json) {
   const knex = builder.knex();
-  const declaredColumns = getDeclaredColumns(builder.modelClass());
+  const modelClass = builder.modelClass();
+  const declaredColumns = getDeclaredColumns(modelClass);
   const convertedJson = {};
 
   for (const key of Object.keys(json)) {
@@ -118,10 +120,30 @@ function convertFieldExpressionsToRaw(builder, model, json) {
 
     if (isFieldExpressionKey(key, declaredColumns)) {
       // 'col:attr' : ref('other:lol') is transformed to
-      // "col" : raw(`jsonb_set("col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      // "col" : raw(`jsonb_set("table"."col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      // with the column qualified, as it is ambiguous with `excluded` in merge().
       warnIfNotPostgres(knex);
 
       let parsed = ref(key);
+
+      // The field expression would be lost or produce invalid SQL next to a
+      // value for the whole json column. Report it with the property names:
+      if (Object.prototype.hasOwnProperty.call(json, parsed.column)) {
+        const property = modelClass.columnNameToPropertyName(parsed.column);
+        throw modelClass.createValidationError({
+          type: ValidationErrorType.ModelValidation,
+          data: {
+            [modelClass.columnNameToPropertyName(key)]: [
+              {
+                message: `can't be combined with a value for the json column '${property}'`,
+                keyword: null,
+                params: { property },
+              },
+            ],
+          },
+        });
+      }
+
       let jsonPath = toPostgresJsonPathLiteral(parsed.parsedExpr.access);
       let valuePlaceholder = '?';
 
@@ -133,7 +155,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
 
       convertedJson[parsed.column] = knex.raw(
         `jsonb_set(??, ${jsonPath}, ${valuePlaceholder}, true)`,
-        [convertedJson[parsed.column] || parsed.column, val],
+        [convertedJson[parsed.column] || `${builder.tableRef()}.${parsed.column}`, val],
       );
 
       delete model[key];
@@ -170,4 +192,5 @@ function getDeclaredColumns(modelClass) {
 module.exports = {
   UpdateOperation,
   convertFieldExpressionsToRaw,
+  getDeclaredColumns,
 };

package/lib/queryBuilder/operations/jsonApi/postgresJsonApi.js

@@ -47,7 +47,7 @@ const { warnOnce } = require('../../../utils/warnings');
 
 // JSON field expressions and the `whereJson*()` methods generate Postgres-only
 // SQL (ditojs#113). As some of it happens to run on other databases, only warn.
-// TODO: Consider throwing an error instead in objection 4.0.
+// TODO: Consider throwing an error instead in objection 4.0 (#272).
 function warnIfNotPostgres(knex) {
   if (!isPostgres(knex)) {
     warnOnce(

package/lib/queryBuilder/operations/select/Selection.js

@@ -63,11 +63,11 @@ class Selection {
     if (selectionInBuilder.column === '*') {
       if (selectionInBuilder.table) {
         if (selectionToTest.column === '*') {
-          return isSameIdentifier(builder, selectionToTest.table, selectionInBuilder.table);
+          return isSameTable(builder, selectionToTest.table, selectionInBuilder.table);
         } else {
           return (
             selectionToTest.table === null ||
-            isSameIdentifier(builder, selectionToTest.table, selectionInBuilder.table)
+            isSameTable(builder, selectionToTest.table, selectionInBuilder.table)
           );
         }
       } else {
@@ -82,7 +82,7 @@ class Selection {
         return (
           isSameIdentifier(builder, selectionToTest.column, selectionInBuilder.column) &&
           (selectionToTest.table === null ||
-            isSameIdentifier(builder, selectionToTest.table, selectionInBuilderTable))
+            isSameTable(builder, selectionToTest.table, selectionInBuilderTable))
         );
       }
     }
@@ -110,6 +110,26 @@ function isSameIdentifier(builder, identifier1, identifier2) {
   }
 }
 
+// As in SQL, a table name without a schema refers to the table with a schema:
+// `persons` and `public.persons` are the same table.
+function isSameTable(builder, table1, table2) {
+  if (isSameIdentifier(builder, table1, table2)) {
+    return true;
+  } else if (!table1 || !table2 || hasSchema(table1) === hasSchema(table2)) {
+    return false;
+  } else {
+    return isSameIdentifier(builder, withoutSchema(table1), withoutSchema(table2));
+  }
+}
+
+function hasSchema(table) {
+  return table.includes('.');
+}
+
+function withoutSchema(table) {
+  return table.slice(table.lastIndexOf('.') + 1);
+}
+
 function mapIdentifier(builder, identifier) {
   const knex = builder.unsafeKnex();
   const wrapIdentifier = knex && knex.client && knex.client.config.wrapIdentifier;
@@ -211,5 +231,7 @@ function createSelectionFromString(selection) {
 module.exports = {
   Selection,
   isSameIdentifier,
+  isSameTable,
   mapIdentifier,
+  withoutSchema,
 };

package/lib/relations/RelationFindOperation.js

@@ -76,9 +76,12 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
-  // The columns of the result rows that hold the keys of their owners:
-  ownerKeyColumns() {
-    return this.relation.relatedProp.cols;
+  // The expressions of the result rows in `table` that hold the keys of their
+  // owners, including json references:
+  ownerKeys(builder, table) {
+    return this.relation.relatedProp
+      .refs(builder)
+      .map((ref) => ref.table(table).toKnexRaw(builder));
   }
 
   warnOnInvalidOwnerProps() {
@@ -93,7 +96,7 @@ class RelationFindOperation extends FindOperation {
   // `select()`, silently get no related models (#1832). Only `undefined`
   // is reported, as `null` is a legit value for a missing relation, and
   // owner props that may legitimately be unset are skipped (#132).
-  // TODO: Consider throwing an error instead in objection 4.0.
+  // TODO: Consider throwing an error instead in objection 4.0 (#272).
   warnOnMissingOwnerProps() {
     const { ownerProp } = this.relation;
 

package/lib/relations/RelationOwner.js

@@ -2,6 +2,7 @@
 
 const { isObject, asArray, asSingle, uniqBy } = require('../utils/objectUtils');
 const { normalizeIds } = require('../utils/normalizeIds');
+const { valuesKey } = require('../model/modelValues');
 
 const Type = {
   Models: 'Models',
@@ -123,7 +124,7 @@ class RelationOwner {
       return null;
     }
 
-    return uniqBy(props, join);
+    return uniqBy(props, valuesKey);
   }
 
   _getPropsFromIdentifiers(relation, ownerProp) {
@@ -218,10 +219,6 @@ function containsNonNull(arr) {
   return false;
 }
 
-function join(id) {
-  return id.map((x) => (Buffer.isBuffer(x) ? x.toString('hex') : x)).join(',');
-}
-
 function isIdProp(relationProp) {
   const idProp = relationProp.modelClass.getIdRelationProperty();
   return idProp.props.every((prop, i) => prop === relationProp.props[i]);

package/lib/relations/RelationProperty.js

@@ -2,7 +2,7 @@
 
 const { asArray, isObject, uniqBy, get, set } = require('../utils/objectUtils');
 const { ref: createRef } = require('../queryBuilder/ReferenceBuilder');
-const { propToStr, PROP_KEY_PREFIX } = require('../model/modelValues');
+const { valuesKey } = require('../model/modelValues');
 
 class ModelNotFoundError extends Error {
   constructor(tableName) {
@@ -86,20 +86,9 @@ class RelationProperty {
     }
   }
 
-  // Creates a concatenated string from the property values of the given object.
+  // Creates a key from the property values of the given object.
   propKey(obj) {
-    const size = this.size;
-    let key = PROP_KEY_PREFIX;
-
-    for (let i = 0; i < size; ++i) {
-      key += propToStr(this.getProp(obj, i));
-
-      if (i !== size - 1) {
-        key += ',';
-      }
-    }
-
-    return key;
+    return valuesKey(this.getProps(obj));
   }
 
   // Returns the property values of the given object as an array.

package/lib/relations/belongsToOne/BelongsToOneInsertOperation.js

@@ -2,6 +2,7 @@
 
 const { RelationInsertOperation } = require('../RelationInsertOperation');
 const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
+const { InsertGraphOperation } = require('../../queryBuilder/operations/InsertGraphOperation');
 
 class BelongsToOneInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
@@ -17,7 +18,10 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
   async onAfter1(builder, ret) {
     const inserted = await super.onAfter1(builder, ret);
 
-    if (!builder.isExecutable()) {
+    // A query resolved without executing it, e.g. with `resolve()`, inserted
+    // nothing. `insertGraph()` resolves the query itself, but always inserts
+    // the graph.
+    if (!builder.isExecutable() && !builder.has(InsertGraphOperation)) {
       return inserted;
     }
 

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

@@ -84,7 +84,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
   }
 
   // @override
-  ownerKeyColumns() {
+  ownerKeys() {
     return this.ownerJoinColumnAlias;
   }
 

package/lib/relations/manyToMany/insert/ManyToManyInsertOperation.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { hasBatchInsert } = require('../../../utils/knexUtils');
 const { RelationInsertOperation } = require('../../RelationInsertOperation');
 const { ManyToManyRelateOperation } = require('../relate/ManyToManyRelateOperation');
 
@@ -19,13 +20,6 @@ class ManyToManyInsertOperation extends RelationInsertOperation {
   async onAfter1(builder, ret) {
     const inserted = await super.onAfter1(builder, ret);
 
-    const relateOp = new ManyToManyRelateOperation('relate', {
-      dontCopyReturning: true,
-      dontCopyOnConflict: true,
-      relation: this.relation,
-      owner: this.owner,
-    });
-
     const modelsToRelate = inserted.filter((it) => {
       return this.relation.relatedProp.hasProps(it);
     });
@@ -36,13 +30,26 @@ class ManyToManyInsertOperation extends RelationInsertOperation {
       }
     }
 
-    if (modelsToRelate.length === 0) {
-      return inserted;
+    if (modelsToRelate.length > 0) {
+      // Without batch inserts, `insertGraph()` inserts the related models one at
+      // a time, and so we need to do the same with their join rows:
+      const batches = hasBatchInsert(builder.knex())
+        ? [modelsToRelate]
+        : modelsToRelate.map((model) => [model]);
+
+      for (const batch of batches) {
+        const relateOp = new ManyToManyRelateOperation('relate', {
+          dontCopyReturning: true,
+          dontCopyOnConflict: true,
+          relation: this.relation,
+          owner: this.owner,
+        });
+
+        relateOp.onAdd(builder, [batch]);
+        await relateOp.queryExecutor(builder);
+      }
     }
 
-    relateOp.onAdd(builder, [modelsToRelate]);
-    await relateOp.queryExecutor(builder);
-
     return inserted;
   }
 }

package/lib/relations/manyToMany/update/ManyToManyUpdateMySqlOperation.js

@@ -3,24 +3,9 @@
 const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
 const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
 
-const LimitSelector = /^(orderBy\w*|limit|offset)$/;
-
 class ManyToManyUpdateMySqlOperation extends ManyToManyMySqlModifyMixin(
   ManyToManyUpdateOperationBase,
-) {
-  // MySQL is the only database that supports a limit in updates. Updates that
-  // modify the join rows too update the related rows by their ids, so the limit
-  // and the order pick these ids instead of limiting each batch of them. Without
-  // a limit or an offset, the order picks nothing and the query stays as it is.
-  onBuild(builder) {
-    super.onBuild(builder);
-
-    if (this.relatedIdsQuery && builder.has(/^(limit|offset)$/)) {
-      this.relatedIdsQuery.copyFrom(builder, LimitSelector);
-      builder.clear(LimitSelector);
-    }
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUpdateMySqlOperation,

package/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -3,11 +3,14 @@
 const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
 const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
 const { chunk } = require('../../../utils/objectUtils');
+const { isMySql, isMsSql } = require('../../../utils/knexUtils');
 
 // Stay below the limits of bound values per statement of SQLite before 3.32
 // (999) and SQL Server (2100), leaving room for the patched values:
 const maxBatchValues = 500;
 
+const LimitSelector = /^(orderBy\w*|limit|offset)$/;
+
 class ManyToManyUpdateOperationBase extends UpdateOperation {
   constructor(name, opt) {
     super(name, opt);
@@ -59,9 +62,21 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
 
   onBuild(builder) {
     if (this.modifiesJoinTable && this.modifyFilterSubquery) {
+      // MySQL and SQL Server are the only databases that support a limit in
+      // updates. As the related rows are updated by their ids, the limit and
+      // the order pick these ids instead of limiting each batch of them.
+      // Without a limit or an offset, the order picks nothing and the query
+      // stays as it is.
+      const knex = builder.knex();
+      const hasLimit = (isMySql(knex) || isMsSql(knex)) && builder.has(/^(limit|offset)$/);
+
       // The related rows to update are identified by their ids first, see
       // `onAfterBuild()`.
-      this.relatedIdsQuery = this.createRelatedIdsQuery(builder);
+      this.relatedIdsQuery = this.createRelatedIdsQuery(builder, hasLimit);
+      if (hasLimit) {
+        this.relatedIdsQuery.copyFrom(builder, LimitSelector);
+        builder.clear(LimitSelector);
+      }
     }
 
     return super.onBuild(builder);
@@ -69,11 +84,23 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
 
   // Selects the ids of the related rows to update. Fetch raw rows, so that no
   // hooks run for them.
-  createRelatedIdsQuery(builder) {
-    const relatedIdsQuery = this.relation.relatedModelClass.query().childQueryOf(builder);
-    const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
-
-    return this.applyModifyFilterForRelatedTable(relatedIdsQuery).select(idRefs);
+  createRelatedIdsQuery(builder, hasLimit) {
+    const { relatedModelClass } = this.relation;
+
+    if (hasLimit) {
+      // The limit picks related rows, not join rows, so filter the related
+      // table by the ids of the matching join rows:
+      const relatedIdsQuery = relatedModelClass.query().childQueryOf(builder);
+      const idRefs = relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
+      return this.applyModifyFilterForRelatedTable(relatedIdsQuery).select(idRefs);
+    } else {
+      // Select the ids from the filter subquery itself. Filtering the related
+      // table by them again lets Postgres pick plans that run the subquery
+      // once per related row, which takes minutes for a few thousand (#161).
+      const relatedIdsQuery = this.modifyFilterSubquery.clone();
+      const idRefs = relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
+      return relatedIdsQuery.distinct(idRefs);
+    }
   }
 
   // Update the join rows before the related rows, while the filters still
@@ -88,6 +115,7 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
         this.relatedIds = rows.map((row) => Object.values(row));
       }
 
+      let numJoinRowsUpdated;
       if (this.relatedIdsQuery?.has(/^(limit|offset)$/)) {
         // The filters match the join rows of more related rows than the limit
         // picks, so only update the join rows of the picked ones.
@@ -95,7 +123,15 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
           await this.updateJoinRows(builder, ids);
         }
       } else {
-        await this.updateJoinRows(builder);
+        numJoinRowsUpdated = await this.updateJoinRows(builder);
+      }
+
+      if (this.hasNothingToUpdate) {
+        // Only the join rows change, so count the related rows that they
+        // belong to, as the update of the related rows does. Without their
+        // ids, the join rows all belong to the updated model, see
+        // `applyIdFilterForJoinTable()`.
+        builder.resolve(this.relatedIds?.length ?? Math.min(numJoinRowsUpdated, 1));
       }
     }
   }

package/lib/utils/knexUtils.js

@@ -36,6 +36,12 @@ function isMsSql(knex) {
   return getDialect(knex) === 'mssql';
 }
 
+// Only Postgres and SQL Server return the identifiers of all the rows inserted
+// by one query.
+function hasBatchInsert(knex) {
+  return isPostgres(knex) || isMsSql(knex);
+}
+
 // MySQL supports window functions since 8.0, MariaDB since 10.2. Without a
 // version, knex assumes the latest one, and so do we.
 function hasWindowFunctions(knex) {
@@ -82,6 +88,7 @@ module.exports = {
   isSqlite,
   isMsSql,
   isOracle,
+  hasBatchInsert,
   hasWindowFunctions,
   isKnexQueryBuilder,
   isKnexJoinBuilder,

package/lib/utils/objectUtils.js

@@ -16,6 +16,10 @@ function isObject(value) {
   return value !== null && typeof value === 'object';
 }
 
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
 // Quick and dirty check if an object is a plain object and not
 // for example an instance of some class.
 function isPlainObject(value) {
@@ -502,6 +506,7 @@ module.exports = {
   isString,
   isRegExp,
   isObject,
+  hasOwn,
   isNumber,
   isFunction,
   jsonEquals,

package/lib/utils/parseFieldExpression.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const jsonFieldExpressionParser = require('../queryBuilder/parsers/jsonFieldExpressionParser');
-const { isObject } = require('./objectUtils');
+const { isObject, hasOwn } = require('./objectUtils');
 const cache = new Map();
 
 function parseFieldExpression(expr) {
@@ -51,10 +51,7 @@ function freezeParsedExpr(parsedExpr) {
 // `'meta:a.b'` that write into json columns, unless they are `declared`: the
 // `properties` of the schema, or an object with their column names as keys.
 function isFieldExpressionKey(key, declared) {
-  return (
-    key.includes(':') &&
-    !(isObject(declared) && Object.prototype.hasOwnProperty.call(declared, key))
-  );
+  return key.includes(':') && !(isObject(declared) && hasOwn(declared, key));
 }
 
 // Formats the json path of a parsed field expression as a Postgres text array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",

package/typings/objection/index.d.ts

@@ -374,20 +374,30 @@ declare namespace Objection {
 
   /**
    * Converts the query builder NQB to the same result kind as QB:
-   * array, single, maybe-single or page. Any other result type, e.g. after
+   * array, page, single or maybe-single. Any other result type, e.g. after
    * `castTo()` or `patch()`, falls back to QB, without narrowing.
+   * QB's model type M and result type R are separate parameters so that QB
+   * only appears in the result, and TypeScript can relate the kinds of two
+   * query builders, e.g. of a custom query builder and its base class, through
+   * QB alone. The page and `object` checks come before the single ones, so
+   * that results like `number` or `Page<M>` are ruled out for a generic M too.
    */
-  type WithResultKind<QB extends AnyQueryBuilder, NQB extends AnyQueryBuilder> = [
-    ResultType<QB>,
-  ] extends [ModelType<QB>[]]
+  type WithResultKind<
+    QB extends AnyQueryBuilder,
+    NQB extends AnyQueryBuilder,
+    M extends Model = ModelType<QB>,
+    R = ResultType<QB>,
+  > = [R] extends [M[]]
     ? ArrayQueryBuilder<NQB>
-    : [ResultType<QB>] extends [ModelType<QB>]
-      ? SingleQueryBuilder<NQB>
-      : [ResultType<QB>] extends [ModelType<QB> | undefined]
-        ? MaybeSingleQueryBuilder<NQB>
-        : [ResultType<QB>] extends [Page<ModelType<QB>>]
-          ? PageQueryBuilder<NQB>
-          : QB;
+    : [R] extends [Page<M>]
+      ? PageQueryBuilder<NQB>
+      : [R] extends [object | undefined]
+        ? [R] extends [M]
+          ? SingleQueryBuilder<NQB>
+          : [R] extends [M | undefined]
+            ? MaybeSingleQueryBuilder<NQB>
+            : QB
+        : QB;
 
   /**
    * If T is an array, returns the item type, otherwise returns T.