@loopback/repository 4.1.1 → 5.0.1

package/src/relations/has-one/has-one.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
@@ -18,6 +18,7 @@ const debug = debugFactory('loopback:repository:relations:has-one:helpers');
 export type HasOneResolvedDefinition = HasOneDefinition & {
   keyFrom: string;
   keyTo: string;
+  polymorphic: false | {discriminator: string};
 };
 
 /**
@@ -60,25 +61,51 @@ export function resolveHasOneMetadata(
     keyFrom = sourceModel.getIdProperties()[0];
   }
 
+  let keyTo;
   // Make sure that if it already keys to the foreign key property,
   // the key exists in the target model
   if (relationMeta.keyTo && targetModelProperties[relationMeta.keyTo]) {
     // The explicit cast is needed because of a limitation of type inference
-    return Object.assign(relationMeta, {keyFrom}) as HasOneResolvedDefinition;
-  }
+    keyTo = relationMeta.keyTo;
+  } else {
+    debug(
+      'Resolved model %s from given metadata: %o',
+      targetModel.modelName,
+      targetModel,
+    );
+    keyTo = camelCase(sourceModel.modelName + '_id');
+    const hasDefaultFkProperty = targetModelProperties[keyTo];
 
-  debug(
-    'Resolved model %s from given metadata: %o',
-    targetModel.modelName,
-    targetModel,
-  );
-  const defaultFkName = camelCase(sourceModel.modelName + '_id');
-  const hasDefaultFkProperty = targetModelProperties[defaultFkName];
+    if (!hasDefaultFkProperty) {
+      const reason = `target model ${targetModel.name} is missing definition of foreign key ${keyTo}`;
+      throw new InvalidRelationError(reason, relationMeta);
+    }
+  }
 
-  if (!hasDefaultFkProperty) {
-    const reason = `target model ${targetModel.name} is missing definition of foreign key ${defaultFkName}`;
-    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: defaultFkName});
+  return Object.assign(relationMeta, {
+    keyFrom: keyFrom,
+    keyTo: keyTo,
+    polymorphic: polymorphic,
+  });
 }

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

@@ -1,9 +1,11 @@
-// 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 {cloneDeep} from 'lodash';
+import {includeFieldIfNot, InvalidPolymorphismError} from '../../';
 import {AnyObject, Options} from '../../common-types';
 import {Entity} from '../../model';
 import {EntityCrudRepository} from '../../repositories';
@@ -22,18 +24,22 @@ import {resolveHasOneMetadata} from './has-one.helpers';
  *
  * Notice: scope field for inclusion is not supported yet.
  *
- * @param meta
- * @param getTargetRepo
+ * @param meta - resolved HasOneMetadata
+ * @param getTargetRepoDict - dictionary of target model type - target repository
+ * i.e where related instances for different types are
  */
+
 export function createHasOneInclusionResolver<
   Target extends Entity,
   TargetID,
   TargetRelations extends object,
 >(
   meta: HasOneDefinition,
-  getTargetRepo: Getter<
-    EntityCrudRepository<Target, TargetID, TargetRelations>
-  >,
+  getTargetRepoDict: {
+    [repoType: string]: Getter<
+      EntityCrudRepository<Target, TargetID, TargetRelations>
+    >;
+  },
 ): InclusionResolver<Entity, Target> {
   const relationMeta = resolveHasOneMetadata(meta);
 
@@ -44,22 +50,110 @@ export function createHasOneInclusionResolver<
   ): Promise<((Target & TargetRelations) | 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 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,
-      sourceIds,
-      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,
+        sourceIdsCategorized[k],
+        scope,
+        Object.assign(cloneDeep(options ?? {}), {polymorphicType: k}),
+      );
+      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/has-one/has-one.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
@@ -36,10 +36,14 @@ export interface HasOneRepositoryFactory<
  * via a HasOne relation, then, the relational repository returned by the
  * factory function would be constrained by a Customer model instance's id(s).
  *
+ * If the target model is polymorphic, i.e. stored within different repositories,
+ * supply the targetRepositoryGetter with a dictionary in the form of {[typeName: string]: repositoryGetter}
+ *
  * @param relationMetadata - The relation metadata used to describe the
  * relationship and determine how to apply the constraint.
- * @param targetRepositoryGetter - The repository which represents the target model of a
- * relation attached to a datasource.
+ * @param targetRepositoryGetter - The repository or a dictionary of classname - repository,
+ * which represents the target model of a relation attached to a datasource.
+ * For the dictionary, the key is the class name of the concrete class the the polymorphic model.
  * @returns The factory function which accepts a foreign key value to constrain
  * the given target repository
  */
