objection 3.6.0 → 3.8.0

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -4,13 +4,14 @@ const { getModel } = require('../../model/getModel');
 const { Relation } = require('../Relation');
 const { RelationProperty } = require('../RelationProperty');
 
-const { isSqlite, isMySql, isPostgres } = require('../../utils/knexUtils');
+const { isSqlite, isMySql } = require('../../utils/knexUtils');
 const { inheritModel } = require('../../model/inheritModel');
 const { resolveModel } = require('../../utils/resolveModel');
 const { mapAfterAllReturn } = require('../../utils/promiseUtils');
 const { isFunction, isObject, isString } = require('../../utils/objectUtils');
 const { createModifier } = require('../../utils/createModifier');
 const { addWhereGroup } = require('../../queryBuilder/whereGroups');
+const { withoutOrder } = require('../../queryBuilder/withoutOrder');
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
@@ -21,14 +22,10 @@ const {
   ManyToManyUnrelateSqliteOperation,
 } = require('./unrelate/ManyToManyUnrelateSqliteOperation');
 const { ManyToManyUnrelateMySqlOperation } = require('./unrelate/ManyToManyUnrelateMySqlOperation');
-const {
-  ManyToManyUnrelatePostgresOperation,
-} = require('./unrelate/ManyToManyUnrelatePostgresOperation');
 
 const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
 const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
 const { ManyToManyUpdateMySqlOperation } = require('./update/ManyToManyUpdateMySqlOperation');
-const { ManyToManyUpdatePostgresOperation } = require('./update/ManyToManyUpdatePostgresOperation');
 
 const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
 const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
@@ -117,6 +114,8 @@ class ManyToManyRelation extends Relation {
       .as(joinTableAlias);
     if (joinTableSelect.isSelectAll()) {
       joinTableSelect = aliasedTableName(joinTable, joinTableAlias);
+    } else {
+      withoutOrder(joinTableSelect);
     }
 
     builder.join(joinTableSelect, (join) => {
@@ -148,6 +147,8 @@ class ManyToManyRelation extends Relation {
     if (relatedJoinSelect.isSelectAll()) {
       // No need to join a subquery if the query is `select * from "RelatedTable"`.
       relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+    } else {
+      withoutOrder(relatedJoinSelect);
     }
 
     let joinTableSelect = this.joinTableModelClass
@@ -157,6 +158,8 @@ class ManyToManyRelation extends Relation {
       .as(joinTableAlias);
     if (joinTableSelect.isSelectAll()) {
       joinTableSelect = aliasedTableName(this.joinTable, joinTableAlias);
+    } else {
+      withoutOrder(joinTableSelect);
     }
 
     return builder[joinOperation](joinTableSelect, (join) => {
@@ -503,26 +506,25 @@ function parseBeforeInsert(ctx) {
 }
 
 function finalizeJoinModelClass(ctx) {
-  if (ctx.joinTableModelClass.getIdColumn() === null) {
-    // We cannot know if the join table has a primary key. Therefore we set some
-    // known column as the idColumn so that inserts will work.
+  // We cannot know if the join table has a primary key. Therefore we set some
+  // known column as the idColumn of the join model class that we created. A
+  // `through.modelClass` is left untouched, even if it has no `idColumn` (#2305).
+  if (!ctx.mapping.join.through.modelClass) {
     ctx.joinTableModelClass.idColumn = ctx.joinTableRelatedProp.cols;
   }
 
   return ctx;
 }
 
-// The modify operations need dialect specific code to only modify the join
-// rows that match the filters, see the `ManyToMany*ModifyMixin` classes.
-function getOperationClass(builder, { sqlite, mysql, postgres, other }) {
+// The modify operations need dialect specific code on sqlite and mysql, see
+// the `ManyToMany*ModifyMixin` classes.
+function getOperationClass(builder, { sqlite, mysql, other }) {
   const knex = builder.knex();
 
   if (isSqlite(knex)) {
     return sqlite;
   } else if (isMySql(knex)) {
     return mysql;
-  } else if (isPostgres(knex)) {
-    return postgres;
   } else {
     return other;
   }
@@ -532,7 +534,6 @@ function getUpdateOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyUpdateSqliteOperation,
     mysql: ManyToManyUpdateMySqlOperation,
-    postgres: ManyToManyUpdatePostgresOperation,
     other: ManyToManyUpdateOperation,
   });
 }
@@ -541,7 +542,6 @@ function getUnrelateOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyUnrelateSqliteOperation,
     mysql: ManyToManyUnrelateMySqlOperation,
-    postgres: ManyToManyUnrelatePostgresOperation,
     other: ManyToManyUnrelateOperation,
   });
 }
@@ -551,7 +551,6 @@ function getDeleteOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyDeleteSqliteOperation,
     mysql: ManyToManyDeleteOperation,
-    postgres: ManyToManyDeleteOperation,
     other: ManyToManyDeleteOperation,
   });
 }

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -15,19 +15,6 @@ const ManyToManySqliteModifyMixin = (Operation) => {
 
       return builder.whereInComposite(rowIdRef, subquery);
     }
-
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-      const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
-
-      const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
-
-      return builder
-        .whereInComposite(rowIdRef, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
   };
 };
 

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

