@loopback/repository 3.6.0 → 3.7.3

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

@@ -59,8 +59,9 @@ export interface HasManyRepository<Target extends Entity> {
 export class DefaultHasManyRepository<
   TargetEntity extends Entity,
   TargetID,
-  TargetRepository extends EntityCrudRepository<TargetEntity, TargetID>
-> implements HasManyRepository<TargetEntity> {
+  TargetRepository extends EntityCrudRepository<TargetEntity, TargetID>,
+> implements HasManyRepository<TargetEntity>
+{
   /**
    * Constructor of DefaultHasManyEntityCrudRepository
    * @param getTargetRepository - the getter of the related target model repository instance

package/src/relations/has-one/has-one.inclusion-resolver.ts

@@ -28,7 +28,7 @@ import {resolveHasOneMetadata} from './has-one.helpers';
 export function createHasOneInclusionResolver<
   Target extends Entity,
   TargetID,
-  TargetRelations extends object
+  TargetRelations extends object,
 >(
   meta: HasOneDefinition,
   getTargetRepo: Getter<

package/src/relations/has-one/has-one.repository-factory.ts

@@ -18,7 +18,7 @@ const debug = debugFactory(
 
 export interface HasOneRepositoryFactory<
   Target extends Entity,
-  ForeignKeyType
+  ForeignKeyType,
 > {
   /**
    * Invoke the function to obtain HasOneRepository.
@@ -46,7 +46,7 @@ export interface HasOneRepositoryFactory<
 export function createHasOneRepositoryFactory<
   Target extends Entity,
   TargetID,
-  ForeignKeyType
+  ForeignKeyType,
 >(
   relationMetadata: HasOneDefinition,
   targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetID>>,

package/src/relations/has-one/has-one.repository.ts

@@ -61,8 +61,9 @@ export interface HasOneRepository<Target extends Entity> {
 export class DefaultHasOneRepository<
   TargetEntity extends Entity,
   TargetID,
-  TargetRepository extends EntityCrudRepository<TargetEntity, TargetID>
-> implements HasOneRepository<TargetEntity> {
+  TargetRepository extends EntityCrudRepository<TargetEntity, TargetID>,
+> implements HasOneRepository<TargetEntity>
+{
   /**
    * Constructor of DefaultHasOneEntityCrudRepository
    * @param getTargetRepository - the getter of the related target model repository instance

package/src/relations/relation.helpers.ts

@@ -30,34 +30,65 @@ const debug = debugFactory('loopback:repository:relation-helpers');
 export async function findByForeignKeys<
   Target extends Entity,
   TargetRelations extends object,
-  ForeignKey extends StringKeyOf<Target>
+  ForeignKey extends StringKeyOf<Target>,
 >(
   targetRepository: EntityCrudRepository<Target, unknown, TargetRelations>,
   fkName: ForeignKey,
   fkValues: Target[ForeignKey][] | Target[ForeignKey],
-  scope?: Filter<Target>,
+  scope?: Filter<Target> & {totalLimit?: number},
   options?: Options,
 ): Promise<(Target & TargetRelations)[]> {
   let value;
   scope = cloneDeep(scope);
-
   if (Array.isArray(fkValues)) {
     if (fkValues.length === 0) return [];
     value = fkValues.length === 1 ? fkValues[0] : {inq: fkValues};
   } else {
     value = fkValues;
   }
+  let useScopeFilterGlobally = false;
+  if (options) {
+    useScopeFilterGlobally = options.isThroughModelInclude;
+    //if its an include from a through model, fkValues will be an array
+    //however, in this case we DO want to use the scope in the entire query
+    //no in a per fk basis
+  }
+  //This code is to keep backward compatability. See https://github.com/loopbackio/loopback-next/issues/6832
+  //for more info
+  if (scope?.totalLimit) {
+    scope.limit = scope.totalLimit;
+    useScopeFilterGlobally = true;
+    delete scope.totalLimit;
+  }
 
-  const where = ({[fkName]: value} as unknown) as Where<Target>;
-
-  if (scope && !_.isEmpty(scope)) {
-    // combine where clause to scope filter
-    scope = new FilterBuilder(scope).impose({where}).filter;
+  const isScopeSet = scope && !_.isEmpty(scope);
+  if (isScopeSet && Array.isArray(fkValues) && !useScopeFilterGlobally) {
+    // since there is a scope, there could be a where filter, a limit, an order
+    // and we should run the scope in multiple queries so we can respect the
+    // scope filter params
+    const findPromises = fkValues.map(fk => {
+      const where = {[fkName]: fk} as unknown as Where<Target>;
+      let localScope = cloneDeep(scope);
+      // combine where clause to scope filter
+      localScope = new FilterBuilder(localScope).impose({where}).filter;
+      return targetRepository.find(localScope, options);
+    });
+    return Promise.all(findPromises).then(findResults => {
+      //findResults is an array of arrays for each scope result, so we need to flatten it before returning it
+      return _.flatten(findResults);
+    });
   } else {
-    scope = {where} as Filter<Target>;
-  }
+    const where = {[fkName]: value} as unknown as Where<Target>;
 
-  return targetRepository.find(scope, options);
+    if (isScopeSet) {
+      // combine where clause to scope filter
+      scope = new FilterBuilder(scope).impose({where}).filter;
+    } else {
+      scope = {where} as Filter<Target>;
+    }
+
+    return targetRepository.find(scope, options);
+  }
 }
 
 export type StringKeyOf<T> = Extract<keyof T, string>;
@@ -74,7 +105,7 @@ export type StringKeyOf<T> = Extract<keyof T, string>;
 
 export async function includeRelatedModels<
   T extends Entity,
-  Relations extends object = {}
+  Relations extends object = {},
 >(
   targetRepository: EntityCrudRepository<T, unknown, Relations>,
   entities: T[],

package/src/repositories/kv.repository.bridge.ts

@@ -13,7 +13,8 @@ import {ensurePromise, juggler} from './legacy-juggler-bridge';
  * An implementation of KeyValueRepository based on loopback-datasource-juggler
  */
 export class DefaultKeyValueRepository<T extends Model>
-  implements KeyValueRepository<T> {
+  implements KeyValueRepository<T>
+{
   /**
    * A legacy KeyValueModel class
    */
@@ -29,9 +30,8 @@ export class DefaultKeyValueRepository<T extends Model>
   ) {
     // KVModel class is placeholder to receive methods from KeyValueAccessObject
     // through mixin
-    this.kvModelClass = ds.createModel<typeof juggler.KeyValueModel>(
-      '_kvModel',
-    );
+    this.kvModelClass =
+      ds.createModel<typeof juggler.KeyValueModel>('_kvModel');
   }
 
   delete(key: string, options?: Options): Promise<void> {

package/src/repositories/legacy-juggler-bridge.ts

@@ -111,8 +111,9 @@ export function ensurePromise<T>(p: legacy.PromiseOrVoid<T>): Promise<T> {
 export class DefaultCrudRepository<
   T extends Entity,
   ID,
-  Relations extends object = {}
-> implements EntityCrudRepository<T, ID, Relations> {
+  Relations extends object = {},
+> implements EntityCrudRepository<T, ID, Relations>
+{
   modelClass: juggler.PersistedModelClass;
 
   public readonly inclusionResolvers: Map<
@@ -236,7 +237,7 @@ export class DefaultCrudRepository<
   protected _createHasManyRepositoryFactoryFor<
     Target extends Entity,
     TargetID,
-    ForeignKeyType
+    ForeignKeyType,
   >(
     relationName: string,
     targetRepoGetter: Getter<EntityCrudRepository<Target, TargetID>>,
@@ -278,7 +279,7 @@ export class DefaultCrudRepository<
   protected createHasManyRepositoryFactoryFor<
     Target extends Entity,
     TargetID,
-    ForeignKeyType
+    ForeignKeyType,
   >(
     relationName: string,
     targetRepoGetter: Getter<EntityCrudRepository<Target, TargetID>>,
@@ -325,7 +326,7 @@ export class DefaultCrudRepository<
     TargetID,
     Through extends Entity,
     ThroughID,
-    ForeignKeyType
+    ForeignKeyType,
   >(
     relationName: string,
     targetRepoGetter: Getter<EntityCrudRepository<Target, TargetID>>,
@@ -390,7 +391,7 @@ export class DefaultCrudRepository<
   protected _createHasOneRepositoryFactoryFor<
     Target extends Entity,
     TargetID,
-    ForeignKeyType
+    ForeignKeyType,
   >(
     relationName: string,
     targetRepoGetter: Getter<EntityCrudRepository<Target, TargetID>>,
@@ -410,7 +411,7 @@ export class DefaultCrudRepository<
   protected createHasOneRepositoryFactoryFor<
     Target extends Entity,
     TargetID,
-    ForeignKeyType
+    ForeignKeyType,
   >(
     relationName: string,
     targetRepoGetter: Getter<EntityCrudRepository<Target, TargetID>>,
@@ -770,10 +771,11 @@ export class DefaultCrudRepository<
 export class DefaultTransactionalRepository<
     T extends Entity,
     ID,
-    Relations extends object = {}
+    Relations extends object = {},
   >
   extends DefaultCrudRepository<T, ID, Relations>
-  implements TransactionalEntityRepository<T, ID, Relations> {
+  implements TransactionalEntityRepository<T, ID, Relations>
+{
   async beginTransaction(
     options?: IsolationLevel | Options,
   ): Promise<Transaction> {

package/src/repositories/repository.ts

@@ -46,7 +46,7 @@ export interface ExecutableRepository<T extends Model> extends Repository<T> {
 export type TransactionalEntityRepository<
   T extends Entity,
   ID,
-  Relations extends object = {}
+  Relations extends object = {},
 > = TransactionalRepository<T> & EntityCrudRepository<T, ID>;
 /**
  * Repository Interface for Repositories that support Transactions
@@ -69,7 +69,7 @@ export interface TransactionalRepository<T extends Entity>
  */
 export interface CrudRepository<
   T extends ValueObject | Entity,
-  Relations extends object = {}
+  Relations extends object = {},
 > extends Repository<T> {
   /**
    * Create a new record
@@ -137,7 +137,7 @@ export interface EntityRepository<T extends Entity, ID>
 export interface EntityCrudRepository<
   T extends Entity,
   ID,
-  Relations extends object = {}
+  Relations extends object = {},
 > extends EntityRepository<T, ID>,
     CrudRepository<T, Relations> {
   // entityClass should have type "typeof T", but that's not supported by TSC
@@ -254,7 +254,8 @@ export interface EntityCrudRepository<
  * ```
  */
 export class CrudRepositoryImpl<T extends Entity, ID>
-  implements EntityCrudRepository<T, ID> {
+  implements EntityCrudRepository<T, ID>
+{
   private connector: CrudConnector;
   public readonly inclusionResolvers: Map<
     string,

package/src/type-resolver.ts

@@ -26,7 +26,7 @@ import {Class} from './common-types';
  */
 export type TypeResolver<
   Type extends Object,
-  StaticMembers = Function
+  StaticMembers = Function,
 > = () => Class<Type> & StaticMembers;
 
 /**