feat: add crud relation methods

Author: jannyHou

packages/repository/src/repositories/constraint-utils.ts

@@ -55,6 +55,8 @@ export function constrainDataObject<T extends Entity>(
 ): DataObject<T> {
   const constrainedData = cloneDeep(originalData);
   for (const c in constraint) {
+    if (constrainedData.hasOwnProperty(c))
+      throw new Error(`Property "${c}" cannot be changed!`);
     constrainedData[c] = constraint[c];
   }
   return constrainedData;

packages/repository/src/repositories/relation.repository.ts

@@ -4,10 +4,14 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {EntityCrudRepository} from './repository';
-import {constrainDataObject, constrainFilter} from './constraint-utils';
-import {AnyObject, Options} from '../common-types';
+import {
+  constrainDataObject,
+  constrainFilter,
+  constrainWhere,
+} from './constraint-utils';
+import {DataObject, AnyObject, Options} from '../common-types';
 import {Entity} from '../model';
-import {Filter} from '../query';
+import {Filter, Where} from '../query';
 
 /**
  * CRUD operations for a target repository of a HasMany relation
@@ -26,7 +30,26 @@ export interface HasManyEntityCrudRepository<T extends Entity> {
    * @param options Options for the operation
    * @returns A promise which resolves with the found target instance(s)
    */
-  find(filter?: Filter | undefined, options?: Options): Promise<T[]>;
+  find(filter?: Filter, options?: Options): Promise<T[]>;
+  /**
+   * Delete multiple target model instances
+   * @param where Instances within the where scope are deleted
+   * @param options
+   * @returns A promise which resolves the deleted target model instances
+   */
+  delete(where?: Where, options?: Options): Promise<number>;
+  /**
+   * Patch multiple target model instances
+   * @param dataObject The fields and their new values to patch
+   * @param where Instances within the where scope are patched
+   * @param options
+   * @returns A promise which resolves the patched target model instances
+   */
+  patch(
+    dataObject: DataObject<T>,
+    where?: Where,
+    options?: Options,
+  ): Promise<number>;
 }
 
 export class DefaultHasManyEntityCrudRepository<
@@ -51,10 +74,29 @@ export class DefaultHasManyEntityCrudRepository<
     );
   }
 
-  async find(filter?: Filter | undefined, options?: Options): Promise<T[]> {
+  async find(filter?: Filter, options?: Options): Promise<T[]> {
     return await this.targetRepository.find(
       constrainFilter(filter, this.constraint),
       options,
     );
   }
+
+  async delete(where?: Where, options?: Options): Promise<number> {
+    return await this.targetRepository.deleteAll(
+      constrainWhere(where, this.constraint),
+      options,
+    );
+  }
+
+  async patch(
+    dataObject: Partial<T>,
+    where?: Where,
+    options?: Options,
+  ): Promise<number> {
+    return await this.targetRepository.updateAll(
+      constrainDataObject(dataObject, this.constraint),
+      constrainWhere(where, this.constraint),
+      options,
+    );
+  }
 }

packages/repository/test/acceptance/has-many.relation.acceptance.ts

@@ -13,8 +13,10 @@ import {
   hasManyRepositoryFactory,
   HasManyDefinition,
   RelationType,
+  HasManyEntityCrudRepository,
 } from '../..';
 import {expect} from '@loopback/testlab';
