@loopback/repository 4.1.1 → 5.0.1

package/src/relations/belongs-to/belongs-to.helpers.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2019. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2019. All Rights Reserved.
 // Node module: @loopback/repository
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
@@ -18,6 +18,7 @@ const debug = debugFactory('loopback:repository:relations:belongs-to:helpers');
 export type BelongsToResolvedDefinition = BelongsToDefinition & {
   keyFrom: string;
   keyTo: string;
+  polymorphic: false | {discriminator: string};
 };
 
 /**
@@ -27,7 +28,9 @@ export type BelongsToResolvedDefinition = BelongsToDefinition & {
  * @param relationMeta - belongsTo metadata to resolve
  * @internal
  */
-export function resolveBelongsToMetadata(relationMeta: BelongsToDefinition) {
+export function resolveBelongsToMetadata(
+  relationMeta: BelongsToDefinition,
+): BelongsToResolvedDefinition {
   if ((relationMeta.type as RelationType) !== RelationType.belongsTo) {
     const reason = 'relation type must be BelongsTo';
     throw new InvalidRelationError(reason, relationMeta);
@@ -61,18 +64,42 @@ export function resolveBelongsToMetadata(relationMeta: BelongsToDefinition) {
   const targetProperties = targetModel.definition.properties;
   debug('relation metadata from %o: %o', targetName, targetProperties);
 
+  let keyTo;
   if (relationMeta.keyTo && targetProperties[relationMeta.keyTo]) {
     // The explicit cast is needed because of a limitation of type inference
-    return Object.assign(relationMeta, {
-      keyFrom,
-    }) as BelongsToResolvedDefinition;
+    keyTo = relationMeta.keyTo;
+  } else {
+    keyTo = targetModel.definition.idProperties()[0];
+    if (!keyTo) {
+      const reason = `${targetName} does not have any primary key (id property)`;
+      throw new InvalidRelationError(reason, relationMeta);
+    }
   }
 
-  const targetPrimaryKey = targetModel.definition.idProperties()[0];
-  if (!targetPrimaryKey) {
-    const reason = `${targetName} does not have any primary key (id property)`;
-    throw new InvalidRelationError(reason, relationMeta);
+  let polymorphic: false | {discriminator: string};
+  if (
+    relationMeta.polymorphic === undefined ||
+    relationMeta.polymorphic === false ||
+    !relationMeta.polymorphic
+  ) {
+    const polymorphicFalse = false as const;
+    polymorphic = polymorphicFalse;
+  } else {
+    if (relationMeta.polymorphic === true) {
+      const polymorphicObject: {discriminator: string} = {
+        discriminator: camelCase(relationMeta.target().name + '_type'),
+      };
+      polymorphic = polymorphicObject;
+    } else {
+      const polymorphicObject: {discriminator: string} =
+        relationMeta.polymorphic as {discriminator: string};
+      polymorphic = polymorphicObject;
+    }
   }
 
-  return Object.assign(relationMeta, {keyFrom, keyTo: targetPrimaryKey});
+  return Object.assign(relationMeta, {
+    keyFrom,
+    keyTo: keyTo,
+    polymorphic: polymorphic,
+  });
 }

package/src/relations/belongs-to/belongs-to.inclusion-resolver.ts

@@ -1,9 +1,10 @@
-// Copyright IBM Corp. 2019,2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2019,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, InclusionFilter} from '@loopback/filter';
+import {includeFieldIfNot, InvalidPolymorphismError} from '../../';
 import {AnyObject, Options} from '../../common-types';
 import {Entity} from '../../model';
 import {EntityCrudRepository} from '../../repositories';
@@ -28,7 +29,8 @@ import {resolveBelongsToMetadata} from './belongs-to.helpers';
  * Notice: scope field for inclusion is not supported yet
  *
  * @param meta - resolved BelongsToMetadata
- * @param getTargetRepo - target repository i.e where related instances are
+ * @param getTargetRepoDict - dictionary of target model type - target repository
+ * i.e where related instances for different types are
  */
 export function createBelongsToInclusionResolver<
   Target extends Entity,
@@ -36,36 +38,125 @@ export function createBelongsToInclusionResolver<
   TargetRelations extends object,
 >(
   meta: BelongsToDefinition,
-  getTargetRepo: Getter<
-    EntityCrudRepository<Target, TargetID, TargetRelations>
-  >,
+  getTargetRepoDict: {
+    [repoType: string]: Getter<
+      EntityCrudRepository<Target, TargetID, TargetRelations>
+    >;
+  },
 ): InclusionResolver<Entity, Target> {
   const relationMeta = resolveBelongsToMetadata(meta);
 
-  return async function fetchIncludedModels(
+  return async function fetchBelongsToModel(
     entities: Entity[],
     inclusion: InclusionFilter,
     options?: Options,
-  ): Promise<((Target & TargetRelations) | undefined)[]> {
+  ): Promise<((Target & object) | undefined)[]> {
     if (!entities.length) return [];
 
+    // Source ids are grouped by their target polymorphic types
+    // Each type search for target instances and then merge together in a merge-sort-like manner
+
     const sourceKey = relationMeta.keyFrom;
-    const sourceIds = entities.map(e => (e as AnyObject)[sourceKey]);
     const targetKey = relationMeta.keyTo as StringKeyOf<Target>;
-    const dedupedSourceIds = deduplicate(sourceIds);
+    const targetDiscriminator: keyof Entity | undefined =
+      relationMeta.polymorphic
+        ? (relationMeta.polymorphic.discriminator as keyof Entity)
+        : undefined;
 
     const scope =
       typeof inclusion === 'string' ? {} : (inclusion.scope as Filter<Target>);
 
-    const targetRepo = await getTargetRepo();
-    const targetsFound = await findByForeignKeys(
-      targetRepo,
-      targetKey,
-      dedupedSourceIds.filter(e => e),
-      scope,
-      options,
-    );
+    // sourceIds in {targetType -> sourceId}
+    const sourceIdsCategorized: {
+      [concreteItemType: string]: Target[StringKeyOf<Target>][];
+    } = {};
+    if (targetDiscriminator) {
+      entities.forEach((value, index, allEntites) => {
+        const concreteType = String(value[targetDiscriminator]);
+        if (!getTargetRepoDict[concreteType]) {
+          throw new InvalidPolymorphismError(concreteType, targetDiscriminator);
+        }
+        if (!sourceIdsCategorized[concreteType]) {
+          sourceIdsCategorized[concreteType] = [];
+        }
+        sourceIdsCategorized[concreteType].push(
+          (value as AnyObject)[sourceKey],
+        );
+      });
+    } else {
+      const concreteType = relationMeta.target().name;
+      if (!getTargetRepoDict[concreteType]) {
+        throw new InvalidPolymorphismError(concreteType);
+      }
+      entities.forEach((value, index, allEntites) => {
+        if (!sourceIdsCategorized[concreteType]) {
+          sourceIdsCategorized[concreteType] = [];
+        }
+        sourceIdsCategorized[concreteType].push(
+          (value as AnyObject)[sourceKey],
+        );
+      });
+    }
+
+    // Ensure targetKey is included otherwise flatten function cannot work
+    const changedTargetKeyField = includeFieldIfNot(scope?.fields, targetKey);
+    let needToRemoveTargetKeyFieldLater = false;
+    if (changedTargetKeyField !== false) {
+      scope.fields = changedTargetKeyField;
+      needToRemoveTargetKeyFieldLater = true;
+    }
+    // Each sourceIds array with same target type extract target instances
+    const targetCategorized: {
+      [concreteItemType: string]: ((Target & TargetRelations) | undefined)[];
+    } = {};
+    for (const k of Object.keys(sourceIdsCategorized)) {
+      const targetRepo = await getTargetRepoDict[k]();
+      const targetsFound = await findByForeignKeys(
+        targetRepo,
+        targetKey,
+        deduplicate(sourceIdsCategorized[k]).filter(e => e),
+        scope,
+        options,
+      );
+      targetCategorized[k] = flattenTargetsOfOneToOneRelation(
+        sourceIdsCategorized[k],
+        targetsFound,
+        targetKey,
+      );
+
+      // Remove targetKey if should be excluded but included above
+      if (needToRemoveTargetKeyFieldLater) {
+        targetCategorized[k] = targetCategorized[k].map(e => {
+          if (e) {
+            delete e[targetKey];
+          }
+          return e;
+        });
+      }
+    }
 
-    return flattenTargetsOfOneToOneRelation(sourceIds, targetsFound, targetKey);
+    // Merge
+    // Why the order is correct:
+    // e.g. target model 1 = a, target model 2 = b
+    // all entities: [S(a-1), S(a-2), S(b-3), S(a-4), S(b-5)]
+    // a-result: [a-1, a-2, a-4]
+    // b-result: [b-3, b-4]
+    // merged:
+    // entities[1]->a => targets: [a-1 from a-result.shift()]
+    // entities[2]->a => targets: [a-1, a-2 from a-result.shift()]
+    // entities[3]->b => targets: [a-1, a-2, b-3 from b-result.shift()]
+    // entities[4]->a => targets: [a-1, a-2, b-3, a-4 from a-result.shift()]
+    // entities[5]->b => targets: [a-1, a-2, b-3, a-4, b-5 from b-result.shift()]
+    if (targetDiscriminator) {
+      const allTargets: ((Target & TargetRelations) | undefined)[] = [];
+      entities.forEach((value, index, allEntites) => {
+        allTargets.push(
+          targetCategorized[String(value[targetDiscriminator])].shift(),
+        );
+      });
+      return allTargets;
+    } else {
+      return targetCategorized[relationMeta.target().name];
+    }
   };
 }

package/src/relations/belongs-to/belongs-to.repository.ts

@@ -1,14 +1,14 @@
-// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2018,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 {Getter} from '@loopback/core';
+import {cloneDeep} from 'lodash';
+import {EntityNotFoundError, TypeResolver} from '../../';
 import {DataObject, Options} from '../../common-types';
-import {EntityNotFoundError} from '../../errors';
 import {Entity} from '../../model';
 import {constrainFilter, EntityCrudRepository} from '../../repositories';
-
 /**
  * CRUD operations for a target repository of a BelongsTo relation
  */
@@ -16,10 +16,16 @@ export interface BelongsToRepository<Target extends Entity> {
   /**
    * Gets the target model instance
    * @param options
+   * options.polymorphicType - a string or a string array of polymorphic type names
+   * to specify which repositories should are expected to be searched
+   * It is highly recommended to contain this param especially for
+   * datasources using deplicated ids across tables
    * @returns A promise resolved with the target object or rejected
    * with an EntityNotFoundError when target model instance was not found.
    */
-  get(options?: Options): Promise<Target>;
+  get(
+    options?: Options & {polymorphicType?: string | string[]},
+  ): Promise<Target>;
 }
 
 export class DefaultBelongsToRepository<
@@ -30,26 +36,80 @@ export class DefaultBelongsToRepository<
 {
   /**
    * Constructor of DefaultBelongsToEntityCrudRepository
-   * @param getTargetRepository - the getter of the related target model repository instance
+   * @param getTargetRepository - either a dictionary of target model type - target repository instance
+   * or a single target repository instance
+   * e.g. if the target is of a non-polymorphic type "Student", put the studentRepositoryGetterInstance
+   * if the target is of a polymorphic type "Person" which can be either a "Student" or a "Teacher"
+   * then put "{Student: studentRepositoryGetterInstance, Teacher: teacherRepositoryGetterInstance}"
    * @param constraint - the key value pair representing foreign key name to constrain
    * the target repository instance
+   * @param targetResolver - () => Target to resolve the target class
+   * e.g. if the target is of type "Student", then put "() => Student"
    */
+
   constructor(
-    public getTargetRepository: Getter<TargetRepository>,
+    public getTargetRepository:
+      | Getter<TargetRepository>
+      | {
+          [repoType: string]: Getter<TargetRepository>;
+        },
     public constraint: DataObject<TargetEntity>,
-  ) {}
+    public targetResolver: TypeResolver<Entity, typeof Entity>,
+  ) {
+    if (typeof getTargetRepository === 'function') {
+      this.getTargetRepositoryDict = {
+        [targetResolver().name]:
+          getTargetRepository as Getter<TargetRepository>,
+      };
+    } else {
+      this.getTargetRepositoryDict = getTargetRepository as {
+        [repoType: string]: Getter<TargetRepository>;
+      };
+    }
+  }
+
+  public getTargetRepositoryDict: {
+    [repoType: string]: Getter<TargetRepository>;
+  };
 
-  async get(options?: Options): Promise<TargetEntity> {
-    const targetRepo = await this.getTargetRepository();
-    const result = await targetRepo.find(
-      constrainFilter(undefined, this.constraint),
-      options,
-    );
-    if (!result.length) {
-      // We don't have a direct access to the foreign key value here :(
-      const id = 'constraint ' + JSON.stringify(this.constraint);
-      throw new EntityNotFoundError(targetRepo.entityClass, id);
+  async get(
+    options?: Options & {polymorphicType?: string | string[]},
+  ): Promise<TargetEntity> {
+    let polymorphicTypes = options?.polymorphicType;
+    let allKeys: string[];
+    if (Object.keys(this.getTargetRepositoryDict).length <= 1) {
+      allKeys = Object.keys(this.getTargetRepositoryDict);
+    } else if (!polymorphicTypes || polymorphicTypes.length === 0) {
+      console.warn(
+        'It is highly recommended to specify the polymorphicTypes param when using polymorphic types.',
+      );
+      allKeys = Object.keys(this.getTargetRepositoryDict);
+    } else {
+      if (typeof polymorphicTypes === 'string') {
+        polymorphicTypes = [polymorphicTypes];
+      }
+      allKeys = [];
+      new Set(polymorphicTypes!).forEach(element => {
+        if (Object.keys(this.getTargetRepositoryDict).includes(element)) {
+          allKeys.push(element);
+        }
+      });
+    }
+    let result: TargetEntity[] = [];
+    for (const key of allKeys) {
+      const targetRepository = await this.getTargetRepositoryDict[key]();
+      result = result.concat(
+        await targetRepository.find(
+          constrainFilter(undefined, this.constraint),
+          Object.assign(cloneDeep(options ?? {}), {polymorphicType: key}),
+        ),
+      );
+      if (result.length >= 1) {
+        return result[0];
+      }
     }
-    return result[0];
+    // We don't have a direct access to the foreign key value here :(
+    const id = 'constraint ' + JSON.stringify(this.constraint);
+    throw new EntityNotFoundError(this.targetResolver().name, id);
   }
 }

package/src/relations/belongs-to/index.ts

@@ -1,9 +1,9 @@
-// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 2018,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
 
-export * from './belongs-to.decorator';
-export * from './belongs-to.repository';
 export * from './belongs-to.accessor';
+export * from './belongs-to.decorator';
 export * from './belongs-to.inclusion-resolver';
+export * from './belongs-to.repository';

package/src/relations/has-many/has-many-through.helpers.ts

@@ -1,4 +1,4 @@
-// Copyright IBM Corp. 2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 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
@@ -25,6 +25,7 @@ export type HasManyThroughResolvedDefinition = HasManyDefinition & {
   through: {
     keyTo: string;
     keyFrom: string;
+    polymorphic: false | {discriminator: string};
   };
 };
 
@@ -308,7 +309,10 @@ export function resolveHasManyThroughMetadata(
     relationMeta.through.keyFrom &&
     throughModelProperties[relationMeta.through.keyFrom] &&
     relationMeta.keyTo &&
-    targetModelProperties[relationMeta.keyTo]
+    targetModelProperties[relationMeta.keyTo] &&
+    (relationMeta.through.polymorphic === false ||
+      (typeof relationMeta.through.polymorphic === 'object' &&
+        relationMeta.through.polymorphic.discriminator.length > 0))
   ) {
     // The explicit cast is needed because of a limitation of type inference
     return relationMeta as HasManyThroughResolvedDefinition;
@@ -349,6 +353,27 @@ export function resolveHasManyThroughMetadata(
     throw new InvalidRelationError(reason, relationMeta);
   }
 
+  let throughPolymorphic: false | {discriminator: string};
+  if (
+    relationMeta.through.polymorphic === undefined ||
+    relationMeta.through.polymorphic === false ||
+    !relationMeta.through.polymorphic
+  ) {
+    const polymorphicFalse = false as const;
+    throughPolymorphic = polymorphicFalse;
+  } else {
+    if (relationMeta.through.polymorphic === true) {
+      const polymorphicObject: {discriminator: string} = {
+        discriminator: camelCase(relationMeta.target().name + '_type'),
+      };
+      throughPolymorphic = polymorphicObject;
+    } else {
+      const polymorphicObject: {discriminator: string} = relationMeta.through
+        .polymorphic as {discriminator: string};
+      throughPolymorphic = polymorphicObject;
+    }
+  }
+
   return Object.assign(relationMeta, {
     keyTo: targetPrimaryKey,
     keyFrom: relationMeta.keyFrom!,
@@ -356,6 +381,7 @@ export function resolveHasManyThroughMetadata(
       ...relationMeta.through,
       keyTo: targetFkName,
       keyFrom: sourceFkName,
+      polymorphic: throughPolymorphic,
     },
   });
 }

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

@@ -1,10 +1,11 @@
-// Copyright IBM Corp. 2020. All Rights Reserved.
+// Copyright IBM Corp. and LoopBack contributors 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, InclusionFilter} from '@loopback/filter';
 import debugFactory from 'debug';
+import {InvalidPolymorphismError} from '../..';
 import {AnyObject, Options} from '../../common-types';
 import {Entity} from '../../model';
 import {EntityCrudRepository} from '../../repositories';
@@ -14,7 +15,7 @@ import {
   StringKeyOf,
 } from '../relation.helpers';
 import {Getter, HasManyDefinition, InclusionResolver} from '../relation.types';
-import {resolveHasManyMetadata} from './has-many.helpers';
+import {resolveHasManyThroughMetadata} from './has-many-through.helpers';
 
 const debug = debugFactory(
   'loopback:repository:relations:has-many-through:inclusion-resolver',
@@ -44,17 +45,25 @@ export function createHasManyThroughInclusionResolver<
   getThroughRepo: Getter<
     EntityCrudRepository<Through, ThroughID, ThroughRelations>
   >,
-  getTargetRepo: Getter<
-    EntityCrudRepository<Target, TargetID, TargetRelations>
-  >,
+  getTargetRepoDict: {
+    [repoType: string]: Getter<
+      EntityCrudRepository<Target, TargetID, TargetRelations>
+    >;
+  },
 ): InclusionResolver<Entity, Target> {
-  const relationMeta = resolveHasManyMetadata(meta);
+  const relationMeta = resolveHasManyThroughMetadata(meta);
 
   return async function fetchHasManyThroughModels(
     entities: Entity[],
     inclusion: InclusionFilter,
     options?: Options,
   ): Promise<((Target & TargetRelations)[] | undefined)[]> {
+    if (!relationMeta.through) {
+      throw new Error(
+        `relationMeta.through must be defined on ${relationMeta}`,
+      );
+    }
+
     if (!entities.length) return [];
 
     debug('Fetching target models for entities:', entities);
@@ -85,7 +94,6 @@ export function createHasManyThroughInclusionResolver<
     );
 
     const throughRepo = await getThroughRepo();
-    const targetRepo = await getTargetRepo();
 
     // find through models
     const throughFound = await findByForeignKeys(
@@ -102,34 +110,117 @@ export function createHasManyThroughInclusionResolver<
       throughKeyFrom,
     );
 
-    const result = [];
-
     const scope =
       typeof inclusion === 'string' ? {} : (inclusion.scope as Filter<Target>);
 
-    // 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
+    // whether the polymorphism is configured
+    const targetDiscriminator: keyof (Through & ThroughRelations) | undefined =
+      relationMeta.through!.polymorphic
+        ? (relationMeta.through!.polymorphic.discriminator as keyof (Through &
+            ThroughRelations))
+        : undefined;
+    if (targetDiscriminator) {
+      // put through results into arrays based on the target polymorphic types
+      const throughArrayByTargetType: {
+        [targetType: string]: (Through & ThroughRelations)[];
+      } = {};
+      for (const throughArray of throughResult) {
+        if (throughArray) {
+          for (const throughItem of throughArray) {
+            const targetType = String(throughItem[targetDiscriminator]);
+            if (!getTargetRepoDict[targetType]) {
+              throw new InvalidPolymorphismError(
+                targetType,
+                String(targetDiscriminator),
+              );
+            }
+            if (!throughArrayByTargetType[targetType]) {
+              throughArrayByTargetType[targetType] = [];
+            }
+            throughArrayByTargetType[targetType].push(throughItem);
+          }
+        }
+      }
+      // get targets based on their polymorphic types
+      const targetOfTypes: {
+        [targetType: string]: (Target & TargetRelations)[];
+      } = {};
+      for (const targetType of Object.keys(throughArrayByTargetType)) {
+        const targetIds = throughArrayByTargetType[targetType].map(
+          throughItem => throughItem[throughKeyTo],
+        );
+        const targetRepo = await getTargetRepoDict[targetType]();
         const targetEntityList = await findByForeignKeys<
           Target,
           TargetRelations,
           StringKeyOf<Target>
-        >(targetRepo, targetKey, targetIds as unknown as [], scope, {
-          ...options,
-          isThroughModelInclude: true,
-        });
-        result.push(targetEntityList);
-      } else {
-        // no entities found, add undefined to results
-        result.push(entityList);
+        >(targetRepo, targetKey, targetIds as unknown as [], scope, options);
+        targetOfTypes[targetType] = targetEntityList;
+      }
+      // put targets into arrays reflecting their throughs
+      // Why the order is correct:
+      // e.g. through model = T(target instance), target model 1 = a, target model 2 = b
+      // all entities: [S1, S2, S2]
+      // through-result: [[T(b-11), T(a-12), T(b-13), T(b-14)], [T(a-21), T(a-22), T(b-23)], [T(b-31), T(b-32), T(a-33)]]
+      // through-array-by-target-type: {a:[T(a-12), T(a-21), T(a-22), T(a-33)] b: [T(b-11), T(b-13), T(b-14), T(b-23), T(b-31), T(b-32)]}
+      // target-array-by-target-type: {a:[a-12, a-21, a-22, a-33] b: [b-11, b-13, b-14, b-23, b-31, b-32]}
+      // merged:
+      // through-result[0][0]->b => targets: [[b-11 from b.shift()]]
+      // through-result[0][1]->a => targets: [[b-11, a-12 from a.shift()]]
+      // through-result[0][2]->b => targets: [[b-11, a-12, b-13 from b.shift()]]
+      // through-result[0][3]->b => targets: [[b-11, a-12, b-13, b-14 from b.shift()]]
+      // through-result[1][0]->a => targets: [[b-11, a-12, b-13, b-14], [a-21, from a.shift()]]
+      // through-result[1][1]->a => targets: [[b-11, a-12, b-13, b-14], [a-21, a-22 from a.shift()]]
+      // through-result[1][2]->b => targets: [[b-11, a-12, b-13, b-14], [a-21, a-22, b-23 from b.shift()]]
+      // through-result[2][0]->b => targets: [[b-11, a-12, b-13, b-14], [a-21, a-22, b-23], [b-31, from b.shift()]]
+      // through-result[2][1]->b => targets: [[b-11, a-12, b-13, b-14], [a-21, a-22, b-23], [b-31, b-32 from b.shift()]]
+      // through-result[2][1]->b => targets: [[b-11, a-12, b-13, b-14], [a-21, a-22, b-23], [b-31, b-32, a-33 from a.shift()]]
+      const allTargetsOfThrough: ((Target & TargetRelations)[] | undefined)[] =
+        [];
+      for (const throughArray of throughResult) {
+        if (throughArray && throughArray.length > 0) {
+          const currentTargetThroughArray: (Target & TargetRelations)[] = [];
+          for (const throughItem of throughArray) {
+            const itemToAdd =
+              targetOfTypes[String(throughItem[targetDiscriminator])].shift();
+            if (itemToAdd) {
+              currentTargetThroughArray.push(itemToAdd);
+            }
+          }
+          allTargetsOfThrough.push(currentTargetThroughArray);
+        } else {
+          allTargetsOfThrough.push(undefined);
+        }
+      }
+      return allTargetsOfThrough;
+    } else {
+      const targetRepo = await getTargetRepoDict[relationMeta.target().name]();
+      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 [], scope, {
+            ...options,
+            isThroughModelInclude: true,
+          });
+          result.push(targetEntityList);
+        } else {
+          // no entities found, add undefined to results
+          result.push(entityList);
+        }
       }
-    }
 
-    debug('fetchHasManyThroughModels result', result);
-    return result;
+      debug('fetchHasManyThroughModels result', result);
+      return result;
+    }
   };
 }