objection 3.3.0 → 3.4.1

package/lib/queryBuilder/join/RelationJoiner.js

@@ -2,13 +2,14 @@
 
 const { uniqBy } = require('../../utils/objectUtils');
 const { Selection } = require('../operations/select/Selection');
+const { SelectOperation } = require('../operations/select/SelectOperation');
 const { createModifier } = require('../../utils/createModifier');
 const { map: mapPromise } = require('../../utils/promiseUtils');
 const { ValidationErrorType } = require('../../model/ValidationError');
 
 const { TableTree } = require('./TableTree');
 const { JoinResultParser } = require('./JoinResultParser');
-const { ID_LENGTH_LIMIT } = require('./utils');
+const { getIdentifierLengthLimit } = require('./utils');
 
 /**
  * Given a relation expression, builds a query using joins to fetch it.
@@ -124,7 +125,7 @@ class RelationJoiner {
     // also contain selects.
     userSelectQuery.modify(tableNode.relation.modify);
 
-    if (selectsOnlyAliasesKeepingSelectAll(userSelectQuery.findAllSelections())) {
+    if (selectsOnlyAliasesKeepingSelectAll(findJoinSelections(userSelectQuery))) {
       // All columns are selected from the joined subquery in the main query,
       // so the subquery needs to select them too.
       subqueryToJoin.select(`${subqueryToJoin.tableRef()}.*`);
@@ -179,8 +180,10 @@ class RelationJoiner {
       userSelectQueries,
     });
 
+    const lengthLimit = getIdentifierLengthLimit(builder.knex());
+
     for (const selection of selections) {
-      checkAliasLength(tableNode.modelClass, selection.name);
+      checkAliasLength(tableNode.modelClass, selection.name, lengthLimit);
     }
 
     // Save the selections that were added internally (not by the user)
@@ -266,7 +269,7 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
   ];
 
   const selectStrings = uniqBy(cols)
-    .filter((col) => !builder.hasSelectionAs(col, col))
+    .filter((col) => !hasSelectionAs(builder, col))
     .map((col) => `${tableRef}.${col}`);
 
   return builder.select(selectStrings);
@@ -274,7 +277,7 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
 
 function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
   const userSelectQuery = userSelectQueries.get(tableNode);
-  const userSelections = userSelectQuery.findAllSelections();
+  const userSelections = findUserSelections(userSelectQuery, tableNode);
   const userSelectedAllColumns = isSelectAllSelectionSet(userSelections);
 
   let selections = [];
@@ -296,7 +299,7 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
     const idSelections = getIdSelectionsForNode({ tableNode });
 
     for (const idSelection of idSelections) {
-      if (!userSelectQuery.hasSelectionAs(idSelection.column, idSelection.column)) {
+      if (!hasUserSelectionAs(userSelectQuery, tableNode, idSelection.column)) {
         selections.push(idSelection);
         internalSelections.push(idSelection);
       }
@@ -316,6 +319,54 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
   };
 }
 
+// Like `builder.findAllSelections()`, but aggregates select their aliases
+// instead of the columns they're passed. Aggregates without an alias are left
+// out, as their column name differs between databases.
+function findJoinSelections(builder) {
+  let selections = [];
+
+  builder.forEachOperation(true, (op) => {
+    if (op.constructor === SelectOperation) {
+      selections = selections.concat(op.aggregateSelections || op.selections);
+    }
+  });
+
+  return selections;
+}
+
+// Like `builder.hasSelectionAs(column, column)`, but ignoring the columns
+// passed to aggregates, as they don't select them.
+function hasSelectionAs(builder, column) {
+  if (builder.has(isAggregateOperation)) {
+    // Explicit, as a query with only aggregates doesn't select all columns.
+    return builder.clone().clear(isAggregateOperation).hasSelectionAs(column, column, true);
+  } else {
+    return builder.hasSelectionAs(column, column);
+  }
+}
+
+// Only the joined subqueries select aggregates by their aliases. The root
+// query keeps treating the columns passed to them as selected.
+function findUserSelections(builder, tableNode) {
+  if (tableNode.parentNode) {
+    return findJoinSelections(builder);
+  } else {
+    return builder.findAllSelections();
+  }
+}
+
+function hasUserSelectionAs(builder, tableNode, column) {
+  if (tableNode.parentNode) {
+    return hasSelectionAs(builder, column);
+  } else {
+    return builder.hasSelectionAs(column, column);
+  }
+}
+
+function isAggregateOperation(op) {
+  return op.constructor === SelectOperation && op.aggregateSelections !== null;
+}
+
 function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode }) {
   return userSelections.filter(isNotSelectAll).map((selection) => {
     return new Selection(
@@ -393,11 +444,13 @@ function selectsOnlyAliasesKeepingSelectAll(selections) {
   return selections.length > 0 && selections.every((it) => it.keepsSelectAll);
 }
 
-function checkAliasLength(modelClass, alias) {
-  if (alias.length > ID_LENGTH_LIMIT) {
+function checkAliasLength(modelClass, alias, lengthLimit) {
+  if (alias.length > lengthLimit) {
     throw modelClass.createValidationError({
       type: ValidationErrorType.RelationExpression,
-      message: `identifier ${alias} is over ${ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
+      message:
+        `identifier ${alias} is over ${lengthLimit} characters long and would be truncated by the database engine. ` +
+        'Use the `minimize` option of withGraphJoined() to shorten the aliases.',
     });
   }
 }

package/lib/queryBuilder/join/utils.js

@@ -1,10 +1,27 @@
 'use strict';
 
 const { ValidationErrorType } = require('../../model/ValidationError');
+const { isPostgres, isMySql, isMsSql, isSqlite } = require('../../utils/knexUtils');
 
-const ID_LENGTH_LIMIT = 63;
 const RELATION_RECURSION_LIMIT = 64;
 
+// The maximum length of the column aliases of the joined relations, after
+// which the database would truncate them. Unknown databases use the strictest
+// of the known limits, the one of postgres.
+function getIdentifierLengthLimit(knex) {
+  if (isPostgres(knex)) {
+    return 63;
+  } else if (isMySql(knex)) {
+    return 256;
+  } else if (isMsSql(knex)) {
+    return 128;
+  } else if (isSqlite(knex)) {
+    return Infinity;
+  } else {
+    return 63;
+  }
+}
+
 // Given a relation expression, goes through all first level children.
 function forEachChildExpression(expr, modelClass, callback) {
   if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
@@ -18,8 +35,9 @@ function forEachChildExpression(expr, modelClass, callback) {
 }
 
 module.exports = {
-  ID_LENGTH_LIMIT,
   RELATION_RECURSION_LIMIT,
 
+  getIdentifierLengthLimit,
+
   forEachChildExpression,
 };

package/lib/queryBuilder/operations/InsertOperation.js

@@ -38,18 +38,20 @@ class InsertOperation extends QueryBuilderOperation {
   onBuildKnex(knexBuilder, builder) {
     const knex = builder.knex();
 
-    if (!builder.has(/returning/)) {
+    const defaultReturning = getDefaultReturning(builder);
+
+    if (!builder.has(/returning/) && defaultReturning !== null) {
       if (!isSqlite(knex) && !isMySql(knex)) {
         // If the user hasn't specified a `returning` clause, we make sure
         // that at least the identifier is returned. With `onConflict()` the
         // conflict columns are returned too, so that the returned rows can
         // be matched to the models when some of the rows are ignored.
-        knexBuilder = knexBuilder.returning(getDefaultReturning(builder));
+        knexBuilder = knexBuilder.returning(defaultReturning);
       } else if (isSqlite(knex) && builder.has('onConflict')) {
         // Without a `returning` clause, SQLite returns the id of the last
         // inserted row, which belongs to a previous insert if the row was
         // ignored. Use `returning` to find out what was actually inserted.
-        knexBuilder = knexBuilder.returning(getDefaultReturning(builder));
+        knexBuilder = knexBuilder.returning(defaultReturning);
       }
     }
 
@@ -77,7 +79,7 @@ class InsertOperation extends QueryBuilderOperation {
           this.models[i].$setDatabaseJson(ret[i]);
         }
       }
-    } else {
+    } else if (builder.modelClass().getIdColumnArray().length > 0) {
       // If the return value is not an array of objects, we assume it is an array of identifiers.
       for (let i = 0, l = this.models.length; i < l; ++i) {
         const model = this.models[i];
@@ -113,10 +115,15 @@ class InsertOperation extends QueryBuilderOperation {
   }
 }
 
+// Returns `null` if there's nothing to return, e.g. for models without an `idColumn`.
 function getDefaultReturning(builder) {
   const idColumns = builder.modelClass().getIdColumnArray();
   const columns = Array.from(new Set(idColumns.concat(getConflictColumns(builder))));
 
+  if (columns.length === 0) {
+    return null;
+  }
+
   return columns.length === 1 ? columns[0] : columns;
 }
 

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -5,6 +5,7 @@ const { isEmpty } = require('../../utils/objectUtils');
 const { toPostgresJsonPathLiteral } = require('../../utils/parseFieldExpression');
 const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
 const { StaticHookArguments } = require('../StaticHookArguments');
 
 class UpdateOperation extends QueryBuilderOperation {
@@ -103,6 +104,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
     if (key.indexOf(':') > -1) {
       // 'col:attr' : ref('other:lol') is transformed to
       // "col" : raw(`jsonb_set("col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      warnIfNotPostgres(knex);
 
       let parsed = ref(key);
       let jsonPath = toPostgresJsonPathLiteral(parsed.parsedExpr.access);

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

@@ -5,6 +5,7 @@ const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConver
 
 class WhereJsonHasPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
+    jsonApi.warnIfNotPostgres(builder.knex());
     const args = this.getKnexArgs(builder);
 
     const rawArgs = jsonApi.whereJsonFieldRightStringArrayOnLeftQuery(

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

@@ -5,6 +5,7 @@ const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConver
 
 class WhereJsonNotObjectPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
+    jsonApi.warnIfNotPostgres(builder.knex());
     return this.whereJsonNotObject(knexBuilder, builder.knex(), this.getKnexArgs(builder)[0]);
   }
 

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

@@ -2,9 +2,28 @@
 
 const jsonApi = require('./postgresJsonApi');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
+const { parseFieldExpression } = require('../../../utils/parseFieldExpression');
+const { isPlainObject, isString, isFunction } = require('../../../utils/objectUtils');
+const { isMySql } = require('../../../utils/knexUtils');
 
 class WhereJsonPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
+    const knex = builder.knex();
+
+    if (isMySql(knex) && this.canDelegateToKnex(knexBuilder)) {
+      // On MySQL, knex's version of the method works (ditojs#113). The `or`
+      // variants are wrapped in `orWhere()`, as knex < 3 ignores their `or`.
+      const [column, value] = this.getKnexArgs(builder);
+      const { knexMethod } = this.opt;
+
+      if (this.opt.bool === 'or') {
+        return knexBuilder.orWhere((qb) => qb[knexMethod](column, value));
+      } else {
+        return knexBuilder[knexMethod](column, value);
+      }
+    }
+
+    jsonApi.warnIfNotPostgres(knex);
     const args = this.getKnexArgs(builder);
 
     const rawArgs = jsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
@@ -22,6 +41,20 @@ class WhereJsonPostgresOperation extends ObjectionToKnexConvertingOperation {
 
     return knexBuilder;
   }
+
+  // Only the simple form with a plain column and a plain object or array value
+  // can be passed on to knex, as knex doesn't understand field expressions.
+  canDelegateToKnex(knexBuilder) {
+    const [column, value] = this.args;
+
+    return (
+      !!this.opt.knexMethod &&
+      isFunction(knexBuilder[this.opt.knexMethod]) &&
+      isString(column) &&
+      parseFieldExpression(column).access.length === 0 &&
+      (isPlainObject(value) || Array.isArray(value))
+    );
+  }
 }
 
 module.exports = {

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

@@ -2,7 +2,8 @@
 
 const parser = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isString } = require('../../../utils/objectUtils');
-const { isKnexRaw, isKnexQueryBuilder } = require('../../../utils/knexUtils');
+const { isKnexRaw, isKnexQueryBuilder, isPostgres } = require('../../../utils/knexUtils');
+const { deprecate } = require('../../../utils/deprecate');
 
 /**
  * @typedef {String} FieldExpression
@@ -44,6 +45,19 @@ const { isKnexRaw, isKnexQueryBuilder } = require('../../../utils/knexUtils');
  *     not currently supported
  */
 
