objection 3.5.0 → 3.6.0

package/lib/relations/Relation.js

@@ -83,6 +83,12 @@ class Relation {
     return false;
   }
 
+  // Whether owner models may legitimately lack the owner join property at
+  // `index`, so that it isn't reported as missing (#132).
+  isOptionalOwnerProp(_index) {
+    return false;
+  }
+
   clone() {
     const relation = new this.constructor(this.name, this.ownerModelClass);
 

package/lib/relations/RelationFindOperation.js

@@ -85,12 +85,17 @@ class RelationFindOperation extends FindOperation {
 
   // 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.
+  // 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.
   warnOnMissingOwnerProps() {
     const { ownerProp } = this.relation;
 
     for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
+      if (this.relation.isOptionalOwnerProp(c)) {
+        continue;
+      }
+
       if (this.owner.modelArray.some((owner) => ownerProp.getProp(owner, c) === undefined)) {
         deprecate(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +

package/lib/relations/belongsToOne/BelongsToOneRelation.js

@@ -11,6 +11,15 @@ class BelongsToOneRelation extends Relation {
     return true;
   }
 
+  // The foreign key is unset when no related model was ever assigned, e.g. on
+  // models returned by `insert()` or created with `fromJson()`, where no
+  // related model is the right result. This can't be told apart from a
+  // foreign key left out of a partial `select()`. Foreign keys that are part
+  // of the id are always expected to be set (#132).
+  isOptionalOwnerProp(index) {
+    return !this.ownerModelClass.getIdPropertyArray().includes(this.ownerProp.props[index]);
+  }
+
   insert(_, owner) {
     return new BelongsToOneInsertOperation('insert', {
       relation: this,

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -16,10 +16,13 @@ const ManyToManyModifyMixin = (Operation) => {
     constructor(...args) {
       super(...args);
       this.modifyFilterSubquery = null;
+      this.skipRelationFilter = false;
     }
 
+    // Updates of rows that are known to be related, like the patches of
+    // `upsertGraph()`, keep their own filters (#135).
     get modifyMainQuery() {
-      return true;
+      return !this.skipRelationFilter;
     }
 
     // At this point `builder` should only have the user's own wheres and joins. There can
@@ -108,6 +111,7 @@ const ManyToManyModifyMixin = (Operation) => {
     clone() {
       const clone = super.clone();
       clone.modifyFilterSubquery = this.modifyFilterSubquery;
+      clone.skipRelationFilter = this.skipRelationFilter;
       return clone;
     }
   };

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -93,7 +93,8 @@ class ManyToManyRelation extends Relation {
 
   // 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).
+  // wrong rows (#1803). Inserting and relating would insert the join rows as
+  // new related rows (#133).
   assertCanModifyJoinTable(builder, operationName) {
     if (this.isJoinTableRelatedTable(builder)) {
       throw this.createError(
@@ -188,7 +189,9 @@ class ManyToManyRelation extends Relation {
     });
   }
 
-  insert(_, owner) {
+  insert(builder, owner) {
+    this.assertCanModifyJoinTable(builder, 'insert');
+
     return new ManyToManyInsertOperation('insert', {
       relation: this,
       owner,
@@ -218,6 +221,8 @@ class ManyToManyRelation extends Relation {
   }
 
   relate(builder, owner) {
+    this.assertCanModifyJoinTable(builder, 'relate');
+
     return new ManyToManyRelateOperation('relate', {
       relation: this,
       owner,

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

@@ -18,6 +18,11 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   onAdd(builder, args) {
     const obj = args[0];
 
+    // The modified rows are known to be related to the owner, so they are
+    // filtered by their own ids instead of a subquery that joins the join
+    // table. On MySQL, concurrent updates with that subquery deadlock (#135).
+    this.skipRelationFilter = builder.internalOptions().skipRelationFilter;
+
     // Copy all extra properties to the `joinTablePatch` object.
     for (const extra of this.relation.joinTableExtras) {
       if (extra.aliasProp in obj) {
@@ -50,7 +55,9 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
         .patch(this.joinTablePatch);
 
       addWhereGroup(joinTableUpdateQuery, () =>
-        this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
+        this.skipRelationFilter
+          ? this.applyIdFilterForJoinTable(joinTableUpdateQuery)
+          : this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
       );
       addWhereGroup(joinTableUpdateQuery, () =>
         joinTableUpdateQuery.modify(this.relation.joinTableModify),
@@ -63,6 +70,19 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     }
   }
 
+  // Filters the join rows by the ids of the owner and the updated model.
+  applyIdFilterForJoinTable(builder) {
+    return builder
+      .whereInComposite(
+        this.relation.joinTableOwnerProp.refs(builder),
+        this.owner.getProps(this.relation),
+      )
+      .whereComposite(
+        this.relation.joinTableRelatedProp.refs(builder),
+        this.relation.relatedProp.getProps(this.model),
+      );
+  }
+
   /* istanbul ignore next */
   applyModifyFilterForRelatedTable(builder) {
     throw new Error('not implemented');

package/lib/utils/objectUtils.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { clone, cloneDeep } = require('./clone');
 const SMALL_ARRAY_SIZE = 10;
 
 function isEmpty(item) {
@@ -389,6 +388,83 @@ function mergeMaps(map1, map2) {
   return map;
 }
 
+// Clones `value` deeply, like lodash's `cloneDeep()`: objects keep their
+// prototype and get copies of their own enumerable properties, symbols
+// included. Arrays, dates, regular expressions, maps, sets, buffers, typed
+// arrays and array buffers are copied, circular references are kept.
+// Anything else, like functions and errors, is kept as it is.
+function cloneDeep(value, clones = new Map()) {
+  if (!isObject(value)) {
+    return value;
+  } else if (clones.has(value)) {
+    return clones.get(value);
+  }
+
+  const Ctor = value.constructor;
+  const tag = Object.prototype.toString.call(value);
+  let copy;
+
+  if (tag === '[object Object]') {
+    copy = Object.create(Object.getPrototypeOf(value));
+    clones.set(value, copy);
+
+    for (const key of Object.keys(value)) {
+      const item = cloneDeep(value[key], clones);
+
+      if (key === '__proto__') {
+        // Assigning it would set the prototype instead of the property.
+        Object.defineProperty(copy, key, {
+          value: item,
+          writable: true,
+          enumerable: true,
+          configurable: true,
+        });
+      } else {
+        copy[key] = item;
+      }
+    }
+
+    for (const symbol of Object.getOwnPropertySymbols(value)) {
+      if (Object.prototype.propertyIsEnumerable.call(value, symbol)) {
+        copy[symbol] = cloneDeep(value[symbol], clones);
+      }
+    }
+  } else if (tag === '[object Array]') {
+    copy = new Ctor(value.length);
+    clones.set(value, copy);
+
+    for (let i = 0, l = value.length; i < l; ++i) {
+      copy[i] = cloneDeep(value[i], clones);
+    }
+  } else if (Buffer.isBuffer(value)) {
+    copy = Buffer.from(value);
+  } else if (tag === '[object DataView]') {
+    copy = new Ctor(value.buffer.slice(0), value.byteOffset, value.byteLength);
+  } else if (ArrayBuffer.isView(value)) {
+    copy = value.slice();
+  } else if (tag === '[object ArrayBuffer]') {
+    copy = value.slice(0);
+  } else if (tag === '[object Date]') {
+    copy = new Ctor(+value);
+  } else if (tag === '[object RegExp]') {
+    copy = new Ctor(value.source, value.flags);
+    copy.lastIndex = value.lastIndex;
+  } else if (tag === '[object Map]') {
+    copy = new Ctor();
+    clones.set(value, copy);
+    value.forEach((item, key) => copy.set(key, cloneDeep(item, clones)));
+  } else if (tag === '[object Set]') {
+    copy = new Ctor();
+    clones.set(value, copy);
+    value.forEach((item) => copy.add(cloneDeep(item, clones)));
+  } else {
+    return value;
+  }
+
+  clones.set(value, copy);
+  return copy;
+}
+
 module.exports = {
   isEmpty,
   isString,
@@ -411,7 +487,6 @@ module.exports = {
   values,
   union,
   chunk,
-  clone,
   omit,
   once,
   last,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",
@@ -8,8 +8,11 @@
     "test": "npm run eslint && mocha --slow 10 --timeout 15000 --reporter spec --recursive tests --exclude \"tests/unit/relations/files/**\" && npm run test:typings",
     "test:fast": "mocha --slow 10 --timeout 15000 --reporter spec --recursive tests --bail --exclude \"tests/unit/relations/files/**\"",
     "test:typings": "tsc && prettier --check \"typings/**/*.ts\" \"tests/ts/**/*.ts\"",
+    "db:up": "docker compose up -d --wait",
+    "db:down": "docker compose down -v",
+    "build:parsers": "npx --yes peggy@5.1.0 --format commonjs -o lib/queryBuilder/parsers/jsonFieldExpressionParser.js lib/queryBuilder/parsers/jsonFieldExpressionParser.pegjs && npx --yes peggy@5.1.0 --format commonjs -o lib/queryBuilder/parsers/relationExpressionParser.js lib/queryBuilder/parsers/relationExpressionParser.pegjs && prettier --write \"lib/queryBuilder/parsers/*Parser.js\"",
     "prettier": "prettier --write \"{examples,lib,tests,testUtils,typings,doc}/**/*.{js,ts}\"",
-    "eslint": "eslint --format codeframe \"examples/**/*.js\" \"lib/**/*.js\" \"tests/**/*.js\"",
+    "eslint": "eslint --format codeframe \"examples/**/*.js\" \"lib/**/*.js\" \"tests/**/*.js\" \"testUtils/**/*.js\" \"*.js\"",
     "docs:dev": "vitepress dev doc",
     "docs:build": "vitepress build doc",
     "docs:preview": "vitepress preview doc"

package/typings/objection/index.d.ts

@@ -1058,7 +1058,7 @@ declare namespace Objection {
   }
 
   export interface InsertGraphOptions {
-    relate?: boolean | string[];
+    relate?: boolean | string | string[];
     allowRefs?: boolean;
   }
 
@@ -1077,15 +1077,15 @@ declare namespace Objection {
   }
 
   export interface UpsertGraphOptions {
-    relate?: boolean | string[];
-    unrelate?: boolean | string[];
-    insertMissing?: boolean | string[];
-    update?: boolean | string[];
-    noInsert?: boolean | string[];
-    noUpdate?: boolean | string[];
-    noDelete?: boolean | string[];
-    noRelate?: boolean | string[];
-    noUnrelate?: boolean | string[];
+    relate?: boolean | string | string[];
+    unrelate?: boolean | string | string[];
+    insertMissing?: boolean | string | string[];
+    update?: boolean | string | string[];
+    noInsert?: boolean | string | string[];
+    noUpdate?: boolean | string | string[];
+    noDelete?: boolean | string | string[];
+    noRelate?: boolean | string | string[];
+    noUnrelate?: boolean | string | string[];
     allowRefs?: boolean;
   }