@loopback/repository 3.0.1 → 3.1.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.1.0](https://github.com/strongloop/loopback-next/compare/@loopback/repository@3.0.1...@loopback/repository@3.1.0) (2020-10-07)
+
+
+### Bug Fixes
+
+* tidy up type inferences for OpenAPI SchemaObject ([013bb7e](https://github.com/strongloop/loopback-next/commit/013bb7e4c0f7499a7f77c152dea7caa14e19b7cc))
+
+
+### Features
+
+* **repository:** implement hasManyThrough resolver ([8e7767d](https://github.com/strongloop/loopback-next/commit/8e7767df0a4679c8c70ad524e56aea9783def521))
+
+
+
+
+
 ## [3.0.1](https://github.com/strongloop/loopback-next/compare/@loopback/repository@3.0.0...@loopback/repository@3.0.1) (2020-09-17)
 
 **Note:** Version bump only for package @loopback/repository

package/dist/common-types.d.ts

@@ -72,15 +72,17 @@ export interface Count {
 }
 /**
  * JSON Schema describing the Count interface. It's the response type for
- * REST calls to APIs which return Count
+ * REST calls to APIs which return `count`. The type is compatible with
+ * `SchemaObject` from `@loopback/openapi-v3`, which is not an explicit
+ * dependency for `@loopback/repository`.
  */
 export declare const CountSchema: {
-    type: string;
+    type: "object";
     title: string;
     'x-typescript-type': string;
     properties: {
         count: {
-            type: string;
+            type: "number";
         };
     };
 };

package/dist/common-types.js

@@ -7,12 +7,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CountSchema = void 0;
 /**
  * JSON Schema describing the Count interface. It's the response type for
- * REST calls to APIs which return Count
+ * REST calls to APIs which return `count`. The type is compatible with
+ * `SchemaObject` from `@loopback/openapi-v3`, which is not an explicit
+ * dependency for `@loopback/repository`.
  */
-exports.CountSchema = {
+exports.CountSchema /* :SchemaObject */ = {
     type: 'object',
     title: 'loopback.Count',
     'x-typescript-type': '@loopback/repository#Count',
-    properties: { count: { type: 'number' } },
+    properties: {
+        count: {
+            type: 'number',
+        },
+    },
 };
 //# sourceMappingURL=common-types.js.map

package/dist/common-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../src/common-types.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,oCAAoC;AACpC,+CAA+C;AAC/C,gEAAgE;;;AA6FhE;;;GAGG;AACU,QAAA,WAAW,GAAG;IACzB,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,gBAAgB;IACvB,mBAAmB,EAAE,4BAA4B;IACjD,UAAU,EAAE,EAAC,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC,EAAC;CACtC,CAAC"}
+{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../src/common-types.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,oCAAoC;AACpC,+CAA+C;AAC/C,gEAAgE;;;AA6FhE;;;;;GAKG;AACU,QAAA,WAAW,CAAC,mBAAmB,GAAG;IAC7C,IAAI,EAAE,QAAiB;IACvB,KAAK,EAAE,gBAAgB;IACvB,mBAAmB,EAAE,4BAA4B;IACjD,UAAU,EAAE;QACV,KAAK,EAAE;YACL,IAAI,EAAE,QAAiB;SACxB;KACF;CACF,CAAC"}

package/dist/mixins/repository.mixin.d.ts

@@ -1,4 +1,4 @@
-import { Binding, BindingFromClassOptions } from '@loopback/core';
+import { Binding, BindingFromClassOptions, BindingScope } from '@loopback/core';
 import { Application, Component, Constructor, MixinTarget } from '@loopback/core';
 import { Class } from '../common-types';
 import { SchemaMigrationOptions } from '../datasource';
@@ -164,6 +164,7 @@ export declare function RepositoryMixin<T extends MixinTarget<Application>>(supe
         interceptor: (interceptor: loopbackContext.Interceptor | Constructor<loopbackContext.Provider<loopbackContext.Interceptor>>, nameOrOptions?: string | loopbackContext.InterceptorBindingOptions | undefined) => Binding<loopbackContext.Interceptor>;
         readonly name: string;
         readonly subscriptionManager: loopbackContext.ContextSubscriptionManager;
+        scope: BindingScope;
         readonly parent: loopbackContext.Context | undefined;
         emitEvent: <T_6 extends loopbackContext.ContextEvent>(type: string, event: T_6) => void;
         emitError: (err: unknown) => void;
@@ -181,7 +182,10 @@ export declare function RepositoryMixin<T extends MixinTarget<Application>>(supe
         createView: <T_7 = unknown>(filter: loopbackContext.BindingFilter, comparator?: loopbackContext.BindingComparator | undefined) => loopbackContext.ContextView<T_7>;
         contains: (key: loopbackContext.BindingAddress<unknown>) => boolean;
         isBound: (key: loopbackContext.BindingAddress<unknown>) => boolean;
-        getOwnerContext: (key: loopbackContext.BindingAddress<unknown>) => loopbackContext.Context | undefined;
+        getOwnerContext: (keyOrBinding: string | loopbackContext.BindingKey<unknown> | Readonly<Binding<unknown>>) => loopbackContext.Context | undefined;
+        getScopedContext: (scope: BindingScope.APPLICATION | BindingScope.SERVER | BindingScope.REQUEST) => loopbackContext.Context | undefined;
+        getResolutionContext: (binding: Readonly<Binding<unknown>>) => loopbackContext.Context | undefined;
+        isVisibleTo: (ctx: loopbackContext.Context) => boolean;
         find: <ValueType_1 = any>(pattern?: string | RegExp | loopbackContext.BindingFilter | undefined) => Readonly<Binding<ValueType_1>>[];
         findByTag: <ValueType_2 = any>(tagFilter: string | RegExp | Record<string, any>) => Readonly<Binding<ValueType_2>>[];
         get: {

package/dist/relations/has-many/has-many-through-repository.factory.d.ts

@@ -1,4 +1,4 @@
-import { Entity, EntityCrudRepository, Getter, HasManyDefinition } from '../..';
+import { Entity, EntityCrudRepository, Getter, HasManyDefinition, InclusionResolver } from '../..';
 import { HasManyThroughRepository } from './has-many-through.repository';
 /**
  * a factory to generate hasManyThrough repository class.
@@ -7,5 +7,11 @@ import { HasManyThroughRepository } from './has-many-through.repository';
  * If backwards-incompatible changes are made, a new major version may not be
  * released.
  */
-export declare type HasManyThroughRepositoryFactory<TargetEntity extends Entity, TargetID, ThroughEntity extends Entity, SourceID> = (fkValue: SourceID) => HasManyThroughRepository<TargetEntity, TargetID, ThroughEntity>;
+export declare type HasManyThroughRepositoryFactory<TargetEntity extends Entity, TargetID, ThroughEntity extends Entity, SourceID> = {
+    (fkValue: SourceID): HasManyThroughRepository<TargetEntity, TargetID, ThroughEntity>;
+    /**
+     * Use `resolver` property to obtain an InclusionResolver for this relation.
+     */
+    inclusionResolver: InclusionResolver<Entity, TargetEntity>;
+};
 export declare function createHasManyThroughRepositoryFactory<Target extends Entity, TargetID, Through extends Entity, ThroughID, SourceID>(relationMetadata: HasManyDefinition, targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetID>>, throughRepositoryGetter: Getter<EntityCrudRepository<Through, ThroughID>>): HasManyThroughRepositoryFactory<Target, TargetID, Through, SourceID>;

package/dist/relations/has-many/has-many-through-repository.factory.js

@@ -1,7 +1,12 @@
 "use strict";
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHasManyThroughRepositoryFactory = void 0;
 const has_many_through_helpers_1 = require("./has-many-through.helpers");
+const has_many_through_inclusion_resolver_1 = require("./has-many-through.inclusion.resolver");
 const has_many_through_repository_1 = require("./has-many-through.repository");
 function createHasManyThroughRepositoryFactory(relationMetadata, targetRepositoryGetter, throughRepositoryGetter) {
     const meta = has_many_through_helpers_1.resolveHasManyThroughMetadata(relationMetadata);
@@ -25,6 +30,7 @@ function createHasManyThroughRepositoryFactory(relationMetadata, targetRepositor
         }
         return new has_many_through_repository_1.DefaultHasManyThroughRepository(targetRepositoryGetter, throughRepositoryGetter, getTargetConstraintFromThroughModels, getTargetKeys, getThroughConstraintFromSource, getTargetIds, getThroughConstraintFromTarget);
     };
+    result.inclusionResolver = has_many_through_inclusion_resolver_1.createHasManyThroughInclusionResolver(meta, throughRepositoryGetter, targetRepositoryGetter);
     return result;
 }
 exports.createHasManyThroughRepositoryFactory = createHasManyThroughRepositoryFactory;

package/dist/relations/has-many/has-many-through-repository.factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"has-many-through-repository.factory.js","sourceRoot":"","sources":["../../../src/relations/has-many/has-many-through-repository.factory.ts"],"names":[],"mappings":";;;AAWA,yEAOoC;AACpC,+EAGuC;AAmBvC,SAAgB,qCAAqC,CAOnD,gBAAmC,EACnC,sBAAsE,EACtE,uBAAyE;IAEzE,MAAM,IAAI,GAAG,wDAA6B,CAAC,gBAAgB,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,UAAU,OAAiB;QACxC,SAAS,oCAAoC,CAC3C,gBAA2B;YAE3B,OAAO,4DAAiC,CACtC,IAAI,EACJ,gBAAgB,CACjB,CAAC;QACJ,CAAC;QACD,SAAS,aAAa,CAAC,gBAA2B;YAChD,OAAO,yDAA8B,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAChE,CAAC;QACD,SAAS,8BAA8B;YACrC,MAAM,UAAU,GAAwB,4DAAiC,CAGvE,IAAI,EAAE,OAAO,CAAC,CAAC;YACjB,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,SAAS,YAAY,CAAC,eAAyB;YAC7C,OAAO,uDAA4B,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAC7D,CAAC;QACD,SAAS,8BAA8B,CACrC,QAAoB;YAEpB,MAAM,UAAU,GAAwB,4DAAiC,CAGvE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAClB,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,6DAA+B,CAQxC,sBAAsB,EACtB,uBAAuB,EACvB,oCAAoC,EACpC,aAAa,EACb,8BAA8B,EAC9B,YAAY,EACZ,8BAA8B,CAC/B,CAAC;IACJ,CAAC,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC;AA9DD,sFA8DC"}
+{"version":3,"file":"has-many-through-repository.factory.js","sourceRoot":"","sources":["../../../src/relations/has-many/has-many-through-repository.factory.ts"],"names":[],"mappings":";AAAA,iDAAiD;AACjD,oCAAoC;AACpC,+CAA+C;AAC/C,gEAAgE;;;AAUhE,yEAOoC;AACpC,+FAA4F;AAC5F,+EAGuC;AA4BvC,SAAgB,qCAAqC,CAOnD,gBAAmC,EACnC,sBAAsE,EACtE,uBAAyE;IAEzE,MAAM,IAAI,GAAG,wDAA6B,CAAC,gBAAgB,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,UAAU,OAAiB;QACxC,SAAS,oCAAoC,CAC3C,gBAA2B;YAE3B,OAAO,4DAAiC,CACtC,IAAI,EACJ,gBAAgB,CACjB,CAAC;QACJ,CAAC;QACD,SAAS,aAAa,CAAC,gBAA2B;YAChD,OAAO,yDAA8B,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAChE,CAAC;QACD,SAAS,8BAA8B;YACrC,MAAM,UAAU,GAAwB,4DAAiC,CAGvE,IAAI,EAAE,OAAO,CAAC,CAAC;YACjB,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,SAAS,YAAY,CAAC,eAAyB;YAC7C,OAAO,uDAA4B,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAC7D,CAAC;QACD,SAAS,8BAA8B,CACrC,QAAoB;YAEpB,MAAM,UAAU,GAAwB,4DAAiC,CAGvE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAClB,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,6DAA+B,CAQxC,sBAAsB,EACtB,uBAAuB,EACvB,oCAAoC,EACpC,aAAa,EACb,8BAA8B,EAC9B,YAAY,EACZ,8BAA8B,CAC/B,CAAC;IACJ,CAAC,CAAC;IACF,MAAM,CAAC,iBAAiB,GAAG,2EAAqC,CAC9D,IAAI,EACJ,uBAAuB,EACvB,sBAAsB,CACvB,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC;AAnED,sFAmEC"}

package/dist/relations/has-many/has-many-through.inclusion.resolver.d.ts

@@ -0,0 +1,16 @@
+import { Entity } from '../../model';
+import { EntityCrudRepository } from '../../repositories/repository';
+import { Getter, HasManyDefinition, InclusionResolver } from '../relation.types';
+/**
+ * Creates InclusionResolver for HasManyThrough relation.
+ * Notice that this function only generates the inclusionResolver.
+ * It doesn't register it for the source repository.
+ *
+ *
+ * @param meta - metadata of the hasMany relation (including through)
+ * @param getThroughRepo - through repository getter i.e. where through
+ * instances are
+ * @param getTargetRepo - target repository getter i.e where target instances
+ * are
+ */
+export declare function createHasManyThroughInclusionResolver<Through extends Entity, ThroughID, ThroughRelations extends object, Target extends Entity, TargetID, TargetRelations extends object>(meta: HasManyDefinition, getThroughRepo: Getter<EntityCrudRepository<Through, ThroughID, ThroughRelations>>, getTargetRepo: Getter<EntityCrudRepository<Target, TargetID, TargetRelations>>): InclusionResolver<Entity, Target>;

package/dist/relations/has-many/has-many-through.inclusion.resolver.js

@@ -0,0 +1,74 @@
+"use strict";
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHasManyThroughInclusionResolver = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const relation_helpers_1 = require("../relation.helpers");
+const has_many_helpers_1 = require("./has-many.helpers");
+const debug = debug_1.default('loopback:repository:has-many-through-inclusion-resolver');
+/**
+ * Creates InclusionResolver for HasManyThrough relation.
+ * Notice that this function only generates the inclusionResolver.
+ * It doesn't register it for the source repository.
+ *
+ *
+ * @param meta - metadata of the hasMany relation (including through)
+ * @param getThroughRepo - through repository getter i.e. where through
+ * instances are
+ * @param getTargetRepo - target repository getter i.e where target instances
+ * are
+ */
+function createHasManyThroughInclusionResolver(meta, getThroughRepo, getTargetRepo) {
+    const relationMeta = has_many_helpers_1.resolveHasManyMetadata(meta);
+    return async function fetchHasManyThroughModels(entities, inclusion, options) {
+        if (!entities.length)
+            return [];
+        debug('Fetching target models for entities:', entities);
+        debug('Relation metadata:', relationMeta);
+        const sourceKey = relationMeta.keyFrom;
+        const sourceIds = entities.map(e => e[sourceKey]);
+        const targetKey = relationMeta.keyTo;
+        if (!relationMeta.through) {
+            throw new Error(`relationMeta.through must be defined on ${relationMeta}`);
+        }
+        const throughKeyTo = relationMeta.through.keyTo;
+        const throughKeyFrom = relationMeta.through.keyFrom;
+        debug('Parameters:', {
+            sourceKey,
+            sourceIds,
+            targetKey,
+            throughKeyTo,
+            throughKeyFrom,
+        });
+        debug('sourceId types', sourceIds.map(i => typeof i));
+        const throughRepo = await getThroughRepo();
+        const targetRepo = await getTargetRepo();
+        // find through models
+        const throughFound = await relation_helpers_1.findByForeignKeys(throughRepo, throughKeyFrom, sourceIds, {}, // scope will be applied at the target level
+        options);
+        const throughResult = relation_helpers_1.flattenTargetsOfOneToManyRelation(sourceIds, throughFound, throughKeyFrom);
+        const result = [];
+        // convert from through entities to the target entities
+        for (const entityList of throughResult) {
+            if (entityList) {
+                // get target ids from the through entities by foreign key
+                const targetIds = entityList.map(entity => entity[throughKeyTo]);
+                // the explicit types and casts are needed
+                const targetEntityList = await relation_helpers_1.findByForeignKeys(targetRepo, targetKey, targetIds, inclusion.scope, options);
+                result.push(targetEntityList);
+            }
+            else {
+                // no entities found, add undefined to results
+                result.push(entityList);
+            }
+        }
+        debug('fetchHasManyThroughModels result', result);
+        return result;
+    };
+}
+exports.createHasManyThroughInclusionResolver = createHasManyThroughInclusionResolver;
+//# sourceMappingURL=has-many-through.inclusion.resolver.js.map

package/dist/relations/has-many/has-many-through.inclusion.resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-many-through.inclusion.resolver.js","sourceRoot":"","sources":["../../../src/relations/has-many/has-many-through.inclusion.resolver.ts"],"names":[],"mappings":";AAAA,iDAAiD;AACjD,oCAAoC;AACpC,+CAA+C;AAC/C,gEAAgE;;;;AAGhE,0DAAiC;AAIjC,0DAI6B;AAE7B,yDAA0D;AAE1D,MAAM,KAAK,GAAG,eAAY,CACxB,yDAAyD,CAC1D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,SAAgB,qCAAqC,CAQnD,IAAuB,EACvB,cAEC,EACD,aAEC;IAED,MAAM,YAAY,GAAG,yCAAsB,CAAC,IAAI,CAAC,CAAC;IAElD,OAAO,KAAK,UAAU,yBAAyB,CAC7C,QAAkB,EAClB,SAAoB,EACpB,OAAiB;QAEjB,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO,EAAE,CAAC;QAEhC,KAAK,CAAC,sCAAsC,EAAE,QAAQ,CAAC,CAAC;QACxD,KAAK,CAAC,oBAAoB,EAAE,YAAY,CAAC,CAAC;QAE1C,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC;QACvC,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAE,CAAe,CAAC,SAAS,CAAC,CAAC,CAAC;QACjE,MAAM,SAAS,GAAG,YAAY,CAAC,KAA4B,CAAC;QAC5D,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE;YACzB,MAAM,IAAI,KAAK,CACb,2CAA2C,YAAY,EAAE,CAC1D,CAAC;SACH;QACD,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,KAA6B,CAAC;QACxE,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,CAAC,OAA+B,CAAC;QAE5E,KAAK,CAAC,aAAa,EAAE;YACnB,SAAS;YACT,SAAS;YACT,SAAS;YACT,YAAY;YACZ,cAAc;SACf,CAAC,CAAC;QAEH,KAAK,CACH,gBAAgB,EAChB,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAC7B,CAAC;QAEF,MAAM,WAAW,GAAG,MAAM,cAAc,EAAE,CAAC;QAC3C,MAAM,UAAU,GAAG,MAAM,aAAa,EAAE,CAAC;QAEzC,sBAAsB;QACtB,MAAM,YAAY,GAAG,MAAM,oCAAiB,CAC1C,WAAW,EACX,cAAc,EACd,SAAS,EACT,EAAE,EAAE,4CAA4C;QAChD,OAAO,CACR,CAAC;QAEF,MAAM,aAAa,GAAG,oDAAiC,CACrD,SAAS,EACT,YAAY,EACZ,cAAc,CACf,CAAC;QAEF,MAAM,MAAM,GAAG,EAAE,CAAC;QAElB,uDAAuD;QACvD,KAAK,MAAM,UAAU,IAAI,aAAa,EAAE;YACtC,IAAI,UAAU,EAAE;gBACd,0DAA0D;gBAC1D,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;gBAEjE,0CAA0C;gBAC1C,MAAM,gBAAgB,GAAG,MAAM,oCAAiB,CAK9C,UAAU,EACV,SAAS,EACR,SAA2B,EAC5B,SAAS,CAAC,KAAuB,EACjC,OAAO,CACR,CAAC;gBACF,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;aAC/B;iBAAM;gBACL,8CAA8C;gBAC9C,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACzB;SACF;QAED,KAAK,CAAC,kCAAkC,EAAE,MAAM,CAAC,CAAC;QAClD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AApGD,sFAoGC"}

package/dist/relations/relation.helpers.d.ts

@@ -5,7 +5,7 @@ import { AnyObject, Entity, EntityCrudRepository, Filter, Inclusion, Options } f
  * @param targetRepository - The target repository where the related model instances are found
  * @param fkName - Name of the foreign key
  * @param fkValues - One value or array of values of the foreign key to be included
- * @param scope - Additional scope constraints (not currently supported)
+ * @param scope - Additional scope constraints
  * @param options - Options for the operations
  */
 export declare function findByForeignKeys<Target extends Entity, TargetRelations extends object, ForeignKey extends StringKeyOf<Target>>(targetRepository: EntityCrudRepository<Target, unknown, TargetRelations>, fkName: ForeignKey, fkValues: Target[ForeignKey][] | Target[ForeignKey], scope?: Filter<Target>, options?: Options): Promise<(Target & TargetRelations)[]>;

package/dist/relations/relation.helpers.js

@@ -17,7 +17,7 @@ const debug = debug_1.default('loopback:repository:relation-helpers');
  * @param targetRepository - The target repository where the related model instances are found
  * @param fkName - Name of the foreign key
  * @param fkValues - One value or array of values of the foreign key to be included
- * @param scope - Additional scope constraints (not currently supported)
+ * @param scope - Additional scope constraints
  * @param options - Options for the operations
  */
 async function findByForeignKeys(targetRepository, fkName, fkValues, scope, options) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@loopback/repository",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "Define and implement a common set of interfaces for interacting with databases",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "engines": {
-    "node": ">=10.16"
+    "node": "^10.16 || 12 || 14"
   },
   "scripts": {
     "acceptance": "lb-mocha \"dist/__tests__/acceptance/**/*.js\"",
@@ -22,13 +22,13 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@loopback/core": "^2.10.1"
+    "@loopback/core": "^2.11.0"
   },
   "devDependencies": {
-    "@loopback/build": "^6.2.4",
-    "@loopback/core": "^2.10.1",
-    "@loopback/eslint-config": "^10.0.0",
-    "@loopback/testlab": "^3.2.6",
+    "@loopback/build": "^6.2.5",
+    "@loopback/core": "^2.11.0",
+    "@loopback/eslint-config": "^10.0.1",
+    "@loopback/testlab": "^3.2.7",
     "@types/bson": "^4.0.2",
     "@types/json-schema": "^7.0.6",
     "@types/lodash": "^4.14.161",
@@ -36,12 +36,12 @@
     "bson": "4.1.0"
   },
   "dependencies": {
-    "@loopback/filter": "^1.1.1",
+    "@loopback/filter": "^1.1.2",
     "@types/debug": "^4.1.5",
-    "debug": "^4.1.1",
+    "debug": "^4.2.0",
     "lodash": "^4.17.20",
     "loopback-datasource-juggler": "^4.24.0",
-    "tslib": "^2.0.1"
+    "tslib": "^2.0.2"
   },
   "files": [
     "README.md",
@@ -54,5 +54,5 @@
     "url": "https://github.com/strongloop/loopback-next.git",
     "directory": "packages/repository"
   },
-  "gitHead": "79327fd7e68ebb05be0aa689f4986b54e2a99a6b"
+  "gitHead": "390f2794d10eea3d969ae417963af815ce1bc417"
 }

package/src/common-types.ts

@@ -96,13 +96,19 @@ export interface Count {
 
 /**
  * JSON Schema describing the Count interface. It's the response type for
- * REST calls to APIs which return Count
+ * REST calls to APIs which return `count`. The type is compatible with
+ * `SchemaObject` from `@loopback/openapi-v3`, which is not an explicit
+ * dependency for `@loopback/repository`.
  */
-export const CountSchema = {
-  type: 'object',
+export const CountSchema /* :SchemaObject */ = {
+  type: 'object' as const, // Force to be `object` type instead of `string`
   title: 'loopback.Count',
   'x-typescript-type': '@loopback/repository#Count',
-  properties: {count: {type: 'number'}},
+  properties: {
+    count: {
+      type: 'number' as const, // Force to be `number` type instead of `string`
+    },
+  },
 };
 
 /**

package/src/relations/has-many/has-many-through-repository.factory.ts

@@ -2,12 +2,14 @@
 // Node module: @loopback/repository
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
+
 import {
   DataObject,
   Entity,
   EntityCrudRepository,
   Getter,
   HasManyDefinition,
+  InclusionResolver,
 } from '../..';
 import {
   createTargetConstraintFromThrough,
@@ -17,6 +19,7 @@ import {
   getTargetKeysFromThroughModels,
   resolveHasManyThroughMetadata,
 } from './has-many-through.helpers';
+import {createHasManyThroughInclusionResolver} from './has-many-through.inclusion.resolver';
 import {
   DefaultHasManyThroughRepository,
   HasManyThroughRepository,
@@ -35,9 +38,18 @@ export type HasManyThroughRepositoryFactory<
   TargetID,
   ThroughEntity extends Entity,
   SourceID
-> = (
-  fkValue: SourceID,
-) => HasManyThroughRepository<TargetEntity, TargetID, ThroughEntity>;
+> = {
+  (fkValue: SourceID): HasManyThroughRepository<
+    TargetEntity,
+    TargetID,
+    ThroughEntity
+  >;
+
+  /**
+   * Use `resolver` property to obtain an InclusionResolver for this relation.
+   */
+  inclusionResolver: InclusionResolver<Entity, TargetEntity>;
+};
 
 export function createHasManyThroughRepositoryFactory<
   Target extends Entity,
@@ -100,5 +112,10 @@ export function createHasManyThroughRepositoryFactory<
       getThroughConstraintFromTarget,
     );
   };
+  result.inclusionResolver = createHasManyThroughInclusionResolver(
+    meta,
+    throughRepositoryGetter,
+    targetRepositoryGetter,
+  );
   return result;
 }

package/src/relations/has-many/has-many-through.inclusion.resolver.ts

@@ -0,0 +1,135 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Filter, Inclusion} from '@loopback/filter';
+import debugFactory from 'debug';
+import {AnyObject, Options} from '../../common-types';
+import {Entity} from '../../model';
+import {EntityCrudRepository} from '../../repositories/repository';
+import {
+  findByForeignKeys,
+  flattenTargetsOfOneToManyRelation,
+  StringKeyOf,
+} from '../relation.helpers';
+import {Getter, HasManyDefinition, InclusionResolver} from '../relation.types';
+import {resolveHasManyMetadata} from './has-many.helpers';
+
+const debug = debugFactory(
+  'loopback:repository:has-many-through-inclusion-resolver',
+);
+
+/**
+ * Creates InclusionResolver for HasManyThrough relation.
+ * Notice that this function only generates the inclusionResolver.
+ * It doesn't register it for the source repository.
+ *
+ *
+ * @param meta - metadata of the hasMany relation (including through)
+ * @param getThroughRepo - through repository getter i.e. where through
+ * instances are
+ * @param getTargetRepo - target repository getter i.e where target instances
+ * are
+ */
+export function createHasManyThroughInclusionResolver<
+  Through extends Entity,
+  ThroughID,
+  ThroughRelations extends object,
+  Target extends Entity,
+  TargetID,
+  TargetRelations extends object
+>(
+  meta: HasManyDefinition,
+  getThroughRepo: Getter<
+    EntityCrudRepository<Through, ThroughID, ThroughRelations>
+  >,
+  getTargetRepo: Getter<
+    EntityCrudRepository<Target, TargetID, TargetRelations>
+  >,
+): InclusionResolver<Entity, Target> {
+  const relationMeta = resolveHasManyMetadata(meta);
+
+  return async function fetchHasManyThroughModels(
+    entities: Entity[],
+    inclusion: Inclusion,
+    options?: Options,
+  ): Promise<((Target & TargetRelations)[] | undefined)[]> {
+    if (!entities.length) return [];
+
+    debug('Fetching target models for entities:', entities);
+    debug('Relation metadata:', relationMeta);
+
+    const sourceKey = relationMeta.keyFrom;
+    const sourceIds = entities.map(e => (e as AnyObject)[sourceKey]);
+    const targetKey = relationMeta.keyTo as StringKeyOf<Target>;
+    if (!relationMeta.through) {
+      throw new Error(
+        `relationMeta.through must be defined on ${relationMeta}`,
+      );
+    }
+    const throughKeyTo = relationMeta.through.keyTo as StringKeyOf<Through>;
+    const throughKeyFrom = relationMeta.through.keyFrom as StringKeyOf<Through>;
+
+    debug('Parameters:', {
+      sourceKey,
+      sourceIds,
+      targetKey,
+      throughKeyTo,
+      throughKeyFrom,
+    });
+
+    debug(
+      'sourceId types',
+      sourceIds.map(i => typeof i),
+    );
+
+    const throughRepo = await getThroughRepo();
+    const targetRepo = await getTargetRepo();
+
+    // find through models
+    const throughFound = await findByForeignKeys(
+      throughRepo,
+      throughKeyFrom,
+      sourceIds,
+      {}, // scope will be applied at the target level
+      options,
+    );
+
+    const throughResult = flattenTargetsOfOneToManyRelation(
+      sourceIds,
+      throughFound,
+      throughKeyFrom,
+    );
+
+    const result = [];
+
+    // convert from through entities to the target entities
+    for (const entityList of throughResult) {
+      if (entityList) {
+        // get target ids from the through entities by foreign key
+        const targetIds = entityList.map(entity => entity[throughKeyTo]);
+
+        // the explicit types and casts are needed
+        const targetEntityList = await findByForeignKeys<
+          Target,
+          TargetRelations,
+          StringKeyOf<Target>
+        >(
+          targetRepo,
+          targetKey,
+          (targetIds as unknown) as [],
+          inclusion.scope as Filter<Target>,
+          options,
+        );
+        result.push(targetEntityList);
+      } else {
+        // no entities found, add undefined to results
+        result.push(entityList);
+      }
+    }
+
+    debug('fetchHasManyThroughModels result', result);
+    return result;
+  };
+}

package/src/relations/relation.helpers.ts

@@ -24,7 +24,7 @@ const debug = debugFactory('loopback:repository:relation-helpers');
  * @param targetRepository - The target repository where the related model instances are found
  * @param fkName - Name of the foreign key
  * @param fkValues - One value or array of values of the foreign key to be included
- * @param scope - Additional scope constraints (not currently supported)
+ * @param scope - Additional scope constraints
  * @param options - Options for the operations
  */
 export async function findByForeignKeys<