+import * as _ from 'lodash';
 
 describe('HasMany relation', () => {
   // Given a Customer and Order models - see definitions at the bottom
@@ -24,32 +26,27 @@ describe('HasMany relation', () => {
   let existingCustomerId: number;
   //FIXME: this should be inferred from relational decorators
   let customerHasManyOrdersRelationMeta: HasManyDefinition;
+  let customerOrders: HasManyEntityCrudRepository<Order>;
 
   beforeEach(async () => {
     existingCustomerId = (await givenPersistedCustomerInstance()).id;
     customerHasManyOrdersRelationMeta = givenHasManyRelationMetadata();
+    // Ideally, we would like to write
+    // customerRepo.orders.create(customerId, orderData);
+    // or customerRepo.orders({id: customerId}).*
+    // The initial "involved" implementation is below
+
+    //FIXME: should be automagically instantiated via DI or other means
+    customerOrders = hasManyRepositoryFactory(
+      existingCustomerId,
+      customerHasManyOrdersRelationMeta,
+      orderRepo,
+    );
   });
 
   it('can create an instance of the related model', async () => {
-    // A controller method - CustomerOrdersController.create()
-    // customerRepo and orderRepo would be injected via constructor arguments
-    async function create(customerId: number, orderData: Partial<Order>) {
-      // Ideally, we would like to write
-      // customerRepo.orders.create(customerId, orderData);
-      // or customerRepo.orders({id: customerId}).*
-      // The initial "involved" implementation is below
-
-      //FIXME: should be automagically instantiated via DI or other means
-      const customerOrders = hasManyRepositoryFactory(
-        customerId,
-        customerHasManyOrdersRelationMeta,
-        orderRepo,
-      );
-      return await customerOrders.create(orderData);
-    }
-
     const description = 'an order desc';
-    const order = await create(existingCustomerId, {description});
+    const order = await customerOrders.create({description});
 
     expect(order.toObject()).to.containDeep({
       customerId: existingCustomerId,
@@ -59,6 +56,59 @@ describe('HasMany relation', () => {
     expect(persisted.toObject()).to.deepEqual(order.toObject());
   });
 
+  it('can patch many instances', async () => {
+    await givenCustomerOrder({description: 'order 1', isDelivered: false});
+    await givenCustomerOrder({description: 'order 2', isDelivered: false});
+    const patchObject = {isDelivered: true};
+    const arePatched = await customerOrders.patch(patchObject);
+    expect(arePatched).to.equal(2);
+    const patchedData = _.map(await customerOrders.find(), d =>
+      _.pick(d, ['customerId', 'description', 'isDelivered']),
+    );
+    expect(patchedData).to.eql([
+      {
+        customerId: existingCustomerId,
+        description: 'order 1',
+        isDelivered: true,
+      },
+      {
+        customerId: existingCustomerId,
+        description: 'order 2',
+        isDelivered: true,
+      },
+    ]);
+  });
+
+  it('throws error when query tries to change the foreignKey', async () => {
+    await expect(
+      customerOrders.patch({customerId: existingCustomerId + 1}),
+    ).to.be.rejectedWith(/Property "customerId" cannot be changed!/);
+  });
+
+  it('can delete many instances', async () => {
+    await givenCustomerOrder({description: 'order 1'});
+    await givenCustomerOrder({description: 'order 2'});
+    const deletedOrders = await customerOrders.delete();
+    expect(deletedOrders).to.equal(2);
+    const relatedOrders = await customerOrders.find();
+    expect(relatedOrders).to.be.empty();
+  });
+
+  it("does not delete instances that don't belong to the constrained instance", async () => {
+    const newOrder = {
+      customerId: existingCustomerId + 1,
+      description: 'another order',
+    };
+    await orderRepo.create(newOrder);
+    await customerOrders.delete();
+    const orders = await orderRepo.find();
+    expect(orders).to.have.length(1);
+    expect(_.pick(orders[0], ['customerId', 'description'])).to.eql(newOrder);
+  });
+
+  async function givenCustomerOrder(dataObject: Partial<Order>) {
+    await customerOrders.create(dataObject);
+  }
   // This should be enforced by the database to avoid race conditions
   it.skip('reject create request when the customer does not exist');
 
@@ -92,6 +142,12 @@ describe('HasMany relation', () => {
     })
     description: string;
 
+    @property({
+      type: 'boolean',
+      required: false,
+    })
+    isDelivered: boolean;
+
     @property({
       type: 'number',
       required: true,

packages/repository/test/unit/repositories/constraint-utils.unit.ts

@@ -76,14 +76,24 @@ describe('constraint utility functions', () => {
   });
 
   context('constrainDataObject', () => {
-    it('constrain a single data object', () => {
+    it('constrains a single data object', () => {
+      const input = new Order({description: 'order 1'});
+      const constraint: Partial<Order> = {id: 2};
+      expect(constrainDataObject(input, constraint)).to.containDeep({
+        description: 'order 1',
+        id: 2,
+      });
+    });
+
+    it('throws error when the query changes field in constrain', () => {
       const input = new Order({id: 1, description: 'order 1'});
       const constraint: Partial<Order> = {id: 2};
-      const result = constrainDataObject(input, constraint);
-      expect(result).to.containDeep(Object.assign({}, input, constraint));
+      expect(() => {
+        constrainDataObject(input, constraint);
+      }).to.throwError(/Property "id" cannot be changed!/);
     });
 
-    it('constrain array of data objects', () => {
+    it('constrains array of data objects', () => {
       const input = [
         new Order({id: 1, description: 'order 1'}),
         new Order({id: 2, description: 'order 2'}),

packages/repository/test/unit/repositories/relation.repository.unit.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {sinon} from '@loopback/testlab';
+import {sinon, expect} from '@loopback/testlab';
 import {
   EntityCrudRepository,
   HasManyEntityCrudRepository,
@@ -13,6 +13,9 @@ import {
   Entity,
   AnyObject,
   Filter,
+  Options,
+  DataObject,
+  Where,
 } from '../../..';
 
 describe('relation repository', () => {
@@ -34,12 +37,26 @@ describe('relation repository', () => {
         targetModelData: Partial<T>,
         options?: AnyObject | undefined,
       ): Promise<T> {
+        /* istanbul ignore next */
         throw new Error('Method not implemented.');
       }
       find(
         filter?: Filter | undefined,
         options?: AnyObject | undefined,
       ): Promise<T[]> {
+        /* istanbul ignore next */
+        throw new Error('Method not implemented.');
+      }
+      async delete(where?: Where, options?: Options): Promise<number> {
+        /* istanbul ignore next */
+        throw new Error('Method not implemented.');
+      }
+      async patch(
+        dataObject: DataObject<T>,
+        where?: Where,
+        options?: Options,
+      ): Promise<number> {
+        /* istanbul ignore next */
         throw new Error('Method not implemented.');
       }
     }
@@ -61,6 +78,36 @@ describe('relation repository', () => {
       const findStub = repo.find as sinon.SinonStub;
       sinon.assert.calledWithMatch(findStub, {where: {id: 3, name: 'Jane'}});
     });
+
+    context('patch', async () => {
+      it('can patch related model instance', async () => {
+        const constraint: Partial<Customer> = {name: 'Jane'};
+        const HasManyCrudInstance = givenDefaultHasManyCrudInstance(constraint);
+        await HasManyCrudInstance.patch({country: 'US'}, {id: 3});
+        const patchStub = repo.updateAll as sinon.SinonStub;
+        sinon.assert.calledWith(
+          patchStub,
+          {country: 'US', name: 'Jane'},
+          {id: 3, name: 'Jane'},
+        );
+      });
+
+      it('cannot override the constrain data', async () => {
+        const constraint: Partial<Customer> = {name: 'Jane'};
+        const HasManyCrudInstance = givenDefaultHasManyCrudInstance(constraint);
+        await expect(
+          HasManyCrudInstance.patch({name: 'Joe'}),
+        ).to.be.rejectedWith(/Property "name" cannot be changed!/);
+      });
+    });
+
+    it('can delete related model instance', async () => {
+      const constraint: Partial<Customer> = {name: 'Jane'};
+      const HasManyCrudInstance = givenDefaultHasManyCrudInstance(constraint);
+      await HasManyCrudInstance.delete({id: 3});
+      const deleteStub = repo.deleteAll as sinon.SinonStub;
+      sinon.assert.calledWith(deleteStub, {id: 3, name: 'Jane'});
+    });
   });
 
   /*------------- HELPERS ---------------*/