@@ -2,7 +2,7 @@
 
 const { RelationFindOperation } = require('../../RelationFindOperation');
 const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-const { deprecate } = require('../../../utils/deprecate');
+const { warnOnce } = require('../../../utils/warnings');
 
 class ManyToManyFindOperation extends RelationFindOperation {
   constructor(name, opt) {
@@ -36,7 +36,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
     }
 
     if (this.owner.isModels) {
-      this.warnOnMissingOwnerProps();
+      this.warnOnInvalidOwnerProps();
 
       if (this.assignResultToOwner) {
         this.selectMissingJoinColumns(builder);
@@ -83,6 +83,11 @@ class ManyToManyFindOperation extends RelationFindOperation {
     return related;
   }
 
+  // @override
+  ownerKeyColumns() {
+    return this.ownerJoinColumnAlias;
+  }
+
   // 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).
@@ -93,7 +98,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
       const alias = this.ownerJoinColumnAlias[c];
 
       if (related.some((rel) => rel[alias] === undefined)) {
-        deprecate(
+        warnOnce(
           `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 ` +
@@ -122,8 +127,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
-      // Mark them to be omitted later.
-      this.omitProps.push(propName);
+      this.omitFromResult(builder, propName);
     });
 
     super.selectMissingJoinColumns(builder);

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateMySqlOperation.js

@@ -5,11 +5,7 @@ const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
 
 class ManyToManyUnrelateMySqlOperation extends ManyToManyMySqlModifyMixin(
   ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUnrelateMySqlOperation,

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperation.js

@@ -3,11 +3,7 @@
 const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
 const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
 
-class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {}
 
 module.exports = {
   ManyToManyUnrelateOperation,

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -4,6 +4,15 @@ const { UnrelateOperation } = require('../../../queryBuilder/operations/Unrelate
 const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
 
 class ManyToManyUnrelateOperationBase extends UnrelateOperation {
+  get modifiesJoinTable() {
+    return true;
+  }
+
+  // The main query is replaced by the query that `queryExecutor()` returns.
+  get modifiesJoinTableOnly() {
+    return true;
+  }
+
   queryExecutor(builder) {
     const unrelateQuery = this.relation
       .getJoinModelClass(builder.knex())

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateSqliteOperation.js

@@ -5,11 +5,7 @@ const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin'
 
 class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
   ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUnrelateSqliteOperation,

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

@@ -3,9 +3,24 @@
 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

@@ -2,6 +2,11 @@
 
 const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
 const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
+const { chunk } = require('../../../utils/objectUtils');
+
+// 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;
 
 class ManyToManyUpdateOperationBase extends UpdateOperation {
   constructor(name, opt) {
@@ -11,10 +16,16 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     this.owner = opt.owner;
 
     this.hasExtraProps = false;
+    this.relatedIdsQuery = null;
+    this.relatedIds = null;
     this.joinTablePatch = {};
     this.joinTablePatchFilterQuery = null;
   }
 
+  get modifiesJoinTable() {
+    return this.hasExtraProps;
+  }
+
   onAdd(builder, args) {
     const obj = args[0];
 
@@ -46,30 +57,93 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     return res;
   }
 
-  async onAfter1(builder, result) {
-    if (this.hasExtraProps) {
-      const joinTableUpdateQuery = this.relation
-        .getJoinModelClass(builder.knex())
-        .query()
-        .childQueryOf(builder)
-        .patch(this.joinTablePatch);
+  onBuild(builder) {
+    if (this.modifiesJoinTable && this.modifyFilterSubquery) {
+      // The related rows to update are identified by their ids first, see
+      // `onAfterBuild()`.
+      this.relatedIdsQuery = this.createRelatedIdsQuery(builder);
+    }
 
+    return super.onBuild(builder);
+  }
+
+  // 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);
+  }
+
+  // Update the join rows before the related rows, while the filters still
+  // match them (#161). A query resolved without updating anything, e.g. with
+  // `none()`, leaves the join rows untouched too.
+  async onAfterBuild(builder) {
+    if (this.hasExtraProps && !this.isResolvedWithoutUpdate(builder)) {
+      if (this.relatedIdsQuery) {
+        // The filters can also reference the extras that the join rows change,
+        // so identify the related rows to modify first.
+        const rows = await this.relatedIdsQuery.toKnexQuery();
+        this.relatedIds = rows.map((row) => Object.values(row));
+      }
+
+      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.
+        for (const ids of this.relatedIdBatches()) {
+          await this.updateJoinRows(builder, ids);
+        }
+      } else {
+        await this.updateJoinRows(builder);
+      }
+    }
+  }
+
+  updateJoinRows(builder, relatedIds = null) {
+    const joinTableUpdateQuery = this.relation
+      .getJoinModelClass(builder.knex())
+      .query()
+      .childQueryOf(builder)
+      .patch(this.joinTablePatch);
+
+    addWhereGroup(joinTableUpdateQuery, () =>
+      this.skipRelationFilter
+        ? this.applyIdFilterForJoinTable(joinTableUpdateQuery)
+        : this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
+    );
+    if (relatedIds) {
       addWhereGroup(joinTableUpdateQuery, () =>
-        this.skipRelationFilter
-          ? this.applyIdFilterForJoinTable(joinTableUpdateQuery)
-          : this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
-      );
-      addWhereGroup(joinTableUpdateQuery, () =>
-        joinTableUpdateQuery.modify(this.relation.joinTableModify),
+        joinTableUpdateQuery.whereInComposite(
+          this.relation.joinTableRelatedProp.refs(joinTableUpdateQuery),
+          relatedIds,
+        ),
       );
+    }
+    addWhereGroup(joinTableUpdateQuery, () =>
+      joinTableUpdateQuery.modify(this.relation.joinTableModify),
+    );
+
+    return joinTableUpdateQuery;
+  }
 
-      await joinTableUpdateQuery;
-      return result;
+  // Update the related rows in batches of their ids, as databases limit the
+  // number of values in one statement.
+  queryBatches(builder) {
+    if (this.relatedIds) {
+      const batches = this.relatedIdBatches();
+      // Without ids, still execute the query once for the dialect's result:
+      return batches.length > 0 ? batches : [[]];
     } else {
-      return result;
+      return null;
     }
   }
 
+  relatedIdBatches() {
+    const idSize = this.relation.relatedModelClass.getIdRelationProperty().size;
+    return chunk(this.relatedIds, Math.floor(maxBatchValues / idSize));
+  }
+
   // Filters the join rows by the ids of the owner and the updated model.
   applyIdFilterForJoinTable(builder) {
     return builder
@@ -97,6 +171,8 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     const clone = super.clone();
 
     clone.hasExtraProps = this.hasExtraProps;
+    clone.relatedIdsQuery = this.relatedIdsQuery;
+    clone.relatedIds = this.relatedIds;
     clone.joinTablePatch = this.joinTablePatch;
     clone.joinTablePatchFilterQuery = this.joinTablePatchFilterQuery;
 

package/lib/utils/identifierMapping.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isObject, isPlainObject } = require('./objectUtils');
+const { isObject } = require('./objectUtils');
 
 // Super fast memoize for single argument functions.
 function memoize(func) {
@@ -149,9 +149,8 @@ function mapLastPart(mapper, separator) {
 }
 
 // Returns a function that takes an object as an input and maps the object's keys
-// using `mapper`, and its values using the optional `valueMapper`. If the input
-// is not an object, the input is returned unchanged.
-function keyMapper(mapper, valueMapper) {
+// using `mapper`. If the input is not an object, the input is returned unchanged.
+function keyMapper(mapper) {
   return (obj) => {
     if (!isObject(obj) || Array.isArray(obj)) {
       return obj;
@@ -162,7 +161,7 @@ function keyMapper(mapper, valueMapper) {
 
     for (let i = 0, l = keys.length; i < l; ++i) {
       const key = keys[i];
-      out[mapper(key)] = valueMapper ? valueMapper(obj[key]) : obj[key];
+      out[mapper(key)] = obj[key];
     }
 
     return out;
@@ -172,8 +171,8 @@ function keyMapper(mapper, valueMapper) {
 // Returns a function that only calls `mapper` for the part of the input string
 // before the first `separator`, and leaves the rest untouched. For field
 // expressions like `jsonColumn:some.jsonPath` this maps the column but keeps
-// the json path as is. Column names can't contain `:`, so the first one marks
-// the boundary.
+// the json path as is. The mapper doesn't know the schema, so the first `:`
+// marks the boundary also in a declared column name like `ns:name`.
 function mapFirstPart(mapper, separator) {
   return (str) => {
     const idx = str.indexOf(separator);
@@ -190,16 +189,10 @@ function snakeCaseMappers(opt = {}) {
   };
 }
 
-function knexIdentifierMappers({ parse, format, idSeparator = ':', mapNestedKeys = false } = {}) {
+function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
   const formatId = memoize(mapLastPart(format, idSeparator));
   const parseId = memoize(mapLastPart(parse, idSeparator));
   const parseKeys = keyMapper(parseId);
-  // With `mapNestedKeys`, also map the keys of plain objects one level down, as
-  // in the rows knex returns with its `nestTables: true` option on MySQL:
-  // `{ tableName: { columnName: value } }`.
-  const parseRow = mapNestedKeys
-    ? keyMapper(parseId, (value) => (isPlainObject(value) ? parseKeys(value) : value))
-    : parseKeys;
 
   return {
     wrapIdentifier(identifier, origWrap) {
@@ -211,12 +204,12 @@ function knexIdentifierMappers({ parse, format, idSeparator = ':', mapNestedKeys
         const output = new Array(result.length);
 
         for (let i = 0, l = result.length; i < l; ++i) {
-          output[i] = parseRow(result[i]);
+          output[i] = parseKeys(result[i]);
         }
 
         return output;
       } else {
-        return parseRow(result);
+        return parseKeys(result);
       }
     },
   };
@@ -226,11 +219,10 @@ function knexSnakeCaseMappers(opt = {}) {
   return knexIdentifierMappers({
     parse: (str) => camelCase(str, opt),
     format: (str) => snakeCase(str, opt),
-    mapNestedKeys: opt.mapNestedKeys,
   });
 }
 
-function knexIdentifierMapping(colToProp, { mapNestedKeys } = {}) {
+function knexIdentifierMapping(colToProp) {
   const propToCol = Object.keys(colToProp).reduce((propToCol, column) => {
     propToCol[colToProp[column]] = column;
     return propToCol;
@@ -239,7 +231,6 @@ function knexIdentifierMapping(colToProp, { mapNestedKeys } = {}) {
   return knexIdentifierMappers({
     parse: (column) => colToProp[column] || column,
     format: (prop) => propToCol[prop] || prop,
-    mapNestedKeys,
   });
 }
 

package/lib/utils/knexUtils.js

@@ -36,6 +36,19 @@ function isMsSql(knex) {
   return getDialect(knex) === 'mssql';
 }
 
+// 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) {
+  const { version, isMariaDB } = knex.client;
+
+  if (isMySql(knex) && version) {
+    const [major, minor] = version.split('.').map(Number);
+    return isMariaDB ? major > 10 || (major === 10 && minor >= 2) : major >= 8;
+  } else {
+    return true;
+  }
+}
+
 function isKnexQueryBuilder(value) {
   return (
     hasConstructor(value) &&
@@ -69,6 +82,7 @@ module.exports = {
   isSqlite,
   isMsSql,
   isOracle,
+  hasWindowFunctions,
   isKnexQueryBuilder,
   isKnexJoinBuilder,
   isKnexRaw,

package/lib/utils/objectUtils.js

@@ -388,11 +388,43 @@ 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.
+// Returns the tag of `value` like `Object.prototype.toString()`, but ignores a
+// `Symbol.toStringTag` that can be overwritten, like lodash's `baseGetTag()`.
+// Objects that define a writable tag, like decimal.js numbers, are plain
+// objects then, while built-ins like `URL` keep their own tag.
+function getRawTag(value) {
+  const tag = Object.prototype.toString.call(value);
+
+  if (!(Symbol.toStringTag in value)) {
+    return tag;
+  }
+
+  const isOwn = Object.prototype.hasOwnProperty.call(value, Symbol.toStringTag);
+  const ownTag = value[Symbol.toStringTag];
+
+  try {
+    value[Symbol.toStringTag] = undefined;
+  } catch (err) {
+    return tag;
+  }
+
+  const rawTag = Object.prototype.toString.call(value);
+
+  if (isOwn) {
+    value[Symbol.toStringTag] = ownTag;
+  } else {
+    delete value[Symbol.toStringTag];
+  }
+
+  return rawTag;
+}
+
+// Clones `value` deeply, like lodash's `cloneDeep()`: plain objects and class
+// instances 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, errors and built-ins
+// with internal state like `URL`, is kept as it is.
 function cloneDeep(value, clones = new Map()) {
   if (!isObject(value)) {
     return value;
@@ -401,7 +433,7 @@ function cloneDeep(value, clones = new Map()) {
   }
 
   const Ctor = value.constructor;
-  const tag = Object.prototype.toString.call(value);
+  const tag = getRawTag(value);
   let copy;
 
   if (tag === '[object Object]') {

package/lib/utils/parseFieldExpression.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const jsonFieldExpressionParser = require('../queryBuilder/parsers/jsonFieldExpressionParser');
+const { isObject } = require('./objectUtils');
 const cache = new Map();
 
 function parseFieldExpression(expr) {
@@ -46,6 +47,16 @@ function freezeParsedExpr(parsedExpr) {
   return parsedExpr;
 }
 
+// Keys with a ':' in the data of patches and updates are field expressions like
+// `'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))
+  );
+}
+
 // Formats the json path of a parsed field expression as a Postgres text array
 // literal, e.g. `{a,"",b}`. Keys that would otherwise be misread (empty keys,
 // keys with whitespace, delimiters, quotes or backslashes and `NULL`) are
@@ -66,14 +77,22 @@ function toPostgresJsonPath(access) {
 // `whereIn(ref(...), values)`), so the keys need to be escaped instead: single
 // quotes are doubled, and `?` is escaped so that knex doesn't read it as a
 // binding placeholder. Backslashes are always doubled by `toPostgresJsonPath()`,
-// so they can't escape the closing quote either.
+// so they can't escape the closing quote either. But knex's Postgres dialect
+// drops all backslashes in front of an escaped `?`, so if the path contains any,
+// an escape string literal is used in which backslashes are written as `\134`.
 function toPostgresJsonPathLiteral(access) {
-  const path = toPostgresJsonPath(access).replace(/'/g, "''").replace(/\?/g, '\\?');
-  return `'${path}'`;
+  const path = toPostgresJsonPath(access).replace(/'/g, "''");
+
+  if (path.includes('\\?')) {
+    return `E'${path.replace(/\\/g, '\\134').replace(/\?/g, '\\?')}'`;
+  } else {
+    return `'${path.replace(/\?/g, '\\?')}'`;
+  }
 }
 
 module.exports = {
   parseFieldExpression,
+  isFieldExpressionKey,
   toPostgresJsonPath,
   toPostgresJsonPathLiteral,
 };

package/lib/utils/warnings.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const LOGGED_WARNINGS = new Set();
+
+// Log each warning only once.
+function warnOnce(message) {
+  if (!LOGGED_WARNINGS.has(message)) {
+    LOGGED_WARNINGS.add(message);
+    console.warn(`[objection] ${message}`);
+  }
+}
+
+function deprecate(message) {
+  warnOnce(message);
+}
+
+// Only meant for tests that need to see a warning again.
+function resetWarnings() {
+  LOGGED_WARNINGS.clear();
+}
+
+module.exports = {
+  warnOnce,
+  deprecate,
+  resetWarnings,
+};