[WIP] feat(repository): hasManyThrough

packages/repository-tests/src/crud/relations/acceptance/has-many-through.relation.acceptance.ts

@@ -0,0 +1,99 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {expect, toJSON} from '@loopback/testlab';
+import {
+  CrudFeatures,
+  CrudRepositoryCtor,
+  CrudTestContext,
+  DataSourceOptions,
+} from '../../..';
+import {
+  deleteAllModelsInDefaultDataSource,
+  MixedIdType,
+  withCrudCtx,
+} from '../../../helpers.repository-tests';
+import {
+  Customer,
+  CustomerRepository,
+  Order,
+  OrderRepository,
+  Seller,
+  SellerRepository,
+} from '../fixtures/models';
+import {givenBoundCrudRepositories} from '../helpers';
+
+export function hasManyThroughRelationAcceptance(
+  dataSourceOptions: DataSourceOptions,
+  repositoryClass: CrudRepositoryCtor,
+  features: CrudFeatures,
+) {
+  describe('HasManyThrough relation (acceptance)', () => {
+    before(deleteAllModelsInDefaultDataSource);
+    let customerRepo: CustomerRepository;
+    let orderRepo: OrderRepository;
+    let sellerRepo: SellerRepository;
+    let existingCustomerId: MixedIdType;
+
+    before(
+      withCrudCtx(async function setupRepository(ctx: CrudTestContext) {
+        ({customerRepo, orderRepo, sellerRepo} = givenBoundCrudRepositories(
+          ctx.dataSource,
+          repositoryClass,
+          features,
+        ));
+        await ctx.dataSource.automigrate([
+          Customer.name,
+          Order.name,
+          Seller.name,
+        ]);
+      }),
+    );
+
+    beforeEach(async () => {
+      await customerRepo.deleteAll();
+      await orderRepo.deleteAll();
+      await sellerRepo.deleteAll();
+    });
+
+    beforeEach(async () => {
+      existingCustomerId = (await givenPersistedCustomerInstance()).id;
+    });
+
+    it('can create related models', async () => {
+      // TODO(derdeka): creating seller though order is not the best example usecase - find alternative
+      const sellerData: Partial<Seller> = {
+        name: 'Domino’s Pizza',
+      };
+      const orderData: Partial<Order> = {
+        description: 'pizza',
+      };
+      const seller = await customerRepo
+        .sellers(existingCustomerId)
+        .create(sellerData, {
+          throughData: orderData,
+        });
+      expect(toJSON(seller)).containDeep(toJSON(sellerData));
+
+      // check target object
+      const persistedSeller = await sellerRepo.findById(seller.id);
+      expect(toJSON(persistedSeller)).containDeep(toJSON(sellerData));
+
+      // check through object
+      const persistedOrders: Order[] = await orderRepo.find({
+        where: {
+          sellerId: seller.id,
+          customerId: existingCustomerId,
+        },
+      });
+      expect(persistedOrders.length).to.eql(1);
+      expect(persistedOrders[0]).containDeep(toJSON(orderData));
+    });
+
+    async function givenPersistedCustomerInstance() {
+      return customerRepo.create({name: 'a customer'});
+    }
+  });
+}

packages/repository-tests/src/crud/relations/fixtures/models/customer.model.ts

@@ -5,19 +5,21 @@
 
 import {
   belongsTo,
+  BelongsToAccessor,
   Entity,
   EntityCrudRepository,
   hasMany,
   HasManyRepositoryFactory,
+  HasManyThroughRepositoryFactory,
   hasOne,
   HasOneRepositoryFactory,
   model,
   property,
 } from '@loopback/repository';
-import {BelongsToAccessor} from '@loopback/repository/src';
 import {MixedIdType} from '../../../../helpers.repository-tests';
 import {Address, AddressWithRelations} from './address.model';
 import {Order, OrderWithRelations} from './order.model';