+// 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.
+function warnIfNotPostgres(knex) {
+  if (!isPostgres(knex)) {
+    deprecate(
+      'JSON field expressions and the whereJson*() methods of objection are only supported ' +
+        'on PostgreSQL. Use the JSON methods of knex like whereJsonPath() or jsonExtract() ' +
+        'with other databases.',
+    );
+  }
+}
+
 // Returns the SQL and bindings of a field expression. The column is passed as an
 // identifier binding (`??`), so that knex's `wrapIdentifier` (e.g. used by
 // `knexSnakeCaseMappers()`) is applied to it.
@@ -168,6 +182,7 @@ function normalizeOperator(knex, operator) {
 }
 
 module.exports = {
+  warnIfNotPostgres,
   parseFieldExpression: parseFieldExpression,
   whereJsonbRefOnLeftJsonbValOrRefOnRight: whereJsonbRefOnLeftJsonbValOrRefOnRight,
   whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams:

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

@@ -1,15 +1,30 @@
 'use strict';
 
-const { flatten } = require('../../../utils/objectUtils');
+const { flatten, isString, isPlainObject } = require('../../../utils/objectUtils');
 const { Selection } = require('./Selection');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
 
 const COUNT_REGEX = /count/i;
+const ALIAS_REGEX = /\s+as\s+/i;
+
+const AGGREGATE_METHODS = new Set([
+  'count',
+  'countDistinct',
+  'min',
+  'max',
+  'sum',
+  'sumDistinct',
+  'avg',
+  'avgDistinct',
+]);
 
 class SelectOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.selections = [];
+    // The selections that aggregates select, by their aliases. `null` for
+    // non-aggregate operations.
+    this.aggregateSelections = AGGREGATE_METHODS.has(name) ? [] : null;
   }
 
   onAdd(builder, args) {
@@ -31,6 +46,12 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
       }
     }
 
