feat: add likes in meilisearch (#1715)

* feat: add likes in meilisearch

* refactor: refactor

* fix: add migration for index

* refactor: fix test

Author: pyphilia

package.json

@@ -66,7 +66,7 @@
     "@fastify/type-provider-typebox": "4.1.0",
     "@fastify/websocket": "7.2.0",
     "@graasp/etherpad-api": "2.1.1",
-    "@graasp/sdk": "5.5.0",
+    "@graasp/sdk": "5.6.0",
     "@graasp/translations": "1.42.0",
     "@rapideditor/country-coder": "5.2.2",
     "@sentry/node": "7.119.2",

src/migrations/1736512586095-item-like-index-item.ts

@@ -0,0 +1,13 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class Migrations1736512586095 implements MigrationInterface {
+  name = 'item-like-index-item-1736512586095';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE INDEX "IDX_item_like_item" ON "item_like" ("item_id") `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX "public"."IDX_item_like_item"`);
+  }
+}

src/services/action/entities/action.ts

@@ -38,6 +38,7 @@ export class Action extends BaseEntity {
   })
   @JoinColumn({ referencedColumnName: 'id', name: 'item_id' })
   item?: Item | null;
+
   @Column({
     nullable: false,
     enum: Object.values(Context),

src/services/item/plugins/itemLike/index.ts

@@ -19,7 +19,7 @@ const plugin: FastifyPluginAsyncTypebox = async (fastify) => {
   const { db } = fastify;
 
   const itemService = resolveDependency(ItemService);
-  const itemLikeService = new ItemLikeService(itemService);
+  const itemLikeService = resolveDependency(ItemLikeService);
   const actionService = resolveDependency(ActionService);
 
   //get liked entry for member

src/services/item/plugins/itemLike/itemLike.ts

@@ -2,6 +2,7 @@ import {
   BaseEntity,
   CreateDateColumn,
   Entity,
+  Index,
   JoinColumn,
   ManyToOne,
   PrimaryGeneratedColumn,
@@ -25,6 +26,7 @@ export class ItemLike extends BaseEntity {
   @JoinColumn({ name: 'creator_id' })
   creator: Member;
 
+  @Index('IDX_item_like_item')
   @ManyToOne(() => Item, (item) => item.id, {
     onDelete: 'CASCADE',
     nullable: false,

src/services/item/plugins/itemLike/repository.test.ts

@@ -0,0 +1,85 @@
+import { DataSource, Repository } from 'typeorm';
+import { v4 } from 'uuid';
+
+import { FolderItemFactory, MemberFactory } from '@graasp/sdk';
+
+import { AppDataSource } from '../../../../plugins/datasource';
+import { IllegalArgumentException } from '../../../../repositories/errors';
+import { Member } from '../../../member/entities/member';
+import { Item } from '../../entities/Item';
+import { ItemLike } from './itemLike';
+import { ItemLikeRepository } from './repository';
+
+describe('Tag Repository', () => {
+  let db: DataSource;
+
+  let repository: ItemLikeRepository;
+  let likeRawRepository: Repository<ItemLike>;
+  let itemRawRepository: Repository<Item>;
+  let memberRawRepository: Repository<Member>;
+
+  beforeAll(async () => {
+    db = await AppDataSource.initialize();
+    await db.runMigrations();
+    repository = new ItemLikeRepository(db.manager);
+    likeRawRepository = db.getRepository(ItemLike);
+    itemRawRepository = db.getRepository(Item);
+    memberRawRepository = db.getRepository(Member);
+  });
+
+  afterAll(async () => {
+    await db.dropDatabase();
+    await db.destroy();
+  });
+
+  describe('getByItemIdId', () => {
+    it('throw for invalid id', async () => {
+      await expect(() => repository.getByItemId(undefined!)).rejects.toBeInstanceOf(
+        IllegalArgumentException,
+      );
+    });
+    it('Return null for non-existing item', async () => {
+      expect(await repository.getByItemId(v4())).toEqual([]);
+    });
+    it('Return null for no like for item', async () => {
+      expect(await repository.getByItemId(v4())).toEqual([]);
+    });
+    it('get likes', async () => {
+      const item = await itemRawRepository.save(FolderItemFactory({ creator: null }));
+      const creator = await memberRawRepository.save(MemberFactory());
+      const l1 = await likeRawRepository.save({ item, creator });
+      const creator1 = await memberRawRepository.save(MemberFactory());
+      const l2 = await likeRawRepository.save({ item, creator: creator1 });
+
+      const result = await repository.getByItemId(item.id);
+      expect(result).toHaveLength(2);
+      [l1, l2].forEach((like) => {
+        // should contain item
+        expect(result.find(({ id }) => id === like.id)!.item.id).toEqual(like.item.id);
+      });
+    });
+  });
+
+  describe('getCountByItemId', () => {
+    it('throw for invalid id', async () => {
+      await expect(() => repository.getCountByItemId(undefined!)).rejects.toBeInstanceOf(
+        IllegalArgumentException,
+      );
+    });
+    it('Return 0 for non-existing item', async () => {
+      expect(await repository.getCountByItemId(v4())).toEqual(0);
+    });
+    it('Return 0 for no like for item', async () => {
+      expect(await repository.getCountByItemId(v4())).toEqual(0);
+    });
+    it('get like count', async () => {
+      const item = await itemRawRepository.save(FolderItemFactory({ creator: null }));
+      const creator = await memberRawRepository.save(MemberFactory());
+      await likeRawRepository.save({ item, creator });
+      const creator1 = await memberRawRepository.save(MemberFactory());
+      await likeRawRepository.save({ item, creator: creator1 });
+
+      expect(await repository.getCountByItemId(item.id)).toEqual(2);
+    });
+  });
+});

src/services/item/plugins/itemLike/repository.ts

@@ -65,7 +65,7 @@ export class ItemLikeRepository extends MutableRepository<ItemLike, never> {
    * Get likes for item
    * @param itemId
    */
-  async getByItem(itemId: ItemId): Promise<ItemLike[]> {
+  async getByItemId(itemId: ItemId): Promise<ItemLike[]> {
     this.throwsIfParamIsInvalid('itemId', itemId);
     return await this.repository
       .createQueryBuilder('itemLike')
@@ -74,6 +74,19 @@ export class ItemLikeRepository extends MutableRepository<ItemLike, never> {
       .getMany();
   }
 
+  /**
+   * Get likes count for item
+   * @param itemId
+   * @returns number of likes for item
+   */
+  async getCountByItemId(itemId: ItemId): Promise<number> {
+    this.throwsIfParamIsInvalid('itemId', itemId);
+    return await this.repository
+      .createQueryBuilder('itemLike')
+      .where('itemLike.item_id = :itemId', { itemId })
+      .getCount();
+  }
+
   /**
    * delete an item like
    * @param creatorId user's id

src/services/item/plugins/itemLike/service.test.ts

@@ -0,0 +1,101 @@
+import { v4 } from 'uuid';
+
+import { TagFactory } from '@graasp/sdk';
+
+import { Repositories } from '../../../../utils/repositories';
+import { Member } from '../../../member/entities/member';
+import { Tag } from '../../../tag/Tag.entity';
+import { TagRepository } from '../../../tag/Tag.repository';
+import { Item } from '../../entities/Item';
+import { ItemService } from '../../service';
+import { ItemPublished } from '../publication/published/entities/itemPublished';
+import { MeiliSearchWrapper } from '../publication/published/plugins/search/meilisearch';
+import { ItemPublishedRepository } from '../publication/published/repositories/itemPublished';
+import { ItemLike } from './itemLike';
+import { ItemLikeRepository } from './repository';
+import { ItemLikeService } from './service';
+
+const itemService = { get: jest.fn() as ItemService['get'] } as ItemService;
+const meilisearchWrapper = {
+  updateItem: jest.fn() as MeiliSearchWrapper['updateItem'],
+} as MeiliSearchWrapper;
+
+const itemLikeService = new ItemLikeService(itemService, meilisearchWrapper);
+
+const repositories = {
+  itemLikeRepository: {
+    addOne: jest.fn() as ItemLikeRepository['addOne'],
+    deleteOneByCreatorAndItem: jest.fn() as ItemLikeRepository['deleteOneByCreatorAndItem'],
+    getCountByItemId: jest.fn() as ItemLikeRepository['getCountByItemId'],
+  } as ItemLikeRepository,
+  tagRepository: {
+    addOneIfDoesNotExist: jest.fn(async () => TagFactory() as Tag),
+  } as unknown as TagRepository,
+  itemPublishedRepository: {
+    getForItem: jest.fn() as ItemPublishedRepository['getForItem'],
+  } as ItemPublishedRepository,
+} as Repositories;
+
+const MOCK_LIKE = { creator: { id: v4() }, item: { id: v4() } } as ItemLike;
+
+describe('Item Like post', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it('does not update like count for indexed item if it is not published', async () => {
+    jest.spyOn(itemService, 'get').mockResolvedValue({} as Item);
+    jest.spyOn(repositories.itemLikeRepository, 'addOne').mockResolvedValue(MOCK_LIKE);
+    const updateItemMock = jest.spyOn(meilisearchWrapper, 'updateItem').mockResolvedValue();
+    jest.spyOn(repositories.itemPublishedRepository, 'getForItem').mockResolvedValue(null);
+
+    await itemLikeService.post({} as Member, repositories, v4());
+
+    expect(updateItemMock).not.toHaveBeenCalled();
+  });
+
+  it('update like count for indexed item if it is published', async () => {
+    jest.spyOn(itemService, 'get').mockResolvedValue({} as Item);
+    jest.spyOn(repositories.itemLikeRepository, 'addOne').mockResolvedValue(MOCK_LIKE);
+    const updateItemMock = jest.spyOn(meilisearchWrapper, 'updateItem').mockResolvedValue();
+    jest
+      .spyOn(repositories.itemPublishedRepository, 'getForItem')
+      .mockResolvedValue({} as unknown as ItemPublished);
+
+    await itemLikeService.post({} as Member, repositories, v4());
+
+    expect(updateItemMock).toHaveBeenCalled();
+  });
+});
+
+describe('Item Like removeOne', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it('do not update like count for indexed item if it is not published', async () => {
+    jest.spyOn(itemService, 'get').mockResolvedValue({} as Item);
+    jest
+      .spyOn(repositories.itemLikeRepository, 'deleteOneByCreatorAndItem')
+      .mockResolvedValue(MOCK_LIKE);
+    const updateItemMock = jest.spyOn(meilisearchWrapper, 'updateItem').mockResolvedValue();
+    jest.spyOn(repositories.itemPublishedRepository, 'getForItem').mockResolvedValue(null);
+
+    await itemLikeService.removeOne({} as Member, repositories, v4());
+
+    expect(updateItemMock).not.toHaveBeenCalled();
+  });
+
+  it('update like count for indexed item if it is published', async () => {
+    jest.spyOn(itemService, 'get').mockResolvedValue({} as Item);
+    jest
+      .spyOn(repositories.itemLikeRepository, 'deleteOneByCreatorAndItem')
+      .mockResolvedValue(MOCK_LIKE);
+    const updateItemMock = jest.spyOn(meilisearchWrapper, 'updateItem').mockResolvedValue();
+    jest
+      .spyOn(repositories.itemPublishedRepository, 'getForItem')
+      .mockResolvedValue({} as unknown as ItemPublished);
+
+    await itemLikeService.removeOne({} as Member, repositories, v4());
+
+    expect(updateItemMock).toHaveBeenCalled();
+  });
+});

src/services/item/plugins/itemLike/service.ts

@@ -1,13 +1,19 @@
+import { singleton } from 'tsyringe';
+
 import { Repositories } from '../../../../utils/repositories';
 import { filterOutPackedItems } from '../../../authorization';
 import { ItemService } from '../../../item/service';
 import { Actor, Member } from '../../../member/entities/member';
+import { MeiliSearchWrapper } from '../publication/published/plugins/search/meilisearch';
 
+@singleton()
 export class ItemLikeService {
   private itemService: ItemService;
+  private readonly meilisearchClient: MeiliSearchWrapper;
 
-  constructor(itemService: ItemService) {
+  constructor(itemService: ItemService, meilisearchClient: MeiliSearchWrapper) {
     this.itemService = itemService;
+    this.meilisearchClient = meilisearchClient;
   }
 
   async getForMember(member: Member, repositories: Repositories) {
@@ -35,23 +41,41 @@ export class ItemLikeService {
 
     await this.itemService.get(actor, repositories, itemId);
 
-    return itemLikeRepository.getByItem(itemId);
+    return itemLikeRepository.getByItemId(itemId);
   }
 
   async removeOne(member: Member, repositories: Repositories, itemId: string) {
-    const { itemLikeRepository } = repositories;
+    const { itemLikeRepository, itemPublishedRepository } = repositories;
 
     // QUESTION: allow public to be liked?
     const item = await this.itemService.get(member, repositories, itemId);
 
-    return itemLikeRepository.deleteOneByCreatorAndItem(member.id, item.id);
+    const result = await itemLikeRepository.deleteOneByCreatorAndItem(member.id, item.id);
+
+    // update index if item is published
+    const isPublished = await itemPublishedRepository.getForItem(item);
+    if (isPublished) {
+      const likes = await itemLikeRepository.getCountByItemId(item.id);
+      await this.meilisearchClient.updateItem(item.id, { likes });
+    }
+
+    return result;
   }
 
   async post(member: Member, repositories: Repositories, itemId: string) {
-    const { itemLikeRepository } = repositories;
+    const { itemLikeRepository, itemPublishedRepository } = repositories;
 
     // QUESTION: allow public to be liked?
     const item = await this.itemService.get(member, repositories, itemId);
-    return itemLikeRepository.addOne({ creatorId: member.id, itemId: item.id });
+    const result = await itemLikeRepository.addOne({ creatorId: member.id, itemId: item.id });
+
+    // update index if item is published
+    const isPublished = await itemPublishedRepository.getForItem(item);
+    if (isPublished) {
+      const likes = await itemLikeRepository.getCountByItemId(item.id);
+      await this.meilisearchClient.updateItem(item.id, { likes });
+    }
+
+    return result;
   }
 }