Merge pull request #75 from GeneralMagicio/update-polls-count-on-delete-poll

Update polls count on deletePoll

Author: RamRamez

src/poll/poll.module.ts

@@ -1,9 +1,12 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { PollService } from './poll.service';
 import { PollController } from './poll.controller';
+import { UserModule } from '../user/user.module';
+import { UserService } from '../user/user.service';
 
 @Module({
+  imports: [forwardRef(() => UserModule)],
   controllers: [PollController],
-  providers: [PollService],
+  providers: [PollService, UserService],
 })
 export class PollModule {}

src/poll/poll.service.ts

@@ -1,6 +1,12 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
 import { ActionType, Prisma } from '@prisma/client';
 import { DatabaseService } from 'src/database/database.service';
+import { UserService } from 'src/user/user.service';
 import {
   PollNotFoundException,
   UnauthorizedActionException,
@@ -10,7 +16,25 @@ import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
 
 @Injectable()
 export class PollService {
-  constructor(private readonly databaseService: DatabaseService) {}
+  constructor(
+    private readonly databaseService: DatabaseService,
+    @Inject(forwardRef(() => UserService))
+    private readonly userService: UserService,
+  ) {}
+
+  async updatePollParticipantCount(
+    pollId: number,
+    prismaClient?: Prisma.TransactionClient, // To ensure Prisma transaction function runs queries in order
+  ) {
+    const prisma = prismaClient || this.databaseService;
+    const participantCount = await prisma.userAction.count({
+      where: { pollId, type: ActionType.VOTED },
+    });
+    await prisma.poll.update({
+      where: { pollId },
+      data: { participantCount },
+    });
+  }
 
   private async searchPolls(searchTerm: string): Promise<number[]> {
     const searchQuery = searchTerm
@@ -64,18 +88,11 @@ export class PollService {
           type: ActionType.CREATED,
         },
       });
-      const pollsCreatedCount = await tx.userAction.count({
-        where: {
-          userId: user.id,
-          type: ActionType.CREATED,
-        },
-      });
-      await tx.user.update({
-        where: { worldID: createPollDto.worldID },
-        data: {
-          pollsCreatedCount,
-        },
-      });
+      await this.userService.updateUserPollsCount(
+        user.id,
+        ActionType.CREATED,
+        tx,
+      );
       return newPoll;
     });
   }
@@ -209,19 +226,30 @@ export class PollService {
       throw new UnauthorizedActionException();
     }
     return this.databaseService.$transaction(async (tx) => {
+      const pollParticipants = await tx.userAction.findMany({
+        where: { pollId, type: ActionType.VOTED },
+        select: { userId: true },
+      });
+      const participantUserIds = [
+        ...new Set(pollParticipants.map((v) => v.userId)),
+      ];
       const deleted = await tx.poll.delete({
         where: {
           pollId,
         },
       });
-      await tx.user.update({
-        where: { id: deleted.authorUserId },
-        data: {
-          pollsCreatedCount: {
-            decrement: 1,
-          },
-        },
-      });
+      await this.userService.updateUserPollsCount(
+        deleted.authorUserId,
+        ActionType.CREATED,
+        tx,
+      );
+      for (const userId of participantUserIds) {
+        await this.userService.updateUserPollsCount(
+          userId,
+          ActionType.VOTED,
+          tx,
+        );
+      }
       return deleted;
     });
   }

src/user/user.module.ts

@@ -1,9 +1,11 @@
-import { Module } from '@nestjs/common';
-import { PollService } from '../poll/poll.service';
+import { forwardRef, Module } from '@nestjs/common';
 import { UserController } from './user.controller';
 import { UserService } from './user.service';
+import { PollModule } from '../poll/poll.module';
+import { PollService } from '../poll/poll.service';
 
 @Module({
+  imports: [forwardRef(() => PollModule)],
   controllers: [UserController],
   providers: [UserService, PollService],
 })

src/user/user.service.ts

@@ -1,5 +1,5 @@
-import { Injectable } from '@nestjs/common';
-import { ActionType } from '@prisma/client';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { ActionType, Prisma } from '@prisma/client';
 import { VOTING_POWER } from '../common/constants';
 import {
   CreateUserException,
@@ -47,6 +47,7 @@ type UserActionFilters = {
 export class UserService {
   constructor(
     private readonly databaseService: DatabaseService,
+    @Inject(forwardRef(() => PollService))
     private readonly pollService: PollService,
   ) {}
 
@@ -82,29 +83,41 @@ export class UserService {
     }
   }
 
+  async updateUserPollsCount(
+    userId: number,
+    type: ActionType,
+    prismaClient?: Prisma.TransactionClient, // To ensure Prisma transaction function runs queries in order
+  ) {
+    const prisma = prismaClient || this.databaseService;
+    const pollsCount = await prisma.userAction.count({
+      where: { userId, type },
+    });
+    await prisma.user.update({
+      where: { id: userId },
+      data: {
+        pollsCreatedCount: type === ActionType.CREATED ? pollsCount : undefined,
+        pollsParticipatedCount:
+          type === ActionType.VOTED ? pollsCount : undefined,
+      },
+    });
+  }
+
   async getUserData(dto: GetUserDataDto): Promise<UserDataResponseDto> {
     const user = await this.databaseService.user.findUnique({
       where: { worldID: dto.worldID },
-      select: { id: true, worldID: true },
+      select: {
+        id: true,
+        worldID: true,
+        pollsCreatedCount: true,
+        pollsParticipatedCount: true,
+      },
     });
     if (!user) {
       throw new UserNotFoundException();
     }
-    const pollsCreated = await this.databaseService.userAction.count({
-      where: {
-        userId: user.id,
-        type: ActionType.CREATED,
-      },
-    });
-    const pollsParticipated = await this.databaseService.userAction.count({
-      where: {
-        userId: user.id,
-        type: ActionType.VOTED,
-      },
-    });
     return {
-      pollsCreated,
-      pollsParticipated,
+      pollsCreated: user.pollsCreatedCount,
+      pollsParticipated: user.pollsParticipatedCount,
       worldID: user.worldID,
       worldProfilePic: null,
     };
@@ -262,30 +275,8 @@ export class UserService {
           type: ActionType.VOTED,
         },
       });
-      const pollsParticipatedCount = await prisma.userAction.count({
-        where: {
-          userId: user.id,
-          type: ActionType.VOTED,
-        },
-      });
-      const participantCount = await prisma.userAction.count({
-        where: {
-          pollId: dto.pollId,
-          type: ActionType.VOTED,
-        },
-      });
-      await prisma.user.update({
-        where: { worldID: dto.worldID },
-        data: {
-          pollsParticipatedCount,
-        },
-      });
-      await prisma.poll.update({
-        where: { pollId: dto.pollId },
-        data: {
-          participantCount,
-        },
-      });
+      await this.updateUserPollsCount(user.id, ActionType.VOTED, prisma);
+      await this.pollService.updatePollParticipantCount(dto.pollId, prisma);
       return {
         voteID: vote.voteID,
         actionId: action.id,