fix: seperate content price to model collection

src/__tests__/acceptance/unlockable-content.acceptance.ts

@@ -1,9 +1,11 @@
 import {Client, expect} from '@loopback/testlab';
+import {omit} from 'lodash';
 import {MyriadApiApplication} from '../../application';
 import {ReferenceType} from '../../enums';
 import {Token} from '../../interfaces';
 import {Currency, UnlockableContentWithRelations, User} from '../../models';
 import {
+  ContentPriceRepository,
   CurrencyRepository,
   ServerRepository,
   TransactionRepository,
@@ -13,6 +15,7 @@ import {
 import {
   deleteAllRepository,
   givenAccesToken,
+  givenContentPriceRepository,
   givenCurrencyInstance,
   givenCurrencyRepository,
   givenOtherUser,
@@ -38,6 +41,7 @@ describe('UnlockableContentApplication', () => {
   let transactionRepository: TransactionRepository;
   let currencyRepository: CurrencyRepository;
   let unlockableContentRepository: UnlockableContentRepository;
+  let contentPriceRepository: ContentPriceRepository;
   let user: User;
   let currency: Currency;
 
@@ -53,6 +57,7 @@ describe('UnlockableContentApplication', () => {
     transactionRepository = await givenTransactionRepository(app);
     unlockableContentRepository = await givenUnlockableContentRepository(app);
     serverRepository = await givenServerRepository(app);
+    contentPriceRepository = await givenContentPriceRepository(app);
   });
 
   beforeEach(async () => {
@@ -72,15 +77,26 @@ describe('UnlockableContentApplication', () => {
   });
 
   it('create an unlockable content', async () => {
-    const content = givenUnlockableContent({createdBy: user.id});
+    const content = givenUnlockableContent({
+      createdBy: user.id,
+      contentPrices: [{currencyId: currency.id, amount: 100}],
+    });
     const response = await client
       .post('/user/unlockable-contents')
       .set('Authorization', `Bearer ${token}`)
       .send(content)
       .expect(200);
-    expect(response.body).to.containDeep(content);
+    expect(response.body).to.containDeep(omit(content, ['contentPrices']));
     const result = await unlockableContentRepository.findById(response.body.id);
-    expect(result).to.containDeep(content);
+    expect(result).to.containDeep(omit(content, ['contentPrices']));
+    const contentPrice = await contentPriceRepository.findOne({
+      where: {unlockableContentId: result.id},
+    });
+    expect(contentPrice).to.containEql({
+      currencyId: currency.id,
+      amount: 100,
+      unlockableContentId: result.id,
+    });
   });
 
   context('when dealing with a single persisted unlockable content', () => {

src/__tests__/helpers/database.helper.ts

@@ -33,6 +33,7 @@ import {
   UserOTPRepository,
   IdentityRepository,
   UnlockableContentRepository,
+  ContentPriceRepository,
 } from '../../repositories';
 import {
   ActivityLogService,
@@ -103,8 +104,18 @@ export async function givenRepositories(testdb: any) {
     async () => postRepository,
     async () => userRepository,
   );
+  const contentPriceRepository: ContentPriceRepository =
+    new ContentPriceRepository(
+      testdb,
+      async () => currencyRepository,
+      async () => unlockableContentRepository,
+    );
   const unlockableContentRepository: UnlockableContentRepository =
-    new UnlockableContentRepository(testdb, async () => userRepository);
+    new UnlockableContentRepository(
+      testdb,
+      async () => userRepository,
+      async () => contentPriceRepository,
+    );
   const postRepository: PostRepository = new PostRepository(
     testdb,
     async () => peopleRepository,
@@ -321,6 +332,7 @@ export async function givenRepositories(testdb: any) {
   );
 
   const transactionService = new TransactionService(
+    contentPriceRepository,
     currencyRepository,
     peopleRepository,
     transactionRepository,
@@ -415,6 +427,7 @@ export async function givenRepositories(testdb: any) {
   );
 
   const userService = new UserService(
+    contentPriceRepository,
     changeEmailRequestRepository,
     experienceRepository,
     identityRepository,
@@ -484,6 +497,7 @@ export async function givenRepositories(testdb: any) {
     socialMediaService,
     tagService,
     unlockableContentRepository,
+    contentPriceRepository,
   };
 }
 
@@ -513,6 +527,7 @@ export async function givenEmptyDatabase(testdb: any) {
     userCurrencyRepository,
     serverRepository,
     unlockableContentRepository,
+    contentPriceRepository,
   } = await givenRepositories(testdb);
 
   await tagRepository.deleteAll();
@@ -539,4 +554,5 @@ export async function givenEmptyDatabase(testdb: any) {
   await userCurrencyRepository.deleteAll();
   await serverRepository.deleteAll();
   await unlockableContentRepository.deleteAll();
+  await contentPriceRepository.deleteAll();
 }

src/__tests__/helpers/given-instances.ts

@@ -32,7 +32,7 @@ import {
   SocialMediaVerificationDto,
   Tag,
   Transaction,
-  UnlockableContent,
+  UnlockableContentWithPrice,
   User,
   UserExperience,
   UserReport,
@@ -892,28 +892,24 @@ export function givenIdentityInstance(
 }
 
 export function givenUnlockableContent(
-  unlockableContent?: Partial<UnlockableContent>,
+  unlockableContentWithPrice?: Partial<UnlockableContentWithPrice>,
 ) {
   const data = Object.assign(
     {
       content: {
         text: 'Hello world',
       },
-      prices: [
-        {
-          ...givenCurrency(),
-          amount: 100,
-        },
-      ],
     },
-    unlockableContent,
+    unlockableContentWithPrice,
   );
-  return new UnlockableContent(data);
+  return new UnlockableContentWithPrice(data);
 }
 
 export function givenUnlockableContentInstance(
   unlockableRepository: UnlockableContentRepository,
-  unlockableContent?: Partial<UnlockableContent>,
+  unlockableContentWithPrice?: Partial<UnlockableContentWithPrice>,
 ) {
-  return unlockableRepository.create(givenUnlockableContent(unlockableContent));
+  return unlockableRepository.create(
+    givenUnlockableContent(unlockableContentWithPrice),
+  );
 }

src/__tests__/helpers/given-repositories.ts

@@ -26,6 +26,7 @@ import {
   ServerRepository,
   IdentityRepository,
   UnlockableContentRepository,
+  ContentPriceRepository,
 } from '../../repositories';
 
 export async function givenUserRepository(app: MyriadApiApplication) {
@@ -138,6 +139,10 @@ export async function givenUnlockableContentRepository(
   return app.getRepository(UnlockableContentRepository);
 }
 
+export async function givenContentPriceRepository(app: MyriadApiApplication) {
+  return app.getRepository(ContentPriceRepository);
+}
+
 export async function deleteAllRepository(app: MyriadApiApplication) {
   const userRepository = await givenUserRepository(app);
   const friendRepository = await givenFriendRepository(app);
@@ -168,6 +173,7 @@ export async function deleteAllRepository(app: MyriadApiApplication) {
   const unlockableContentRepository = await givenUnlockableContentRepository(
     app,
   );
+  const contentPriceRepository = await givenContentPriceRepository(app);
 
   await userRepository.deleteAll();
   await friendRepository.deleteAll();
@@ -196,4 +202,5 @@ export async function deleteAllRepository(app: MyriadApiApplication) {
   await serverRepository.deleteAll();
   await identityRepository.deleteAll();
   await unlockableContentRepository.deleteAll();
+  await contentPriceRepository.deleteAll();
 }

src/controllers/user/unlockable-content.controller.ts

@@ -16,7 +16,7 @@ import {
   response,
 } from '@loopback/rest';
 import {PaginationInterceptor} from '../../interceptors';
-import {UnlockableContent} from '../../models';
+import {UnlockableContent, UnlockableContentWithPrice} from '../../models';
 import {UserService} from '../../services';
 
 @authenticate('jwt')
@@ -30,21 +30,21 @@ export class UserUnlockableContentController {
   @response(200, {
     description: 'CREATE user unlockable-content',
     'application/json': {
-      schema: getModelSchemaRef(UnlockableContent),
+      schema: getModelSchemaRef(UnlockableContentWithPrice),
     },
   })
   async create(
     @requestBody({
       content: {
         'application/json': {
-          schema: getModelSchemaRef(UnlockableContent, {
+          schema: getModelSchemaRef(UnlockableContentWithPrice, {
             title: 'NewUnlockableContent',
             exclude: ['id'],
           }),
         },
       },
     })
-    content: Omit<UnlockableContent, 'id'>,
+    content: Omit<UnlockableContentWithPrice, 'id'>,
   ): Promise<UnlockableContent> {
     return this.userService.createUnlockableContent(content);
   }

src/models/content-price.model.ts

@@ -0,0 +1,45 @@
+import {Entity, model, property, belongsTo} from '@loopback/repository';
+import {Currency} from './currency.model';
+import {UnlockableContent} from './unlockable-content.model';
+
+@model({
+  settings: {
+    strictObjectIDCoercion: true,
+    mongodb: {
+      collection: 'contentPrices',
+    },
+  },
+})
+export class ContentPrice extends Entity {
+  @property({
+    type: 'string',
+    id: true,
+    generated: true,
+    mongodb: {
+      dataType: 'ObjectId',
+    },
+  })
+  id: string;
+
+  @property({
+    type: 'number',
+    required: true,
+  })
+  amount: number;
+
+  @belongsTo(() => Currency)
+  currencyId: string;
+
+  @belongsTo(() => UnlockableContent)
+  unlockableContentId: string;
+
+  constructor(data?: Partial<ContentPrice>) {
+    super(data);
+  }
+}
+
+export interface ContentPriceRelations {
+  // describe navigational properties here
+}
+
+export type ContentPriceWithRelations = ContentPrice & ContentPriceRelations;

src/models/index.ts

@@ -46,3 +46,4 @@ export * from './user-personal-access-token.model';
 export * from './user.model';
 export * from './vote.model';
 export * from './wallet.model';
+export * from './content-price.model';

src/models/unlockable-content.model.ts

@@ -4,13 +4,10 @@ import {
   model,
   property,
   belongsTo,
+  hasMany,
 } from '@loopback/repository';
-import {Currency} from './currency.model';
 import {User, UserWithRelations} from './user.model';
-
-type Price = Currency & {
-  amount: string;
-};
+import {ContentPrice} from './content-price.model';
 
 @model({
   settings: {
@@ -46,13 +43,6 @@ export class UnlockableContent extends Entity {
   })
   content?: AnyObject;
 
-  @property({
-    type: 'array',
-    itemType: 'object',
-    required: true,
-  })
-  prices: Price[];
-
   @property({
     type: 'date',
     required: false,
@@ -73,6 +63,9 @@ export class UnlockableContent extends Entity {
   })
   deletedAt?: string;
 
+  @hasMany(() => ContentPrice)
+  prices: ContentPrice[];
+
   @belongsTo(() => User, {name: 'user'})
   createdBy: string;
 
@@ -88,3 +81,21 @@ export interface UnlockableContentRelations {
 
 export type UnlockableContentWithRelations = UnlockableContent &
   UnlockableContentRelations;
+
+export interface Price {
+  currencyId: string;
+  amount: number;
+}
+
+export class UnlockableContentWithPrice extends UnlockableContent {
+  @property({
+    type: 'array',
+    itemType: 'object',
+    required: false,
+  })
+  contentPrices: Price[];
+
+  constructor(data?: Partial<UnlockableContentWithPrice>) {
+    super(data);
+  }
+}