objection 3.6.0 → 3.7.0

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

@@ -66,10 +66,17 @@ 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 = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",

package/typings/objection/index.d.ts

@@ -374,7 +374,8 @@ declare namespace Objection {
 
   /**
    * Converts the query builder NQB to the same result kind as QB:
-   * array, single, maybe-single or page.
+   * array, single, maybe-single or page. Any other result type, e.g. after
+   * `castTo()` or `patch()`, falls back to QB, without narrowing.
    */
   type WithResultKind<QB extends AnyQueryBuilder, NQB extends AnyQueryBuilder> = [
     ResultType<QB>,
@@ -423,7 +424,9 @@ declare namespace Objection {
         ? I extends Model
           ? I[] | PartialModelObject<I>[]
           : Expression<T[K]>
-        : Expression<T[K]>;
+        : NonNullable<T[K]> extends Model
+          ? Expression<T[K]> | PartialModelObject<NonNullable<T[K]>> // nullable to-one relations
+          : Expression<T[K]>;
   };
 
   /**
@@ -1000,14 +1003,36 @@ declare namespace Objection {
     includeTriggerModifications?: boolean;
   }
 
+  type ReturningColumn = string | Raw | readonly (string | Raw)[];
+
+  /**
+   * The arguments of `returning()`: any number of columns or column arrays,
+   * optionally followed by an options object.
+   */
+  type ReturningArgs =
+    ReturningColumn[] | [ReturningColumn, ...ReturningColumn[], ReturningOptions | undefined];
+
   interface ReturningMethod {
     <QB extends AnyQueryBuilder>(
       this: QB,
-      column: string | Raw | (string | Raw)[] | readonly (string | Raw)[],
-      options?: ReturningOptions,
+      ...args: ReturningArgs
     ): QB extends NumberQueryBuilder<QB> ? ArrayQueryBuilder<QB> : QB;
   }
 
+  /**
+   * With `returning()`, `relate()` returns the inserted join rows for
+   * many-to-many relations, the updated related rows for has-many relations
+   * and the updated owner rows for belongs-to-one relations. The typings can't
+   * tell these apart, so the rows are typed as `any`.
+   */
+  interface RelateReturningMethod<M extends Model> {
+    (...args: ReturningArgs): QueryBuilder<M, any[]>;
+  }
+
+  type RelateQueryBuilder<QB extends AnyQueryBuilder> = {
+    returning: RelateReturningMethod<ModelType<QB>>;
+  } & NumberQueryBuilder<QB>;
+
   interface TimeoutOptions {
     cancel: boolean;
   }
@@ -1060,6 +1085,7 @@ declare namespace Objection {
   export interface InsertGraphOptions {
     relate?: boolean | string | string[];
     allowRefs?: boolean;
+    allowMarkers?: boolean;
   }
 
   interface InsertGraphMethod<M extends Model> {
@@ -1087,6 +1113,7 @@ declare namespace Objection {
     noRelate?: boolean | string | string[];
     noUnrelate?: boolean | string | string[];
     allowRefs?: boolean;
+    allowMarkers?: boolean;
   }
 
   interface UpsertGraphMethod<M extends Model> {
@@ -1386,7 +1413,7 @@ declare namespace Objection {
 
     relate(
       ids: MaybeCompositeId | MaybeCompositeId[] | PartialModelObject<M> | PartialModelObject<M>[],
-    ): NumberQueryBuilder<this>;
+    ): RelateQueryBuilder<this>;
 
     unrelate(): NumberQueryBuilder<this>;
     for(ids: ForIdValue | ForIdValue[]): this;
@@ -1718,34 +1745,25 @@ declare namespace Objection {
     constructor(config: AjvConfig);
   }
 
-  export interface SnakeCaseMappersOptions {
+  /**
+   * The options shared by `snakeCaseMappers` and `knexSnakeCaseMappers`.
+   */
+  export interface SnakeCaseOptions {
     upperCase?: boolean;
     underscoreBeforeDigits?: boolean;
     underscoreBetweenUppercaseLetters?: boolean;
     noDoubleUnderscores?: boolean;
+  }
+
+  export interface SnakeCaseMappersOptions extends SnakeCaseOptions {
     /**
      * Only convert the column part of field expressions like
      * `jsonColumn:someKey` and keep their JSON keys as written.
-     * Only used by `snakeCaseMappers`.
      */
     preserveJsonKeys?: boolean;
-    /**
-     * Also convert the keys of plain objects one level down in the results,
-     * e.g. the rows of knex's `nestTables: true` option on MySQL. Also applies
-     * to JSON columns parsed by the driver.
-     * Only used by `knexSnakeCaseMappers`.
-     */
-    mapNestedKeys?: boolean;
   }
 
-  export interface KnexIdentifierMappingOptions {
-    /**
-     * Also convert the keys of plain objects one level down in the results,
-     * e.g. the rows of knex's `nestTables: true` option on MySQL. Also applies
-     * to JSON columns parsed by the driver.
-     */
-    mapNestedKeys?: boolean;
-  }
+  export interface KnexSnakeCaseMappersOptions extends SnakeCaseOptions {}
 
   export interface ColumnNameMappers {
     parse(json: Pojo): Pojo;
@@ -1762,11 +1780,11 @@ declare namespace Objection {
   }
 
   export interface KnexSnakeCaseMappersFactory {
-    (options?: SnakeCaseMappersOptions): KnexMappers;
+    (options?: KnexSnakeCaseMappersOptions): KnexMappers;
   }
 
   export interface KnexIdentifierMappingFactory {
-    (colToProp: Record<string, string>, options?: KnexIdentifierMappingOptions): KnexMappers;
+    (colToProp: Record<string, string>): KnexMappers;
   }
 
   export type ValidationErrorType =
@@ -2040,14 +2058,16 @@ declare namespace Objection {
     static bindKnex<M>(this: M, trxOrKnex: TransactionOrKnex): M;
     static bindTransaction<M>(this: M, trxOrKnex: TransactionOrKnex): M;
 
-    static fetchGraph<M extends Model, const E extends RelationExpression<M>>(
+    // E defaults to `string` so that `fetchGraph<Person>(...)` still compiles,
+    // without narrowing, as TypeScript doesn't infer the remaining arguments.
+    static fetchGraph<M extends Model, const E extends RelationExpression<M> = string>(
       this: ConstructorType<M>,
       modelOrObject: PartialModelObject<M>,
       expression: E,
       options?: FetchGraphOptions,
     ): SingleQueryBuilder<WithGraphModelQueryBuilder<M, E>>;
 
-    static fetchGraph<M extends Model, const E extends RelationExpression<M>>(
+    static fetchGraph<M extends Model, const E extends RelationExpression<M> = string>(
       this: ConstructorType<M>,
       modelOrObject: PartialModelObject<M>[],
       expression: E,

package/lib/relations/manyToMany/ManyToManyPostgresModifyMixin.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
-
-// Like `ManyToManySqliteModifyMixin`, this identifies the join rows to modify
-// by their physical row id, so that only the join rows that match the filters
-// are modified (#1853). `tableoid` makes `ctid` unique for partitioned tables.
-const ManyToManyPostgresModifyMixin = (Operation) => {
-  return class extends ManyToManyModifyMixin(Operation) {
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-      const rowIdRefs = [`${tableRef}.tableoid`, `${tableRef}.ctid`];
-
-      const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRefs);
-
-      return builder
-        .whereInComposite(rowIdRefs, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
-  };
-};
-
-module.exports = {
-  ManyToManyPostgresModifyMixin,
-};

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

@@ -1,16 +0,0 @@
-'use strict';
-
-const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
-const { ManyToManyPostgresModifyMixin } = require('../ManyToManyPostgresModifyMixin');
-
-class ManyToManyUnrelatePostgresOperation extends ManyToManyPostgresModifyMixin(
-  ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
-
-module.exports = {
-  ManyToManyUnrelatePostgresOperation,
-};

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

@@ -1,12 +0,0 @@
-'use strict';
-
-const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
-const { ManyToManyPostgresModifyMixin } = require('../ManyToManyPostgresModifyMixin');
-
-class ManyToManyUpdatePostgresOperation extends ManyToManyPostgresModifyMixin(
-  ManyToManyUpdateOperationBase,
-) {}
-
-module.exports = {
-  ManyToManyUpdatePostgresOperation,
-};