[PB-5187] feat: remove limits and expire rooms after 30 days (#45)

* feat: remove limits and expire rooms after 30 days

* fix(remove-limits): fix unit tests

* feat: add tests for removing limits

* refactor: improve tests and webhook service

* feat: remove call if expired

* chore: add unit tests

* chore: added jitsi webhook event fixtures

Author: apsantiso

migrations/20251030151411-add-removed-at-to-room-table.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.addColumn('rooms', 'remove_at', {
+      type: Sequelize.DATE,
+      allowNull: true,
+    });
+  },
+
+  async down(queryInterface, Sequelize) {
+    await queryInterface.removeColumn('rooms', 'remove_at');
+  },
+};

src/modules/call/call.controller.spec.ts

@@ -63,16 +63,6 @@ describe('Testing Call Endpoints', () => {
   });
 
   describe('Creating a call', () => {
-    it('When the user id is not provided (uuid), then an error indicating so is thrown', async () => {
-      await expect(
-        callController.createCall(
-          createMockUserToken({
-            payload: { ...createMockUserToken().payload, uuid: undefined },
-          }).payload,
-        ),
-      ).rejects.toThrow(BadRequestException);
-    });
-
     it('When the user id exists and has meet enabled, then should create the call and the room', async () => {
       const mockUserToken = createMockUserToken();
       const mockResponse = {
@@ -267,14 +257,6 @@ describe('Testing Call Endpoints', () => {
       });
       expect(result).toEqual(mockJoinCallResponse);
     });
-
-    it('When joining a call with invalid room name (not UUID), then it should throw', async () => {
-      callUseCase.joinCall.mockResolvedValue(mockJoinCallResponse);
-
-      await expect(
-        callController.joinCall('invalid room name', null, mockJoinCallDto),
-      ).rejects.toThrow(BadRequestException);
-    });
   });
 
   describe('Getting users in a call', () => {

src/modules/call/call.controller.ts

@@ -33,7 +33,7 @@ import { CallUseCase } from './call.usecase';
 import { CreateCallResponseDto } from './dto/create-call.dto';
 import { JoinCallDto, JoinCallResponseDto } from './dto/join-call.dto';
 import { LeaveCallDto } from './dto/leave-call.dto';
-import { isUUID } from 'class-validator';
+import { ValidateUUIDPipe } from '../../common/pipes/validate-uuid.pipe';
 
 @ApiTags('Call')
 @Controller('call')
@@ -115,14 +115,10 @@ export class CallController {
   @ApiConflictResponse({ description: 'User is already in this room' })
   @ApiInternalServerErrorResponse({ description: 'Internal server error' })
   async joinCall(
-    @Param('id') roomId: string,
+    @Param('id', ValidateUUIDPipe) roomId: string,
     @User() user: UserTokenData['payload'],
     @Body() joinCallDto?: JoinCallDto,
   ): Promise<JoinCallResponseDto> {
-    if (!isUUID(roomId)) {
-      throw new BadRequestException('Room id is not valid');
-    }
-
     const { uuid, email } = user || {};
     const isUserAnonymous =
       !user || !!joinCallDto?.anonymousId || joinCallDto?.anonymous === true;

src/modules/call/call.usecase.spec.ts

@@ -3,6 +3,7 @@ import {
   BadRequestException,
   ConflictException,
   ForbiddenException,
+  GoneException,
   NotFoundException,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
@@ -14,6 +15,7 @@ import { CallService } from './services/call.service';
 import { CallUseCase } from './call.usecase';
 import { mockRoomData, mockUserPayload } from './fixtures';
 import { v4 } from 'uuid';
+import { Time } from '../../common/time';
 
 const autoGeneratedUUID = 'generated-uuid';
 
@@ -124,6 +126,10 @@ describe('CallUseCase', () => {
       anonymous: true,
     });
 
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
     it('When joining call with registered user data, then it should join successfully with current user data', async () => {
       const userData = {
         userId,
@@ -280,6 +286,62 @@ describe('CallUseCase', () => {
       expect(roomService.getRoomByRoomId).toHaveBeenCalledWith(roomId);
     });
 
+    it('When room is expired, then it should remove the room and throw', async () => {
+      const userData = { userId };
+      const pastDate = Time.now('2024-01-01');
+      const currentDate = Time.now('2024-01-02');
+      const expiredRoomMock = {
+        ...roomMock,
+        removeAt: pastDate,
+      };
+      jest.useFakeTimers();
+      jest.setSystemTime(currentDate);
+
+      roomService.getRoomByRoomId.mockResolvedValueOnce(expiredRoomMock);
+      roomService.removeRoom.mockResolvedValueOnce(undefined);
+
+      await expect(callUseCase.joinCall(roomId, userData)).rejects.toThrow(
+        GoneException,
+      );
+      expect(roomService.getRoomByRoomId).toHaveBeenCalledWith(roomId);
+      expect(roomService.removeRoom).toHaveBeenCalledWith(expiredRoomMock.id);
+    });
+
+    it('When room has removeAt in the future, then it should allow joining', async () => {
+      const userData = {
+        userId,
+        name: userName,
+        lastName: userLastName,
+      };
+      const futureDate = new Date('2024-01-03');
+      const currentDate = new Date('2024-01-02');
+      const nonExpiredRoomMock = {
+        ...roomMock,
+        removeAt: futureDate,
+      };
+      jest.useFakeTimers();
+      jest.setSystemTime(currentDate);
+      roomService.getRoomByRoomId.mockResolvedValueOnce(nonExpiredRoomMock);
+      roomService.getUserInRoom.mockResolvedValueOnce(null);
+      roomService.countUsersInRoom.mockResolvedValueOnce(0);
+      roomService.handleUserJoined.mockResolvedValueOnce({
+        roomUser: roomUserMock,
+        oldParticipantId: undefined,
+      });
+      callService.generateJitsiJWT.mockReturnValueOnce('test-jwt-token');
+
+      const result = await callUseCase.joinCall(roomId, userData);
+
+      expect(roomService.getRoomByRoomId).toHaveBeenCalledWith(roomId);
+      expect(roomService.removeRoom).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        token: 'test-jwt-token',
+        room: roomId,
+        userId,
+        appId: 'jitsi-app-id',
+      });
+    });
+
     it('When non-owner tries to join closed room, then it should throw', async () => {
       const userData = { userId };
       const closedRoomMock = {

src/modules/call/call.usecase.ts

@@ -2,6 +2,7 @@ import {
   BadRequestException,
   ConflictException,
   ForbiddenException,
+  GoneException,
   Injectable,
   Logger,
   NotFoundException,
@@ -15,6 +16,7 @@ import { CallService } from './services/call.service';
 import { CreateCallResponseDto } from './dto/create-call.dto';
 import { JoinCallResponseDto } from './dto/join-call.dto';
 import { ConfigService } from '@nestjs/config';
+import { Time } from '../../common/time';
 
 @Injectable()
 export class CallUseCase {
@@ -29,19 +31,6 @@ export class CallUseCase {
   async createCallAndRoom(
     user: User | UserTokenData['payload'],
   ): Promise<CreateCallResponseDto> {
-    const activeRoom = await this.roomService.getOpenRoomByHostId(user.uuid);
-
-    // TODO: Remove this check and look for a better way to handle this
-    if (activeRoom) {
-      this.logger.warn(
-        { userId: user.uuid, roomId: activeRoom.id },
-        `User already has an active room as host, closing previous room`,
-      );
-      await this.roomService.removeRoom(activeRoom.id);
-    }
-
-    await this.validateUserHasNoActiveRoom(user.uuid, user.email);
-
     const call = await this.callService.createCall(user);
 
     const newRoom = new Room({
@@ -85,6 +74,11 @@ export class CallUseCase {
       throw new NotFoundException(`Specified room not found`);
     }
 
+    if (room.removeAt && Time.isBefore(room.removeAt, Time.now())) {
+      await this.roomService.removeRoom(room.id);
+      throw new GoneException('Room is expired');
+    }
+
     const joiningUserData = {
       userId: userData?.anonymous
         ? (userData?.anonymousId ?? v4())
@@ -131,7 +125,7 @@ export class CallUseCase {
       await this.callService.kickParticipant(roomId, oldParticipantId);
     }
 
-    const tokenData = this.callService.generateJitsiJWT(
+    const callTokenData = this.callService.generateJitsiJWT(
       {
         id: joiningUserData.userId,
         userRoomId: roomUser.id,
@@ -151,7 +145,7 @@ export class CallUseCase {
     }
 
     return {
-      token: tokenData,
+      token: callTokenData,
       room: roomId,
       userId: roomUser.userId,
       appId: this.configService.get<string>('jitsi.appId'),

src/modules/call/domain/room.domain.ts

@@ -1,8 +1,10 @@
+const ROOM_EXPIRATION_DAYS = 30;
 export interface RoomAttributes {
   id: string;
   maxUsersAllowed: number;
   hostId: string;
   isClosed?: boolean;
+  removeAt?: Date;
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -12,6 +14,7 @@ export class Room implements RoomAttributes {
   maxUsersAllowed: number;
   hostId: string;
   isClosed?: boolean;
+  removeAt?: Date;
   createdAt?: Date;
   updatedAt?: Date;
 
@@ -25,17 +28,22 @@ export class Room implements RoomAttributes {
       maxUsersAllowed: this.maxUsersAllowed,
       hostId: this.hostId,
       isClosed: this.isClosed,
+      removeAt: this.removeAt,
       createdAt: this.createdAt,
       updatedAt: this.updatedAt,
     };
   }
+  static getRoomExpirationDays() {
+    return ROOM_EXPIRATION_DAYS;
+  }
 
   static build(attributes: RoomAttributes): Room {
     return new Room({
       id: attributes.id,
       maxUsersAllowed: attributes.maxUsersAllowed,
       hostId: attributes.hostId,
       isClosed: attributes.isClosed,
+      removeAt: attributes.removeAt,
       createdAt: attributes.createdAt,
       updatedAt: attributes.updatedAt,
     });

src/modules/call/fixtures.ts

@@ -5,6 +5,11 @@ import { CreateCallResponseDto } from './dto/create-call.dto';
 import { RoomUser, RoomUserAttributes } from './domain/room-user.domain';
 import { User } from '../../shared/user/user.domain';
 import { v4 } from 'uuid';
+import {
+  JitsiParticipantJoinedWebHookPayload,
+  JitsiGenericWebHookEvent,
+} from './webhooks/jitsi/interfaces/JitsiGenericWebHookPayload';
+import { JitsiParticipantLeftWebHookPayload } from './webhooks/jitsi/interfaces/JitsiParticipantLeftData';
 
 const randomDataGenerator = new Chance();
 
@@ -40,13 +45,22 @@ export const mockRoomData = {
   isClosed: false,
   createdAt: randomDataGenerator.date(),
   updatedAt: randomDataGenerator.date(),
+  removeAt: undefined,
 };
 
-export const createMockRoom = (overrides?: Partial<Room>): Room => ({
-  ...mockRoomData,
-  ...overrides,
-  toJSON: () => mockRoomData,
-});
+export const createMockRoom = (attributes?: Partial<Room>): Room => {
+  const mockRoom = new Room({
+    id: randomDataGenerator.guid(),
+    hostId: randomDataGenerator.guid(),
+    maxUsersAllowed: randomDataGenerator.integer({ min: 2, max: 10 }),
+    isClosed: false,
+    createdAt: randomDataGenerator.date(),
+    updatedAt: randomDataGenerator.date(),
+    removeAt: undefined,
+    ...attributes,
+  });
+  return mockRoom;
+};
 
 export const mockCallResponse: CreateCallResponseDto = {
   room: mockRoomData.id,
@@ -99,3 +113,44 @@ export const createMockUser = (overrides?: Partial<User>): User => {
     ...overrides,
   });
 };
+
+export const createMockJitsiWebhookEvent = ({
+  overrides,
+  participantId,
+  roomUserId,
+  roomId,
+  appId,
+  eventType,
+}: {
+  overrides?: Partial<
+    JitsiParticipantJoinedWebHookPayload | JitsiParticipantLeftWebHookPayload
+  >;
+  participantId?: string;
+  roomUserId?: string;
+  roomId?: string;
+  appId?: string;
+  eventType: JitsiGenericWebHookEvent;
+}): JitsiParticipantJoinedWebHookPayload => {
+  const mockParticipantId = participantId ?? randomDataGenerator.guid();
+  const mockRoomUserId = roomUserId ?? v4();
+  const mockAppId = appId ?? randomDataGenerator.word();
+  const mockRoomId = roomId ?? randomDataGenerator.guid();
+
+  return {
+    idempotencyKey: v4(),
+    customerId: randomDataGenerator.guid(),
+    appId: mockAppId,
+    eventType,
+    sessionId: v4(),
+    timestamp: Date.now(),
+    fqn: `${mockAppId}/${mockRoomId}`,
+    data: {
+      moderator: false,
+      name: randomDataGenerator.name(),
+      id: `${mockParticipantId}/${mockRoomUserId}`,
+      participantJid: randomDataGenerator.guid(),
+      participantId: mockParticipantId,
+    },
+    ...overrides,
+  };
+};

src/modules/call/infrastructure/room-user.repository.spec.ts

@@ -57,7 +57,9 @@ describe('SequelizeRoomUserRepository', () => {
 
       const result = await repository.create(roomUserCreateData);
 
-      expect(createRoomUserSpy).toHaveBeenCalledWith(roomUserCreateData, { transaction: undefined });
+      expect(createRoomUserSpy).toHaveBeenCalledWith(roomUserCreateData, {
+        transaction: undefined,
+      });
       expect(result).toBeInstanceOf(RoomUser);
       expect(result.id).toEqual(mockRoomUserData.id);
       expect(result.roomId).toEqual(mockRoomUserData.roomId);

src/modules/call/infrastructure/room.repository.ts

@@ -3,6 +3,7 @@ import { InjectModel } from '@nestjs/sequelize';
 import { OmitCreateProperties } from '../../../shared/types/OmitCreateProperties';
 import { Room, RoomAttributes } from '../domain/room.domain';
 import { RoomModel } from '../models/room.model';
+import { Transaction } from 'sequelize';
 
 @Injectable()
 export class SequelizeRoomRepository {
@@ -38,6 +39,14 @@ export class SequelizeRoomRepository {
     await this.roomModel.update(data, { where: { id } });
   }
 
+  async updateWhere(
+    where: Partial<RoomAttributes>,
+    data: Partial<RoomAttributes>,
+    t?: Transaction,
+  ): Promise<void> {
+    await this.roomModel.update(data, { where, transaction: t });
+  }
+
   async delete(id: RoomAttributes['id']): Promise<void> {
     await this.roomModel.destroy({ where: { id } });
   }