@loopback/repository 4.1.2 → 5.0.2

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;
+    }
   };
 }

package/src/relations/has-many/has-many-through.repository-factory.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
@@ -59,10 +59,22 @@ export function createHasManyThroughRepositoryFactory<
   SourceID,
 >(
   relationMetadata: HasManyDefinition,
-  targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetID>>,
+  targetRepositoryGetter:
+    | Getter<EntityCrudRepository<Target, TargetID>>
+    | {
+        [repoType: string]: Getter<EntityCrudRepository<Target, TargetID>>;
+      },
   throughRepositoryGetter: Getter<EntityCrudRepository<Through, ThroughID>>,
 ): HasManyThroughRepositoryFactory<Target, TargetID, Through, SourceID> {
   const meta = resolveHasManyThroughMetadata(relationMetadata);
+  // resolve the repositoryGetter into a dictionary
+  if (typeof targetRepositoryGetter === 'function') {
+    targetRepositoryGetter = {
+      [meta.target().name]: targetRepositoryGetter as Getter<
+        EntityCrudRepository<Target, TargetID>
+      >,
+    };
+  }
   const result = function (fkValue: SourceID) {
     function getTargetConstraintFromThroughModels(
       throughInstances: Through[],
@@ -103,19 +115,25 @@ export function createHasManyThroughRepositoryFactory<
       ThroughID,
       EntityCrudRepository<Through, ThroughID>
     >(
-      targetRepositoryGetter,
+      targetRepositoryGetter as {
+        [repoType: string]: Getter<EntityCrudRepository<Target, TargetID>>;
+      },
       throughRepositoryGetter,
       getTargetConstraintFromThroughModels,
       getTargetKeys,
       getThroughConstraintFromSource,
       getTargetIds,
       getThroughConstraintFromTarget,
+      relationMetadata.target,
+      relationMetadata.through!.model,
     );
   };
   result.inclusionResolver = createHasManyThroughInclusionResolver(
     meta,
     throughRepositoryGetter,
-    targetRepositoryGetter,
+    targetRepositoryGetter as {
+      [repoType: string]: Getter<EntityCrudRepository<Target, TargetID>>;
+    },
   );
   return result;
 }