feat: Implement room duration management and notifications for chat rooms

Author: HARRIFIED

src/migrations/1766007704989-AutoGenerated.ts

@@ -0,0 +1,14 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AutoGenerated1766007704989 implements MigrationInterface {
+    name = 'AutoGenerated1766007704989'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "rooms" ALTER COLUMN "ephemeral" SET DEFAULT true`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "rooms" ALTER COLUMN "ephemeral" SET DEFAULT false`);
+    }
+
+}

src/rooms/entities/room.entity.ts

@@ -26,7 +26,7 @@ export class Room {
   @Column({ default: true })
   isOpen: boolean;
 
-  @Column({ default: false })
+  @Column({ default: true })
   ephemeral: boolean;
 
   @Column({ type: 'int', default: 2592000 })

src/rooms/rooms.controller.ts

@@ -340,6 +340,15 @@ export class RoomsController {
     return false;
   }
 
+  @Get(':id/remaining-time')
+  async getRemainingTime(@Param('id') id: string) {
+    const remainingSeconds = await this.roomsService.getRoomRemainingTime(id);
+    return {
+      remainingSeconds,
+      hasTimeLimit: remainingSeconds !== null,
+    };
+  }
+
   private async claimUsernameAtomically(roomId: string, username: string): Promise<boolean> {
     const client = this.redisService.getClient();
     const key = `room:${roomId}:username:${username}`;

src/rooms/rooms.module.ts

@@ -9,6 +9,7 @@ import { ParticipantsModule } from '../participants/participants.module';
 import {RoomBan} from "../participants/entities/room-ban.entity";
 import {WebsocketModule} from "../websocket/websocket.module";
 import { RoomFingerprint } from './entities/room-fingerprint.entity';
+import { forwardRef } from '@nestjs/common';
 
 @Module({
   imports: [
@@ -20,7 +21,7 @@ import { RoomFingerprint } from './entities/room-fingerprint.entity';
     AuthModule, 
     RedisModule, 
     ParticipantsModule, 
-    WebsocketModule
+    forwardRef(() => WebsocketModule)
   ],
   providers: [RoomsService],
   controllers: [RoomsController],

src/rooms/rooms.service.ts

@@ -9,10 +9,13 @@ import { SessionService } from '../auth/session.service';
 import { ParticipantsService } from '../participants/participants.service';
 import { RoomBan } from '../participants/entities/room-ban.entity';
 import { RoomFingerprint } from './entities/room-fingerprint.entity';
+import { forwardRef, Inject } from '@nestjs/common';
 
 @Injectable()
 export class RoomsService {
   private readonly logger = new Logger(RoomsService.name);
+  private roomTimers = new Map<string, NodeJS.Timeout>();
+  private chatGateway: any; // Will be set after module initialization to avoid circular dependency
 
   constructor(
     @InjectRepository(Room) private readonly roomRepo: Repository<Room>,
@@ -22,6 +25,11 @@ export class RoomsService {
     @InjectRepository(RoomFingerprint) private readonly roomFingerprintRepo: Repository<RoomFingerprint>,
   ) {}
 
+  // Setter to inject ChatGateway after initialization
+  setChatGateway(gateway: any) {
+    this.chatGateway = gateway;
+  }
+
   async verifyModeratorToken(roomId: string, moderatorToken: string) {
     const room = await this.roomRepo.findOne({ where: { id: roomId } });
     if (!room) {
@@ -200,6 +208,9 @@ export class RoomsService {
       throw new ForbiddenException('Invalid moderator token');
     }
 
+    // Cancel the duration timer if it exists
+    this.cancelRoomDurationTimer(roomId);
+
     // First, close the room so no new participants can join
     await this.roomRepo
       .createQueryBuilder()
@@ -273,4 +284,123 @@ export class RoomsService {
       .where("id = :id", { id: roomId })
       .execute();
   }
+
+  /**
+   * Start a timer for a room based on its chatDurationSeconds.
+   * When the timer expires, the room will be automatically closed and all sessions ended.
+   */
+  async startRoomDurationTimer(roomId: string) {
+    // Check if timer already exists
+    if (this.roomTimers.has(roomId)) {
+      this.logger.log(`Timer already exists for room ${roomId}`);
+      return;
+    }
+
+    const room = await this.roomRepo.findOne({ where: { id: roomId } });
+    if (!room) {
+      this.logger.warn(`Cannot start timer for non-existent room ${roomId}`);
+      return;
+    }
+
+    if (!room.chatDurationSeconds || room.chatDurationSeconds <= 0) {
+      this.logger.log(`Room ${roomId} has no duration limit, skipping timer`);
+      return;
+    }
+
+    // Calculate remaining time
+    const now = new Date();
+    const elapsed = (now.getTime() - room.createdAt.getTime()) / 1000;
+    const remaining = room.chatDurationSeconds - elapsed;
+
+    if (remaining <= 0) {
+      this.logger.log(`Room ${roomId} duration already expired, ending immediately`);
+      await this.endRoomByDuration(roomId);
+      return;
+    }
+
+    this.logger.log(`Starting ${remaining}s timer for room ${roomId}`);
+    const timeout = setTimeout(() => {
+      this.endRoomByDuration(roomId);
+    }, remaining * 1000);
+
+    this.roomTimers.set(roomId, timeout);
+  }
+
+  /**
+   * End a room automatically when its chat duration is reached.
+   */
+  async endRoomByDuration(roomId: string) {
+    this.logger.log(`Room ${roomId} duration reached, ending all sessions`);
+    
+    // Clear the timer
+    const timer = this.roomTimers.get(roomId);
+    if (timer) {
+      clearTimeout(timer);
+      this.roomTimers.delete(roomId);
+    }
+
+    const room = await this.roomRepo.findOne({ where: { id: roomId } });
+    if (!room) {
+      this.logger.warn(`Room ${roomId} not found when trying to end by duration`);
+      return;
+    }
+
+    if (room.closedAt) {
+      this.logger.log(`Room ${roomId} already closed`);
+      return;
+    }
+
+    // Close the room
+    await this.roomRepo
+      .createQueryBuilder()
+      .update(Room)
+      .set({ isOpen: false, closedAt: new Date() })
+      .where("id = :id", { id: roomId })
+      .execute();
+
+    this.logger.log(`Room ${roomId} closed due to duration limit, destroying sessions`);
+
+    // Notify all participants that the room has ended due to duration
+    if (this.chatGateway) {
+      this.chatGateway.emitRoomEnded(roomId, 'Chat duration time limit has been reached');
+    }
+
+    // Destroy all sessions for the room
+    await this.sessionService.destroyAllSessionsForRoom(roomId);
+  }
+
+  /**
+   * Cancel the duration timer for a room (e.g., if manually closed by moderator)
+   */
+  cancelRoomDurationTimer(roomId: string) {
+    const timer = this.roomTimers.get(roomId);
+    if (timer) {
+      clearTimeout(timer);
+      this.roomTimers.delete(roomId);
+      this.logger.log(`Cancelled duration timer for room ${roomId}`);
+    }
+  }
+
+  /**
+   * Get remaining time in seconds for a room's chat duration.
+   * Returns null if no duration limit or if already expired/closed.
+   */
+  async getRoomRemainingTime(roomId: string): Promise<number | null> {
+    const room = await this.roomRepo.findOne({ where: { id: roomId } });
+    if (!room) return null;
+
+    if (!room.chatDurationSeconds || room.chatDurationSeconds <= 0) {
+      return null; // No duration limit
+    }
+
+    if (room.closedAt || !room.isOpen) {
+      return 0; // Room is closed
+    }
+
+    const now = new Date();
+    const elapsed = (now.getTime() - room.createdAt.getTime()) / 1000;
+    const remaining = room.chatDurationSeconds - elapsed;
+
+    return remaining > 0 ? remaining : 0;
+  }
 }

src/websocket/chat.gateway.ts

@@ -8,7 +8,7 @@ import {
   ConnectedSocket,
 } from '@nestjs/websockets';
 import { Server, Socket } from 'socket.io';
-import { Logger } from '@nestjs/common';
+import { Logger, forwardRef, Inject } from '@nestjs/common';
 import { RedisService } from '../redis/redis.service';
 import { SessionService } from '../auth/session.service';
 import { MessagesService } from '../messages/messages.service';
@@ -24,13 +24,19 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
 
   // Track active connections to prevent duplicate presence events
   private activeConnections = new Map<string, { socketId: string; timestamp: number }>();
+  private roomsService: any; // Will be set after initialization
 
   constructor(
     private readonly redisService: RedisService,
     private readonly sessionService: SessionService,
     private readonly messagesService: MessagesService,
   ) {}
 
+  // Setter to inject RoomsService after initialization
+  setRoomsService(roomsService: any) {
+    this.roomsService = roomsService;
+  }
+
   afterInit(server: Server) {
     this.server = server;
     this.logger.log('WebSocket server initialized');
@@ -179,6 +185,13 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
       })
     );
 
+    // Start room duration timer when first participant joins
+    const presenceCount = await redis.hlen(`presence:${roomId}`);
+    if (presenceCount === 1 && this.roomsService) {
+      this.logger.log(`First participant joined room ${roomId}, starting duration timer`);
+      await this.roomsService.startRoomDurationTimer(roomId);
+    }
+
     // Only emit presence if this is a new connection
     this.server.to(`room_${roomId}`)
       .emit('presence', { 

src/websocket/websocket.module.ts

@@ -1,13 +1,38 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef, OnModuleInit } from '@nestjs/common';
 import { ChatGateway } from './chat.gateway';
 import { RedisModule } from '../redis/redis.module';
 import { AuthModule } from '../auth/auth.module';
 import { MessagesModule } from '../messages/messages.module';
-
+import { ModuleRef } from '@nestjs/core';
 
 @Module({
-  imports: [RedisModule, AuthModule, MessagesModule],
+  imports: [
+    RedisModule, 
+    AuthModule, 
+    MessagesModule,
+  ],
   providers: [ChatGateway],
   exports: [ChatGateway],
 })
-export class WebsocketModule {}
+export class WebsocketModule implements OnModuleInit {
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly chatGateway: ChatGateway,
+  ) {}
+
+  async onModuleInit() {
+    // Dynamically resolve RoomsService to avoid circular dependency at module level
+    try {
+      const { RoomsService } = await import('../rooms/rooms.service');
+      const roomsService = this.moduleRef.get(RoomsService, { strict: false });
+      
+      if (roomsService) {
+        this.chatGateway.setRoomsService(roomsService);
+        roomsService.setChatGateway(this.chatGateway);
+        console.log('Successfully linked ChatGateway and RoomsService');
+      }
+    } catch (error) {
+      console.error('Failed to link ChatGateway and RoomsService:', error);
+    }
+  }
+}