+    if (this.aggregateSelections) {
+      this.aggregateSelections = getAggregateAliases(selections).map(
+        (alias) => new Selection(null, null, alias),
+      );
+    }
+
     return ret;
   }
 
@@ -57,10 +78,27 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
   clone() {
     const clone = super.clone();
     clone.selections = this.selections.slice();
+    clone.aggregateSelections = this.aggregateSelections && this.aggregateSelections.slice();
     return clone;
   }
 }
 
+// Returns the aliases of the columns an aggregate selects, supporting the same
+// argument forms as knex: `count('col as alias')`, `count('col', { as: 'alias' })`
+// and `count({ alias: 'col' })`. Aggregates without an alias are skipped, as
+// their column name differs between databases.
+function getAggregateAliases([column, options]) {
+  if (isString(column) && ALIAS_REGEX.test(column)) {
+    return [column.split(ALIAS_REGEX)[1].trim()];
+  } else if (isPlainObject(options) && isString(options.as)) {
+    return [options.as];
+  } else if (isPlainObject(column)) {
+    return Object.keys(column);
+  } else {
+    return [];
+  }
+}
+
 module.exports = {
   SelectOperation,
 };

package/lib/relations/RelationFindOperation.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { FindOperation } = require('../queryBuilder/operations/FindOperation');
+const { deprecate } = require('../utils/deprecate');
 
 class RelationFindOperation extends FindOperation {
   constructor(name, opt) {
@@ -19,8 +20,13 @@ class RelationFindOperation extends FindOperation {
     this.maybeApplyAlias(builder);
     this.relation.findQuery(builder, this.owner);
 
-    if (this.assignResultToOwner && this.owner.isModels) {
-      this.selectMissingJoinColumns(builder);
+    if (this.owner.isModels) {
+      this.warnOnMissingOwnerProps();
+
+      if (this.assignResultToOwner) {
+        this.warnOnArrayOwnerProps();
+        this.selectMissingJoinColumns(builder);
+      }
     }
   }
 
@@ -44,6 +50,8 @@ class RelationFindOperation extends FindOperation {
         arr.push(rel);
       }
 
+      this.warnOnMissingRelatedProps(related);
+
       for (let i = 0, l = owners.length; i < l; ++i) {
         const own = owners[i];
         const key = this.relation.ownerProp.propKey(own);
@@ -75,6 +83,62 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  // Owner models without the join columns, e.g. loaded with a partial
+  // `select()`, silently get no related models (#1832). Only `undefined`
+  // is reported, as `null` is a legit value for a missing relation.
+  // TODO: Consider throwing an error instead in objection 4.0.
+  warnOnMissingOwnerProps() {
+    const { ownerProp } = this.relation;
+
+    for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
+      if (this.owner.modelArray.some((owner) => ownerProp.getProp(owner, c) === undefined)) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `some owner models are missing the join property "${ownerProp.propDescription(c)}", ` +
+            'so no related models are found for them. Select the column in the owner query.',
+        );
+      }
+    }
+  }
+
+  // Owner join properties holding an array of keys, e.g. a JSON array column,
+  // aren't supported: The query finds the related models, but they can't be
+  // assigned to their owners, so all owners silently get no related models
+  // (#2667). `$relatedQuery()` without assigning the results isn't affected.
+  warnOnArrayOwnerProps() {
+    const { ownerProp } = this.relation;
+
+    for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
+      if (this.owner.modelArray.some((owner) => Array.isArray(ownerProp.getProp(owner, c)))) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `the join property "${ownerProp.propDescription(c)}" of some owner models holds ` +
+            'an array, which is not supported, so no related models are found for them. ' +
+            'Use a ManyToManyRelation through a join table instead.',
+        );
+      }
+    }
+  }
+
+  // Related models without the join properties can't be assigned to their
+  // owners and are silently dropped (#2258). This happens for example when the
+  // relation mapping uses column names but the rows come back with different
+  // property names, e.g. snake_case mappings with `knexSnakeCaseMappers`.
+  warnOnMissingRelatedProps(related) {
+    const { relatedProp } = this.relation;
+
+    for (let c = 0, lc = relatedProp.size; c < lc; ++c) {
+      if (related.some((rel) => relatedProp.getProp(rel, c) === undefined)) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `some related models are missing the join property "${relatedProp.propDescription(c)}", ` +
+            'so they are not assigned to any owner. Check that the relation mapping uses the ' +
+            'property names of the models, e.g. camelCase names when using knexSnakeCaseMappers.',
+        );
+      }
+    }
+  }
+
   selectMissingJoinColumns(builder) {
     const relatedProp = this.relation.relatedProp;
     const addedSelects = [];

package/lib/relations/RelationProperty.js

@@ -31,10 +31,11 @@ class RelationProperty {
   //
   // modelClassResolver must be a function that takes a table name
   // and returns a model class.
-  constructor(references, modelClassResolver) {
+  constructor(references, modelClassResolver, { allowEmpty = false } = {}) {
     const refs = createRefs(asArray(references));
     const paths = createPaths(refs, modelClassResolver);
-    const modelClass = resolveModelClass(paths);
+    const modelClass =
+      allowEmpty && refs.length === 0 ? modelClassResolver(null) : resolveModelClass(paths);
 
     this._refs = refs.map((ref) => ref.model(modelClass));
     this._modelClass = modelClass;

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -75,10 +75,39 @@ class ManyToManyRelation extends Relation {
     return [];
   }
 
+  isJoinTableRelatedTable(builder) {
+    return builder.tableNameFor(this.joinTable) === builder.tableNameFor(this.relatedModelClass);
+  }
+
+  // Returns the alias of the join table in `findQuery`. If the join table is
+  // also the related table, it needs an alias of its own (#1803).
+  joinTableAliasFor(builder) {
+    const joinTableRef = builder.tableRefFor(this.joinTable);
+
+    if (this.isJoinTableRelatedTable(builder)) {
+      return this.ownerModelClass.joinTableAlias(joinTableRef);
+    } else {
+      return joinTableRef;
+    }
+  }
+
+  // The modify operations can't tell the join rows apart from the related rows
+  // if the join table is also the related table, so they would modify the
+  // wrong rows (#1803).
+  assertCanModifyJoinTable(builder, operationName) {
+    if (this.isJoinTableRelatedTable(builder)) {
+      throw this.createError(
+        `${operationName} is not supported when the join table is also the related table`,
+      );
+    }
+  }
+
   findQuery(builder, owner) {
-    const joinTableOwnerRefs = this.joinTableOwnerProp.refs(builder);
     const joinTable = builder.tableNameFor(this.joinTable);
-    const joinTableAlias = builder.tableRefFor(this.joinTable);
+    const joinTableAlias = this.joinTableAliasFor(builder);
+    const joinTableOwnerRefs = this.joinTableOwnerProp
+      .refs(builder)
+      .map((ref) => ref.table(joinTableAlias));
 
     let joinTableSelect = this.joinTableModelClass
       .query()
@@ -92,7 +121,7 @@ class ManyToManyRelation extends Relation {
     builder.join(joinTableSelect, (join) => {
       this.relatedProp.forEach((i) => {
         const relatedRef = this.relatedProp.ref(builder, i);
-        const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i);
+        const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i).table(joinTableAlias);
 
         join.on(relatedRef, joinTableRelatedRef);
       });
@@ -196,6 +225,8 @@ class ManyToManyRelation extends Relation {
   }
 
   unrelate(builder, owner) {
+    this.assertCanModifyJoinTable(builder, 'unrelate');
+
     return new (getUnrelateOperationClass(builder))('unrelate', {
       relation: this,
       owner,

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

@@ -2,6 +2,7 @@
 
 const { RelationFindOperation } = require('../../RelationFindOperation');
 const { getTempColumn } = require('../../../utils/tmpColumnUtils');
+const { deprecate } = require('../../../utils/deprecate');
 
 class ManyToManyFindOperation extends RelationFindOperation {
   constructor(name, opt) {
@@ -29,13 +30,17 @@ class ManyToManyFindOperation extends RelationFindOperation {
 
       // Also select all extra columns.
       for (const extra of this.relation.joinTableExtras) {
-        const joinTable = builder.tableRefFor(this.relation.joinTable);
+        const joinTable = this.relation.joinTableAliasFor(builder);
         builder.select(`${joinTable}.${extra.joinTableCol} as ${extra.aliasCol}`);
       }
     }
 
-    if (this.assignResultToOwner && this.owner.isModels) {
-      this.selectMissingJoinColumns(builder);
+    if (this.owner.isModels) {
+      this.warnOnMissingOwnerProps();
+
+      if (this.assignResultToOwner) {
+        this.selectMissingJoinColumns(builder);
+      }
     }
   }
 
@@ -60,6 +65,8 @@ class ManyToManyFindOperation extends RelationFindOperation {
         arr.push(rel);
       }
 
+      this.warnOnMissingRelatedProps(related);
+
       for (let i = 0, l = owners.length; i < l; ++i) {
         const own = owners[i];
         const key = ownerProp.propKey(own);
@@ -76,6 +83,27 @@ class ManyToManyFindOperation extends RelationFindOperation {
     return related;
   }
 
+  // The related models are assigned to their owners by the owner join columns
+  // selected from the join table. If they get lost, e.g. in a custom
+  // `$parseDatabaseJson()`, the related models are silently dropped (#2258).
+  warnOnMissingRelatedProps(related) {
+    const { joinTableOwnerProp } = this.relation;
+
+    for (let c = 0, lc = this.ownerJoinColumnAlias.length; c < lc; ++c) {
+      const alias = this.ownerJoinColumnAlias[c];
+
+      if (related.some((rel) => rel[alias] === undefined)) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `some related models are missing the join table column ` +
+            `"${joinTableOwnerProp.propDescription(c)}" selected as "${alias}", so they are not ` +
+            'assigned to any owner. Check that $parseDatabaseJson() and the column name mappers ' +
+            'of the related model keep it.',
+        );
+      }
+    }
+  }
+
   clone() {
     const clone = super.clone();
     clone.ownerJoinColumnAlias = this.ownerJoinColumnAlias.slice();
@@ -88,7 +116,9 @@ 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.
     joinTableOwnerProp.forEach((i) => {
-      const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
+      const joinTableOwnerRef = joinTableOwnerProp
+        .ref(builder, i)
+        .table(this.relation.joinTableAliasFor(builder));
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));

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

@@ -26,6 +26,10 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
       }
     }
 
+    if (this.hasExtraProps) {
+      this.relation.assertCanModifyJoinTable(builder, `${this.name} with extra properties`);
+    }
+
     const res = super.onAdd(builder, args);
 
     if (this.hasExtraProps) {