@loopback/repository 2.6.0 → 2.10.0

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

@@ -7,6 +7,7 @@ import debugFactory from 'debug';
 import {camelCase} from 'lodash';
 import {
   DataObject,
+  deduplicate,
   Entity,
   HasManyDefinition,
   InvalidRelationError,
@@ -26,10 +27,9 @@ export type HasManyThroughResolvedDefinition = HasManyDefinition & {
 };
 
 /**
- * Creates constraint used to query target
- * @param relationMeta - hasManyThrough metadata to resolve
- * @param throughInstances - Instances of through entities used to constrain the target
- * @internal
+ * Creates target constraint based on through models
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param throughInstances - an array of through instances
  *
  * @example
  * ```ts
@@ -43,33 +43,40 @@ export type HasManyThroughResolvedDefinition = HasManyDefinition & {
  *    keyTo: 'productId',
  *  },
  * };
-
- * createTargetConstraint(resolvedMetadata, [
+ * createTargetConstraintFromThrough(resolvedMetadata,[{
+        id: 2,
+        categoryId: 2,
+        productId: 8,
+      }]);
+ * >>> {id: 8}
+ * createTargetConstraintFromThrough(resolvedMetadata, [
       {
         id: 2,
         categoryId: 2,
         productId: 8,
       }, {
-        id: 2,
+        id: 1,
         categoryId: 2,
         productId: 9,
       }
   ]);
+
+  >>> {id: {inq: [9, 8]}}
  * ```
  */
-export function createTargetConstraint<
+export function createTargetConstraintFromThrough<
   Target extends Entity,
   Through extends Entity
 >(
   relationMeta: HasManyThroughResolvedDefinition,
   throughInstances: Through[],
 ): DataObject<Target> {
-  const targetPrimaryKey = relationMeta.keyTo;
-  const targetFkName = relationMeta.through.keyTo;
-  const fkValues = throughInstances.map(
-    (throughInstance: Through) =>
-      throughInstance[targetFkName as keyof Through],
+  const fkValues = getTargetKeysFromThroughModels(
+    relationMeta,
+    throughInstances,
   );
+  const targetPrimaryKey = relationMeta.keyTo;
+
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const constraint: any = {
     [targetPrimaryKey]: fkValues.length === 1 ? fkValues[0] : {inq: fkValues},
@@ -78,11 +85,64 @@ export function createTargetConstraint<
 }
 
 /**
- * Creates constraint used to query through model
+ * Returns an array of target fks of the given throughInstances.
  *
- * @param relationMeta - hasManyThrough metadata to resolve
- * @param fkValue - Value of the foreign key of the source model used to constrain through
- * @param targetInstance - Instance of target entity used to constrain through
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param throughInstances - an array of through instances
+ *
+ * @example
+ * ```ts
+ * const resolvedMetadata = {
+ *  // .. other props
+ *  keyFrom: 'id',
+ *  keyTo: 'id',
+ *  through: {
+ *    model: () => CategoryProductLink,
+ *    keyFrom: 'categoryId',
+ *    keyTo: 'productId',
+ *  },
+ * };
+ * getTargetKeysFromThroughModels(resolvedMetadata,[{
+        id: 2,
+        categoryId: 2,
+        productId: 8,
+      }]);
+ * >>> [8]
+ * getTargetKeysFromThroughModels(resolvedMetadata, [
+      {
+        id: 2,
+        categoryId: 2,
+        productId: 8,
+      }, {
+        id: 1,
+        categoryId: 2,
+        productId: 9,
+      }
+  ]);
+  >>> [8, 9]
+ */
+export function getTargetKeysFromThroughModels<
+  Through extends Entity,
+  TargetID
+>(
+  relationMeta: HasManyThroughResolvedDefinition,
+  throughInstances: Through[],
+): TargetID[] {
+  const targetFkName = relationMeta.through.keyTo;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let fkValues: any = throughInstances.map(
+    (throughInstance: Through) =>
+      throughInstance[targetFkName as keyof Through],
+  );
+  fkValues = deduplicate(fkValues);
+  return fkValues as TargetID[];
+}
+
+/**
+ * Creates through constraint based on the source key
+ *
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param fkValue - foreign key of the source instance
  * @internal
  *
  * @example
@@ -97,12 +157,17 @@ export function createTargetConstraint<
  *    keyTo: 'productId',
  *  },
  * };
- * createThroughConstraint(resolvedMetadata, 1);
+ * createThroughConstraintFromSource(resolvedMetadata, 1);
+ *
+ * >>> {categoryId: 1}
  * ```
  */
-export function createThroughConstraint<Through extends Entity, ForeignKeyType>(
+export function createThroughConstraintFromSource<
+  Through extends Entity,
+  SourceID
+>(
   relationMeta: HasManyThroughResolvedDefinition,
-  fkValue: ForeignKeyType,
+  fkValue: SourceID,
 ): DataObject<Through> {
   const sourceFkName = relationMeta.through.keyFrom;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -110,6 +175,102 @@ export function createThroughConstraint<Through extends Entity, ForeignKeyType>(
   return constraint;
 }
 
+/**
+ * Returns an array of target ids of the given target instances.
+ *
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param targetInstances - an array of target instances
+ *
+ * @example
+ * ```ts
+ * const resolvedMetadata = {
+ *  // .. other props
+ *  keyFrom: 'id',
+ *  keyTo: 'id',
+ *  through: {
+ *    model: () => CategoryProductLink,
+ *    keyFrom: 'categoryId',
+ *    keyTo: 'productId',
+ *  },
+ * };
+ * getTargetKeysFromTargetModels(resolvedMetadata,[{
+        id: 2,
+        des: 'a target',
+      }]);
+ * >>> [2]
+ * getTargetKeysFromTargetModels(resolvedMetadata, [
+      {
+        id: 2,
+        des: 'a target',
+      }, {
+        id: 1,
+        des: 'a target',
+      }
+  ]);
+  >>> [2, 1]
+ */
+export function getTargetIdsFromTargetModels<Target extends Entity, TargetID>(
+  relationMeta: HasManyThroughResolvedDefinition,
+  targetInstances: Target[],
+): TargetID[] {
+  const targetId = relationMeta.keyTo;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let ids = [] as any;
+  ids = targetInstances.map(
+    (targetInstance: Target) => targetInstance[targetId as keyof Target],
+  );
+  ids = deduplicate(ids);
+  return ids as TargetID[];
+}
+
+/**
+ * Creates through constraint based on the target foreign key
+ *
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param fkValue an array of the target instance foreign keys
+ * @internal
+ *
+ * @example
+ * ```ts
+ * const resolvedMetadata = {
+ *  // .. other props
+ *  keyFrom: 'id',
+ *  keyTo: 'id',
+ *  through: {
+ *    model: () => CategoryProductLink,
+ *    keyFrom: 'categoryId',
+ *    keyTo: 'productId',
+ *  },
+ * };
+ * createThroughConstraintFromTarget(resolvedMetadata, [3]);
+ *
+ * >>> {productId: 3}
+ *
+ * createThroughConstraintFromTarget(resolvedMetadata, [3,4]);
+ *
+ * >>> {productId: {inq:[3,4]}}
+ */
+export function createThroughConstraintFromTarget<
+  Through extends Entity,
+  TargetID
+>(
+  relationMeta: HasManyThroughResolvedDefinition,
+  fkValues: TargetID[],
+): DataObject<Through> {
+  if (fkValues === undefined || fkValues.length === 0) {
+    throw new Error('"fkValue" must be provided');
+  }
+  const targetFkName = relationMeta.through.keyTo;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const constraint: any =
+    fkValues.length === 1
+      ? {[targetFkName]: fkValues[0]}
+      : {[targetFkName]: {inq: fkValues}};
+
+  return constraint as DataObject<Through>;
+}
+
 /**
  * Resolves given hasMany metadata if target is specified to be a resolver.
  * Mainly used to infer what the `keyTo` property should be from the target's
@@ -147,7 +308,7 @@ export function resolveHasManyThroughMetadata(
     relationMeta.keyTo &&
     targetModelProperties[relationMeta.keyTo]
   ) {
-    // The explict cast is needed because of a limitation of type inference
+    // The explicit cast is needed because of a limitation of type inference
     return relationMeta as HasManyThroughResolvedDefinition;
   }
 

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

@@ -3,7 +3,20 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Count, DataObject, Entity, Filter, Options, Where} from '../..';
+import {
+  constrainDataObject,
+  constrainFilter,
+  constrainWhere,
+  constrainWhereOr,
+  Count,
+  DataObject,
+  Entity,
+  EntityCrudRepository,
+  Filter,
+  Getter,
+  Options,
+  Where,
+} from '../..';
 
 /**
  * CRUD operations for a target repository of a HasManyThrough relation
@@ -83,7 +96,7 @@ export interface HasManyThroughRepository<
       throughData?: DataObject<Through>;
       throughOptions?: Options;
     },
-  ): Promise<Target>;
+  ): Promise<void>;
 
   /**
    * Removes an association to an existing target model instance
@@ -98,3 +111,179 @@ export interface HasManyThroughRepository<
     },
   ): Promise<void>;
 }
+
+/**
+ * a class for CRUD operations for hasManyThrough relation.
+ *
+ * Warning: The hasManyThrough interface is experimental and is subject to change.
+ * If backwards-incompatible changes are made, a new major version may not be
+ * released.
+ */
+export class DefaultHasManyThroughRepository<
+  TargetEntity extends Entity,
+  TargetID,
+  TargetRepository extends EntityCrudRepository<TargetEntity, TargetID>,
+  ThroughEntity extends Entity,
+  ThroughID,
+  ThroughRepository extends EntityCrudRepository<ThroughEntity, ThroughID>
+> implements HasManyThroughRepository<TargetEntity, TargetID, ThroughEntity> {
+  constructor(
+    public getTargetRepository: Getter<TargetRepository>,
+    public getThroughRepository: Getter<ThroughRepository>,
+    public getTargetConstraintFromThroughModels: (
+      throughInstances: ThroughEntity[],
+    ) => DataObject<TargetEntity>,
+    public getTargetKeys: (throughInstances: ThroughEntity[]) => TargetID[],
+    public getThroughConstraintFromSource: () => DataObject<ThroughEntity>,
+    public getTargetIds: (targetInstances: TargetEntity[]) => TargetID[],
+    public getThroughConstraintFromTarget: (
+      targetID: TargetID[],
+    ) => DataObject<ThroughEntity>,
+  ) {}
+
+  async create(
+    targetModelData: DataObject<TargetEntity>,
+    options?: Options & {
+      throughData?: DataObject<ThroughEntity>;
+      throughOptions?: Options;
+    },
+  ): Promise<TargetEntity> {
+    const targetRepository = await this.getTargetRepository();
+    const targetInstance = await targetRepository.create(
+      targetModelData,
+      options,
+    );
+    await this.link(targetInstance.getId(), options);
+    return targetInstance;
+  }
+
+  async find(
+    filter?: Filter<TargetEntity>,
+    options?: Options & {
+      throughOptions?: Options;
+    },
+  ): Promise<TargetEntity[]> {
+    const targetRepository = await this.getTargetRepository();
+    const throughRepository = await this.getThroughRepository();
+    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,
+    );
+  }
+
+  async delete(
+    where?: Where<TargetEntity>,
+    options?: Options & {
+      throughOptions?: Options;
+    },
+  ): Promise<Count> {
+    const targetRepository = await this.getTargetRepository();
+    const throughRepository = await this.getThroughRepository();
+    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};
+        await throughRepository.deleteAll(
+          constrainDataObject({}, constraints as DataObject<ThroughEntity>),
+          options?.throughOptions,
+        );
+      }
+    } 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(
+      throughInstances,
+    );
+    return targetRepository.deleteAll(
+      constrainWhere(where, targetConstraint as Where<TargetEntity>),
+      options,
+    );
+  }
+  // only allows patch target instances for now
+  async patch(
+    dataObject: DataObject<TargetEntity>,
+    where?: Where<TargetEntity>,
+    options?: Options & {
+      throughOptions?: Options;
+    },
+  ): Promise<Count> {
+    const targetRepository = await this.getTargetRepository();
+    const throughRepository = await this.getThroughRepository();
+    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,
+    );
+  }
+
+  async link(
+    targetId: TargetID,
+    options?: Options & {
+      throughData?: DataObject<ThroughEntity>;
+      throughOptions?: Options;
+    },
+  ): Promise<void> {
+    const throughRepository = await this.getThroughRepository();
+    const sourceConstraint = this.getThroughConstraintFromSource();
+    const targetConstraint = this.getThroughConstraintFromTarget([targetId]);
+    const constraints = {...targetConstraint, ...sourceConstraint};
+    await throughRepository.create(
+      constrainDataObject(
+        options?.throughData ?? {},
+        constraints as DataObject<ThroughEntity>,
+      ),
+      options?.throughOptions,
+    );
+  }
+
+  async unlink(
+    targetId: TargetID,
+    options?: Options & {
+      throughOptions?: Options;
+    },
+  ): Promise<void> {
+    const throughRepository = await this.getThroughRepository();
+    const sourceConstraint = this.getThroughConstraintFromSource();
+    const targetConstraint = this.getThroughConstraintFromTarget([targetId]);
+    const constraints = {...targetConstraint, ...sourceConstraint};
+    await throughRepository.deleteAll(
+      constrainDataObject({}, constraints as DataObject<ThroughEntity>),
+      options?.throughOptions,
+    );
+  }
+}

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

