[Questions] Add filter params for get, better exceptions (#10)

This PR improves error handling, validation, and filtering in the
`questions-services` module. The changes include updating exception
handling in the `RpcExceptionFilter`, enhancing validation in the
`QuestionsController`, and refining database error handling in the
`QuestionsService`.

### Error Handling Improvements:

*
[`project/apps/api-gateway/src/filters/rpc-exception.filter.ts`](diffhunk://#diff-d296104e4b77e6a77f90203da00e7b5c6e57dfcf641bf954420f8c420e07479fL12-R14):
Added a default status code of 500 if `error.statusCode` is undefined.
*
[`project/packages/pipes/src/zod-validation-pipe.pipe.ts`](diffhunk://#diff-5d1894d6f1391424e0b3b8f193c6472aad155978c55467ed8e0aa250ae37c760L1-R1):
Improved error formatting in `ZodValidationPipe` and added structured
error responses for validation failures.
[[1]](diffhunk://#diff-5d1894d6f1391424e0b3b8f193c6472aad155978c55467ed8e0aa250ae37c760L1-R1)
[[2]](diffhunk://#diff-5d1894d6f1391424e0b3b8f193c6472aad155978c55467ed8e0aa250ae37c760R10-R34)

### Validation Enhancements:

*
[`project/apps/api-gateway/src/questions/questions.controller.ts`](diffhunk://#diff-6d78e3581db5b3d5e0c2347d6bb808a1a71518a54e86de60ce58e2b7bd1e5eb6R14-R28):
Moved validation from `questions-service` module to `api-gateway`
module. Added `HttpException` and `HttpStatus` for better error
responses.
[[1]](diffhunk://#diff-6d78e3581db5b3d5e0c2347d6bb808a1a71518a54e86de60ce58e2b7bd1e5eb6R14-R28)
[[2]](diffhunk://#diff-6d78e3581db5b3d5e0c2347d6bb808a1a71518a54e86de60ce58e2b7bd1e5eb6L28-R41)
[[3]](diffhunk://#diff-6d78e3581db5b3d5e0c2347d6bb808a1a71518a54e86de60ce58e2b7bd1e5eb6R50)
[[4]](diffhunk://#diff-6d78e3581db5b3d5e0c2347d6bb808a1a71518a54e86de60ce58e2b7bd1e5eb6L51-R68)
*
[`project/packages/dtos/src/questions.ts`](diffhunk://#diff-7e9b2f555ea4cdd6633cac37c90e669ed96f8101a81fbb843f7b84647ce95e1dL3-R17):
Replaced enum schemas with string schemas for `category` and
`complexity`. Added `getQuestionsQuerySchema` for query validation.
[[1]](diffhunk://#diff-7e9b2f555ea4cdd6633cac37c90e669ed96f8101a81fbb843f7b84647ce95e1dL3-R17)
[[2]](diffhunk://#diff-7e9b2f555ea4cdd6633cac37c90e669ed96f8101a81fbb843f7b84647ce95e1dR33-R34)

### Database Error Handling:

*
[`project/apps/questions-service/src/questions.service.ts`](diffhunk://#diff-3a7f7758daf8d580911308d1a2a9847a586cad97e1192d50d2ed98f6701b9cb8R3-R14):
Refined error handling by introducing `RpcException` for database
operations. Updated `findAll` method to support filtering by `title`,
`category`, and `complexity`.
[[1]](diffhunk://#diff-3a7f7758daf8d580911308d1a2a9847a586cad97e1192d50d2ed98f6701b9cb8R3-R14)
[[2]](diffhunk://#diff-3a7f7758daf8d580911308d1a2a9847a586cad97e1192d50d2ed98f6701b9cb8L28-R67)
[[3]](diffhunk://#diff-3a7f7758daf8d580911308d1a2a9847a586cad97e1192d50d2ed98f6701b9cb8L60-R80)
[[4]](diffhunk://#diff-3a7f7758daf8d580911308d1a2a9847a586cad97e1192d50d2ed98f6701b9cb8L75-R111)
[[5]](diffhunk://#diff-3a7f7758daf8d580911308d1a2a9847a586cad97e1192d50d2ed98f6701b9cb8L112-R127)

Author: jeffrey-jian

project/apps/api-gateway/src/filters/rpc-exception.filter.ts

@@ -9,6 +9,8 @@ export class RpcExceptionFilter implements ExceptionFilter {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse<Response>();
 
-    response.status(error.statusCode).json(error);
+    const statusCode = error?.statusCode || 500;
+
+    response.status(statusCode).json(error);
   }
 }

project/apps/api-gateway/src/questions/questions.controller.ts

@@ -11,10 +11,20 @@ import {
   Put,
   Delete,
   Query,
+  UsePipes,
+  BadRequestException,
 } from '@nestjs/common';
 import { ClientProxy } from '@nestjs/microservices';
 import { AuthGuard } from 'src/auth/auth.guard';
-import { CreateQuestionDto, UpdateQuestionDto } from '@repo/dtos/questions';
+import {
+  CreateQuestionDto,
+  createQuestionSchema,
+  GetQuestionsQueryDto,
+  getQuestionsQuerySchema,
+  UpdateQuestionDto,
+  updateQuestionSchema,
+} from '@repo/dtos/questions';
+import { ZodValidationPipe } from '@repo/pipes/zod-validation-pipe.pipe';
 
 @Controller('questions')
 @UseGuards(AuthGuard) // Can comment out if we dw auth for now
@@ -25,11 +35,9 @@ export class QuestionsController {
   ) {}
 
   @Get()
-  async getQuestions(@Query('includeDeleted') includeDeleted: boolean = false) {
-    return this.questionsServiceClient.send(
-      { cmd: 'get_questions' },
-      includeDeleted,
-    );
+  @UsePipes(new ZodValidationPipe(getQuestionsQuerySchema))
+  async getQuestions(@Query() filters: GetQuestionsQueryDto) {
+    return this.questionsServiceClient.send({ cmd: 'get_questions' }, filters);
   }
 
   @Get(':id')
@@ -38,6 +46,7 @@ export class QuestionsController {
   }
 
   @Post()
+  @UsePipes(new ZodValidationPipe(createQuestionSchema))
   async createQuestion(@Body() createQuestionDto: CreateQuestionDto) {
     return this.questionsServiceClient.send(
       { cmd: 'create_question' },
@@ -48,10 +57,11 @@ export class QuestionsController {
   @Put(':id')
   async updateQuestion(
     @Param('id') id: string,
-    @Body() updateQuestionDto: UpdateQuestionDto,
+    @Body(new ZodValidationPipe(updateQuestionSchema)) // validation on the body only
+    updateQuestionDto: UpdateQuestionDto,
   ) {
     if (id != updateQuestionDto.id) {
-      throw new Error('ID in URL does not match ID in request body');
+      throw new BadRequestException('ID in URL does not match ID in body');
     }
     return this.questionsServiceClient.send(
       { cmd: 'update_question' },

project/apps/questions-service/src/questions.controller.ts

@@ -1,20 +1,18 @@
-import { Controller, UsePipes } from '@nestjs/common';
+import { Controller } from '@nestjs/common';
 import { MessagePattern, Payload } from '@nestjs/microservices';
 import { QuestionsService } from './questions.service';
-import { ZodValidationPipe } from '@repo/pipes/zod-validation-pipe.pipe';
 import {
   CreateQuestionDto,
-  createQuestionSchema,
+  GetQuestionsQueryDto,
   UpdateQuestionDto,
-  updateQuestionSchema,
 } from '@repo/dtos/questions';
 @Controller()
 export class QuestionsController {
   constructor(private readonly questionsService: QuestionsService) {}
 
   @MessagePattern({ cmd: 'get_questions' })
-  async getQuestions(includeDeleted: boolean) {
-    return await this.questionsService.findAll(includeDeleted);
+  async getQuestions(@Payload() filters: GetQuestionsQueryDto) {
+    return await this.questionsService.findAll(filters);
   }
 
   @MessagePattern({ cmd: 'get_question' })
@@ -23,15 +21,13 @@ export class QuestionsController {
   }
 
   @MessagePattern({ cmd: 'create_question' })
-  @UsePipes(new ZodValidationPipe(createQuestionSchema))
   async createQuestion(@Payload() createQuestionDto: CreateQuestionDto) {
     return await this.questionsService.create(createQuestionDto);
   }
 
   @MessagePattern({ cmd: 'update_question' })
-  @UsePipes(new ZodValidationPipe(updateQuestionSchema))
-  async updateQuestion(@Payload() createQuestionDto: UpdateQuestionDto) {
-    return await this.questionsService.update(createQuestionDto);
+  async updateQuestion(@Payload() updateQuestionDto: UpdateQuestionDto) {
+    return await this.questionsService.update(updateQuestionDto);
   }
 
   @MessagePattern({ cmd: 'delete_question' })

project/apps/questions-service/src/questions.service.ts

@@ -1,7 +1,9 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
+import { RpcException } from '@nestjs/microservices';
 import {
   CreateQuestionDto,
+  GetQuestionsQueryDto,
   QuestionDto,
   UpdateQuestionDto,
 } from '@repo/dtos/questions';
@@ -25,16 +27,36 @@ export class QuestionsService {
     this.supabase = createClient(supabaseUrl, supabaseKey);
   }
 
-  private handleError(operation: string, error: unknown): never {
-    this.logger.error(`Error during ${operation}:`, error);
-    throw error;
+  /**
+   * Handles errors by logging the error message and throwing an RpcException.
+   *
+   * @private
+   * @param {string} operation - The name of the operation where the error occurred.
+   * @param {any} error - The error object that was caught. This can be any type of error, including a NestJS HttpException.
+   * @throws {RpcException} - Throws an RpcException wrapping the original error.
+   */
+  private handleError(operation: string, error: any): never {
+    this.logger.error(`Error at ${operation}: ${error.message}`);
+
+    throw new RpcException(error);
   }
 
-  async findAll(includeDeleted: boolean = false): Promise<QuestionDto[]> {
-    const query = this.supabase.from(this.QUESTIONS_TABLE).select();
+  async findAll(filters: GetQuestionsQueryDto): Promise<QuestionDto[]> {
+    const { title, category, complexity, includeDeleted } = filters;
 
+    let query = this.supabase.from(this.QUESTIONS_TABLE).select();
+
+    if (title) {
+      query = query.ilike('q_title', `%${title}%`);
+    }
+    if (category) {
+      query = query.contains('q_category', [category]);
+    }
+    if (complexity) {
+      query = query.eq('q_complexity', complexity);
+    }
     if (!includeDeleted) {
-      query.is('deleted_at', null);
+      query = query.is('deleted_at', null);
     }
 
     const { data, error } = await query;
@@ -44,7 +66,7 @@ export class QuestionsService {
     }
 
     this.logger.log(
-      `fetched ${data.length} questions, includeDeleted: ${includeDeleted}`,
+      `fetched ${data.length} questions with filters: ${JSON.stringify(filters)}`,
     );
     return data;
   }
@@ -65,6 +87,21 @@ export class QuestionsService {
   }
 
   async create(question: CreateQuestionDto): Promise<QuestionDto> {
+    const { data: existingQuestion } = await this.supabase
+      .from(this.QUESTIONS_TABLE)
+      .select()
+      .eq('q_title', question.q_title)
+      .single<QuestionDto>();
+
+    if (existingQuestion) {
+      // this.handleError(
+      //   'create question',
+      //   new BadRequestException(
+      //     `Question with title ${question.q_title} already exists`,
+      //   ),
+      // );
+    }
+
     const { data, error } = await this.supabase
       .from(this.QUESTIONS_TABLE)
       .insert(question)
@@ -80,14 +117,41 @@ export class QuestionsService {
   }
 
   async update(question: UpdateQuestionDto): Promise<QuestionDto> {
-    const updatedQuestion = {
-      ...question,
-      updated_at: new Date(),
-    };
+    // check if the question is soft deleted
+    const { data: deletedQuestion } = await this.supabase
+      .from(this.QUESTIONS_TABLE)
+      .select()
+      .eq('id', question.id)
+      .neq('deleted_at', null)
+      .single<QuestionDto>();
+
+    if (deletedQuestion) {
+      this.handleError(
+        'update question',
+        new BadRequestException('Cannot update a deleted question'),
+      );
+    }
+
+    // check if a question with the same title already exists
+    const { data: existingQuestion } = await this.supabase
+      .from(this.QUESTIONS_TABLE)
+      .select()
+      .eq('q_title', question.q_title)
+      .neq('id', question.id)
+      .single<QuestionDto>();
+
+    if (existingQuestion) {
+      this.handleError(
+        'update question',
+        new BadRequestException(
+          `Question with title ${question.q_title} already exists`,
+        ),
+      );
+    }
 
     const { data, error } = await this.supabase
       .from(this.QUESTIONS_TABLE)
-      .update(updatedQuestion)
+      .update(question)
       .eq('id', question.id)
       .select()
       .single();

project/packages/dtos/src/questions.ts

@@ -1,30 +1,26 @@
 import { z } from "zod";
 
-export enum Complexity {
-  Easy = "Easy",
-  Medium = "Medium",
-  Hard = "Hard",
-}
-
-export enum Category {
-  Strings = "Strings",
-  Algorithms = "Algorithms",
-  DataStructures = "Data Structures",
-  BitManipulation = "Bit Manipulation",
-  Recursion = "Recursion",
-  Databases = "Databases",
-  BrainTeaser = "Brain Teaser",
-  Arrays = "Arrays",
-}
-
-const ComplexitySchema = z.nativeEnum(Complexity);
-const CategorySchema = z.nativeEnum(Category);
+export const categorySchema = z.string().min(1);
+export const complexitySchema = z.string().min(1);
+
+export const getQuestionsQuerySchema = z.object({
+  title: z.string().optional(),
+  category: categorySchema.optional(),
+  complexity: complexitySchema.optional(),
+  includeDeleted: z.coerce.boolean().optional(),
+});
 
 const commonQuestionFields = z.object({
   q_title: z.string().min(1),
   q_desc: z.string().min(1),
-  q_category: z.array(CategorySchema),
-  q_complexity: ComplexitySchema,
+  q_category: z
+    .array(categorySchema)
+    .min(1)
+    // enforce uniqueness of categories
+    .refine((categories) => new Set(categories).size === categories.length, {
+      message: "Categories must be unique",
+    }),
+  q_complexity: complexitySchema,
 });
 
 export const questionSchema = commonQuestionFields.extend({
@@ -40,6 +36,8 @@ export const updateQuestionSchema = commonQuestionFields.extend({
   id: z.string().uuid(),
 });
 
+export type GetQuestionsQueryDto = z.infer<typeof getQuestionsQuerySchema>;
+
 export type QuestionDto = z.infer<typeof questionSchema>;
 export type CreateQuestionDto = z.infer<typeof createQuestionSchema>;
 export type UpdateQuestionDto = z.infer<typeof updateQuestionSchema>;

project/packages/pipes/src/zod-validation-pipe.pipe.ts

@@ -2,6 +2,7 @@ import {
   PipeTransform,
   ArgumentMetadata,
   BadRequestException,
+  InternalServerErrorException,
 } from "@nestjs/common";
 import { ZodError, ZodSchema } from "zod";
 import { RpcException } from "@nestjs/microservices";
@@ -15,11 +16,24 @@ export class ZodValidationPipe implements PipeTransform {
       return parsedValue;
     } catch (error) {
       if (error instanceof ZodError) {
+        // Format Zod errors into a readable format
+        const formattedErrors = error.errors
+          .map((err) => {
+            const path = err.path.join(".");
+            const message = err.message;
+            return `${path}: ${message}`;
+          })
+          .join(", ");
+
+        // Throw HTTP exception wrapped in an RpcException
         throw new RpcException(
-          new BadRequestException(`Validation failed: ${error.errors}`),
+          new BadRequestException(`Validation failed: ${formattedErrors}`)
         );
       }
-      throw new RpcException(new BadRequestException(`Validation failed`));
+      // Fallback for unknown errors
+      throw new RpcException(
+        new InternalServerErrorException("Validation failed, unknown error")
+      );
     }
   }
 }