Implement userid validation

Author: evanyan13

backend/gateway-service/src/modules/match/match.controller.ts

@@ -19,6 +19,7 @@ import {
   MATCH_TIMEOUT,
   MATCH_REQUESTED,
   MATCH_ERROR,
+  EXCEPTION,
 } from './match.event';
 import { CANCEL_MATCH, FIND_MATCH } from './match.message';
 
@@ -37,6 +38,7 @@ export class MatchGateway implements OnGatewayInit {
 
   constructor(
     @Inject('MATCHING_SERVICE') private matchingClient: ClientProxy,
+    @Inject('USER_SERVICE') private userClient: ClientProxy,
     private redisService: RedisService,
   ) {}
 
@@ -67,22 +69,19 @@ export class MatchGateway implements OnGatewayInit {
       );
       return;
     }
-    // Send the match request to the microservice
+
     try {
-      firstValueFrom(this.matchingClient.send('match-request', payload))
-        .then(() =>
-          console.log(
-            `Match request from user ${payload.userId} received successfully`,
-          ),
-        )
-        .catch((error) =>
-          console.error(
-            `Error requesting match for user ${payload.userId}: ${error.message}`,
-          ),
-        );
-      this.server.to(client.id).emit(MATCH_REQUESTED, {
-        message: `Match request sent to the matching service.`,
-      });
+      const result = await firstValueFrom(
+        this.matchingClient.send('match-request', payload),
+      );
+
+      if (result.success) {
+        this.server.to(client.id).emit(MATCH_REQUESTED, {
+          message: result.message,
+        });
+      } else {
+        client.emit(MATCH_ERROR, result.message);
+      }
     } catch (error) {
       client.emit(MATCH_ERROR, `Error requesting match: ${error.message}`);
       return;
@@ -94,6 +93,14 @@ export class MatchGateway implements OnGatewayInit {
     @ConnectedSocket() client: Socket,
     @MessageBody() payload: { userId: string },
   ) {
+    if (!payload.userId) {
+      client.emit(
+        MATCH_ERROR,
+        'Invalid userId. Please check your payload and try again.',
+      );
+      return;
+    }
+
     firstValueFrom(
       this.matchingClient.send('match-cancel', { userId: payload.userId }),
     )
@@ -137,11 +144,42 @@ export class MatchGateway implements OnGatewayInit {
     });
   }
 
