@loopback/repository-tests 0.20.2 → 0.21.0

package/src/crud/relations/acceptance/has-one.relation.polymorphic.acceptance.ts

@@ -0,0 +1,328 @@
+// Copyright IBM Corp. 2019,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 {DataObject, EntityNotFoundError} from '@loopback/repository';
+import {expect, toJSON} from '@loopback/testlab';
+import {
+  CrudFeatures,
+  CrudRepositoryCtor,
+  CrudTestContext,
+  DataSourceOptions,
+} from '../../..';
+import {
+  deleteAllModelsInDefaultDataSource,
+  MixedIdType,
+  withCrudCtx,
+} from '../../../helpers.repository-tests';
+import {
+  Cash,
+  CashRepository,
+  CreditCard,
+  CreditCardRepository,
+  Customer,
+  CustomerRepository,
+  PaymentMethod,
+} from '../fixtures/models';
+import {givenBoundCrudRepositories} from '../helpers';
+
+export function hasOneRelationPolymorphicAcceptance(
+  dataSourceOptions: DataSourceOptions,
+  repositoryClass: CrudRepositoryCtor,
+  features: CrudFeatures,
+) {
+  describe('hasOne relation polymorphic (acceptance)', () => {
+    let customerRepo: CustomerRepository;
+    let creditCardRepo: CreditCardRepository;
+    let cashRepo: CashRepository;
+    let existingCustomerId: MixedIdType;
+
+    before(deleteAllModelsInDefaultDataSource);
+
+    before(
+      withCrudCtx(async function setupRepository(ctx: CrudTestContext) {
+        ({customerRepo, creditCardRepo, cashRepo} = givenBoundCrudRepositories(
+          ctx.dataSource,
+          repositoryClass,
+          features,
+        ));
+        const models = [Customer, CreditCard, Cash];
+        await ctx.dataSource.automigrate(models.map(m => m.name));
+      }),
+    );
+
+    beforeEach(async () => {
+      await customerRepo.deleteAll();
+      await creditCardRepo.deleteAll();
+      await cashRepo.deleteAll();
+      existingCustomerId = (await givenPersistedCustomerInstance()).id;
+    });
+
+    it('can create an instance of the related model', async () => {
+      const address = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      expect(toJSON(address)).to.containDeep(
+        toJSON({
+          customerId: existingCustomerId,
+        }),
+      );
+
+      const persisted = await creditCardRepo.findById(address.id);
+      expect(toJSON(persisted)).to.deepEqual(
+        toJSON({
+          ...address,
+          zipcode: features.emptyValue,
+          city: features.emptyValue,
+          province: features.emptyValue,
+        }),
+      );
+    });
+
+    // We do not enforce referential integrity at the moment. It is up to
+    // our users to set up unique constraint(s) between related models at the
+    // database level
+    it.skip('refuses to create related model instance twice', async () => {
+      const creditCard = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      await expect(
+        createCustomerPaymentMethod(existingCustomerId, {}, 'Cash'),
+      ).to.be.rejectedWith(/Duplicate entry for PaymentMethod.customerId/);
+      expect(creditCard.toObject()).to.containDeep({
+        customerId: existingCustomerId,
+      });
+
+      const persisted = await creditCardRepo.findById(creditCard.id);
+      expect(persisted.toObject()).to.deepEqual(creditCard.toObject());
+    });
+
+    it('can find instance of the related model', async () => {
+      const creditCard = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      const foundCreditCard = await findCustomerPaymentMethod(
+        existingCustomerId,
+        'CreditCard',
+      );
+      expect(toJSON(foundCreditCard)).to.containEql(toJSON(creditCard));
+      expect(toJSON(foundCreditCard)).to.deepEqual(
+        toJSON({
+          ...creditCard,
+        }),
+      );
+
+      const persisted = await creditCardRepo.find({
+        where: {customerId: existingCustomerId},
+      });
+      expect(persisted[0]).to.deepEqual(foundCreditCard);
+    });
+
+    it('reports EntityNotFound error when related model is deleted', async () => {
+      const paymentMethod = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+      await creditCardRepo.deleteById(paymentMethod.id);
+
+      await expect(
+        findCustomerPaymentMethod(existingCustomerId, 'CreditCard'),
+      ).to.be.rejectedWith(EntityNotFoundError);
+    });
+
+    it('can PATCH hasOne instances', async () => {
+      const paymentMethod = await createCustomerPaymentMethod(
+        existingCustomerId,
+        {},
+        'CreditCard',
+      );
+
+      const patchObject = {cardNumber: 46458921} as DataObject<PaymentMethod>;
+      const arePatched = await patchCustomerPaymentMethod(
+        existingCustomerId,
+        {CreditCard: patchObject as DataObject<CreditCard>} as {
+          [polymorphicType: string]: DataObject<CreditCard>;
+        },
+        true,
+      );
+
+      expect(arePatched).to.deepEqual({count: 1});
+      const patchedData = await creditCardRepo.findById(paymentMethod.id);
+
+      expect(toJSON(patchedData)).to.deepEqual(
+        toJSON({
+          id: paymentMethod.id,
+          customerId: existingCustomerId,
+          cardNumber: 46458921,
+        }),
+      );
+    });
+
+    it('patches the related instance only', async () => {
+      const bob = await customerRepo.create({name: 'Bob'});
+      await customerRepo
+        .paymentMethod(bob.id)
+        .create({cardNumber: 12345} as DataObject<PaymentMethod>, {
+          polymorphicType: 'CreditCard',
+        });
+
+      const alice = await customerRepo.create({name: 'Alice'});
+      await customerRepo
+        .paymentMethod(alice.id)
+        .create({cardNumber: 67890} as DataObject<PaymentMethod>, {
+          polymorphicType: 'CreditCard',
+        });
+
+      const result = await patchCustomerPaymentMethod(
+        alice.id,
+        {
+          CreditCard: {
+            cardNumber: 7894512,
+          } as DataObject<CreditCard>,
+        } as {[polymorphicType: string]: DataObject<CreditCard>},
+        true,
+      );
+
+      expect(result).to.deepEqual({count: 1});
+
+      const foundBob = await customerRepo
+        .paymentMethod(bob.id)
+        .get(undefined, {polymorphicType: 'CreditCard'});
+      expect(toJSON(foundBob)).to.containDeep({cardNumber: 12345});
+
+      const foundAlice = await customerRepo
+        .paymentMethod(bob.id)
+        .get(undefined, {polymorphicType: 'CreditCard'});
+      expect(toJSON(foundAlice)).to.containDeep({cardNumber: 12345});
+    });
+
+    it('throws an error when PATCH tries to change the foreignKey', async () => {
+      const anotherId = (await givenPersistedCustomerInstance()).id;
+      await expect(
+        patchCustomerPaymentMethod(
+          existingCustomerId,
+          {
+            CreditCard: {
+              customerId: anotherId,
+            } as DataObject<CreditCard>,
+          } as {[polymorphicType: string]: DataObject<CreditCard>},
+          true,
+        ),
+      ).to.be.rejectedWith(/Property "customerId" cannot be changed!/);
+    });
+
+    it('can DELETE hasOne relation instances', async () => {
+      await createCustomerPaymentMethod(existingCustomerId, {}, 'CreditCard');
+
+      const areDeleted = await deleteCustomerPaymentMethod(
+        existingCustomerId,
+        'CreditCard',
+      );
+      expect(areDeleted).to.deepEqual({count: 1});
+
+      await expect(
+        findCustomerPaymentMethod(existingCustomerId, 'CreditCard'),
+      ).to.be.rejectedWith(EntityNotFoundError);
+    });
+
+    it('deletes the related model instance only', async () => {
+      const bob = await customerRepo.create({name: 'Bob'});
+      await customerRepo
+        .paymentMethod(bob.id)
+        .create({}, {polymorphicType: 'CreditCard'});
+
+      const alice = await customerRepo.create({name: 'Alice'});
+      await customerRepo
+        .paymentMethod(alice.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const brown = await customerRepo.create({name: 'Brown'});
+      await customerRepo
+        .paymentMethod(brown.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const result = await deleteCustomerPaymentMethod(alice.id, 'Cash');
+
+      expect(result).to.deepEqual({count: 1});
+
+      const found = await cashRepo.find();
+      expect(found).to.have.length(1);
+    });
+
+    it('deletes the related model instance with wrong type', async () => {
+      const bob = await customerRepo.create({name: 'Bob'});
+      await customerRepo
+        .paymentMethod(bob.id)
+        .create({}, {polymorphicType: 'CreditCard'});
+
+      const alice = await customerRepo.create({name: 'Alice'});
+      await customerRepo
+        .paymentMethod(alice.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const brown = await customerRepo.create({name: 'Brown'});
+      await customerRepo
+        .paymentMethod(brown.id)
+        .create({}, {polymorphicType: 'Cash'});
+
+      const result = await deleteCustomerPaymentMethod(alice.id, 'CreditCard');
+
+      expect(result).to.deepEqual({count: 0});
+
+      const found = await cashRepo.find();
+      expect(found).to.have.length(2);
+    });
+
+    /*---------------- HELPERS -----------------*/
+
+    async function createCustomerPaymentMethod(
+      customerId: MixedIdType,
+      paymentMethodData: DataObject<PaymentMethod>,
+      polymorphicTypeName: string,
+    ): Promise<PaymentMethod> {
+      return customerRepo
+        .paymentMethod(customerId)
+        .create(paymentMethodData, {polymorphicType: polymorphicTypeName});
+    }
+
+    async function findCustomerPaymentMethod(
+      customerId: MixedIdType,
+      polymorphicType: string,
+    ) {
+      return customerRepo
+        .paymentMethod(customerId)
+        .get(undefined, {polymorphicType: polymorphicType});
+    }
+
+    async function patchCustomerPaymentMethod(
+      customerId: MixedIdType,
+      paymentMethodData: DataObject<PaymentMethod>,
+      isMultipleTypes: boolean,
+    ) {
+      return customerRepo
+        .paymentMethod(customerId)
+        .patch(paymentMethodData, {isPolymorphic: isMultipleTypes});
+    }
+
+    async function deleteCustomerPaymentMethod(
+      customerId: MixedIdType,
+      polymorphicType: string,
+    ) {
+      return customerRepo
+        .paymentMethod(customerId)
+        .delete({polymorphicType: polymorphicType});
+    }
+
+    async function givenPersistedCustomerInstance() {
+      return customerRepo.create({name: 'a customer'});
+    }
+  });
+}

package/src/crud/relations/fixtures/models/contact.model.ts

@@ -0,0 +1,56 @@
+// Copyright IBM Corp. 2019. 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 {
+  belongsTo,
+  BelongsToAccessor,
+  Entity,
+  EntityCrudRepository,
+  model,
+  property,
+} from '@loopback/repository';
+import {MixedIdType} from '../../../../helpers.repository-tests';
+import {CustomerWithRelations} from './customer.model';
+import {Stakeholder} from './stakeholder.model';
+
+@model()
+export class Contact extends Entity {
+  @property({
+    id: true,
+    generated: true,
+    useDefaultIdType: true,
+  })
+  id: MixedIdType;
+  @property({
+    type: 'string',
+  })
+  name: string;
+  @property({
+    type: 'string',
+  })
+  email: string;
+
+  @belongsTo(() => Stakeholder, {polymorphic: true})
+  stakeholderId: MixedIdType;
+
+  @property({
+    type: 'string',
+    required: true,
+    default: 'Customer',
+  })
+  stakeholderType: string;
+}
+
+export interface ContactRelations {
+  stakeholder?: CustomerWithRelations;
+}
+
+export type ContactWithRelations = Contact & ContactRelations;
+
+export interface ContactRepository
+  extends EntityCrudRepository<Contact, typeof Contact.prototype.id> {
+  // define additional members like relation methods here
+  stakeholder: BelongsToAccessor<Stakeholder, MixedIdType>;
+}

package/src/crud/relations/fixtures/models/customer-promotion-link.model.ts

@@ -0,0 +1,52 @@
+// 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,
+  model,
+  property,
+} from '@loopback/repository';
+import {MixedIdType} from '../../../../helpers.repository-tests';
+
+@model()
+export class CustomerPromotionLink extends Entity {
+  @property({
+    id: true,
+    generated: true,
+    useDefaultIdType: true,
+  })
+  id: MixedIdType;
+
+  @property()
+  customerId: MixedIdType;
+
+  @property()
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  promotion_id: MixedIdType;
+
+  @property({
+    type: 'string',
+    default: 'HalfPrice',
+    required: true,
+  })
+  promotiontype: string;
+
+  @property({
+    type: 'string',
+  })
+  description?: string;
+}
+
+export interface CustomerPromotionLinkRelations {}
+
+export type CustomerPromotionLinkWithRelations = CustomerPromotionLink &
+  CustomerPromotionLinkRelations;
+
+export interface CustomerPromotionLinkRepository
+  extends EntityCrudRepository<
+    CustomerPromotionLink,
+    typeof CustomerPromotionLink.prototype.id
+  > {}

package/src/crud/relations/fixtures/models/customer.model.ts

@@ -5,7 +5,6 @@
 
 import {
   belongsTo,
-  Entity,
   EntityCrudRepository,
   hasMany,
   HasManyRepositoryFactory,
@@ -19,18 +18,19 @@ import {BelongsToAccessor} from '@loopback/repository/src';
 import {MixedIdType} from '../../../../helpers.repository-tests';
 import {Address, AddressWithRelations} from './address.model';
 import {CartItem, CartItemWithRelations} from './cart-item.model';
+import {Contact, ContactWithRelations} from './contact.model';
 import {CustomerCartItemLink} from './customer-cart-item-link.model';
+import {CustomerPromotionLink} from './customer-promotion-link.model';
 import {Order, OrderWithRelations} from './order.model';
+import {
+  PaymentMethod,
+  PaymentMethodWithRelations,
+} from './payment-method.model';
+import {Promotion, PromotionWithRelations} from './promotion.model';
+import {Stakeholder} from './stakeholder.model';
 
 @model()
-export class Customer extends Entity {
-  @property({
-    id: true,
-    generated: true,
-    useDefaultIdType: true,
-  })
-  id: MixedIdType;
-
+export class Customer extends Stakeholder {
   @property({
     type: 'string',
   })
@@ -50,6 +50,25 @@ export class Customer extends Entity {
 
   @hasMany(() => CartItem, {through: {model: () => CustomerCartItemLink}})
   cartItems: CartItem[];
+
+  @hasMany(() => Promotion, {
+    through: {
+      model: () => CustomerPromotionLink,
+      keyTo: 'promotion_id',
+      polymorphic: {discriminator: 'promotiontype'},
+    },
+  })
+  promotions: Promotion[];
+
+  @hasOne(() => PaymentMethod, {polymorphic: true})
+  paymentMethod: PaymentMethod;
+
+  @property({
+    type: 'string',
+    required: true,
+    default: 'CreditCard',
+  })
+  paymentMethodType: string;
 }
 
 export interface CustomerRelations {
@@ -58,6 +77,9 @@ export interface CustomerRelations {
   customers?: CustomerWithRelations[];
   parentCustomer?: CustomerWithRelations;
   cartItems?: CartItemWithRelations[];
+  paymentMethod: PaymentMethodWithRelations;
+  promotions?: PromotionWithRelations[];
+  contact?: ContactWithRelations;
 }
 
 export type CustomerWithRelations = Customer & CustomerRelations;
@@ -75,4 +97,12 @@ export interface CustomerRepository
     CustomerCartItemLink,
     MixedIdType
   >;
+  promotions: HasManyThroughRepositoryFactory<
+    Promotion,
+    MixedIdType,
+    CustomerPromotionLink,
+    MixedIdType
+  >;
+  paymentMethod: HasOneRepositoryFactory<PaymentMethod, MixedIdType>;
+  contact: HasOneRepositoryFactory<Contact, MixedIdType>;
 }

package/src/crud/relations/fixtures/models/index.ts

@@ -5,9 +5,15 @@
 
 export * from './address.model';
 export * from './cart-item.model';
+export * from './contact.model';
 export * from './customer-cart-item-link.model';
+export * from './customer-promotion-link.model';
 export * from './customer.model';
 export * from './order.model';
+export * from './payment-method.model';
+export * from './promotion.model';
 export * from './shipment.model';
+export * from './stakeholder.model';
+export * from './supplier.model';
 export * from './user-link.model';
 export * from './user.model';

package/src/crud/relations/fixtures/models/payment-method.model.ts

@@ -0,0 +1,118 @@
+// Copyright IBM Corp. 2019,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 {
+  belongsTo,
+  Entity,
+  EntityCrudRepository,
+  hasOne,
+  HasOneRepositoryFactory,
+  model,
+  property,
+} from '@loopback/repository';
+import {BelongsToAccessor} from '@loopback/repository/src';
+import {Customer, CustomerWithRelations} from '.';
+import {MixedIdType} from '../../../../helpers.repository-tests';
+import {Stakeholder} from './stakeholder.model';
+
+@model()
+export class PaymentMethod extends Entity {
+  @property({
+    id: true,
+    generated: true,
+    useDefaultIdType: true,
+  })
+  id: MixedIdType;
+
+  @belongsTo(() => Stakeholder)
+  customerId: MixedIdType;
+}
+
+export interface PaymentMethodRelations {
+  customer?: CustomerWithRelations[];
+}
+
+export type PaymentMethodWithRelations = PaymentMethod & PaymentMethodRelations;
+
+@model()
+export class CardInfo extends Entity {
+  @property({
+    id: true,
+    generated: true,
+    useDefaultIdType: true,
+  })
+  id: MixedIdType;
+
+  @belongsTo(() => CreditCard)
+  creditCardId: MixedIdType;
+
+  @property({
+    type: 'string',
+    required: true,
+    default: 'default holder',
+  })
+  cardHolder: string;
+}
+
+export interface CardInfoRelations {
+  creditCard?: CreditCardWithRelations[];
+}
+
+export type CardInfoWithRelations = CardInfo & CardInfoRelations;
+
+@model()
+export class CreditCard extends PaymentMethod {
+  @property({
+    type: 'number',
+    required: true,
+    default: 0,
+  })
+  cardNumber: number;
+
+  @hasOne(() => CardInfo)
+  cardInfo: CardInfo;
+}
+
+export interface CreditCardRelations {
+  customer?: CustomerWithRelations[];
+  cardInfo: CardInfoWithRelations;
+}
+
+export type CreditCardWithRelations = CreditCard & CreditCardRelations;
+
+@model()
+export class Cash extends PaymentMethod {
+  @property({
+    type: 'string',
+    required: true,
+    default: 'default cash detail',
+  })
+  detail: string;
+}
+
+export interface CashRelations {
+  customer?: CustomerWithRelations[];
+}
+
+export type CashWithRelations = Cash & CashRelations;
+
+export interface CreditCardRepository
+  extends EntityCrudRepository<CreditCard, typeof CreditCard.prototype.id> {
+  // define additional members like relation methods here
+  customer: BelongsToAccessor<Customer, MixedIdType>;
+  cardInfo: HasOneRepositoryFactory<CardInfo, MixedIdType>;
+}
+
+export interface CashRepository
+  extends EntityCrudRepository<Cash, typeof Cash.prototype.id> {
+  // define additional members like relation methods here
+  customer: BelongsToAccessor<Customer, MixedIdType>;
+}
+
+export interface CardInfoRepository
+  extends EntityCrudRepository<CardInfo, typeof CardInfo.prototype.id> {
+  // define additional members like relation methods here
+  creditCard: BelongsToAccessor<CreditCard, MixedIdType>;
+}