@@ -34,8 +34,7 @@ export function resolveHasManyMetadata(
   relationMeta = resolveHasManyMetaHelper(relationMeta);
 
   const targetModel = relationMeta.target();
-  const targetModelProperties =
-    targetModel.definition && targetModel.definition.properties;
+  const targetModelProperties = targetModel.definition?.properties;
 
   const sourceModel = relationMeta.source;
 

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

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Getter} from '@loopback/context';
+import {Getter} from '@loopback/core';
 import {Count, DataObject, Options} from '../../common-types';
 import {Entity} from '../../model';
 import {Filter, Where} from '../../query';

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

@@ -3,7 +3,9 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-export * from './has-many.decorator';
-export * from './has-many.repository';
 export * from './has-many-repository.factory';
+export * from './has-many-through-repository.factory';
+export * from './has-many-through.repository';
+export * from './has-many.decorator';
 export * from './has-many.inclusion-resolver';
+export * from './has-many.repository';

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

@@ -41,8 +41,7 @@ export function resolveHasOneMetadata(
   }
 
   const targetModel = relationMeta.target();
-  const targetModelProperties =
-    targetModel.definition && targetModel.definition.properties;
+  const targetModelProperties = targetModel.definition?.properties;
 
   const sourceModel = relationMeta.source;
   if (!sourceModel || !sourceModel.modelName) {

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

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Getter} from '@loopback/context';
+import {Getter} from '@loopback/core';
 import {Count, DataObject, Options} from '../../common-types';
 import {EntityNotFoundError} from '../../errors';
 import {Entity} from '../../model';

