feat: add validation on dto

Author: sourcecode71

src/config/validation/joi-validation.pipe.ts

@@ -0,0 +1,25 @@
+import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';
+import { ObjectSchema } from 'joi';
+
+@Injectable()
+export class JoiValidationPipe implements PipeTransform {
+  constructor(private schema: ObjectSchema) {}
+
+  transform(value: any): Record<string, any> {
+    try {
+      const { error } = this.schema.validate(value, { abortEarly: false });
+      if (error) {
+        throw new BadRequestException({
+          message: 'Validation failed',
+          details: error.details.map((detail) => detail.message),
+        });
+      }
+      return value as Record<string, any>;
+    } catch {
+      throw new BadRequestException({
+        message: 'Joi validation error',
+        level: 'error',
+      });
+    }
+  }
+}

src/notification/domain/interfaces/notification-repository.interface.ts

@@ -14,4 +14,6 @@ export interface INotificationRepository {
    * @returns A promise that resolves to the found notification entity, or null if not found.
    */
   findById(id: string): Promise<Notification | null>;
+
+  findAll(skip: number, limit: number): Promise<Notification[]>;
 }

src/notification/infrastructure/repositories/notification.repository.ts

@@ -11,10 +11,19 @@ export class NotificationRepository implements INotificationRepository {
     @InjectModel('Notification')
     private readonly notificationModel: Model<NotificationDocument>,
   ) {}
+
   findById(id: string): Promise<Notification | null> {
     throw new Error(`Method not implemented. ID: ${id}`);
   }
 
+  async findAll(skip: number, limit: number): Promise<Notification[]> {
+    const docs = await this.notificationModel
+      .find()
+      .skip(skip)
+      .limit(limit)
+      .exec();
+    return docs.map((doc) => this.toEntity(doc));
+  }
   async save(notification: Notification): Promise<Notification> {
     const doc = new this.notificationModel(notification);
     const saved = await doc.save();

src/notification/presentation/controllers/notification.controller.ts

@@ -16,19 +16,20 @@ import {
   ApiQuery,
 } from '@nestjs/swagger';
 import { NotificationFactory } from '../../application/factories/notification.factory';
-import { NotificationValidator } from '../../application/validators/notification.validator';
-import { SendNotificationDto } from '../dtos/send-notification.dto';
+import {
+  SendNotificationDto,
+  SendNotificationSchema,
+} from '../dtos/send-notification.dto';
 import { Notification } from '../../domain/entities/notification.entity';
 import { INotificationStrategy } from '../../domain/interfaces/notification-strategy.interface';
 import { INotificationRepository } from '../../domain/interfaces/notification-repository.interface';
 import { LoggerServiceFile } from '../../../logger/services/logger.service.file';
 import { LoggerServiceDb } from '../../../logger/services/logger.service.db';
-import { number } from 'joi';
+import { JoiValidationPipe } from '../../../config/validation/joi-validation.pipe';
 
 @ApiTags('Notifications')
 @Controller('api/notifications')
 export class NotificationController {
-  notificationModel: import('mongoose').Model<Notification>;
   constructor(
     private readonly notificationFactory: NotificationFactory,
     @Inject('INotificationRepository')
@@ -52,14 +53,10 @@ export class NotificationController {
     status: 400,
     description: 'Validation failed',
   })
-  async send(@Body() dto: SendNotificationDto): Promise<void> {
-    // Validate input
-    const { error } = NotificationValidator.validateCreateNotification(dto);
-    if (error) {
-      this.logger.error(`Validation failed: ${error.message}`);
-      throw new Error(`Validation failed: ${error.message}`);
-    }
-
+  async send(
+    @Body(new JoiValidationPipe(SendNotificationSchema))
+    dto: SendNotificationDto,
+  ): Promise<void> {
     // Create notification entity
     const notification = new Notification(
       dto.recipient,
@@ -87,11 +84,15 @@ export class NotificationController {
 
     await this.loggerDb.error({
       level: 'info',
-      message: 'Exception occurred while sending notification',
+      message: `Notification (${dto.notificationType}) sent to ${dto.recipient} via ${dto.mediaType}`,
       timestamp: new Date(),
     });
   }
+
   @Get('history')
+  @ApiOperation({
+    summary: 'Retrieve notification history',
+  })
   @ApiResponse({
     status: HttpStatus.OK,
     description: 'Notification history retrieved',
@@ -113,17 +114,13 @@ export class NotificationController {
     @Query('limit') limit = 10,
   ) {
     const skip = (page - 1) * limit;
-    const notifications = await this.notificationModel
-      .find()
-      .sort({ createdAt: -1 })
-      .skip(skip)
-      .limit(limit)
-      .exec();
-    const total = await this.notificationModel.countDocuments().exec();
+    const notifications: Notification[] =
+      await this.notificationRepository.findAll(skip, limit);
+    const total = notifications.length;
     return {
       data: notifications,
-      total: number,
-      page: number,
+      total,
+      page,
       totalPages: Math.ceil(total / limit),
     };
   }

src/notification/presentation/dtos/send-notification.dto.ts

@@ -1,4 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
+import * as Joi from 'joi';
 import { NotificationChannel } from '../../../config/notification.config';
 
 export enum NotificationType {
@@ -46,3 +47,53 @@ export class SendNotificationDto {
   })
   notificationType: NotificationType;
 }
+
+export const SendNotificationSchema = Joi.object({
+  recipient: Joi.string().required().messages({
+    'string.empty': 'Recipient is required',
+  }),
+  subject: Joi.string().min(3).max(100).required().messages({
+    'string.min': 'Subject must be at least 3 characters',
+    'string.max': 'Subject must not exceed 100 characters',
+    'string.empty': 'Subject is required',
+  }),
+  body: Joi.string().min(10).max(1000).required().messages({
+    'string.min': 'Body must be at least 10 characters',
+    'string.max': 'Body must not exceed 1000 characters',
+    'string.empty': 'Body is required',
+  }),
+  mediaType: Joi.string()
+    .valid(...Object.values(NotificationChannel))
+    .required()
+    .messages({
+      'any.only': 'Invalid mediaType, must be one of: EMAIL, SMS',
+      'string.empty': 'mediaType is required',
+    }),
+  notificationType: Joi.string()
+    .valid(...Object.values(NotificationType))
+    .required()
+    .messages({
+      'any.only': 'Invalid notificationType',
+      'string.empty': 'notificationType is required',
+    }),
+}).custom((value: Record<string, any>, helpers) => {
+  if (
+    value.mediaType === NotificationChannel.EMAIL &&
+    !Joi.string().email().validate(value.recipient).value
+  ) {
+    return helpers.message({
+      custom: 'Recipient must be a valid email for EMAIL channel',
+    });
+  }
+  if (
+    value.mediaType === NotificationChannel.SMS &&
+    !Joi.string()
+      .pattern(/^\+?[1-9]\d{1,14}$/)
+      .validate(value.recipient).value
+  ) {
+    return helpers.message({
+      custom: 'Recipient must be a valid phone number for SMS channel',
+    });
+  }
+  return value;
+});