Merge pull request SaboStudios#201 from Xaxxoo/fetch-notification

feat: implement notifications module with CRUD operations and paginat…

Author: aji70

backend/src/modules/fetch-notification/get-notifications-query.dto.ts

@@ -0,0 +1,40 @@
+// src/notifications/dto/get-notifications-query.dto.ts
+import { IsOptional, IsBoolean, IsEnum, IsInt, Min, Max } from 'class-validator';
+import { Transform, Type } from 'class-transformer';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { NotificationType } from '../entities/notification.entity';
+
+export class GetNotificationsQueryDto {
+  @ApiPropertyOptional({ default: 1, description: 'Page number (1-based)' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ default: 20, description: 'Items per page (max 100)' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit?: number = 20;
+
+  @ApiPropertyOptional({ description: 'Filter by read status' })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    return value;
+  })
+  @IsBoolean()
+  isRead?: boolean;
+
+  @ApiPropertyOptional({
+    enum: NotificationType,
+    description: 'Filter by notification type',
+  })
+  @IsOptional()
+  @IsEnum(NotificationType)
+  type?: NotificationType;
+}

backend/src/modules/fetch-notification/notification.entity.ts

@@ -0,0 +1,44 @@
+// src/notifications/entities/notification.entity.ts
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  Index,
+} from 'typeorm';
+
+export enum NotificationType {
+  NEW_MESSAGE = 'new_message',
+  MENTION = 'mention',
+  TOKEN_RECEIVED = 'token_received',
+  SYSTEM = 'system',
+  ALERT = 'alert',
+}
+
+@Entity('notifications')
+@Index('idx_notifications_user_unread', ['userId', 'isRead']) // composite — most common query pattern
+export class Notification {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ name: 'user_id' })
+  @Index('idx_notifications_user_id')
+  userId: string;
+
+  @Column({ type: 'enum', enum: NotificationType, default: NotificationType.SYSTEM })
+  @Index('idx_notifications_type')
+  type: NotificationType;
+
+  @Column({ type: 'varchar', length: 255 })
+  title: string;
+
+  @Column({ type: 'text' })
+  content: string;
+
+  @Column({ name: 'is_read', default: false })
+  @Index('idx_notifications_is_read')
+  isRead: boolean;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+}

backend/src/modules/fetch-notification/notifications.controller.spec.ts

@@ -0,0 +1,173 @@
+// src/notifications/tests/notifications.controller.spec.ts
+import { Test, TestingModule } from '@nestjs/testing';
+import { NotificationsController } from '../notifications.controller';
+import { NotificationsService } from '../notifications.service';
+import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard';
+import { NotificationType } from '../entities/notification.entity';
+import { GetNotificationsQueryDto } from '../dto/get-notifications-query.dto';
+import {
+  PaginatedNotificationsResponseDto,
+  PaginationMetaDto,
+} from '../dto/paginated-notifications-response.dto';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+const mockUser = { sub: 'user-uuid-1', email: 'user@example.com' };
+
+const makePaginatedResponse = (
+  overrides: Partial<PaginatedNotificationsResponseDto> = {},
+): PaginatedNotificationsResponseDto => ({
+  data: [
+    {
+      id: 'notif-uuid-1',
+      userId: 'user-uuid-1',
+      type: NotificationType.SYSTEM,
+      title: 'Test',
+      content: 'Test content',
+      isRead: false,
+      createdAt: new Date('2024-01-01T00:00:00.000Z'),
+    },
+  ],
+  meta: {
+    page: 1,
+    limit: 20,
+    total: 1,
+    totalPages: 1,
+    hasNextPage: false,
+    hasPreviousPage: false,
+  },
+  ...overrides,
+});
+
+// ─── Mock Service ─────────────────────────────────────────────────────────────
+
+const mockNotificationsService = {
+  findAllForUser: jest.fn(),
+  getUnreadCount: jest.fn(),
+};
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('NotificationsController', () => {
+  let controller: NotificationsController;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [NotificationsController],
+      providers: [
+        { provide: NotificationsService, useValue: mockNotificationsService },
+      ],
+    })
+      // Bypass JwtAuthGuard in unit tests — integration tests cover auth
+      .overrideGuard(JwtAuthGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
+
+    controller = module.get<NotificationsController>(NotificationsController);
+  });
+
+  // ── GET /api/notifications ──────────────────────────────────────────────────
+
+  describe('getNotifications', () => {
+    it('should call service.findAllForUser with user id and query params', async () => {
+      const expected = makePaginatedResponse();
+      mockNotificationsService.findAllForUser.mockResolvedValue(expected);
+
+      const query: GetNotificationsQueryDto = { page: 1, limit: 20 };
+      const result = await controller.getNotifications(mockUser as any, query);
+
+      expect(mockNotificationsService.findAllForUser).toHaveBeenCalledWith(
+        mockUser.sub,
+        query,
+      );
+      expect(result).toBe(expected);
+    });
+
+    it('should pass isRead filter to service', async () => {
+      mockNotificationsService.findAllForUser.mockResolvedValue(
+        makePaginatedResponse({ data: [] }),
+      );
+
+      const query: GetNotificationsQueryDto = { page: 1, limit: 20, isRead: false };
+      await controller.getNotifications(mockUser as any, query);
+
+      expect(mockNotificationsService.findAllForUser).toHaveBeenCalledWith(
+        mockUser.sub,
+        expect.objectContaining({ isRead: false }),
+      );
+    });
+
+    it('should pass type filter to service', async () => {
+      mockNotificationsService.findAllForUser.mockResolvedValue(
+        makePaginatedResponse({ data: [] }),
+      );
+
+      const query: GetNotificationsQueryDto = {
+        page: 1,
+        limit: 20,
+        type: NotificationType.MENTION,
+      };
+      await controller.getNotifications(mockUser as any, query);
+
+      expect(mockNotificationsService.findAllForUser).toHaveBeenCalledWith(
+        mockUser.sub,
+        expect.objectContaining({ type: NotificationType.MENTION }),
+      );
+    });
+
+    it('should return the paginated response from service', async () => {
+      const expected = makePaginatedResponse();
+      mockNotificationsService.findAllForUser.mockResolvedValue(expected);
+
+      const result = await controller.getNotifications(
+        mockUser as any,
+        { page: 1, limit: 20 },
+      );
+
+      expect(result.data).toHaveLength(1);
+      expect(result.meta.total).toBe(1);
+    });
+  });
+
+  // ── GET /api/notifications/count ────────────────────────────────────────────
+
+  describe('getUnreadCount', () => {
+    it('should call service.getUnreadCount with user id', async () => {
+      mockNotificationsService.getUnreadCount.mockResolvedValue(5);
+
+      await controller.getUnreadCount(mockUser as any);
+
+      expect(mockNotificationsService.getUnreadCount).toHaveBeenCalledWith(
+        mockUser.sub,
+      );
+    });
+
+    it('should return { count: number } shape', async () => {
+      mockNotificationsService.getUnreadCount.mockResolvedValue(5);
+
+      const result = await controller.getUnreadCount(mockUser as any);
+
+      expect(result).toEqual({ count: 5 });
+    });
+
+    it('should return count of 0 when no unread notifications', async () => {
+      mockNotificationsService.getUnreadCount.mockResolvedValue(0);
+
+      const result = await controller.getUnreadCount(mockUser as any);
+
+      expect(result).toEqual({ count: 0 });
+    });
+
+    it('should always wrap the number in a count object regardless of value', async () => {
+      mockNotificationsService.getUnreadCount.mockResolvedValue(99);
+
+      const result = await controller.getUnreadCount(mockUser as any);
+
+      expect(result).toHaveProperty('count');
+      expect(typeof result.count).toBe('number');
+      expect(result.count).toBe(99);
+    });
+  });
+});

