objection 3.4.1 → 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);
 
@@ -219,8 +225,12 @@ class Relation {
     });
   }
 
-  executeBeforeInsert(models, queryContext, result) {
-    return mapAfterAllReturn(models, (model) => this.beforeInsert(model, queryContext), result);
+  executeBeforeInsert(models, queryContext, result, owner) {
+    return mapAfterAllReturn(
+      models,
+      (model) => this.beforeInsert(model, queryContext, owner),
+      result,
+    );
   }
 
   createError(message) {

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/RelationInsertOperation.js

@@ -11,9 +11,21 @@ class RelationInsertOperation extends InsertOperation {
     this.assignResultToOwner = true;
   }
 
+  get ownerModel() {
+    // The owner model passed to the relation's `beforeInsert` hook. Only known
+    // if the query was started from a single model instance.
+    const { owner } = this;
+    return owner && owner.isModels && owner.modelArray.length === 1 ? owner.model : undefined;
+  }
+
   async onBefore2(builder, result) {
     const queryContext = builder.context();
-    result = await this.relation.executeBeforeInsert(this.models, queryContext, result);
+    result = await this.relation.executeBeforeInsert(
+      this.models,
+      queryContext,
+      result,
+      this.ownerModel,
+    );
     return super.onBefore2(builder, result);
   }
 

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/identifierMapping.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isObject } = require('./objectUtils');
+const { isObject, isPlainObject } = require('./objectUtils');
 
 // Super fast memoize for single argument functions.
 function memoize(func) {
@@ -149,8 +149,9 @@ function mapLastPart(mapper, separator) {
 }
 
 // Returns a function that takes an object as an input and maps the object's keys
-// using `mapper`. If the input is not an object, the input is returned unchanged.
-function keyMapper(mapper) {
+// 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) {
   return (obj) => {
     if (!isObject(obj) || Array.isArray(obj)) {
       return obj;
@@ -161,7 +162,7 @@ function keyMapper(mapper) {
 
     for (let i = 0, l = keys.length; i < l; ++i) {
       const key = keys[i];
-      out[mapper(key)] = obj[key];
+      out[mapper(key)] = valueMapper ? valueMapper(obj[key]) : obj[key];
     }
 
     return out;
@@ -189,10 +190,16 @@ function snakeCaseMappers(opt = {}) {
   };
 }
 
-function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
+function knexIdentifierMappers({ parse, format, idSeparator = ':', mapNestedKeys = false } = {}) {
   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) {
@@ -204,12 +211,12 @@ function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
         const output = new Array(result.length);
 
         for (let i = 0, l = result.length; i < l; ++i) {
-          output[i] = parseKeys(result[i]);
+          output[i] = parseRow(result[i]);
         }
 
         return output;
       } else {
-        return parseKeys(result);
+        return parseRow(result);
       }
     },
   };
@@ -219,10 +226,11 @@ function knexSnakeCaseMappers(opt = {}) {
   return knexIdentifierMappers({
     parse: (str) => camelCase(str, opt),
     format: (str) => snakeCase(str, opt),
+    mapNestedKeys: opt.mapNestedKeys,
   });
 }
 
-function knexIdentifierMapping(colToProp) {
+function knexIdentifierMapping(colToProp, { mapNestedKeys } = {}) {
   const propToCol = Object.keys(colToProp).reduce((propToCol, column) => {
     propToCol[colToProp[column]] = column;
     return propToCol;
@@ -231,6 +239,7 @@ function knexIdentifierMapping(colToProp) {
   return knexIdentifierMappers({
     parse: (column) => colToProp[column] || column,
     format: (prop) => propToCol[prop] || prop,
+    mapNestedKeys,
   });
 }
 

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.4.1",
+  "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

@@ -19,6 +19,11 @@ import { Knex } from 'knex';
 // Export the entire Objection namespace.
 export = Objection;
 
+// Phantom brand of the relation types, used by `TypedRelationMappings`.
+declare const relationKind: unique symbol;
+// Phantom brand of `Generated` properties.
+declare const generated: unique symbol;
+
 declare namespace Objection {
   const raw: RawFunction;
   const val: ValueFunction;
@@ -462,6 +467,65 @@ declare namespace Objection {
           : Expression<F>
         : Expression<F>;
 
+  /**
+   * Marks a model property whose value the database generates, like an
+   * auto-incremented id, a timestamp or a column with a default value. It
+   * reads as T and accepts T, but `Insertable` and `InsertableGraph` treat
+   * the property as optional:
+   *
+   *   id!: Generated<number>;
+   */
+  export type Generated<T> = T extends null | undefined ? T : T & GeneratedBrand;
+
+  interface GeneratedBrand {
+    readonly [generated]?: true;
+  }
+
+  /**
+   * Insert keys are optional for optional, nullable and generated properties.
+   */
+  type OptionalInsertPropertyNames<M> = {
+    [K in keyof M]-?: {} extends Pick<M, K>
+      ? K
+      : null extends M[K]
+        ? K
+        : typeof generated extends keyof NonNullable<M[K]>
+          ? K
+          : never;
+  }[keyof M];
+
+  type InsertablePropertyNames<M> = Exclude<DataPropertyNames<M>, RelationPropertyNames<M>>;
+
+  /**
+   * The data to insert a model M with `insert()`. Unlike `PartialModelObject`,
+   * all properties are required except optional, nullable and `Generated`
+   * ones. Relation properties are left out.
+   */
+  export type Insertable<M extends Model> = {
+    [K in Exclude<InsertablePropertyNames<M>, OptionalInsertPropertyNames<M>>]: Expression<M[K]>;
+  } & {
+    [K in Extract<InsertablePropertyNames<M>, OptionalInsertPropertyNames<M>>]?: Expression<M[K]>;
+  };
+
+  /**
+   * Like `Insertable`, but for `insertGraph()`: relation properties are
+   * optional and hold the insertable graphs of the related models, or
+   * references to existing ones through `#dbRef` or `#ref`.
+   */
+  export type InsertableGraph<M extends Model> = Insertable<M> &
+    Omit<GraphParameters, '#dbRef' | '#ref'> & {
+      [K in RelationPropertyNames<M>]?: InsertableGraphField<M[K]>;
+    };
+
+  type InsertableGraphReference = { '#dbRef': MaybeCompositeId } | { '#ref': string };
+
+  type InsertableGraphField<F> =
+    NonNullable<F> extends (infer I extends Model)[]
+      ? (InsertableGraph<I> | InsertableGraphReference)[]
+      : NonNullable<F> extends infer I extends Model
+        ? InsertableGraph<I> | InsertableGraphReference | Extract<F, null>
+        : never;
+
   /**
    * Extracts the property names (excluding relations) of a model class.
    */
@@ -994,7 +1058,7 @@ declare namespace Objection {
   }
 
   export interface InsertGraphOptions {
-    relate?: boolean | string[];
+    relate?: boolean | string | string[];
     allowRefs?: boolean;
   }
 
@@ -1013,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;
   }
 
@@ -1488,6 +1552,11 @@ declare namespace Objection {
     model: M,
     context: QueryContext,
   ) => Promise<void> | void;
+  type RelationMappingBeforeInsertHook<M extends Model> = (
+    model: M,
+    context: QueryContext,
+    owner?: Model,
+  ) => Promise<void> | void;
   type StringOrReferenceBuilder = string | ReferenceBuilder;
   type RelationMappingColumnRef = StringOrReferenceBuilder | StringOrReferenceBuilder[];
 
@@ -1497,7 +1566,7 @@ declare namespace Objection {
     join: RelationJoin;
     modify?: Modifier<QueryBuilderType<M>>;
     filter?: Modifier<QueryBuilderType<M>>;
-    beforeInsert?: RelationMappingHook<M>;
+    beforeInsert?: RelationMappingBeforeInsertHook<M>;
   }
 
   export interface RelationJoin {
@@ -1518,6 +1587,67 @@ declare namespace Objection {
 
   export interface RelationType extends Constructor<Relation> {}
 
+  // The relation types are branded so that `TypedRelationMappings` can tell
+  // them apart. The brand is optional, so any `RelationType` is assignable.
+  export interface BelongsToOneRelationType extends RelationType {
+    readonly [relationKind]?: 'BelongsToOne';
+  }
+  export interface HasOneRelationType extends RelationType {
+    readonly [relationKind]?: 'HasOne';
+  }
+  export interface HasManyRelationType extends RelationType {
+    readonly [relationKind]?: 'HasMany';
+  }
+  export interface ManyToManyRelationType extends RelationType {
+    readonly [relationKind]?: 'ManyToMany';
+  }
+  export interface HasOneThroughRelationType extends RelationType {
+    readonly [relationKind]?: 'HasOneThrough';
+  }
+
+  /**
+   * Names of the properties of M that hold related models.
+   */
+  type RelationPropertyNames<M> = {
+    [K in keyof M]-?: NonNullable<M[K]> extends Model | Model[] ? K : never;
+  }[keyof M];
+
+  type TypedModelClassSpecifier<M extends Model> =
+    string | ModelConstructor<M> | (() => ModelConstructor<M>);
+
+  /**
+   * A `RelationMapping` for related models of type M with relation type R.
+   */
+  export interface TypedRelationMapping<
+    M extends Model,
+    R extends RelationType = RelationType,
+  > extends RelationMapping<M> {
+    relation: R;
+    modelClass: TypedModelClassSpecifier<M>;
+  }
+
+  type TypedRelationMappingFor<T> =
+    NonNullable<T> extends (infer I extends Model)[]
+      ? TypedRelationMapping<I, HasManyRelationType | ManyToManyRelationType>
+      : NonNullable<T> extends infer I extends Model
+        ? TypedRelationMapping<
+            I,
+            BelongsToOneRelationType | HasOneRelationType | HasOneThroughRelationType
+          >
+        : never;
+
+  /**
+   * Relation mappings checked against the relation properties of model M.
+   * Use it with `satisfies`, so the inferred type of the mappings is kept:
+   *
+   *   static relationMappings = {
+   *     pets: { ... },
+   *   } satisfies TypedRelationMappings<Person>;
+   */
+  export type TypedRelationMappings<M extends Model> = [RelationPropertyNames<M>] extends [never]
+    ? Record<string, never>
+    : { [K in RelationPropertyNames<M>]?: TypedRelationMappingFor<M[K]> };
+
   export interface Relation {
     name: string;
     ownerModelClass: typeof Model;
@@ -1528,6 +1658,7 @@ declare namespace Objection {
     joinTable: string;
     joinTableOwnerProp: RelationProperty;
     joinTableRelatedProp: RelationProperty;
+    isOneToOne(): boolean;
   }
 
   export interface RelationProperty {
@@ -1598,6 +1729,22 @@ declare namespace Objection {
      * 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 ColumnNameMappers {
@@ -1619,7 +1766,7 @@ declare namespace Objection {
   }
 
   export interface KnexIdentifierMappingFactory {
-    (colToProp: Record<string, string>): KnexMappers;
+    (colToProp: Record<string, string>, options?: KnexIdentifierMappingOptions): KnexMappers;
   }
 
   export type ValidationErrorType =
@@ -1732,11 +1879,11 @@ declare namespace Objection {
     ref: ReferenceFunction;
     fn: FunctionFunction;
 
-    BelongsToOneRelation: RelationType;
-    HasOneRelation: RelationType;
-    HasManyRelation: RelationType;
-    ManyToManyRelation: RelationType;
-    HasOneThroughRelation: RelationType;
+    BelongsToOneRelation: BelongsToOneRelationType;
+    HasOneRelation: HasOneRelationType;
+    HasManyRelation: HasManyRelationType;
+    ManyToManyRelation: ManyToManyRelationType;
+    HasOneThroughRelation: HasOneThroughRelationType;
 
     defaultGraphOptions?: GraphOptions;
 
@@ -1843,11 +1990,11 @@ declare namespace Objection {
     static ref: ReferenceFunction;
     static fn: FunctionFunction;
 
-    static BelongsToOneRelation: RelationType;
-    static HasOneRelation: RelationType;
-    static HasManyRelation: RelationType;
-    static ManyToManyRelation: RelationType;
-    static HasOneThroughRelation: RelationType;
+    static BelongsToOneRelation: BelongsToOneRelationType;
+    static HasOneRelation: HasOneRelationType;
+    static HasManyRelation: HasManyRelationType;
+    static ManyToManyRelation: ManyToManyRelationType;
+    static HasOneThroughRelation: HasOneThroughRelationType;
 
     static defaultGraphOptions?: GraphOptions;