-  handleConnection(@ConnectedSocket() client: Socket) {
-    const userId = client.handshake.query.userId;
-    if (userId) {
-      this.userSockets.set(userId as string, client.id);
-      console.log(`User ${userId} connected with socket ID ${client.id}`);
+  async handleConnection(@ConnectedSocket() client: Socket) {
+    const id = client.handshake.query.userId;
+
+    if (!id) {
+      client.emit(
+        EXCEPTION,
+        'Error connecting to /match socket: No userId provided.',
+      );
+      client.disconnect();
+      return;
+    }
+
+    try {
+      const existingUser = await firstValueFrom(
+        this.userClient.send({ cmd: 'get-user-by-id' }, id),
+      );
+
+      if (!existingUser) {
+        client.emit(
+          EXCEPTION,
+          'Error connecting to /match socket: Invalid userId.',
+        );
+        client.disconnect();
+        return;
+      }
+
+      if (id) {
+        this.userSockets.set(id as string, client.id);
+        console.log(`User ${id} connected with socket ID ${client.id}`);
+      }
+    } catch (error) {
+      client.emit(
+        EXCEPTION,
+        `Error connecting to /match socket: ${error.message}`,
+      );
+      return;
     }
   }
 

backend/gateway-service/src/modules/match/match.event.ts

@@ -4,3 +4,4 @@ export const MATCH_CANCELLED = 'matchCancelled'; // Emitted when a match is canc
 export const MATCH_CONFIRMED = 'matchConfirmed'; // Emitted when a match is confirmed
 export const MATCH_TIMEOUT = 'matchTimeout'; // Emitted after 5 minutes of inactivity
 export const MATCH_ERROR = 'matchError'; // Emitted when an error occurs
+export const EXCEPTION = 'exception'; // Emitted when an exception occurs

backend/matching-service/src/app.controller.ts

@@ -9,7 +9,7 @@ export class AppController {
 
   @MessagePattern('match-request')
   async handleMatchRequest(@Payload() data: MatchRequestDto) {
-    await this.appService.requestMatch(data);
+    return this.appService.requestMatch(data);
   }
 
   @MessagePattern('match-cancel')

backend/matching-service/src/app.service.ts

@@ -1,14 +1,15 @@
 import { Injectable } from '@nestjs/common';
 import { MatchRequestDto } from './dto/match-request.dto';
 import { RedisService } from './redis.service';
+import { MatchResponse } from './interfaces';
 
 @Injectable()
 export class AppService {
   constructor(private redisService: RedisService) {}
 
   // Add user to the Redis pool
-  async requestMatch(data: MatchRequestDto): Promise<void> {
-    await this.redisService.addUserToPool(data);
+  async requestMatch(data: MatchRequestDto): Promise<MatchResponse> {
+    return this.redisService.addUserToPool(data);
   }
 
   // Remove user from the Redis pool

backend/matching-service/src/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './match-job.interface';
+export * from './match-response.interface';

backend/matching-service/src/interfaces/match-response.interface.ts

@@ -0,0 +1,4 @@
+export interface MatchResponse {
+  success: boolean;
+  message: string;
+}

backend/matching-service/src/match-worker.service.ts

@@ -10,47 +10,68 @@ export class MatchWorkerService {
   // Poll for matches at a regular interval
   async pollForMatches() {
     setInterval(async () => {
-      const users = await this.redisService.getUsersFromPool();
+      const users = await this.redisService.getAllUsersFromPool();
       const currentTime = Date.now();
       const timeout = 300000; // 5 minutes to remove any zombie users
       console.log('Polling', users);
       // Filter out users who have timed out
-      const activeUsers = users.filter(user => currentTime - user.timestamp < timeout);
+      const activeUsers = users.filter(
+        (user) => currentTime - user.timestamp < timeout,
+      );
 
       if (activeUsers.length < users.length) {
-        const timedOutUsers = users.filter(user => currentTime - user.timestamp >= timeout);
-        await this.notifyGatewayTimeout(timedOutUsers.map(user => user.userId));
-        await this.redisService.removeUsersFromPool(timedOutUsers.map(user => user.userId));
+        const timedOutUsers = users.filter(
+          (user) => currentTime - user.timestamp >= timeout,
+        );
+        await this.notifyGatewayTimeout(
+          timedOutUsers.map((user) => user.userId),
+        );
+        await this.redisService.removeUsersFromPool(
+          timedOutUsers.map((user) => user.userId),
+        );
       }
 
       if (activeUsers.length >= 2) {
         const matches = this.rankUsers(activeUsers);
         const bestMatch = matches[0];
 
         // Notify the gateway via Redis Pub/Sub
-        await this.notifyGateway([bestMatch.user1.userId, bestMatch.user2.userId]);
+        await this.notifyGateway([
+          bestMatch.user1.userId,
+          bestMatch.user2.userId,
+        ]);
 
         // Remove the matched users from the Redis pool
-        await this.redisService.removeUsersFromPool([bestMatch.user1.userId, bestMatch.user2.userId]);
+        await this.redisService.removeUsersFromPool([
+          bestMatch.user1.userId,
+          bestMatch.user2.userId,
+        ]);
       }
     }, 5000);
   }
 
   // Ranking logic for matches
-  rankUsers(users: MatchRequestDto[]): { user1: MatchRequestDto, user2: MatchRequestDto, score: number }[] {
+  rankUsers(
+    users: MatchRequestDto[],
+  ): { user1: MatchRequestDto; user2: MatchRequestDto; score: number }[] {
     const matches = [];
     for (let i = 0; i < users.length; i++) {
       for (let j = i + 1; j < users.length; j++) {
         const score = this.calculateScore(users[i], users[j]);
         matches.push({ user1: users[i], user2: users[j], score });
       }
     }
-    return matches.sort((a, b) => b.score - a.score)
+    return matches.sort((a, b) => b.score - a.score);
   }
 
-  private calculateScore(user1: MatchRequestDto, user2: MatchRequestDto): number {
+  private calculateScore(
+    user1: MatchRequestDto,
+    user2: MatchRequestDto,
+  ): number {
     let score = 0;
-    const matchingTopics = user1.selectedTopic.filter(topic => user2.selectedTopic.includes(topic));
+    const matchingTopics = user1.selectedTopic.filter((topic) =>
+      user2.selectedTopic.includes(topic),
+    );
     score += matchingTopics.length * 3;
     if (user1.selectedDifficulty === user2.selectedDifficulty) {
       score += 2;
@@ -67,4 +88,3 @@ export class MatchWorkerService {
     await this.redisService.publishTimedOutUsers(userIds);
   }
 }
-

backend/matching-service/src/redis.service.ts

@@ -3,6 +3,8 @@ import Redis from 'ioredis';
 import { MatchRequestDto } from './dto/match-request.dto';
 import { MatchJob } from './interfaces/match-job.interface';
 import { config } from 'src/configs';
+import { RpcException } from '@nestjs/microservices';
+import { MatchResponse } from './interfaces';
 
 @Injectable()
 export class RedisService {
@@ -21,27 +23,51 @@ export class RedisService {
   }
 
   // Add user to Redis pool
-  async addUserToPool(data: MatchRequestDto): Promise<void> {
-    const payload: MatchJob = {
-      userId: data.userId,
-      selectedTopic: data.selectedTopic,
-      selectedDifficulty: data.selectedDifficulty,
-      timestamp: Date.now(),
-    };
+  async addUserToPool(data: MatchRequestDto): Promise<MatchResponse> {
+    try {
+      const payload: MatchJob = {
+        userId: data.userId,
+        selectedTopic: data.selectedTopic,
+        selectedDifficulty: data.selectedDifficulty,
+        timestamp: Date.now(),
+      };
+      console.log('Adding user to pool:', payload);
 
-    
-    await this.redisPublisher.sadd('userPool', JSON.stringify(payload));
+      const existingUser = await this.getUserFromPool(data.userId);
+      if (existingUser) {
+        return {
+          success: false,
+          message: 'User already in pool',
+        };
+      }
+
+      await this.redisPublisher.sadd('userPool', JSON.stringify(payload));
+      return {
+        success: true,
+        message: 'User added to pool successfully',
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to add user to matching pool: ${error.message}`,
+      };
+    }
+  }
+
+  async getUserFromPool(userId: string): Promise<boolean> {
+    const users = await this.redisPublisher.smembers('userPool');
+    return users.some((user) => JSON.parse(user).userId === userId);
   }
 
   // Get users from Redis pool
-  async getUsersFromPool(): Promise<MatchJob[]> {
+  async getAllUsersFromPool(): Promise<MatchJob[]> {
     const users = await this.redisPublisher.smembers('userPool');
     return users.map((user) => JSON.parse(user));
   }
 
   // Remove users from Redis pool
   async removeUsersFromPool(userIds: string[]) {
-    const users = await this.getUsersFromPool();
+    const users = await this.getAllUsersFromPool();
 
     // Find and remove users whose userId matches the provided userIds
     userIds.forEach(async (userId) => {

backend/user-service/src/app.service.ts

@@ -1,7 +1,6 @@
-import * as bcrypt from 'bcryptjs';
 import { Injectable } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
+import mongoose, { Model } from 'mongoose';
 import { RpcException } from '@nestjs/microservices';
 import { User } from './schema/user.schema';
 import {
@@ -25,6 +24,10 @@ export class AppService {
   }
 
   public async getUserById(id: string): Promise<User> {
+    if (!mongoose.Types.ObjectId.isValid(id)) {
+      throw new RpcException('Invalid _id format (Provide an ObjectId)');
+    }
+
     const user = await this.userModel.findById(id).exec();
     return user;
   }