backend/src/modules/fetch-notification/notifications.controller.ts

@@ -0,0 +1,93 @@
+// src/notifications/notifications.controller.ts
+import {
+  Controller,
+  Get,
+  Query,
+  UseGuards,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBearerAuth,
+  ApiQuery,
+} from '@nestjs/swagger';
+import { NotificationsService } from './notifications.service';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { CurrentUser } from '../auth/decorators/current-user.decorator';
+import { PaginatedNotificationsResponseDto } from './dto/paginated-notifications-response.dto';
+import { GetNotificationsQueryDto } from './dto/get-notifications-query.dto';
+import { UnreadCountResponseDto } from './dto/unread-count-response.dto';
+import { JwtPayload } from '../auth/interfaces/jwt-payload.interface';
+
+@ApiTags('Notifications')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('api/notifications')
+export class NotificationsController {
+  constructor(private readonly notificationsService: NotificationsService) {}
+
+  /**
+   * GET /api/notifications
+   * Returns a paginated list of notifications for the authenticated user.
+   */
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({
+    summary: 'Get paginated notifications for the authenticated user',
+    description:
+      'Returns a paginated list of notifications. Supports filtering by read status and notification type.',
+  })
+  @ApiQuery({ name: 'page', required: false, type: Number, example: 1 })
+  @ApiQuery({ name: 'limit', required: false, type: Number, example: 20 })
+  @ApiQuery({
+    name: 'isRead',
+    required: false,
+    type: Boolean,
+    description: 'Filter by read/unread status',
+  })
+  @ApiQuery({
+    name: 'type',
+    required: false,
+    type: String,
+    description: 'Filter by notification type',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Paginated notifications list',
+    type: PaginatedNotificationsResponseDto,
+  })
+  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  async getNotifications(
+    @CurrentUser() user: JwtPayload,
+    @Query() query: GetNotificationsQueryDto,
+  ): Promise<PaginatedNotificationsResponseDto> {
+    return this.notificationsService.findAllForUser(user.sub, query);
+  }
+
+  /**
+   * GET /api/notifications/count
+   * Returns the unread notification count for the authenticated user.
+   */
+  @Get('count')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({
+    summary: 'Get unread notification count',
+    description:
+      'Returns a simple count object representing the number of unread notifications. Used for UI badge indicators.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Unread notification count',
+    type: UnreadCountResponseDto,
+  })
+  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  async getUnreadCount(
+    @CurrentUser() user: JwtPayload,
+  ): Promise<UnreadCountResponseDto> {
+    const count = await this.notificationsService.getUnreadCount(user.sub);
+    return { count };
+  }
+}