package/src/relations/relation.decorator.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {PropertyDecoratorFactory} from '@loopback/context';
+import {PropertyDecoratorFactory} from '@loopback/core';
 import {buildModelDefinition} from '../decorators';
 import {Model, RelationDefinitionMap} from '../model';
 import {RelationType} from './relation.types';

package/src/relations/relation.types.ts

@@ -117,7 +117,7 @@ export interface BelongsToDefinition extends RelationDefinitionBase {
   /*
    * The foreign key in the source model, e.g. Order#customerId.
    */
-  keyFrom: string;
+  keyFrom?: string;
 
   /*
    * The primary key of the target model, e.g Customer#id.
@@ -155,7 +155,7 @@ export type RelationMetadata =
   | RelationDefinitionBase;
 
 // Re-export Getter so that users don't have to import from @loopback/context
-export {Getter} from '@loopback/context';
+export {Getter} from '@loopback/core';
 
 /**
  * @returns An array of resolved values, the items must be ordered in the same

package/src/repositories/constraint-utils.ts

@@ -41,6 +41,23 @@ export function constrainWhere<T extends object>(
   const builder = new WhereBuilder<T>(where);
   return builder.impose(constraint).build();
 }
+/**
+ * A utility function which takes a where filter and enforces constraint(s)
+ * on it with OR clause
+ * @param originalWhere - the where filter to apply the constrain(s) to
+ * @param constraint - the constraint which is to be applied on the filter with
+ * or clause
+ * @returns Filter the modified filter with the constraint, otherwise
+ * the original filter
+ */
+export function constrainWhereOr<T extends object>(
+  originalWhere: Where<T> | undefined,
+  constraint: Where<T>[],
+): Where<T> {
+  const where = cloneDeep(originalWhere);
+  const builder = new WhereBuilder<T>(where);
+  return builder.or(constraint).build();
+}
 /**
  * A utility function which takes a model instance data and enforces constraint(s)
  * on it

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

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Getter} from '@loopback/context';
+import {Getter} from '@loopback/core';
 import assert from 'assert';
 import legacy from 'loopback-datasource-juggler';
 import {
@@ -29,9 +29,11 @@ import {
   BelongsToDefinition,
   createBelongsToAccessor,
   createHasManyRepositoryFactory,
+  createHasManyThroughRepositoryFactory,
   createHasOneRepositoryFactory,
   HasManyDefinition,
   HasManyRepositoryFactory,
+  HasManyThroughRepositoryFactory,
   HasOneDefinition,
   HasOneRepositoryFactory,
   includeRelatedModels,
@@ -283,6 +285,62 @@ export class DefaultCrudRepository<
     );
   }
 
+  /**
+   * Function to create a constrained hasManyThrough relation repository factory
+   *
+   * @example
+   * ```ts
+   * class CustomerRepository extends DefaultCrudRepository<
+   *   Customer,
+   *   typeof Customer.prototype.id,
+   *   CustomerRelations
+   * > {
+   *   public readonly cartItems: HasManyRepositoryFactory<CartItem, typeof Customer.prototype.id>;
+   *
+   *   constructor(
+   *     protected db: juggler.DataSource,
+   *     cartItemRepository: EntityCrudRepository<CartItem, typeof, CartItem.prototype.id>,
+   *     throughRepository: EntityCrudRepository<Through, typeof Through.prototype.id>,
+   *   ) {
+   *     super(Customer, db);
+   *     this.cartItems = this.createHasManyThroughRepositoryFactoryFor(
+   *       'cartItems',
+   *       cartItemRepository,
+   *     );
+   *   }
+   * }
+   * ```
+   *
+   * @param relationName - Name of the relation defined on the source model
+   * @param targetRepo - Target repository instance
+   * @param throughRepo - Through repository instance
+   */
+  protected createHasManyThroughRepositoryFactoryFor<
+    Target extends Entity,
+    TargetID,
+    Through extends Entity,
+    ThroughID,
+    ForeignKeyType
+  >(
+    relationName: string,
+    targetRepoGetter: Getter<EntityCrudRepository<Target, TargetID>>,
+    throughRepoGetter: Getter<EntityCrudRepository<Through, ThroughID>>,
+  ): HasManyThroughRepositoryFactory<
+    Target,
+    TargetID,
+    Through,
+    ForeignKeyType
+  > {
+    const meta = this.entityClass.definition.relations[relationName];
+    return createHasManyThroughRepositoryFactory<
+      Target,
+      TargetID,
+      Through,
+      ThroughID,
+      ForeignKeyType
+    >(meta as HasManyDefinition, targetRepoGetter, throughRepoGetter);
+  }
+
   /**
    * @deprecated
    * Function to create a belongs to accessor