@loopback/repository 4.1.1 → 5.0.1

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

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

@@ -1,8 +1,9 @@
-// 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 {cloneDeep} from 'lodash';
 import {
   constrainDataObject,
   constrainFilter,
@@ -14,7 +15,10 @@ import {
   EntityCrudRepository,
   Filter,
   Getter,
+  InvalidPolymorphismError,
   Options,
+  StringKeyOf,
+  TypeResolver,
   Where,
 } from '../..';
 
@@ -33,6 +37,8 @@ export interface HasManyThroughRepository<
    * Create a target model instance
    * @param targetModelData - The target model data
    * @param options - Options for the operation
+   * options.polymorphicType a string or a string array of polymorphic type names
+   * specify of which concrete model the created instance should be
    * @returns A promise which resolves to the newly created target model instance
    */
   create(
@@ -40,33 +46,43 @@ export interface HasManyThroughRepository<
     options?: Options & {
       throughData?: DataObject<Through>;
       throughOptions?: Options;
-    },
+    } & {polymorphicType?: string},
   ): Promise<Target>;
 
   /**
    * Find target model instance(s)
    * @param filter - A filter object for where, order, limit, etc.
    * @param options - Options for the operation
+   * options.throughOptions.discriminator - target discriminator field on through
+   * 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 which resolves with the found target instance(s)
    */
   find(
     filter?: Filter<Target>,
     options?: Options & {
-      throughOptions?: Options;
-    },
+      throughOptions?: Options & {discriminator?: string};
+    } & {polymorphicType?: string | string[]},
   ): Promise<Target[]>;
 
   /**
    * Delete multiple target model instances
    * @param where - Instances within the where scope are deleted
    * @param options
+   * options.throughOptions.discriminator - target discriminator field on through
+   * 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 which resolves the deleted target model instances
    */
   delete(
     where?: Where<Target>,
     options?: Options & {
-      throughOptions?: Options;
-    },
+      throughOptions?: Options & {discriminator?: string};
+    } & {polymorphicType?: string | string[]},
   ): Promise<Count>;
 
   /**
@@ -74,14 +90,18 @@ export interface HasManyThroughRepository<
    * @param dataObject - The fields and their new values to patch
    * @param where - Instances within the where scope are patched
    * @param options
+   * options.throughOptions.discriminator - target discriminator field on through
+   * options.isPolymorphic - whether dataObject is a dictionary
    * @returns A promise which resolves the patched target model instances
    */
   patch(
-    dataObject: DataObject<Target>,
+    dataObject:
+      | DataObject<Target>
+      | {[polymorphicType: string]: DataObject<Target>},
     where?: Where<Target>,
     options?: Options & {
-      throughOptions?: Options;
-    },
+      throughOptions?: Options & {discriminator?: string};
+    } & {isPolymorphic?: boolean},
   ): Promise<Count>;
 
   /**
@@ -140,7 +160,11 @@ export class DefaultHasManyThroughRepository<
 > implements HasManyThroughRepository<TargetEntity, TargetID, ThroughEntity>
 {
   constructor(
-    public getTargetRepository: Getter<TargetRepository>,
+    public getTargetRepository:
+      | Getter<TargetRepository>
+      | {
+          [repoType: string]: Getter<TargetRepository>;
+        },
     public getThroughRepository: Getter<ThroughRepository>,
     public getTargetConstraintFromThroughModels: (
       throughInstances: ThroughEntity[],
@@ -151,16 +175,52 @@ export class DefaultHasManyThroughRepository<
     public getThroughConstraintFromTarget: (
       targetID: TargetID[],
     ) => DataObject<ThroughEntity>,
-  ) {}
+    public targetResolver: TypeResolver<Entity, typeof Entity>,
+    public throughResolver: 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 create(
     targetModelData: DataObject<TargetEntity>,
     options?: Options & {
       throughData?: DataObject<ThroughEntity>;
       throughOptions?: Options;
-    },
+    } & {polymorphicType?: string},
   ): Promise<TargetEntity> {
-    const targetRepository = await this.getTargetRepository();
+    let targetPolymorphicTypeName = options?.polymorphicType;
+    if (targetPolymorphicTypeName) {
+      if (!this.getTargetRepositoryDict[targetPolymorphicTypeName]) {
+        throw new InvalidPolymorphismError(targetPolymorphicTypeName);
+      }
+    } else {
+      if (Object.keys(this.getTargetRepositoryDict).length > 1) {
+        console.warn(
+          'It is highly recommended to specify the polymorphicTypes param when using polymorphic types.',
+        );
+      }
+      targetPolymorphicTypeName = this.targetResolver().name;
+      if (!this.getTargetRepositoryDict[targetPolymorphicTypeName]) {
+        throw new InvalidPolymorphismError(targetPolymorphicTypeName);
+      }
+    }
+
+    const targetRepository = await this.getTargetRepositoryDict[
+      targetPolymorphicTypeName
+    ]();
     const targetInstance = await targetRepository.create(
       targetModelData,
       options,
@@ -172,91 +232,298 @@ export class DefaultHasManyThroughRepository<
   async find(
     filter?: Filter<TargetEntity>,
     options?: Options & {
-      throughOptions?: Options;
-    },
+      throughOptions?: Options & {discriminator?: string};
+    } & {polymorphicType?: string | string[]},
   ): Promise<TargetEntity[]> {
-    const targetRepository = await this.getTargetRepository();
-    const throughRepository = await this.getThroughRepository();
+    const targetDiscriminatorOnThrough = options?.throughOptions?.discriminator;
+    let targetPolymorphicTypes = options?.polymorphicType;
+    let allKeys: string[];
+    if (Object.keys(this.getTargetRepositoryDict).length <= 1) {
+      allKeys = Object.keys(this.getTargetRepositoryDict);
+    } else {
+      if (!targetDiscriminatorOnThrough) {
+        console.warn(
+          'It is highly recommended to specify the targetDiscriminatorOnThrough param when using polymorphic types.',
+        );
+      }
+      if (!targetPolymorphicTypes || targetPolymorphicTypes.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 targetPolymorphicTypes === 'string') {
+          targetPolymorphicTypes = [targetPolymorphicTypes];
+        }
+        allKeys = [];
+        new Set(targetPolymorphicTypes!).forEach(element => {
+          if (Object.keys(this.getTargetRepositoryDict).includes(element)) {
+            allKeys.push(element);
+          }
+        });
+      }
+    }
+
     const sourceConstraint = this.getThroughConstraintFromSource();
-    const throughInstances = await throughRepository.find(
-      constrainFilter(undefined, sourceConstraint),
-      options?.throughOptions,
-    );
-    const targetConstraint =
-      this.getTargetConstraintFromThroughModels(throughInstances);
-    return targetRepository.find(
-      constrainFilter(filter, targetConstraint),
-      options,
-    );
+
+    const throughCategorized: {[concreteType: string]: (ThroughEntity & {})[]} =
+      {};
+    const throughRepository = await this.getThroughRepository();
+    (
+      await throughRepository.find(
+        constrainFilter(undefined, sourceConstraint),
+        options?.throughOptions,
+      )
+    ).forEach(element => {
+      let concreteTargetType;
+      if (!targetDiscriminatorOnThrough) {
+        concreteTargetType = this.targetResolver().name;
+      } else {
+        concreteTargetType = String(
+          element[targetDiscriminatorOnThrough as StringKeyOf<ThroughEntity>],
+        );
+      }
+      if (!allKeys.includes(concreteTargetType)) {
+        return;
+      }
+      if (!this.getTargetRepositoryDict[concreteTargetType]) {
+        throw new InvalidPolymorphismError(
+          concreteTargetType,
+          targetDiscriminatorOnThrough,
+        );
+      }
+      if (!throughCategorized[concreteTargetType]) {
+        throughCategorized[concreteTargetType] = [];
+      }
+      throughCategorized[concreteTargetType].push(element);
+    });
+
+    let allTargets: TargetEntity[] = [];
+    for (const key of Object.keys(throughCategorized)) {
+      const targetRepository = await this.getTargetRepositoryDict[key]();
+      const targetConstraint = this.getTargetConstraintFromThroughModels(
+        throughCategorized[key],
+      );
+      allTargets = allTargets.concat(
+        await targetRepository.find(
+          constrainFilter(filter, targetConstraint),
+          Object.assign(cloneDeep(options ?? {}), {polymorphicType: key}),
+        ),
+      );
+    }
+
+    return allTargets;
   }
 
   async delete(
     where?: Where<TargetEntity>,
     options?: Options & {
-      throughOptions?: Options;
-    },
+      throughOptions?: Options & {discriminator?: string};
+    } & {polymorphicType?: string | string[]},
   ): Promise<Count> {
-    const targetRepository = await this.getTargetRepository();
-    const throughRepository = await this.getThroughRepository();
+    const targetDiscriminatorOnThrough = options?.throughOptions?.discriminator;
+    let targetPolymorphicTypes = options?.polymorphicType;
+    let allKeys: string[];
+    if (Object.keys(this.getTargetRepositoryDict).length <= 1) {
+      allKeys = Object.keys(this.getTargetRepositoryDict);
+    } else {
+      if (!targetDiscriminatorOnThrough) {
+        console.warn(
+          'It is highly recommended to specify the targetDiscriminatorOnThrough param when using polymorphic types.',
+        );
+      }
+      if (!targetPolymorphicTypes || targetPolymorphicTypes.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 targetPolymorphicTypes === 'string') {
+          targetPolymorphicTypes = [targetPolymorphicTypes];
+        }
+        allKeys = [];
+        new Set(targetPolymorphicTypes!).forEach(element => {
+          if (Object.keys(this.getTargetRepositoryDict).includes(element)) {
+            allKeys.push(element);
+          }
+        });
+      }
+    }
+
     const sourceConstraint = this.getThroughConstraintFromSource();
-    const throughInstances = await throughRepository.find(
-      constrainFilter(undefined, sourceConstraint),
-      options?.throughOptions,
-    );
-    if (where) {
-      // only delete related through models
-      // TODO(Agnes): this performance can be improved by only fetching related data
-      // TODO: add target ids to the `where` constraint
-      const targets = await targetRepository.find({where});
-      const targetIds = this.getTargetIds(targets);
-      if (targetIds.length > 0) {
-        const targetConstraint = this.getThroughConstraintFromTarget(targetIds);
-        const constraints = {...targetConstraint, ...sourceConstraint};
+    let totalCount = 0;
+    const throughCategorized: {[concreteType: string]: (ThroughEntity & {})[]} =
+      {};
+    const throughRepository = await this.getThroughRepository();
+    (
+      await throughRepository.find(
+        constrainFilter(undefined, sourceConstraint),
+        options?.throughOptions,
+      )
+    ).forEach(element => {
+      let concreteTargetType;
+      if (!targetDiscriminatorOnThrough) {
+        concreteTargetType = this.targetResolver().name;
+      } else {
+        concreteTargetType = String(
+          element[targetDiscriminatorOnThrough as StringKeyOf<ThroughEntity>],
+        );
+      }
+      if (!allKeys.includes(concreteTargetType)) {
+        return;
+      }
+      if (!this.getTargetRepositoryDict[concreteTargetType]) {
+        throw new InvalidPolymorphismError(
+          concreteTargetType,
+          targetDiscriminatorOnThrough,
+        );
+      }
+      if (!throughCategorized[concreteTargetType]) {
+        throughCategorized[concreteTargetType] = [];
+      }
+      throughCategorized[concreteTargetType].push(element);
+    });
+
+    for (const targetKey of Object.keys(throughCategorized)) {
+      const targetRepository = await this.getTargetRepositoryDict[targetKey]();
+      if (where) {
+        // only delete related through models
+        // TODO(Agnes): this performance can be improved by only fetching related data
+        // TODO: add target ids to the `where` constraint
+        const targets = await targetRepository.find({where});
+        const targetIds = this.getTargetIds(targets);
+        if (targetIds.length > 0) {
+          const targetConstraint =
+            this.getThroughConstraintFromTarget(targetIds);
+          const constraints = {...targetConstraint, ...sourceConstraint};
+          await throughRepository.deleteAll(
+            constrainDataObject({}, constraints as DataObject<ThroughEntity>),
+            options?.throughOptions,
+          );
+        }
+      } else {
+        // otherwise, delete through models that relate to the sourceId
+        const targetFkValues = this.getTargetKeys(
+          throughCategorized[targetKey],
+        );
+        // delete through instances that have the targets that are going to be deleted
+        const throughFkConstraint =
+          this.getThroughConstraintFromTarget(targetFkValues);
         await throughRepository.deleteAll(
-          constrainDataObject({}, constraints as DataObject<ThroughEntity>),
-          options?.throughOptions,
+          constrainWhereOr({}, [sourceConstraint, throughFkConstraint]),
         );
       }
-    } else {
-      // otherwise, delete through models that relate to the sourceId
-      const targetFkValues = this.getTargetKeys(throughInstances);
-      // delete through instances that have the targets that are going to be deleted
-      const throughFkConstraint =
-        this.getThroughConstraintFromTarget(targetFkValues);
-      await throughRepository.deleteAll(
-        constrainWhereOr({}, [sourceConstraint, throughFkConstraint]),
+      // delete target(s)
+      const targetConstraint = this.getTargetConstraintFromThroughModels(
+        throughCategorized[targetKey],
       );
+      totalCount +=
+        (
+          await targetRepository.deleteAll(
+            constrainWhere(where, targetConstraint as Where<TargetEntity>),
+            options,
+          )
+        )?.count ?? 0;
     }
-    // delete target(s)
-    const targetConstraint =
-      this.getTargetConstraintFromThroughModels(throughInstances);
-    return targetRepository.deleteAll(
-      constrainWhere(where, targetConstraint as Where<TargetEntity>),
-      options,
-    );
+    return {count: totalCount};
   }
+
   // only allows patch target instances for now
   async patch(
-    dataObject: DataObject<TargetEntity>,
+    dataObject:
+      | DataObject<TargetEntity>
+      | {[polymorphicType: string]: DataObject<TargetEntity>},
     where?: Where<TargetEntity>,
     options?: Options & {
-      throughOptions?: Options;
-    },
+      throughOptions?: Options & {discriminator?: string};
+    } & {isPolymorphic?: boolean},
   ): Promise<Count> {
-    const targetRepository = await this.getTargetRepository();
-    const throughRepository = await this.getThroughRepository();
+    const targetDiscriminatorOnThrough = options?.throughOptions?.discriminator;
+    const isMultipleTypes = options?.isPolymorphic;
+    let allKeys: string[];
+    if (!targetDiscriminatorOnThrough) {
+      if (Object.keys(this.getTargetRepositoryDict).length > 1) {
+        console.warn(
+          'It is highly recommended to specify the targetDiscriminatorOnThrough param when using polymorphic types.',
+        );
+      }
+    }
+    if (!isMultipleTypes) {
+      if (Object.keys(this.getTargetRepositoryDict).length > 1) {
+        console.warn(
+          'It is highly recommended to specify the isMultipleTypes param and pass in a dictionary of dataobjects when using polymorphic types.',
+        );
+      }
+      allKeys = Object.keys(this.getTargetRepositoryDict);
+    } else {
+      allKeys = [];
+      new Set(Object.keys(dataObject)).forEach(element => {
+        if (Object.keys(this.getTargetRepositoryDict).includes(element)) {
+          allKeys.push(element);
+        }
+      });
+    }
+
     const sourceConstraint = this.getThroughConstraintFromSource();
-    const throughInstances = await throughRepository.find(
-      constrainFilter(undefined, sourceConstraint),
-      options?.throughOptions,
-    );
-    const targetConstraint =
-      this.getTargetConstraintFromThroughModels(throughInstances);
-    return targetRepository.updateAll(
-      constrainDataObject(dataObject, targetConstraint),
-      constrainWhere(where, targetConstraint as Where<TargetEntity>),
-      options,
-    );
+
+    const throughCategorized: {[concreteType: string]: (ThroughEntity & {})[]} =
+      {};
+    const throughRepository = await this.getThroughRepository();
+    (
+      await throughRepository.find(
+        constrainFilter(undefined, sourceConstraint),
+        options?.throughOptions,
+      )
+    ).forEach(element => {
+      let concreteTargetType;
+      if (!targetDiscriminatorOnThrough) {
+        concreteTargetType = this.targetResolver().name;
+      } else {
+        concreteTargetType = String(
+          element[targetDiscriminatorOnThrough as StringKeyOf<ThroughEntity>],
+        );
+      }
+      if (!allKeys.includes(concreteTargetType)) {
+        return;
+      }
+      if (!this.getTargetRepositoryDict[concreteTargetType]) {
+        throw new InvalidPolymorphismError(
+          concreteTargetType,
+          targetDiscriminatorOnThrough,
+        );
+      }
+      if (!throughCategorized[concreteTargetType]) {
+        throughCategorized[concreteTargetType] = [];
+      }
+      throughCategorized[concreteTargetType].push(element);
+    });
+
+    let updatedCount = 0;
+    for (const key of Object.keys(throughCategorized)) {
+      const targetRepository = await this.getTargetRepositoryDict[key]();
+      const targetConstraint = this.getTargetConstraintFromThroughModels(
+        throughCategorized[key],
+      );
+      updatedCount +=
+        (
+          await targetRepository.updateAll(
+            constrainDataObject(
+              isMultipleTypes
+                ? (
+                    dataObject as {
+                      [polymorphicType: string]: DataObject<TargetEntity>;
+                    }
+                  )[key]
+                : (dataObject as DataObject<TargetEntity>),
+              targetConstraint,
+            ),
+            constrainWhere(where, targetConstraint as Where<TargetEntity>),
+            options,
+          )
+        )?.count ?? 0;
+    }
+
+    return {count: updatedCount};
   }
 
   async link(

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

@@ -1,4 +1,4 @@
-// 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

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

@@ -1,4 +1,4 @@
-// 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

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

@@ -1,4 +1,4 @@
-// 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

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

@@ -1,4 +1,4 @@
-// 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

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

@@ -1,4 +1,4 @@
-// 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

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

@@ -1,11 +1,11 @@
-// 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 './has-many.repository-factory';
-export * from './has-many-through.repository-factory';
 export * from './has-many-through.repository';
+export * from './has-many-through.repository-factory';
 export * from './has-many.decorator';
 export * from './has-many.inclusion-resolver';
 export * from './has-many.repository';
+export * from './has-many.repository-factory';

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

@@ -1,4 +1,4 @@
-// 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