Add redis message queue

Author: Jajared

backend/docker-compose.yml

@@ -86,7 +86,14 @@ services:
     networks:
       - backend-network
     ports:
-      - "3003:4000" 
+      - "3004:4000"
+
+  redis:
+    image: redis:latest
+    ports:
+      - "6379:6379"
+    networks:
+      - backend-network
 
 networks:
   backend-network:

backend/gateway-service/package-lock.json

@@ -30,6 +30,7 @@
     "@nestjs/websockets": "^10.4.4",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "ioredis": "^5.4.1",
     "passport-jwt": "^4.0.1",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.1"

backend/gateway-service/package.json

@@ -5,7 +5,8 @@ import { AuthController } from './modules/auth/auth.controller';
 import { QuestionController } from './modules/question/question.controller';
 import { APP_GUARD } from '@nestjs/core';
 import { AtAuthGuard, RtAuthGuard } from './common/guards';
-import { MatchController } from './modules/match/match.controller';
+import { MatchGateway } from './modules/match/match.controller';
+import { RedisService } from './modules/match/redis.service';
 
 @Module({
   imports: [
@@ -36,21 +37,23 @@ import { MatchController } from './modules/match/match.controller';
       },
       {
         name: 'MATCHING_SERVICE',
-        transport: Transport.REDIS,
+        transport: Transport.TCP,
         options: {
-          host: 'localhost',
-          port: 6379,
+          host: 'matching-service',
+          port: 3004,
         },
       }
     ]),
   ],
-  controllers: [UserController, QuestionController, AuthController, MatchController],
+  controllers: [UserController, QuestionController, AuthController],
   providers: [
     RtAuthGuard,
     {
       provide: APP_GUARD,
       useClass: AtAuthGuard,
     },
+    MatchGateway,
+    RedisService,
   ],
 })
 export class AppModule {}

backend/gateway-service/src/app.module.ts

@@ -1 +1,2 @@
 export { UserMatchOptionsDto } from './user-match-options.dto';
+export { MatchRequestDto } from './match-request.dto';

backend/gateway-service/src/modules/match/dto/index.ts

@@ -0,0 +1,18 @@
+import { Type } from 'class-transformer';
+import { IsArray, IsNotEmpty, IsString } from 'class-validator';
+
+export class MatchRequestDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsNotEmpty()
+  @Type(() => String)
+  selectedTopic: string[];
+
+  @IsString()
+  @IsNotEmpty()
+  selectedDifficulty: string;
+}

backend/gateway-service/src/modules/match/dto/match-request.dto.ts

@@ -3,14 +3,18 @@ import { Type } from 'class-transformer';
 import { IsArray, IsIn, IsNotEmpty, IsString } from 'class-validator';
 
 export class UserMatchOptionsDto {
+
+  @IsString()
+  userId: string;
+  
   @ApiProperty({
     description: 'Either Easy, Medium, or Hard',
     example: 'Easy',
   })
   @IsString()
   @IsNotEmpty()
   @IsIn(['Easy', 'Medium', 'Hard'])
-  difficulty: string;
+  selectedDifficulty: string;
 
   @ApiProperty({
     example: ['Stack', 'String'],
@@ -19,5 +23,5 @@ export class UserMatchOptionsDto {
   @IsString({ each: true })
   @IsNotEmpty()
   @Type(() => String)
-  categories: string[];
+  selectedTopic: string[];
 }

backend/gateway-service/src/modules/match/dto/user-match-options.dto.ts

@@ -1,59 +1,81 @@
-import { Inject } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
-import { ClientProxy } from '@nestjs/microservices';
-import { Socket } from 'socket.io';
 import {
+  WebSocketGateway,
+  WebSocketServer,
+  OnGatewayInit,
   ConnectedSocket,
-  MessageBody,
   SubscribeMessage,
-  WebSocketGateway,
+  MessageBody,
 } from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { RedisService } from './redis.service';
+import { ClientProxy } from '@nestjs/microservices';
+import { Inject } from '@nestjs/common';
 
-@ApiTags('match')
-@ApiBearerAuth('access-token')
 @WebSocketGateway({ namespace: '/match' })
-export class MatchController {
+export class MatchGateway implements OnGatewayInit {
+  @WebSocketServer() server: Server;
+
   constructor(
-    @Inject('MATCHING_SERVICE') private readonly matchingClient: ClientProxy,
+    private redisService: RedisService,
+    @Inject('MATCHING_SERVICE') private matchingClient: ClientProxy,
   ) {}
 
+  afterInit() {
+    // Subscribe to Redis Pub/Sub for user match notifications
+    this.redisService.subscribeToUserMatchEvents((payload) => {
+      this.notifyUsers(payload);
+    });
+  }
+
+  // Handle user connection and add them to a room based on their userId
+  handleConnection(@ConnectedSocket() client: Socket) {
+    const userId = client.handshake.query.userId; // Extract userId from query
+    if (userId) {
+      client.join(userId); // Make the client join a room based on userId
+      console.log(`User ${userId} connected and joined room ${userId}`);
+    } else {
+      console.log('User connected without userId');
+    }
+  }
+
   @SubscribeMessage('requestMatch')
   async handleRequestMatch(
     @ConnectedSocket() client: Socket,
     @MessageBody() payload: any,
-  ): Promise<void> {
-    // Send the match request to the microservice
-    this.matchingClient
-      .emit('match.request', {
-        userId: payload.userId,
-        topic: payload.topic,
-        difficulty: payload.difficulty,
-      })
-      .subscribe({
-        next: () => {
-          client.emit('matchInProgress', 'Finding a match...');
-        },
-        error: (err) => {
-          client.emit('matchError', 'Error finding match');
-        },
-      });
+  ) {
+    const matchPayload = {
+      userId: payload.userId,
+      selectedTopic: payload.selectedTopic,
+      selectedDifficulty: payload.selectedDifficulty,
+    };
+
+    // Emit match request event to the microservice
+    const timeoutRef = setTimeout(() => {
+      client.emit('matchTimeout', 'No match found within 30 seconds');
+    }, 30000); // Timeout after 30 seconds if no match is found
+
+    this.matchingClient.emit('match.request', matchPayload).subscribe({
+      next: () => {
+        // If a match is found, clear the timeout
+        clearTimeout(timeoutRef);
+        client.emit('matchInProgress', 'Finding a match...');
+      },
+      error: (err) => {
+        clearTimeout(timeoutRef);  // Also clear the timeout in case of an error
+        client.emit('matchError', 'Error finding match');
+      },
+    });
   }
 
-  @SubscribeMessage('cancelMatch')
-  async handleCancelMatch(
-    @ConnectedSocket() client: Socket, // Access Socket.io client
-    @MessageBody() payload: any, // Payload from the client
-  ): Promise<void> {
-    // Send the cancel request to the matching microservice
-    this.matchingClient
-      .emit('match.cancel', { userId: payload.userId })
-      .subscribe({
-        next: () => {
-          client.emit('matchCancelled', 'Match cancelled.');
-        },
-        error: (err) => {
-          client.emit('cancelError', 'Error cancelling match');
-        },
+  // Notify matched users via WebSocket
+  notifyUsers(userIds: string[]) {
+    userIds.forEach((userId, index) => {
+      const matchedUserId = userIds[index === 0 ? 1 : 0]; // Get the other matched user's ID
+      console.log(`Notifying user ${userId} about match with ${matchedUserId}`);
+      this.server.to(userId).emit('matchNotification', {
+        message: `You have been matched with user ${matchedUserId}`,
+        matchedUserId: matchedUserId,
       });
+    });
   }
 }