Add public Relation.joinModelClass accessor

lehni · koskimas · commit 49159b616890 · 2018-02-19T15:21:28.000+02:00
Rename private joinModelClass(knex) function to getJoinModelClass(knex) for internal use
diff --git a/doc/includes/API.md b/doc/includes/API.md
@@ -8105,6 +8105,7 @@ ownerModelClass|function|The model class that has defined the relation.
 relatedModelClass|function|The model class of the related objects.
 ownerProp|[`RelationProperty`](#relationproperty)|The relation property in the `ownerModelClass`.
 relatedProp|[`RelationProperty`](#relationproperty)|The relation property in the `relatedModelClass`.
+joinModelClass|function|The model class representing the join table. This class is automatically generated by Objection if none is provided in the `join.through.modelClass` setting of the relation mapping, see [`RelationThrough`](#relationthrough).
 joinTable|string|The name of the join table (only for `ManyToMany` and `HasOneThrough` relations).
 joinTableOwnerProp|[`RelationProperty`](#relationproperty)|The join table property pointing to `ownerProp` (only for `ManyToMany` and `HasOneThrough` relations).
 joinTableRelatedProp|[`RelationProperty`](#relationproperty)|The join table property pointing to `relatedProp` (only for `ManyToMany` and `HasOneThrough` relations).
diff --git a/lib/queryBuilder/graphInserter/GraphInserter.js b/lib/queryBuilder/graphInserter/GraphInserter.js
@@ -186,7 +186,7 @@ class GraphInserter {
         let tableInsertion = batch[conn.relation.joinTable];
 
         const ownerProp = conn.relation.ownerProp.getProps(node.model);
-        const modelClass = conn.relation.joinModelClass(this.knex);
+        const modelClass = conn.relation.getJoinModelClass(this.knex);
         let joinModel = conn.relation.createJoinModels(ownerProp, [conn.node.model])[0];
 
         if (conn.refNode) {
diff --git a/lib/relations/Relation.js b/lib/relations/Relation.js
@@ -63,19 +63,17 @@ class Relation {
   }
 
   get joinTable() {
-    if (this.joinTableModelClass) {
-      return this.joinTableModelClass.getTableName();
-    } else {
-      return null;
-    }
+    return this.joinTableModelClass ? this.joinTableModelClass.getTableName() : null;
   }
 
-  joinModelClass(knex) {
-    if (knex && knex !== this.joinTableModelClass.knex()) {
-      return this.joinTableModelClass.bindKnex(knex);
-    } else {
-      return this.joinTableModelClass;
-    }
+  get joinModelClass() {
+    return this.getJoinModelClass(this.ownerModelClass.knex());
+  }
+
+  getJoinModelClass(knex) {
+    return this.joinTableModelClass && knex !== this.joinTableModelClass.knex()
+      ? this.joinTableModelClass.bindKnex(knex)
+      : this.joinTableModelClass;
   }
 
   relatedTableAlias(builder) {
diff --git a/lib/relations/manyToMany/ManyToManyRelation.js b/lib/relations/manyToMany/ManyToManyRelation.js
@@ -35,7 +35,7 @@ class ManyToManyRelation extends Relation {
       ownerProp: this.ownerProp,
       relatedProp: this.relatedProp,
 
-      joinModelClass: null,
+      joinTableModelClass: null,
       joinTableOwnerProp: null,
       joinTableRelatedProp: null,
       joinTableBeforeInsert: null,
@@ -52,7 +52,7 @@ class ManyToManyRelation extends Relation {
     ctx = finalizeJoinModelClass(ctx);
 
     this.joinTableExtras = ctx.joinTableExtras;
-    this.joinTableModelClass = ctx.joinModelClass;
+    this.joinTableModelClass = ctx.joinTableModelClass;
     this.joinTableOwnerProp = ctx.joinTableOwnerProp;
     this.joinTableRelatedProp = ctx.joinTableRelatedProp;
     this.joinTableBeforeInsert = ctx.joinTableBeforeInsert;
@@ -314,11 +314,11 @@ function checkThroughObject(ctx) {
 }
 
 function resolveJoinModelClassIfDefined(ctx) {
-  let joinModelClass = null;
+  let joinTableModelClass = null;
 
   if (ctx.mapping.join.through.modelClass) {
     try {
-      joinModelClass = resolveModel(
+      joinTableModelClass = resolveModel(
         ctx.mapping.join.through.modelClass,
         ctx.ownerModelClass.modelPaths,
         'join.through.modelClass'
@@ -328,7 +328,7 @@ function resolveJoinModelClassIfDefined(ctx) {
     }
   }
 
-  return Object.assign(ctx, { joinModelClass });
+  return Object.assign(ctx, { joinTableModelClass });
 }
 
 function createJoinProperties(ctx) {
@@ -368,17 +368,17 @@ function createJoinProperties(ctx) {
 
 function createRelationProperty(ctx, refString, messagePrefix) {
   let prop = null;
-  let joinModelClass = ctx.joinModelClass;
+  let joinTableModelClass = ctx.joinTableModelClass;
 
   const resolveModelClass = table => {
-    if (joinModelClass === null) {
-      joinModelClass = inheritModel(getModel());
-      joinModelClass.tableName = table;
-      joinModelClass.idColumn = null;
+    if (joinTableModelClass === null) {
+      joinTableModelClass = inheritModel(getModel());
+      joinTableModelClass.tableName = table;
+      joinTableModelClass.idColumn = null;
     }
 
-    if (joinModelClass.getTableName() === table) {
-      return joinModelClass;
+    if (joinTableModelClass.getTableName() === table) {
+      return joinTableModelClass;
     } else {
       return null;
     }
@@ -397,7 +397,7 @@ function createRelationProperty(ctx, refString, messagePrefix) {
   }
 
   return {
-    ctx: Object.assign(ctx, { joinModelClass }),
+    ctx: Object.assign(ctx, { joinTableModelClass }),
     prop
   };
 }
@@ -421,9 +421,9 @@ function parseExtras(ctx) {
 
     return {
       joinTableCol: val,
-      joinTableProp: ctx.joinModelClass.columnNameToPropertyName(val),
+      joinTableProp: ctx.joinTableModelClass.columnNameToPropertyName(val),
       aliasCol: key,
-      aliasProp: ctx.joinModelClass.columnNameToPropertyName(key)
+      aliasProp: ctx.joinTableModelClass.columnNameToPropertyName(key)
     };
   });
 
@@ -443,10 +443,10 @@ function parseBeforeInsert(ctx) {
 }
 
 function finalizeJoinModelClass(ctx) {
-  if (ctx.joinModelClass.getIdColumn() === null) {
+  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.
-    ctx.joinModelClass.idColumn = ctx.joinTableRelatedProp.cols;
+    ctx.joinTableModelClass.idColumn = ctx.joinTableRelatedProp.cols;
   }
 
   return ctx;
diff --git a/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js b/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js
@@ -16,7 +16,7 @@ const ManyToManySqliteModifyMixin = Operation => {
 
     applyModifyFilterForJoinTable(builder) {
       const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.joinModelClass(builder));
+      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
       const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
 
       const ownerIds = this.relation.ownerProp.getProps(this.owner);
diff --git a/lib/relations/manyToMany/insert/ManyToManyInsertOperation.js b/lib/relations/manyToMany/insert/ManyToManyInsertOperation.js
@@ -17,7 +17,7 @@ class ManyToManyInsertOperation extends RelationInsertOperation {
     return after(maybePromise, inserted => {
       const ownerId = this.relation.ownerProp.getProps(owner);
       const joinModels = this.relation.createJoinModels(ownerId, inserted);
-      const joinModelClass = this.relation.joinModelClass(builder.knex());
+      const joinModelClass = this.relation.getJoinModelClass(builder.knex());
 
       for (let i = 0, l = joinModels.length; i < l; ++i) {
         joinModels[i] = joinModelClass.fromJson(joinModels[i]);
diff --git a/lib/relations/manyToMany/relate/ManyToManyRelateOperation.js b/lib/relations/manyToMany/relate/ManyToManyRelateOperation.js
@@ -11,7 +11,7 @@ class ManyToManyRelateOperation extends RelateOperation {
   queryExecutor(builder) {
     const ownerId = this.relation.ownerProp.getProps(this.owner);
     const joinModels = this.relation.createJoinModels(ownerId, this.ids);
-    const joinModelClass = this.relation.joinModelClass(builder.knex());
+    const joinModelClass = this.relation.getJoinModelClass(builder.knex());
 
     for (let i = 0, l = joinModels.length; i < l; ++i) {
       joinModels[i] = joinModelClass.fromJson(joinModels[i]);
diff --git a/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js b/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js
@@ -3,7 +3,7 @@ const UnrelateOperation = require('../../../queryBuilder/operations/UnrelateOper
 class ManyToManyUnrelateOperationBase extends UnrelateOperation {
   queryExecutor(builder) {
     const unrelateQuery = this.relation
-      .joinModelClass(builder.knex())
+      .getJoinModelClass(builder.knex())
       .query()
       .childQueryOf(builder)
       .delete();
diff --git a/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js b/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js
@@ -53,7 +53,7 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   onAfter1(builder, result) {
     if (this.hasExtraProps) {
       const joinTableUpdateQuery = this.relation
-        .joinModelClass(builder.knex())
+        .getJoinModelClass(builder.knex())
         .query()
         .childQueryOf(builder)
         .patch(this.joinTablePatch);
diff --git a/tests/unit/relations/ManyToManyRelation.js b/tests/unit/relations/ManyToManyRelation.js
@@ -140,7 +140,7 @@ describe('ManyToManyRelation', () => {
     expect(relation.joinTable).to.equal('JoinModel');
     expect(relation.joinTableOwnerProp.cols).to.eql(['ownerId']);
     expect(relation.joinTableRelatedProp.props).to.eql(['relatedId']);
-    expect(classUtils.isSubclassOf(relation.joinModelClass(mockKnex), JoinModel)).to.equal(true);
+    expect(classUtils.isSubclassOf(relation.joinModelClass, JoinModel)).to.equal(true);
   });
 
   it('should accept an absolute file path to a join model in join.through object', () => {
@@ -163,9 +163,9 @@ describe('ManyToManyRelation', () => {
     expect(relation.joinTable).to.equal('JoinModel');
     expect(relation.joinTableOwnerProp.cols).to.eql(['ownerId']);
     expect(relation.joinTableRelatedProp.cols).to.eql(['relatedId']);
-    expect(
-      classUtils.isSubclassOf(relation.joinModelClass(mockKnex), require('./files/JoinModel'))
-    ).to.equal(true);
+    expect(classUtils.isSubclassOf(relation.joinModelClass, require('./files/JoinModel'))).to.equal(
+      true
+    );
   });
 
   it('should accept a composite keys in join.through object (1)', () => {
diff --git a/tests/unit/relations/Relation.js b/tests/unit/relations/Relation.js
@@ -1,5 +1,5 @@
 const _ = require('lodash');
-const knex = require('knex');
+const Knex = require('knex');
 const expect = require('expect.js');
 const objection = require('../../../');
 
@@ -549,4 +549,20 @@ describe('Relation', () => {
     });
     expect(stuff).to.eql('schema_table_rel_testRelation');
   });
+
+  it('joinModelClass should return null for relations without join models', () => {
+    let relation = new Relation('testRelation', OwnerModel);
+
+    relation.setMapping({
+      relation: Relation,
+      modelClass: RelatedModel,
+      join: {
+        from: 'RelatedModel.ownerId',
+        to: 'OwnerModel.id'
+      }
+    });
+
+    const knex = Knex({ client: 'pg' });
+    expect(relation.joinModelClass).to.equal(null);
+  });
 });
