PEER-219: Streamline query logic and integrate with matching service

Signed-off-by: SeeuSim <[email protected]>

Author: SeeuSim

.eslintrc.json

@@ -21,6 +21,13 @@
     "simple-import-sort"
   ],
   "rules": {
+    "@typescript-eslint/array-type": [
+      "error",
+      {
+        "default": "generic",
+        "readonly": "generic"
+      }
+    ],
     "@typescript-eslint/no-explicit-any": "warn",
     "@typescript-eslint/explicit-module-boundary-types": "off",
     "@typescript-eslint/explicit-function-return-type": 0,

backend/matching/src/index.ts

@@ -5,7 +5,7 @@ import { logger } from '@/lib/utils';
 import server, { io } from '@/server';
 import { initWorker } from '@/workers';
 
-const workers: ChildProcess[] = [];
+const workers: Array<ChildProcess> = [];
 
 const port = Number.parseInt(EXPRESS_PORT || '8001');
 

backend/matching/src/services/get-match-items.ts

@@ -3,7 +3,6 @@ import type { IMatchItemsResponse, IMatchType } from '@/types';
 
 import { createRoom } from './collab';
 import { getRandomQuestion } from './question';
-import { fetchAttemptedQuestions } from './user';
 
 export async function getMatchItems(
   searchIdentifier: IMatchType,
@@ -17,26 +16,13 @@ export async function getMatchItems(
       throw new Error('Both user IDs are required');
     }
 
-    let allAttemptedQuestions: number[] = [];
-
-    try {
-      const [attemptedQuestions1, attemptedQuestions2] = await Promise.all([
-        fetchAttemptedQuestions(userId1),
-        fetchAttemptedQuestions(userId2),
-      ]);
-      allAttemptedQuestions = [...new Set([...attemptedQuestions1, ...attemptedQuestions2])];
-    } catch (error) {
-      logger.error('Error in getMatchItems: Failed to fetch attempted questions', error);
-    }
-
     const topics = topic?.split('|') ?? [];
     const payload = {
-      attemptedQuestions: allAttemptedQuestions,
+      userId1,
+      userId2,
       ...(searchIdentifier === 'difficulty' && difficulty ? { difficulty } : {}),
-      ...(searchIdentifier === 'topic' && topic ? { topic: topics } : {}),
-      ...(searchIdentifier === 'exact match' && topic && difficulty
-        ? { topic: topics, difficulty }
-        : {}),
+      ...(searchIdentifier === 'topic' && topic ? { topics } : {}),
+      ...(searchIdentifier === 'exact match' && topic && difficulty ? { topics, difficulty } : {}),
     };
 
     // Get a random question
@@ -55,7 +41,8 @@ export async function getMatchItems(
       questionId: question.id,
     };
   } catch (error) {
-    logger.error('Error in getMatchItems:', error);
+    const { name, message, stack, cause } = error as Error;
+    logger.error(`Error in getMatchItems: ${JSON.stringify({ name, message, stack, cause })}`);
     return undefined;
   }
 }

backend/matching/src/services/question.ts