+import {Seller, SellerWithRelations} from './seller.model';
 
 @model()
 export class Customer extends Entity {
@@ -36,6 +38,13 @@ export class Customer extends Entity {
   @hasMany(() => Order)
   orders: Order[];
 
+  @hasMany(() => Seller, {
+    through: {
+      model: () => Order,
+    },
+  })
+  sellers: Seller[];
+
   @hasOne(() => Address)
   address: Address;
 
@@ -49,6 +58,7 @@ export class Customer extends Entity {
 export interface CustomerRelations {
   address?: AddressWithRelations;
   orders?: OrderWithRelations[];
+  sellers?: SellerWithRelations[];
   customers?: CustomerWithRelations[];
   parentCustomer?: CustomerWithRelations;
 }
@@ -60,6 +70,12 @@ export interface CustomerRepository
   // define additional members like relation methods here
   address: HasOneRepositoryFactory<Address, MixedIdType>;
   orders: HasManyRepositoryFactory<Order, MixedIdType>;
+  sellers: HasManyThroughRepositoryFactory<
+    Seller,
+    typeof Seller.prototype.id,
+    Order,
+    typeof Customer.prototype.id
+  >;
   customers: HasManyRepositoryFactory<Customer, MixedIdType>;
   parent: BelongsToAccessor<Customer, MixedIdType>;
 }

packages/repository-tests/src/crud/relations/fixtures/models/index.ts

@@ -6,4 +6,5 @@
 export * from './address.model';
 export * from './customer.model';
 export * from './order.model';
+export * from './seller.model';
 export * from './shipment.model';

packages/repository-tests/src/crud/relations/fixtures/models/order.model.ts

@@ -13,6 +13,7 @@ import {
 } from '@loopback/repository';
 import {MixedIdType} from '../../../../helpers.repository-tests';
 import {Customer, CustomerWithRelations} from './customer.model';
+import {Seller} from './seller.model';
 import {Shipment, ShipmentWithRelations} from './shipment.model';
 
 @model()
@@ -39,6 +40,9 @@ export class Order extends Entity {
   @belongsTo(() => Customer)
   customerId: MixedIdType;
 
+  @belongsTo(() => Seller)
+  sellerId: MixedIdType;
+
   @belongsTo(() => Shipment, {keyTo: 'shipment_id', name: 'shipment'})
   shipmentInfo: number;
 }

packages/repository-tests/src/crud/relations/fixtures/models/seller.model.ts

@@ -0,0 +1,54 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  Entity,
+  EntityCrudRepository,
+  hasMany,
+  HasManyThroughRepositoryFactory,
+  model,
+  property,
+} from '@loopback/repository';
+import {Customer, CustomerWithRelations} from './customer.model';
+import {Order} from './order.model';
+
+@model()
+export class Seller extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+  })
+  id: number;
+
+  @property({
+    type: 'string',
+    required: true,
+  })
+  name: string;
+
+  @hasMany(() => Customer, {
+    through: {
+      model: () => Order,
+    },
+  })
+  customers?: Customer[];
+}
+
+export interface SellerRelations {
+  customers?: CustomerWithRelations;
+}
+
+export type SellerWithRelations = Seller & SellerRelations;
+
+export interface SellerRepository
+  extends EntityCrudRepository<Seller, typeof Seller.prototype.id> {
+  // define additional members like relation methods here
+  customers: HasManyThroughRepositoryFactory<
+    Customer,
+    typeof Customer.prototype.id,
+    Order,
+    typeof Seller.prototype.id
+  >;
+}

packages/repository-tests/src/crud/relations/fixtures/repositories/customer.repository.ts

@@ -6,18 +6,21 @@
 import {Getter} from '@loopback/context';
 import {
   BelongsToAccessor,
-  HasManyRepositoryFactory,
-  HasOneRepositoryFactory,
-  juggler,
+  BelongsToDefinition,
+  createBelongsToAccessor,
   createHasManyRepositoryFactory,
+  createHasManyThroughRepositoryFactory,
+  createHasOneRepositoryFactory,
   HasManyDefinition,
+  HasManyRepositoryFactory,
+  HasManyThroughDefinition,
+  HasManyThroughRepositoryFactory,
   HasOneDefinition,
-  createBelongsToAccessor,
-  BelongsToDefinition,
-  createHasOneRepositoryFactory,
+  HasOneRepositoryFactory,
+  juggler,
 } from '@loopback/repository';
