Merge pull request #1428 from ovos/m2m-join-table-modify

filters/modify on join table of m2m relations

Author: lehni

doc/api/types/README.md

@@ -30,13 +30,15 @@ This page contains the documentation of all other types and classes than [Model]
 
 ## `type` RelationThrough
 
-| Property     | Type                                                                                               | Description                                                                                                                                                                                                                                                                                                                                                                                                 |
-| ------------ | -------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| from         | string<br>[ReferenceBuilder](/api/objection/#ref)<br>Array                                         | The column that is joined to `from` property of the `RelationJoin`. For example `Person_movies.actorId` where `Person_movies` is the join table. Composite key can be specified using an array of columns e.g. `['persons_movies.a', 'persons_movies.b']`. You can join nested json fields using the [ref](/api/objection/#ref) helper.                                                                     |
-| to           | string<br>[ReferenceBuilder](/api/objection/#ref)<br>Array                                         | The column that is joined to `to` property of the `RelationJoin`. For example `Person_movies.movieId` where `Person_movies` is the join table. Composite key can be specified using an array of columns e.g. `['persons_movies.a', 'persons_movies.b']`. You can join nested json fields using the [ref](/api/objection/#ref) helper.                                                                       |
-| modelClass   | string<br>ModelClass                                                                               | If you have a model class for the join table, you should specify it here. This is optional so you don't need to create a model class if you don't want to.                                                                                                                                                                                                                                                  |
-| extra        | string<br>string[]<br>Object                                                                       | Join table columns listed here are automatically joined to the related objects when they are fetched and automatically written to the join table instead of the related table on insert and update. The values can be aliased by providing an object `{propertyName: 'columnName', otherPropertyName: 'otherColumnName'} instead of array` See [this recipe](/recipes/extra-properties.html) for more info. |
-| beforeInsert | function([Model](/api/model/),&nbsp;[QueryContext](/api/query-builder/other-methods.html#context)) | Optional insert hook that is called for each inserted join table model instance. This function can be async.                                                                                                                                                                                                                                                                                                |
+| Property     | Type                                                                                               | Description                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ------------ | -------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| from         | string<br>[ReferenceBuilder](/api/objection/#ref)<br>Array                                         | The column that is joined to `from` property of the `RelationJoin`. For example `Person_movies.actorId` where `Person_movies` is the join table. Composite key can be specified using an array of columns e.g. `['persons_movies.a', 'persons_movies.b']`. You can join nested json fields using the [ref](/api/objection/#ref) helper.                                                                                            |
+| to           | string<br>[ReferenceBuilder](/api/objection/#ref)<br>Array                                         | The column that is joined to `to` property of the `RelationJoin`. For example `Person_movies.movieId` where `Person_movies` is the join table. Composite key can be specified using an array of columns e.g. `['persons_movies.a', 'persons_movies.b']`. You can join nested json fields using the [ref](/api/objection/#ref) helper.                                                                                              |
+| modelClass   | string<br>ModelClass                                                                               | If you have a model class for the join table, you should specify it here. This is optional so you don't need to create a model class if you don't want to.                                                                                                                                                                                                                                                                         |
+| extra        | string<br>string[]<br>Object                                                                       | Join table columns listed here are automatically joined to the related objects when they are fetched and automatically written to the join table instead of the related table on insert and update. The values can be aliased by providing an object `{propertyName: 'columnName', otherPropertyName: 'otherColumnName'} instead of array` See [this recipe](/recipes/extra-properties.html) for more info.                        |
+| modify       | function([QueryBuilder](/api/query-builder/))<br>string<br>object                                  | Optional modifier for the join table query. If specified as a function, it will be called each time before fetching the relation. If specified as a string, modifier with specified name will be applied each time when fetching the relation. If specified as an object, it will be used as an additional query parameter - e. g. passing {name: 'Jenny'} would additionally narrow fetched rows to the ones with the name 'Jenny'. |
+| filter       | function([QueryBuilder](/api/query-builder/))<br>string<br>object                                  | Alias for modify.                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| beforeInsert | function([Model](/api/model/),&nbsp;[QueryContext](/api/query-builder/other-methods.html#context)) | Optional insert hook that is called for each inserted join table model instance. This function can be async.                                                                                                                                                                                                                                                                                                                       |
 
 ## `type` ModelOptions
 

lib/queryBuilder/QueryBuilder.js

@@ -325,7 +325,7 @@ class QueryBuilder extends QueryBuilderBase {
         );
       } else if (op.constructor === FromOperation) {
         return op.table === tableName;
-      } else if (op.name === 'as' || op.is(FindOperation)) {
+      } else if (op.name === 'as' || op.is(FindOperation) || op.is(OnErrorOperation)) {
         return true;
       } else {
         return false;

lib/relations/manyToMany/ManyToManyRelation.js

@@ -9,6 +9,7 @@ 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 { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
@@ -49,10 +50,12 @@ class ManyToManyRelation extends Relation {
     ctx = resolveJoinModelClassIfDefined(ctx);
     ctx = createJoinProperties(ctx);
     ctx = parseExtras(ctx);
+    ctx = parseModify(ctx);
     ctx = parseBeforeInsert(ctx);
     ctx = finalizeJoinModelClass(ctx);
 
     this.joinTableExtras = ctx.joinTableExtras;
+    this.joinTableModify = ctx.joinTableModify;
     this.joinTableModelClass = ctx.joinTableModelClass;
     this.joinTableOwnerProp = ctx.joinTableOwnerProp;
     this.joinTableRelatedProp = ctx.joinTableRelatedProp;
@@ -70,7 +73,16 @@ class ManyToManyRelation extends Relation {
     const joinTable = builder.tableNameFor(this.joinTable);
     const joinTableAlias = builder.tableRefFor(this.joinTable);
 
-    builder.join(aliasedTableName(joinTable, joinTableAlias), (join) => {
+    let joinTableSelect = this.joinTableModelClass
+      .query()
+      .childQueryOf(builder)
+      .modify(this.joinTableModify)
+      .as(joinTableAlias);
+    if (joinTableSelect.isSelectAll()) {
+      joinTableSelect = aliasedTableName(joinTable, joinTableAlias);
+    }
+
+    builder.join(joinTableSelect, (join) => {
       this.relatedProp.forEach((i) => {
         const relatedRef = this.relatedProp.ref(builder, i);
         const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i);
@@ -101,7 +113,16 @@ class ManyToManyRelation extends Relation {
       relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
     }
 
-    return builder[joinOperation](aliasedTableName(this.joinTable, joinTableAlias), (join) => {
+    let joinTableSelect = this.joinTableModelClass
+      .query()
+      .childQueryOf(builder)
+      .modify(this.joinTableModify)
+      .as(joinTableAlias);
+    if (joinTableSelect.isSelectAll()) {
+      joinTableSelect = aliasedTableName(this.joinTable, joinTableAlias);
+    }
+
+    return builder[joinOperation](joinTableSelect, (join) => {
       const ownerProp = this.ownerProp;
       const joinTableOwnerProp = this.joinTableOwnerProp;
 
@@ -442,6 +463,19 @@ function parseExtras(ctx) {
   return Object.assign(ctx, { joinTableExtras });
 }
 
+function parseModify(ctx) {
+  const mapping = ctx.mapping.join.through;
+  const modifier = mapping.modify || mapping.filter;
+  const joinTableModify =
+    modifier &&
+    createModifier({
+      modifier,
+      modelClass: ctx.relatedModelClass,
+    });
+
+  return Object.assign(ctx, { joinTableModify });
+}
+
 function parseBeforeInsert(ctx) {
   let joinTableBeforeInsert;
 

lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -10,7 +10,7 @@ class ManyToManyUnrelateOperationBase extends UnrelateOperation {
       .childQueryOf(builder)
       .delete();
 
-    return this.applyModifyFilterForJoinTable(unrelateQuery);
+    return this.applyModifyFilterForJoinTable(unrelateQuery).modify(this.relation.joinTableModify);
   }
 
   /* istanbul ignore next */

lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -44,7 +44,9 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
         .childQueryOf(builder)
         .patch(this.joinTablePatch);
 
-      await this.applyModifyFilterForJoinTable(joinTableUpdateQuery);
+      await this.applyModifyFilterForJoinTable(joinTableUpdateQuery).modify(
+        this.relation.joinTableModify
+      );
       return result;
     } else {
       return result;

tests/unit/relations/ManyToManyRelation.js

@@ -435,6 +435,32 @@ describe('ManyToManyRelation', () => {
     });
   });
 
+  it('should accept a modifier in join.through', () => {
+    // modifier defined in join.through.modify
+    let modifier = (builder) => builder.where('someColumn', 'foo');
+    createJoinThroughModifiedRelation(modifier);
+
+    expect(relation.joinTableModify).to.be.a(Function);
+
+    // test also join.through.filter
+    let relationFilter = new ManyToManyRelation('testRelation', OwnerModel);
+    relationFilter.setMapping({
+      relation: ManyToManyRelation,
+      modelClass: RelatedModel,
+      join: {
+        from: 'OwnerModel.id',
+        through: {
+          from: 'JoinModel.ownerId',
+          to: 'JoinModel.relatedId',
+          filter: modifier,
+        },
+        to: 'RelatedModel.ownerId',
+      },
+    });
+
+    expect(relationFilter.joinTableModify).to.be.a(Function);
+  });
+
   describe('find', () => {
     it('should generate a find query', () => {
       let owner = OwnerModel.fromJson({ oid: 666 });
@@ -732,6 +758,30 @@ describe('ManyToManyRelation', () => {
         );
       });
     });
+
+    it('should support modifiers in join.through', () => {
+      createJoinThroughModifiedRelation((builder) => builder.where('someColumn', 'foo'));
+
+      let owner = OwnerModel.fromJson({ oid: 666 });
+
+      let builder = QueryBuilder.forClass(RelatedModel).findOperationFactory(function () {
+        return relation.find(this, RelationOwner.create(owner));
+      });
+
+      return builder.then(() => {
+        expect(executedQueries).to.have.length(1);
+        expect(executedQueries[0]).to.equal(builder.toKnexQuery().toString());
+        expect(executedQueries[0]).to.equal(
+          [
+            'select "RelatedModel".*, "JoinModel"."ownerId" as "objectiontmpjoin0"',
+            'from "RelatedModel"',
+            'inner join (select "JoinModel".* from "JoinModel" where "someColumn" = \'foo\') as "JoinModel"',
+            'on "RelatedModel"."rid" = "JoinModel"."relatedId"',
+            'where "JoinModel"."ownerId" in (666)',
+          ].join(' ')
+        );
+      });
+    });
   });
 
   describe('insert', () => {
@@ -1561,6 +1611,23 @@ describe('ManyToManyRelation', () => {
       },
     });
   }
+
+  function createJoinThroughModifiedRelation(modify) {
+    relation = new ManyToManyRelation('nameOfOurRelation', OwnerModel);
+    relation.setMapping({
+      modelClass: RelatedModel,
+      relation: ManyToManyRelation,
+      join: {
+        from: 'OwnerModel.oid',
+        through: {
+          from: 'JoinModel.ownerId',
+          to: 'JoinModel.relatedId',
+          modify: modify,
+        },
+        to: 'RelatedModel.rid',
+      },
+    });
+  }
 });
 
 function isSubclassOf(Constructor, SuperConstructor) {

typings/objection/index.d.ts

@@ -1253,6 +1253,8 @@ declare namespace Objection {
     to: RelationMappingColumnRef;
     extra?: string | string[] | Record<string, string>;
     modelClass?: ModelClassSpecifier;
+    modify?: Modifier<QueryBuilderType<M>>;
+    filter?: Modifier<QueryBuilderType<M>>;
     beforeInsert?: RelationMappingHook<M>;
   }