objection 4.0.0-rc.3 → 4.0.0

package/lib/queryBuilder/graph/GraphWriter.js

@@ -2,6 +2,7 @@ import { getModel } from '../../model/getModel.js';
 import { restoreOmitFromDatabaseJson } from '../../model/modelUtils.js';
 import { valuesKey } from '../../model/modelValues.js';
 import { UpdateOperation } from '../operations/UpdateOperation.js';
+import { getJsonKeyPatch } from '../operations/fieldExpressions.js';
 import { getMaxRows, hasBatchInsert } from '../../utils/knexUtils.js';
 import { isInternalProp } from '../../utils/internalPropUtils.js';
 import {
@@ -9,6 +10,7 @@ import {
   difference,
   get,
   groupBy,
+  isEmpty,
   isObject,
   jsonEquals,
   nonStrictEquals,
@@ -25,6 +27,10 @@ export class GraphWriter {
   constructor(schedule) {
     this.schedule = schedule;
     this.plan = schedule.plan;
+    // The rows that are written, as the nodes of their models, and whether the
+    // key columns of relations may be null:
+    this.writtenRows = new Set();
+    this.nullableProps = new Map();
   }
 
   async write(builder) {
@@ -125,14 +131,15 @@ export class GraphWriter {
     await promiseMap(batches, (batch) => this._insertBatch(builder, batch), {
       concurrency: getConcurrency(builder, nodes),
     });
-    await this._patch(
-      builder,
-      nodes.filter((node) => this.schedule.slotMovedNodes.has(node)),
-    );
 
     for (const node of references) {
       resolveDependencies(this.schedule, node);
     }
+
+    await this._patch(
+      builder,
+      [...nodes, ...references].filter((node) => this.schedule.earlyNodes.has(node)),
+    );
   }
 
   async _insertBatch(builder, nodes) {
@@ -152,6 +159,7 @@ export class GraphWriter {
     }
 
     const insertNodes = nodes.filter((node) => actions.get(node) === 'insert');
+    await this._clearSlots(builder, insertNodes);
 
     if (insertNodes.length > 0) {
       const [{ modelClass }] = insertNodes;
@@ -177,6 +185,10 @@ export class GraphWriter {
       await fetchGeneratedKeys(builder, modelClass, insertNodes);
       this.schedule.keys.setInserted(insertNodes);
     }
+
+    for (const node of insertNodes) {
+      this.writtenRows.add(node);
+    }
   }
 
   _writeDeferredKeys(builder, dependencies) {
@@ -251,7 +263,60 @@ export class GraphWriter {
     });
   }
 
+  // Rows that swap slots in a cycle can't take them while the other rows still
+  // hold their keys, if they're unique. Under `unrelate`, the rows that leave
+  // the slots clear their keys first, as 3.x does, if they may be null, and
+  // take their new keys with their own writes, once the other rows took their
+  // slots (#489). Keys that can't be null are swapped directly, and so are keys
+  // in json columns, which hold other values:
+  async _clearSlots(builder, nodes) {
+    for (const { dependent, node, isSlotMove } of this.schedule.deferredDependencies) {
+      // The row that moves out of the slot, with its key:
+      const { modelClass } = node;
+      const relatedProp = isSlotMove && node.relation.relatedProp;
+      if (
+        relatedProp &&
+        nodes.includes(dependent) &&
+        !this.writtenRows.has(node.referencedNode || node) &&
+        relatedProp.props.every((_, i) => relatedProp.isColumn(i)) &&
+        this.plan.graphOptions.has(node, 'unrelate') &&
+        (await this._isNullable(builder, relatedProp))
+      ) {
+        // Without validation or hooks, as the row's own write follows:
+        const { schema } = builder.internalOptions();
+        const query = builder.unsafeKnex()(modelClass.getTableName());
+        const idColumns = modelClass.getIdColumnArray();
+        const ids = modelClass.getIdRelationProperty().getProps(node.obj);
+        await (schema ? query.withSchema(schema) : query)
+          .where(Object.fromEntries(idColumns.map((column, i) => [column, ids[i]])))
+          .update(Object.fromEntries(relatedProp.cols.map((column) => [column, null])));
+      }
+    }
+  }
+
+  // Return true if the database allows null in the columns of `prop`:
+  _isNullable(builder, prop) {
+    let isNullable = this.nullableProps.get(prop);
+
+    if (!isNullable) {
+      isNullable = prop.modelClass
+        .query()
+        .childQueryOf(builder)
+        .columnInfo()
+        .then((columnInfo) => prop.cols.every((column) => columnInfo[column]?.nullable));
+      this.nullableProps.set(prop, isNullable);
+    }
+
+    return isNullable;
+  }
+
   async _patch(builder, nodes) {
+    await this._clearSlots(builder, nodes);
+
+    for (const node of nodes) {
+      this.writtenRows.add(node.referencedNode || node);
+    }
+
     // The patches leave out the props that don't change, but the models that
     // the graph returns get them back once the step is written (#371):
     const omittedProps = new Map(nodes.map((node) => [node, node.obj.$omitFromDatabaseJson()]));
@@ -284,6 +349,12 @@ export class GraphWriter {
   _preparePatch(builder, node) {
     const { referencedNode } = node;
 
+    // A row that the graph relates by its key alone isn't looked up, its key is
+    // only written to its owner:
+    if (this.plan.isRelatedByKey(node)) {
+      return null;
+    }
+
     // The props that the graph fills into the model of a `#ref` model are only
     // final now:
     if (referencedNode) {
@@ -304,15 +375,24 @@ export class GraphWriter {
         ? node.relation.relatedProp.props
         : []),
     ];
+    // The path updates of the keys in json columns that the write sets or
+    // clears, by column:
+    let jsonKeyPatches = new Map();
     // Changing the id never makes sense with `upsertGraph()`. A many-to-many
     // `#ref` model whose model writes its row only writes its join row:
     const idProps = node.modelClass.getIdPropertyArray();
     const isJoinRowOnly =
       !!referencedNode && node.relation.keySide === 'join' && this.plan.isCoveredByModel(node);
-    const isWritable = (prop) =>
-      !idProps.includes(prop) &&
-      !this.schedule.keys.isOnlyRead(node, prop) &&
-      (!isJoinRowOnly || node.relation.joinTableExtras.some((extra) => extra.aliasProp === prop));
+    const isWritable = (prop) => {
+      // A json column that its key paths write is unchanged if they are:
+      const jsonKeyPatch = getJsonKeyPatch(node.obj, prop, jsonKeyPatches);
+      return (
+        !idProps.includes(prop) &&
+        !(jsonKeyPatch && isEmpty(jsonKeyPatch)) &&
+        !this.schedule.keys.isOnlyRead(node, prop) &&
+        (!isJoinRowOnly || node.relation.joinTableExtras.some((extra) => extra.aliasProp === prop))
+      );
+    };
 
     const getPropsToUpdate = (changedProps) =>
       (shouldPatch || shouldUpdate ? changedProps : keyProps).filter(isWritable);
@@ -335,21 +415,38 @@ export class GraphWriter {
     // what to update. Otherwise, the hook may still change the model, and we
     // check again after it runs, but only if the model has props to update, as
     // relates are no updates (#2233, #2605).
-    const changes = this._findChanges(node);
-    const propsToUpdate = getPropsToUpdate(changes.changedProps);
     const hasBeforeUpdate = hasHook(node.obj, 'beforeUpdate');
 
-    if (propsToUpdate.length === 0) {
+    const changes = this._findChanges(node);
+
+    if (getPropsToUpdate(changes.changedProps).length === 0) {
       return null;
-    } else if (!hasBeforeUpdate) {
-      handleUpdate(changes);
     }
 
     node.obj.$validate(null, {
       dataPath: node.dataPathKey,
-      patch: shouldPatch || !shouldUpdate,
+      patch: !shouldUpdate,
     });
 
+    // Write the keys in json columns as path updates where their column holds
+    // nothing else, which keeps its other values (#415):
+    jsonKeyPatches = getJsonKeyPatches(node, [
+      ...this.schedule.keys.getSetCells(node),
+      ...this.plan
+        .getRemovedOwnerRelations(node)
+        .flatMap(({ ownerProp }) =>
+          ownerProp.props.map((_, index) => ({ prop: ownerProp, index })),
+        ),
+    ]);
+
+    const propsToUpdate = getPropsToUpdate(changes.changedProps);
+
+    if (propsToUpdate.length === 0) {
+      return null;
+    } else if (!hasBeforeUpdate) {
+      handleUpdate(changes);
+    }
+
     // Rows that their owners relate by their keys can't be found through the
     // relation until the owners are patched, so they're patched directly.
     const { relation } = node;
@@ -360,17 +457,26 @@ export class GraphWriter {
 
     return {
       node,
-      shouldPatch,
+      shouldUpdate,
       hasBeforeUpdate,
       handleUpdate,
       propsToUpdate,
+      jsonKeyPatches,
       isPatchedThroughRelation,
     };
   }
 
   _writePatch(
     builder,
-    { node, shouldPatch, hasBeforeUpdate, handleUpdate, propsToUpdate, isPatchedThroughRelation },
+    {
+      node,
+      shouldUpdate,
+      hasBeforeUpdate,
+      handleUpdate,
+      propsToUpdate,
+      jsonKeyPatches,
+      isPatchedThroughRelation,
+    },
   ) {
     const query = (
       isPatchedThroughRelation
@@ -392,6 +498,7 @@ export class GraphWriter {
         // Join rows are patched with the extras among the props to update. The
         // extras of new join rows are written with them, see `_findChanges()`:
         joinTableExtras: node.relation?.keySide === 'join' && !node.current ? [] : propsToUpdate,
+        jsonKeyPatches,
       })
       .copyFrom(builder, isReturningAll);
 
@@ -405,7 +512,8 @@ export class GraphWriter {
       });
     }
 
-    return (shouldPatch ? query.patch(node.obj) : query.update(node.obj))
+    // Writes of only the keys under `noUpdate` are patches too:
+    return (shouldUpdate ? query.update(node.obj) : query.patch(node.obj))
       .runAfter(async (result, query) => {
         if (isObject(result) && result.$isObjectionModel) {
           // Handle `returning('*')`.
@@ -554,7 +662,7 @@ function resolveDependencies(schedule, node) {
 // Copy the keys and `#ref{}` values that `node` waits for into its model,
 // after those that the graph fills into the models that it reads them from,
 // e.g. the new key of an owner whose BelongsToOne row is replaced. Rows that
-// move first only wait for rows that exist, see `GraphSchedule#_waitsForInserts()`.
+// move first only wait for rows that exist, see `GraphSchedule#_waitsForWrites()`.
 function resolveFilledDependencies(schedule, node, visitedNodes = new Set()) {
   visitedNodes.add(node);
 
@@ -746,6 +854,39 @@ async function fetchGeneratedKeys(builder, modelClass, nodes) {
   }
 }
 
+// Return the path updates of the changed keys of `cells` at the top level of
+// json columns, by the columns that hold nothing but these keys. PostgreSQL and
+// MySQL can't write nested paths whose parents are missing, so their columns
+// are written whole.
+function getJsonKeyPatches(node, cells) {
+  const patchesByColumn = new Map();
+  const pathCells = cells.filter(({ prop, index }) => prop.isJsonKey(index));
+
+  for (const [column, columnCells] of groupBy(pathCells, ({ prop, index }) => prop.props[index])) {
+    const keys = {};
+
+    for (const { prop, index } of columnCells) {
+      prop.setProp(keys, index, prop.getProp(node.obj, index));
+    }
+
+    if (jsonEquals(node.obj[column], keys[column])) {
+      const patch = {};
+
+      for (const { prop, index } of columnCells) {
+        const value = prop.getProp(node.obj, index);
+
+        if (!node.current || !nonStrictEquals(prop.getProp(node.current.obj, index), value)) {
+          prop.patch(patch, index, value);
+        }
+      }
+
+      patchesByColumn.set(column, { keys: keys[column], patch });
+    }
+  }
+
+  return patchesByColumn;
+}
+
 function hasOwnerKeyArray(relation) {
   return relation.keySide === 'owner' && !relation.isOneToOne();
 }

package/lib/queryBuilder/graph/graphChecks.js

@@ -223,7 +223,7 @@ export function checkPlacements(builder, nodes) {
     } else if (!nonStrictEquals(other.value, value)) {
       throw builder.modelClass().createValidationError({
         type: ValidationErrorType.InvalidGraph,
-        message: `the graph gives ${prop} of one ${name} two values, at ${formatPath(other.path)} and at ${formatPath(path)}`,
+        message: `the graph gives ${prop} of one ${name} two values, at ${formatPath(other.path())} and at ${formatPath(path())}`,
       });
     }
   };
@@ -243,7 +243,8 @@ export function checkPlacements(builder, nodes) {
         .map(([cols, rowId]) => `${cols}=${rowId}`),
     ].join(':');
 
-  const getPath = (node, ...keys) => [node.dataPathKey, ...keys].filter(Boolean).join('.');
+  // The data paths are only built for the errors:
+  const getPath = (node, key) => () => [node.dataPathKey, key].filter(Boolean).join('.');
   const isSlot = (relation) => relation.keySide === 'related' && relation.isOneToOne();
 
   // The props that the models give, except for the ids and the keys that the
@@ -405,7 +406,7 @@ export function checkPlacements(builder, nodes) {
       const other = rows.get(otherRowId).get(relatedProp.props[0]);
       throw builder.modelClass().createValidationError({
         type: ValidationErrorType.InvalidGraph,
-        message: `the graph puts two ${relatedModelClass.name} rows in ${relation.name} of one ${owner.modelClass.name}, at ${formatPath(path)} and at ${formatPath(other.path)}`,
+        message: `the graph puts two ${relatedModelClass.name} rows in ${relation.name} of one ${owner.modelClass.name}, at ${formatPath(path())} and at ${formatPath(other.path())}`,
       });
     }
   }
@@ -444,6 +445,42 @@ export function checkReferences(builder, plan) {
   }
 }
 
+// A model that the graph relates by the key of its BelongsToOneRelation alone
+// isn't looked up: only its key is written to its owner. So it can't give other
+// props, unless they aren't written, relations or values that others refer to.
+export function checkKeyRelates(builder, plan) {
+  const { graphOptions } = plan;
+
+  for (const node of plan.activeNodes.filter((node) => plan.isRelatedByKey(node))) {
+    const { modelClass, relation, obj } = node;
+    const relationNames = modelClass.getRelationNames();
+    const idProps = modelClass.getIdPropertyArray();
+    const isWritten = graphOptions.shouldPatch(node) || graphOptions.shouldUpdate(node);
+    const name = Object.keys(obj).find((key) => {
+      const value = obj[key];
+      return (
+        value !== undefined &&
+        !isInternalProp(key) &&
+        !relation.relatedProp.props.includes(key) &&
+        !(value === null && idProps.includes(key)) &&
+        (relationNames.includes(key) || isWritten)
+      );
+    });
+    const isReferenced =
+      node.propertyReferencingNodes.length > 0 ||
+      plan.nodes.some((other) => other.referencedNode === node);
+
+    if (name || isReferenced) {
+      throw builder.modelClass().createValidationError({
+        type: ValidationErrorType.InvalidGraph,
+        message: `the ${modelClass.name} at ${formatPath(node.dataPathKey)} is related by its key alone, so ${
+          name ? `its ${name} can't be written` : "it can't be referenced"
+        }`,
+      });
+    }
+  }
+}
+
 // A `#ref{}` waits for the model it reads if the value only exists once that
 // model is written. These waits follow from the graph alone, so their cycles
 // are found before the first write.