-import {Address, Customer, CustomerRelations, Order} from '../models';
 import {CrudRepositoryCtor} from '../../../../types.repository-tests';
+import {Address, Customer, CustomerRelations, Order, Seller} from '../models';
 
 // create the CustomerRepo by calling this func so that it can be extended from CrudRepositoryCtor
 export function createCustomerRepo(repoClass: CrudRepositoryCtor) {
@@ -30,6 +33,12 @@ export function createCustomerRepo(repoClass: CrudRepositoryCtor) {
       Order,
       typeof Customer.prototype.id
     >;
+    public readonly sellers: HasManyThroughRepositoryFactory<
+      Seller,
+      typeof Seller.prototype.id,
+      Order,
+      typeof Customer.prototype.id
+    >;
     public readonly address: HasOneRepositoryFactory<
       Address,
       typeof Customer.prototype.id
@@ -47,6 +56,7 @@ export function createCustomerRepo(repoClass: CrudRepositoryCtor) {
       db: juggler.DataSource,
       orderRepositoryGetter: Getter<typeof repoClass.prototype>,
       addressRepositoryGetter: Getter<typeof repoClass.prototype>,
+      sellersRepositoryGetter: Getter<typeof repoClass.prototype>,
     ) {
       super(Customer, db);
       const ordersMeta = this.entityClass.definition.relations['orders'];
@@ -56,6 +66,13 @@ export function createCustomerRepo(repoClass: CrudRepositoryCtor) {
         orderRepositoryGetter,
       );
 
+      const sellersMeta = this.entityClass.definition.relations['sellers'];
+      this.sellers = createHasManyThroughRepositoryFactory(
+        sellersMeta as HasManyThroughDefinition,
+        sellersRepositoryGetter,
+        orderRepositoryGetter,
+      );
+
       const addressMeta = this.entityClass.definition.relations['address'];
       this.address = createHasOneRepositoryFactory(
         addressMeta as HasOneDefinition,

packages/repository-tests/src/crud/relations/fixtures/repositories/index.ts

@@ -6,4 +6,5 @@
 export * from './address.repository';
 export * from './customer.repository';
 export * from './order.repository';
+export * from './seller.repository';
 export * from './shipment.repository';

packages/repository-tests/src/crud/relations/fixtures/repositories/seller.repository.ts

@@ -0,0 +1,44 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/repository-tests
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Getter} from '@loopback/context';
+import {
+  createHasManyThroughRepositoryFactory,
+  HasManyThroughDefinition,
+  HasManyThroughRepositoryFactory,
+  juggler,
+} from '@loopback/repository';
+import {CrudRepositoryCtor} from '../../../../types.repository-tests';
+import {Customer, Order, Seller, SellerRelations} from '../models';
+
+// create the SellerRepo by calling this func so that it can be extended from CrudRepositoryCtor
+export function createSellerRepo(repoClass: CrudRepositoryCtor) {
+  return class SellerRepository extends repoClass<
+    Seller,
+    typeof Seller.prototype.id,
+    SellerRelations
+  > {
+    public readonly customers: HasManyThroughRepositoryFactory<
+      Customer,
+      typeof Customer.prototype.id,
+      Order,
+      typeof Seller.prototype.id
+    >;
+
+    constructor(
+      db: juggler.DataSource,
+      customerRepositoryGetter: Getter<typeof repoClass.prototype>,
+      orderRepositoryGetter: Getter<typeof repoClass.prototype>,
+    ) {
+      super(Seller, db);
+      const customersMeta = this.entityClass.definition.relations['customers'];
+      this.customers = createHasManyThroughRepositoryFactory(
+        customersMeta as HasManyThroughDefinition,
+        customerRepositoryGetter,
+        orderRepositoryGetter,
+      );
+    }
+  };
+}