test(repository-tests): add test for bi-drectional hasManyThrough relation inclusion

Signed-off-by: Roderik van Heijst <rvanheijst@0x0a.nl>

Author: 0x0aNL

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

@@ -158,6 +158,56 @@ export function hasManyThroughInclusionResolverAcceptance(
         expect(toJSON(result)).to.deepEqual(toJSON(expected));
       });
 
+      it('includes relations through a bi-directional hasManyThrough relation', async () => {
+        const link = await customerRepo.create({name: 'Link'});
+        const zelda = await customerRepo.create({name: 'Zelda'});
+        const voldemort = await customerRepo.create({name: 'Voldemort'});
+
+        const cart = await customerRepo
+          .cartItems(zelda.id)
+          .create({description: 'crown'});
+        await customerRepo.cartItems(link.id).create({description: 'shield'});
+        await customerRepo
+          .cartItems(link.id)
+          .create({description: 'green hat'});
+
+        // Cart is now shared by Link, Zelda and Voldemort
+        await customerRepo.cartItems(link.id).link(cart.id);
+        await customerRepo.cartItems(voldemort.id).link(cart.id);
+
+        // We're testing the limit and order in the inclusion of customers
+        // within the inclusion of cartItems. The order clause in combination
+        // with the limit clause should return Zelda and Voldemort in that
+        // order, excluding Link due to the limit of 2 and sort by name.
+        const result = await customerRepo.find({
+          limit: 1,
+          order: ['name DESC'],
+          include: [
+            {
+              relation: 'cartItems',
+              scope: {
+                include: [
+                  {
+                    relation: 'customers',
+                    scope: {limit: 2, order: ['name DESC']},
+                  },
+                ],
+              },
+            },
+          ],
+        });
+        const expected = [
+          {
+            ...zelda,
+            parentId: features.emptyValue,
+            cartItems: [{...cart, customers: [zelda, voldemort]}],
+          },
+        ];
+
+        expect(result.length).to.eql(1);
+        expect(toJSON(result)).to.deepEqual(toJSON(expected));
+      });
+
       it('honours field scope when returning a model', async () => {
         const link = await customerRepo.create({name: 'Link'});
         const sword = await customerRepo
@@ -185,19 +235,27 @@ export function hasManyThroughInclusionResolverAcceptance(
         expect(toJSON(result)).to.deepEqual(toJSON(expected));
       });
 
-      it('honours limit scope when returning a model', async () => {
+      it('honours limit and order scope when returning a model', async () => {
         const link = await customerRepo.create({name: 'Link'});
         await customerRepo
           .cartItems(link.id)
           .create({description: 'master sword'});
-        await customerRepo.cartItems(link.id).create({description: 'shield'});
+        const shield = await customerRepo
+          .cartItems(link.id)
+          .create({description: 'shield'});
 
         const result = await customerRepo.find({
-          include: [{relation: 'cartItems', scope: {limit: 1}}],
+          include: [
+            {
+              relation: 'cartItems',
+              scope: {limit: 1, order: ['description DESC']},
+            },
+          ],
         });
 
         expect(result.length).to.eql(1);
         expect(result[0].cartItems.length).to.eql(1);
+        expect(result[0].cartItems[0]?.id).to.eql(shield?.id);
       });
 
       it('finds models with nested inclusion', async () => {

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

@@ -8,10 +8,12 @@ import {
   BelongsToAccessor,
   Entity,
   EntityCrudRepository,
+  hasMany,
+  HasManyThroughRepositoryFactory,
   model,
   property,
 } from '@loopback/repository';
-import {Order, OrderWithRelations} from '.';
+import {Customer, CustomerCartItemLink, Order, OrderWithRelations} from '.';
 import {MixedIdType} from '../../../../helpers.repository-tests';
 
 @model()
@@ -30,15 +32,25 @@ export class CartItem extends Entity {
 
   @belongsTo(() => Order)
   orderId: MixedIdType;
+
+  @hasMany(() => Customer, {through: {model: () => CustomerCartItemLink}})
+  customers: Customer[];
 }
 
 export interface CartItemRelations {
   order?: OrderWithRelations[];
+  customers?: Customer[];
 }
 
 export type CartItemWithRelations = CartItem & CartItemRelations;
 
 export interface CartItemRepository
   extends EntityCrudRepository<CartItem, typeof CartItem.prototype.id> {
   order: BelongsToAccessor<Order, MixedIdType>;
+  customers: HasManyThroughRepositoryFactory<
+    Customer,
+    MixedIdType,
+    CustomerCartItemLink,
+    MixedIdType
+  >;
 }

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

@@ -7,11 +7,20 @@ import {
   BelongsToAccessor,
   BelongsToDefinition,
   createBelongsToAccessor,
+  createHasManyThroughRepositoryFactory,
   Getter,
+  HasManyDefinition,
+  HasManyThroughRepositoryFactory,
   juggler,
 } from '@loopback/repository';
 import {CrudRepositoryCtor} from '../../../..';
-import {CartItem, CartItemRelations, Order} from '../models';
+import {
+  CartItem,
+  CartItemRelations,
+  Customer,
+  CustomerCartItemLink,
+  Order,
+} from '../models';
 
 // create the CartItemRepo by calling this func so that it can be extended from CrudRepositoryCtor
 export function createCartItemRepo(repoClass: CrudRepositoryCtor) {
@@ -24,9 +33,19 @@ export function createCartItemRepo(repoClass: CrudRepositoryCtor) {
       Order,
       typeof CartItem.prototype.id
     >;
+
+    public readonly customers: HasManyThroughRepositoryFactory<
+      Customer,
+      typeof Customer.prototype.id,
+      CustomerCartItemLink,
+      typeof CustomerCartItemLink.prototype.id
+    >;
+
     constructor(
       db: juggler.DataSource,
       orderRepositoryGetter: Getter<typeof repoClass.prototype>,
+      customerRepositoryGetter: Getter<typeof repoClass.prototype>,
+      customerCartItemLinkRepositoryGetter: Getter<typeof repoClass.prototype>,
     ) {
       super(CartItem, db);
       const ordersMeta = this.entityClass.definition.relations['order'];
@@ -35,6 +54,13 @@ export function createCartItemRepo(repoClass: CrudRepositoryCtor) {
         orderRepositoryGetter,
         this,
       );
+
+      const customersMeta = this.entityClass.definition.relations['customers'];
+      this.customers = createHasManyThroughRepositoryFactory(
+        customersMeta as HasManyDefinition,
+        customerRepositoryGetter,
+        customerCartItemLinkRepositoryGetter,
+      );
     }
   };
 }

packages/repository-tests/src/crud/relations/helpers.ts

@@ -201,13 +201,20 @@ export function givenBoundCrudRepositories(
   const cartItemRepo: CartItemRepository = new cartItemRepoClass(
     db,
     async () => orderRepo,
+    async () => customerRepo,
+    async () => customerCartItemLinkRepo,
   );
 
   cartItemRepo.inclusionResolvers.set(
     'order',
     cartItemRepo.order.inclusionResolver,
   );
 
+  cartItemRepo.inclusionResolvers.set(
+    'customers',
+    cartItemRepo.customers.inclusionResolver,
+  );
+
   const customerCartItemLinkRepoClass =
     createCustomerCartItemLinkRepo(repositoryClass);
   const customerCartItemLinkRepo: CustomerCartItemLinkRepository =