objection 3.8.0 → 3.9.1

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

@@ -31,6 +31,14 @@ class GraphPatchAction extends GraphAction {
     // properties. That's why we handle them here.
     const changePropsBecauseOfBelongsToOneDelete = this._handleBelongsToOneDeletes(node);
 
+    // HasManyRelation and HasOneRelation relates write the related object's
+    // foreign keys, also with `noUpdate`.
+    const changedPropsBecauseOfRelate =
+      this.graphOptions.shouldRelate(node, this.graphData) &&
+      node.parentEdge.relation.isObjectionHasManyRelation
+        ? node.parentEdge.relation.relatedProp.props
+        : [];
+
     const handleUpdate = () => {
       const { changedProps, unchangedProps } = this._findChanges(node);
       const allProps = [...changedProps, ...unchangedProps];
@@ -38,7 +46,11 @@ class GraphPatchAction extends GraphAction {
       const propsToUpdate = difference(
         shouldPatch || shouldUpdate
           ? changedProps
-          : [...changedPropsBecauseOfBelongsToOneInsert, ...changePropsBecauseOfBelongsToOneDelete],
+          : [
+              ...changedPropsBecauseOfBelongsToOneInsert,
+              ...changePropsBecauseOfBelongsToOneDelete,
+              ...changedPropsBecauseOfRelate,
+            ],
 
         // Remove id properties from the props to update. With upsertGraph
         // it never makes sense to change the id.
@@ -128,8 +140,9 @@ class GraphPatchAction extends GraphAction {
         edge.relation &&
         edge.relation.isObjectionBelongsToOneRelation &&
         edge.relation.relatedProp.hasProps(edge.relatedNode.obj) &&
-        // Models marked with `#unrelate` or `#delete` are handled below.
-        !edge.relatedNode.toBeUnrelatedOrDeleted
+        // Ignored models don't replace the current one, and models marked with
+        // `#unrelate` or `#delete` are handled below.
+        !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
       ) {
         const { relation } = edge;
 

package/lib/queryBuilder/join/JoinResultParser.js

@@ -9,7 +9,7 @@ class JoinResultParser {
     this.omitColumnAliases = new Set(omitColumnAliases);
 
     this.columnsByTableNode = null;
-    this.parentMap = null;
+    this.modelsByTableNode = null;
     this.rootModels = null;
   }
 
@@ -25,7 +25,8 @@ class JoinResultParser {
     this._checkIdColumns(flatRows[0]);
 
     this.columnsByTableNode = this._createColumns(flatRows[0]);
-    this.parentMap = new Map();
+    // Key the models of each table node by the ids on their path from the root:
+    this.modelsByTableNode = new Map(this.tableTree.nodes.map((node) => [node, new Map()]));
     this.rootModels = [];
 
     for (const flatRow of flatRows) {
@@ -42,14 +43,15 @@ class JoinResultParser {
       return;
     }
 
-    const key = getKey(parentKey, id, tableNode);
-    let model = this.parentMap.get(key);
+    const key = getKey(parentKey, id);
+    const models = this.modelsByTableNode.get(tableNode);
+    let model = models.get(key);
 
     if (!model) {
       model = this._createModel(tableNode, flatRow);
 
       this._addToParent(tableNode, model, parentModel);
-      this.parentMap.set(key, model);
+      models.set(key, model);
     }
 
     for (const childNode of tableNode.childNodes) {
@@ -128,11 +130,14 @@ function getTableNode(column) {
   return column.tableNode;
 }
 
-function getKey(parentKey, id, tableNode) {
+// Escape the separator in the ids, since string ids can contain it.
+function getKey(parentKey, id) {
+  const escapedId = id.includes('/') || id.includes('\\') ? id.replace(/[/\\]/g, '\\$&') : id;
+
   if (parentKey !== null) {
-    return `${parentKey}/${tableNode.relationProperty}/${id}`;
+    return `${parentKey}/${escapedId}`;
   } else {
-    return `/${id}`;
+    return escapedId;
   }
 }
 

package/lib/queryBuilder/join/RelationJoiner.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { uniqBy } = require('../../utils/objectUtils');
-const { Selection, mapIdentifier } = require('../operations/select/Selection');
+const { Selection, isSameTable, mapIdentifier } = require('../operations/select/Selection');
 const { SelectOperation } = require('../operations/select/SelectOperation');
 const { createModifier } = require('../../utils/createModifier');
 const { map: mapPromise } = require('../../utils/promiseUtils');
@@ -487,7 +487,8 @@ function getIdSelectionsForNode({ tableNode }) {
 function removeRootSelectAll(builder) {
   const tableRef = builder.tableRef();
   const isRootSelectAll = (selection) =>
-    selection.column === '*' && (!selection.table || selection.table === tableRef);
+    selection.column === '*' &&
+    (!selection.table || isSameTable(builder, selection.table, tableRef));
   const isSelect = (op) =>
     op.constructor === SelectOperation && !isAggregateOperation(op) && !op.isDistinctOn;
 

package/lib/queryBuilder/join/TableNode.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { propKey, hasProps } = require('../../model/modelValues');
+
 class TableNode {
   constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
     this.tableTree = tableTree;
@@ -86,78 +88,14 @@ class TableNode {
   }
 
   _createIdGetter() {
-    const idColumns = this.modelClass.getIdColumnArray();
-    const columnAliases = idColumns.map((column) => this.getColumnAliasForColumn(column));
-
-    if (idColumns.length === 1) {
-      return createIdGetter(columnAliases);
-    } else {
-      return createCompositeIdGetter(columnAliases);
-    }
-  }
-}
-
-function createIdGetter(columnAliases) {
-  const columnAlias = columnAliases[0];
+    const columnAliases = this.modelClass
+      .getIdColumnArray()
+      .map((column) => this.getColumnAliasForColumn(column));
 
-  return (flatRow) => {
-    const id = flatRow[columnAlias];
-
-    if (id === null) {
-      return null;
-    }
-
-    return `${id}`;
-  };
-}
-
-function createCompositeIdGetter(columnAliases) {
-  if (columnAliases.length === 2) {
-    return createTwoIdGetter(columnAliases);
-  } else {
-    return createMultiIdGetter(columnAliases);
+    return (flatRow) => (hasProps(flatRow, columnAliases) ? propKey(flatRow, columnAliases) : null);
   }
 }
 
-function createTwoIdGetter(columnAliases) {
-  const columnAlias1 = columnAliases[0];
-  const columnAlias2 = columnAliases[1];
-
-  return (flatRow) => {
-    const id1 = flatRow[columnAlias1];
-    const id2 = flatRow[columnAlias2];
-
-    if (id1 === null || id2 === null) {
-      return null;
-    }
-
-    return `${id1},${id2}`;
-  };
-}
-
-function createMultiIdGetter(columnAliases) {
-  return (flatRow) => {
-    let idStr = '';
-
-    for (let i = 0, l = columnAliases.length; i < l; ++i) {
-      const columnAlias = columnAliases[i];
-      const id = flatRow[columnAlias];
-
-      if (id === null) {
-        return null;
-      }
-
-      idStr += id;
-
-      if (i !== l - 1) {
-        idStr += ',';
-      }
-    }
-
-    return idStr;
-  };
-}
-
 module.exports = {
   TableNode,
 };

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -2,6 +2,8 @@
 
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
+const { isMySql } = require('../../utils/knexUtils');
+const { warnOnce } = require('../../utils/warnings');
 
 class DeleteOperation extends QueryBuilderOperation {
   async onBefore2(builder, result) {
@@ -9,6 +11,24 @@ class DeleteOperation extends QueryBuilderOperation {
     return result;
   }
 
+  // knex leaves the offset out of deletes. On MySQL, it leaves out the order as
+  // well, but keeps the limit, so the order doesn't pick the deleted rows. Warn
+  // when the query is executed.
+  onAfterBuild(builder) {
+    if (builder.has('offset')) {
+      warnOnce(
+        'offset() has no effect in delete queries, so no rows are skipped. ' +
+          'This will throw an error in objection 4.0.',
+      );
+    }
+    if (isMySql(builder.knex()) && builder.has('limit') && builder.has(/^orderBy/)) {
+      warnOnce(
+        'orderBy() has no effect in delete queries with limit() on MySQL, so the limit ' +
+          'deletes rows in any order. This will throw an error in objection 4.0.',
+      );
+    }
+  }
+
   onBuildKnex(knexBuilder) {
     return knexBuilder.delete();
   }

package/lib/queryBuilder/operations/InsertOperation.js

@@ -3,8 +3,9 @@
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
 const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
-const { isPostgres, isSqlite, isMySql, isMsSql } = require('../../utils/knexUtils');
+const { isSqlite, isMySql, hasBatchInsert } = require('../../utils/knexUtils');
 const { isObject, isString } = require('../../utils/objectUtils');
+const { removeOverriddenValues } = require('../../model/modelQueryProps');
 
 // Base class for all insert operations.
 class InsertOperation extends QueryBuilderOperation {
@@ -27,10 +28,11 @@ class InsertOperation extends QueryBuilderOperation {
   }
 
   async onBefore2(builder, result) {
-    if (this.models.length > 1 && !isPostgres(builder.knex()) && !isMsSql(builder.knex())) {
+    if (this.models.length > 1 && !hasBatchInsert(builder.knex())) {
       throw new Error('batch insert only works with Postgresql and SQL Server');
     } else {
       await callBeforeInsert(builder, this.models);
+      this.models.forEach(removeOverriddenValues);
       return result;
     }
   }

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -5,6 +5,7 @@ const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
 const { isObject } = require('../../utils/objectUtils');
 const { addWhereGroup } = require('../whereGroups');
+const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
 
 class InstanceUpdateOperation extends UpdateOperation {
   constructor(name, opt) {
@@ -19,6 +20,7 @@ class InstanceUpdateOperation extends UpdateOperation {
 
     if (!this.model) {
       this.model = this.instance;
+      removeOverriddenQueryProps(this.model);
     }
 
     return retVal;

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,9 @@ const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
 const { StaticHookArguments } = require('../StaticHookArguments');
+const { ValidationErrorType } = require('../../model/ValidationError');
+const { removeOverriddenValues } = require('../../model/modelQueryProps');
+const { warnOnce } = require('../../utils/warnings');
 
 class UpdateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
@@ -30,6 +33,7 @@ class UpdateOperation extends QueryBuilderOperation {
 
   async onBefore2(builder, result) {
     await callBeforeUpdate(builder, this.model, this.modelOptions);
+    removeOverriddenValues(this.model);
     return result;
   }
 
@@ -51,6 +55,17 @@ class UpdateOperation extends QueryBuilderOperation {
     return builder.isExplicitlyResolvedOrRejected() && !this.hasNothingToUpdate;
   }
 
+  // knex leaves the offset out of updates, and on SQL Server the limit as well.
+  // Warn when the query is executed.
+  onAfterBuild(builder) {
+    if (builder.has('offset')) {
+      warnOnce(
+        'offset() has no effect in update queries, so no rows are skipped, and on SQL Server ' +
+          'limit() is ignored too. This will throw an error in objection 4.0.',
+      );
+    }
+  }
+
   onBuildKnex(knexBuilder, builder) {
     const json = this.model.$toDatabaseJson(builder);
     const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
@@ -110,7 +125,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 +134,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 +169,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 +206,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/hasMany/HasManyInsertOperation.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { RelationInsertOperation } = require('../RelationInsertOperation');
+const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
 
 class HasManyInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
@@ -14,6 +15,9 @@ class HasManyInsertOperation extends RelationInsertOperation {
       for (let j = 0, lp = relatedProp.size; j < lp; ++j) {
         relatedProp.setProp(model, j, ownerValues[0][j]);
       }
+
+      // The foreign keys set here beat query properties given for them:
+      removeOverriddenQueryProps(model);
     }
 
     return retVal;

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

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