@@ -1,16 +1,16 @@
-import type { IGetRandomQuestionPayload, IQuestion, IServiceResponse } from '@/types';
+import type { IGetRandomQuestionPayload, IQuestion } from '@/types';
 
 import { questionServiceClient, routes } from './_hosts';
 
 export async function getRandomQuestion(payload: IGetRandomQuestionPayload): Promise<IQuestion> {
-  const response = await questionServiceClient.post<IServiceResponse<{ question: IQuestion }>>(
+  const response = await questionServiceClient.post<IQuestion>(
     routes.QUESTION_SERVICE.GET_RANDOM_QN.path,
     payload
   );
 
-  if (response.status !== 200 || !response.data.data) {
-    throw new Error(response.data.error?.message || 'Failed to get a random question');
+  if (response.status !== 200 || !response.data) {
+    throw new Error(response.statusText || 'Failed to get a random question');
   }
 
-  return response?.data?.data?.question ?? undefined;
+  return response?.data ?? undefined;
 }

backend/matching/src/services/user.ts

@@ -1,7 +1,7 @@
 import { routes, userServiceClient } from './_hosts';
 
-export async function fetchAttemptedQuestions(userId: string): Promise<number[]> {
-  const response = await userServiceClient.post<number[]>(
+export async function fetchAttemptedQuestions(userId: string): Promise<Array<number>> {
+  const response = await userServiceClient.post<Array<number>>(
     routes.USER_SERVICE.ATTEMPTED_QNS.GET.path,
     {
       userId,

backend/matching/src/types/index.ts

@@ -10,7 +10,7 @@ export type IRequestMatchRESTPayload = {
 };
 
 export type IRequestMatchWSPayload = {
-  topic: string | string[];
+  topic: string | Array<string>;
   difficulty: string;
 };
 
@@ -61,9 +61,10 @@ export interface IQuestion {
 }
 
 export interface IGetRandomQuestionPayload {
-  attemptedQuestions: number[];
+  userId1: string;
+  userId2: string;
   difficulty?: string;
-  topic?: Array<string>;
+  topics?: Array<string>;
 }
 
 export interface IMatchItemsResponse {

backend/matching/src/workers/matcher.ts

@@ -73,7 +73,7 @@ async function processMatch(
       ]);
 
       // Notify both sockets
-      const { ...matchItems } = await getMatchItems(
+      const matchItems = await getMatchItems(
         searchIdentifier,
         topic,
         difficulty,

backend/question/package.json

@@ -31,7 +31,8 @@
     "http-status-codes": "^2.3.0",
     "pino": "^9.4.0",
     "pino-http": "^10.3.0",
-    "postgres": "^3.4.4"
+    "postgres": "^3.4.4",
+    "uuid": "^11.0.2"
   },
   "devDependencies": {
     "@swc/core": "^1.7.26",

backend/question/src/controller/attempted-controller.ts

@@ -1,6 +1,10 @@
 import { Request, Response } from 'express';
+import { StatusCodes } from 'http-status-codes';
 
-import { addAttempt } from '../services/post/addAttempt';
+import { logger } from '@/lib/utils';
+import { isValidUUID } from '@/lib/uuid';
+import { getQuestionAttempts } from '@/services/get/get-attempts';
+import { addAttempt } from '@/services/post/addAttempt';
 
 // Define the expected request body structure
 interface AddAttemptRequestBody {
@@ -34,14 +38,40 @@ export const createAttempt = async (
     });
 
     // Respond with success
-    res.status(201).json({ message: 'Attempt added successfully', result });
-  } catch (error) {
-    console.error('Error adding attempt:', error);
+    res.status(StatusCodes.OK).json({ message: 'Attempt added successfully', result });
+  } catch (err) {
+    const { name, message, stack, cause } = err as Error;
+    logger.error({ name, message, stack, cause }, 'Error adding attempt');
 
     // Enhanced error response with error details
     res.status(500).json({
       error: 'Error adding attempt',
-      details: error instanceof Error ? error.message : 'Unknown error',
+      details: err instanceof Error ? err.message : 'Unknown error',
+    });
+  }
+};
+
+export const getAttempts = async (
+  req: Request<unknown, unknown, Partial<Parameters<typeof getQuestionAttempts>[0]>, unknown>,
+  res: Response
+) => {
+  const { questionId, userId, limit, offset } = req.body;
+
+  if (!questionId || isNaN(questionId) || !userId || !isValidUUID(userId)) {
+    return res.status(StatusCodes.UNPROCESSABLE_ENTITY).json('Malformed Request');
+  }
+
+  try {
+    const result = await getQuestionAttempts({ questionId, userId, limit, offset });
+    return res.status(StatusCodes.OK).json(result);
+  } catch (err) {
+    const { name, message, stack, cause } = err as Error;
+    logger.error({ name, message, stack, cause }, 'Error retrieving attempts');
+
+    // Enhanced error response with error details
+    res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+      error: 'Error retrieving attempts',
+      details: err instanceof Error ? err.message : 'Unknown error',
     });
   }
 };

backend/question/src/controller/question-controller.ts

@@ -5,15 +5,10 @@ import {
   getDifficultiesService,
   getQuestionDetailsService,
   getQuestionsService,
-  getRandomQuestionService,
   getTopicsService,
   searchQuestionsByTitleService,
 } from '@/services/get/index';
-import type {
-  IGetQuestionPayload,
-  IGetQuestionsPayload,
-  IGetRandomQuestionPayload,
-} from '@/services/get/types';
+import type { IGetQuestionPayload, IGetQuestionsPayload } from '@/services/get/types';
 import {
   createQuestionService,
   deleteQuestionService,
@@ -30,7 +25,7 @@ export const getQuestions = async (req: Request, res: Response): Promise<Respons
   const payload: IGetQuestionsPayload = {
     questionName: questionName as string,
     difficulty: difficulty as string,
-    topic: topic as string[],
+    topic: topic as Array<string>,
     pageNum: parseInt(pageNum as string) || 0,
     recordsPerPage: parseInt(recordsPerPage as string) || 20,
   };
@@ -74,25 +69,6 @@ export const getQuestionDetails = async (req: Request, res: Response): Promise<R
   }
 };
 
-export const getRandomQuestion = async (req: Request, res: Response): Promise<Response> => {
-  const payload: IGetRandomQuestionPayload = {
-    attemptedQuestions: req.body.attemptedQuestions,
-    difficulty: req.body.difficulty,
-    topic: req.body.topic,
-  };
-
-  try {
-    const result = await getRandomQuestionService(payload);
-    return res.status(result.code).json(result);
-  } catch (error) {
-    console.log('error', error);
-
-    return res
-      .status(StatusCodes.INTERNAL_SERVER_ERROR)
-      .json({ success: false, message: 'An error occurred', error });
-  }
-};
-
 export const searchQuestionsByTitle = async (req: Request, res: Response): Promise<Response> => {
   const { title } = req.query;
   const page = parseInt(req.query.page as string) || 1;