@@ -49,9 +53,21 @@ export function createHasOneRepositoryFactory<
   ForeignKeyType,
 >(
   relationMetadata: HasOneDefinition,
-  targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetID>>,
+  targetRepositoryGetter:
+    | Getter<EntityCrudRepository<Target, TargetID>>
+    | {
+        [repoType: string]: Getter<EntityCrudRepository<Target, TargetID>>;
+      },
 ): HasOneRepositoryFactory<Target, ForeignKeyType> {
   const meta = resolveHasOneMetadata(relationMetadata);
+  // resolve the repositoryGetter into a dictionary
+  if (typeof targetRepositoryGetter === 'function') {
+    targetRepositoryGetter = {
+      [meta.target().name]: targetRepositoryGetter as Getter<
+        EntityCrudRepository<Target, TargetID>
+      >,
+    };
+  }
   debug('Resolved HasOne relation metadata: %o', meta);
   const result: HasOneRepositoryFactory<Target, ForeignKeyType> = function (
     fkValue: ForeignKeyType,
@@ -62,11 +78,23 @@ export function createHasOneRepositoryFactory<
       Target,
       TargetID,
       EntityCrudRepository<Target, TargetID>
-    >(targetRepositoryGetter, constraint as DataObject<Target>);
+    >(
+      targetRepositoryGetter as {
+        [repoType: string]: Getter<EntityCrudRepository<Target, TargetID>>;
+      },
+      constraint as DataObject<Target>,
+      relationMetadata.target,
+    );
   };
-  result.inclusionResolver = createHasOneInclusionResolver(
+  result.inclusionResolver = createHasOneInclusionResolver<
+    Target,
+    TargetID,
+    object
+  >(
     meta,
-    targetRepositoryGetter,
+    targetRepositoryGetter as {
+      [repoType: string]: Getter<EntityCrudRepository<Target, TargetID>>;
+    },
   );
   return result;
 }

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

@@ -1,12 +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 {Filter} from '@loopback/filter';
+import {cloneDeep} from 'lodash';
+import {TypeResolver} from '../../';
 import {Count, DataObject, Options} from '../../common-types';
-import {EntityNotFoundError} from '../../errors';
+import {EntityNotFoundError, InvalidPolymorphismError} from '../../errors';
 import {Entity} from '../../model';
 import {
   constrainDataObject,
@@ -23,39 +25,58 @@ export interface HasOneRepository<Target extends Entity> {
    * Create a target model instance
    * @param targetModelData - The target model data
    * @param options - Options for the operation
+   * options.polymorphicType - If polymorphic target model,
+   * specify of which concrete model the created instance should be
    * @returns A promise which resolves to the newly created target model instance
    */
   create(
     targetModelData: DataObject<Target>,
-    options?: Options,
+    options?: Options & {polymorphicType?: string},
   ): Promise<Target>;
 
   /**
    * Find the only target model instance that belongs to the declaring model.
    * @param filter - Query filter without a Where condition
    * @param options - Options for the operations
+   * 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(
     filter?: Pick<Filter<Target>, Exclude<keyof Filter<Target>, 'where'>>,
-    options?: Options,
+    options?: Options & {polymorphicType?: string | string[]},
   ): Promise<Target>;
 
   /**
    * Delete the related 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 which resolves the deleted target model instances
    */
-  delete(options?: Options): Promise<Count>;
+  delete(
+    options?: Options & {polymorphicType?: string | string[]},
+  ): Promise<Count>;
 
   /**
    * Patch the  related target model instance
    * @param dataObject - The target model fields and their new values to patch
+   * If the target models are of different types, this should be a dictionary
    * @param options
+   * options.isPolymorphic - whether dataObject is a dictionary
    * @returns A promise which resolves the patched target model instances
    */
-  patch(dataObject: DataObject<Target>, options?: Options): Promise<Count>;
+  patch(
+    dataObject:
+      | DataObject<Target>
+      | {[polymorphicType: string]: DataObject<Target>},
+    options?: Options & {isPolymorphic?: boolean},
+  ): Promise<Count>;
 }
 
 export class DefaultHasOneRepository<
@@ -66,20 +87,65 @@ export class DefaultHasOneRepository<
 {
   /**
    * Constructor of DefaultHasOneEntityCrudRepository
-   * @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 create(
     targetModelData: DataObject<TargetEntity>,
-    options?: Options,
+    options?: Options & {polymorphicType?: string},
   ): Promise<TargetEntity> {
-    const targetRepository = await this.getTargetRepository();
+    let polymorphicTypeName = options?.polymorphicType;
+    if (polymorphicTypeName) {
+      if (!this.getTargetRepositoryDict[polymorphicTypeName]) {
+        throw new InvalidPolymorphismError(polymorphicTypeName);
+      }
+    } else {
+      if (Object.keys(this.getTargetRepositoryDict).length > 1) {
+        console.warn(
+          'It is highly recommended to specify the polymorphicType param when using polymorphic types.',
+        );
+      }
+      polymorphicTypeName = this.targetResolver().name;
+      if (!this.getTargetRepositoryDict[polymorphicTypeName]) {
+        throw new InvalidPolymorphismError(polymorphicTypeName);
+      }
+    }
+    const targetRepository = await this.getTargetRepositoryDict[
+      polymorphicTypeName
+    ]();
     return targetRepository.create(
       constrainDataObject(targetModelData, this.constraint),
       options,
@@ -91,37 +157,124 @@ export class DefaultHasOneRepository<
       Filter<TargetEntity>,
       Exclude<keyof Filter<TargetEntity>, 'where'>
     >,
-    options?: Options,
+    options?: Options & {polymorphicType?: string | string[]},
   ): Promise<TargetEntity> {
-    const targetRepository = await this.getTargetRepository();
-    const found = await targetRepository.find(
-      Object.assign({limit: 1}, constrainFilter(filter, this.constraint)),
-      options,
-    );
-    if (found.length < 1) {
-      // We don't have a direct access to the foreign key value here :(
-      const id = 'constraint ' + JSON.stringify(this.constraint);
-      throw new EntityNotFoundError(targetRepository.entityClass, id);
+    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 polymorphicType 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);
+        }
+      });
     }
-    return found[0];
+    for (const key of allKeys) {
+      const targetRepository = await this.getTargetRepositoryDict[key]();
+      const found = await targetRepository.find(
+        Object.assign({limit: 1}, constrainFilter(filter, this.constraint)),
+        Object.assign(cloneDeep(options ?? {}), {polymorphicType: key}),
+      );
+      if (found.length >= 1) {
+        return found[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);
   }
-  async delete(options?: Options): Promise<Count> {
-    const targetRepository = await this.getTargetRepository();
-    return targetRepository.deleteAll(
-      constrainWhere({}, this.constraint),
-      options,
-    );
+
+  async delete(
+    options?: Options & {polymorphicType?: string | string[]},
+  ): Promise<Count> {
+    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 polymorphicType 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 total = 0;
+    for (const key of allKeys) {
+      const targetRepository = await this.getTargetRepositoryDict[key]();
+      total +=
+        (
+          await targetRepository.deleteAll(
+            constrainWhere({}, this.constraint),
+            options,
+          )
+        )?.count ?? 0;
+    }
+    return {count: total};
   }
 
   async patch(
-    dataObject: DataObject<TargetEntity>,
-    options?: Options,
+    dataObject:
+      | DataObject<TargetEntity>
+      | {[polymorphicType: string]: DataObject<TargetEntity>},
+    options?: Options & {isPolymorphic?: boolean},
   ): Promise<Count> {
-    const targetRepository = await this.getTargetRepository();
-    return targetRepository.updateAll(
-      constrainDataObject(dataObject, this.constraint),
-      constrainWhere({}, this.constraint),
-      options,
-    );
+    const isMultipleTypes = options?.isPolymorphic;
+    let allKeys: string[];
+    if (!isMultipleTypes) {
+      if (Object.keys(this.getTargetRepositoryDict).length > 1) {
+        console.warn(
+          'It is highly recommended to specify the isPolymorphic 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);
+        }
+      });
+    }
+    let total = 0;
+    for (const key of allKeys) {
+      const targetRepository = await this.getTargetRepositoryDict[key]();
+      total +=
+        (
+          await targetRepository.updateAll(
+            constrainDataObject(
+              isMultipleTypes
+                ? (
+                    dataObject as {
+                      [polymorphicType: string]: DataObject<TargetEntity>;
+                    }
+                  )[key]
+                : (dataObject as DataObject<TargetEntity>),
+              this.constraint,
+            ),
+            constrainWhere({}, this.constraint),
+            options,
+          )
+        )?.count ?? 0;
+    }
+    return {count: total};
   }
 }

package/src/relations/has-one/index.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/index.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
@@ -6,6 +6,8 @@
 export * from './belongs-to';
 export * from './has-many';
 export * from './has-one';
+export * from './references-many';
 export * from './relation.decorator';
+export * from './relation.filter.solver';
 export * from './relation.helpers';
 export * from './relation.types';

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

@@ -0,0 +1,9 @@
+// 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 './references-many.accessor';
+export * from './references-many.decorator';
+export * from './references-many.inclusion-resolver';
+export * from './references-many.repository';