fix(repository): throw INVALID_INCLUSION_FILTER if relation is not pr…

…esent

in the inclusionResolver

GH-0

src/__tests__/integration/repository.integration.ts

@@ -508,6 +508,20 @@ describe('Sequelize CRUD Repository (integration)', function () {
       // Confirming the fact that it used inner join behind the scenes
       expect(relationRes.body.length).to.be.equal(1);
     });
+
+    it('throws error if the repository does not have registered resolvers', async () => {
+      try {
+        await userRepo.find({
+          include: ['nonExistingRelation'],
+        });
+      } catch (err) {
+        expect(err.message).to.be.eql(
+          `Invalid "filter.include" entries: "nonExistingRelation"`,
+        );
+        expect(err.statusCode).to.be.eql(400);
+        expect(err.code).to.be.eql('INVALID_INCLUSION_FILTER');
+      }
+    });
   });
 
   describe('Connections', () => {

src/sequelize/sequelize.repository.base.ts

@@ -455,6 +455,22 @@ export class SequelizeCrudRepository<
     });
   }
 
+  /**
+   * Checks if the resolver of the inclusion relation is registered
+   * in the inclusionResolver of the current repository
+   *
+   * @param include - LoopBack Inclusion filter
+   */
+  protected isInclusionAllowed(include: InclusionFilter): boolean {
+    const relationName =
+      typeof include === 'string' ? include : include.relation;
+    if (!relationName) {
+      return false;
+    }
+    const allowed = this.inclusionResolvers.has(relationName);
+    return allowed;
+  }
+
   /**
    * Build Sequelize compatible `include` filter
    * @param inclusionFilters - loopback style `where` condition
@@ -473,6 +489,25 @@ export class SequelizeCrudRepository<
       sourceModel = this.sequelizeModel;
     }
 
+    if (sourceModel === this.sequelizeModel) {
+      const invalidInclusions = inclusionFilters.filter(
+        inclusionFilter => !this.isInclusionAllowed(inclusionFilter),
+      );
+      if (invalidInclusions.length) {
+        const msg =
+          'Invalid "filter.include" entries: ' +
+          invalidInclusions
+            .map(inclusionFilter => JSON.stringify(inclusionFilter))
+            .join('; ');
+        const err = new Error(msg);
+        Object.assign(err, {
+          code: 'INVALID_INCLUSION_FILTER',
+          statusCode: 400,
+        });
+        throw err;
+      }
+    }
+
     const includable: Includeable[] = [];
 
     for (const filter of inclusionFilters) {