feat(auth): add pagination and limit query support

Add GET /v1/auth/users with cursor/page/limit query params using the
existing PaginationDto and PaginatedResponseDto. Wire findAll in
UsersService with findAndCount, expose via AuthService.findAllUsers,
and add GET /v1/auth/profile endpoint. Update controller spec.

Author: sundayjob996

backend/src/auth-module/auth.controller.spec.ts

@@ -1,11 +1,15 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
+import { PaginatedResponseDto } from '../common/dto/paginated-response.dto';
 
 describe('AuthController', () => {
   let controller: AuthController;
 
-  const mockAuthService = {};
+  const mockAuthService = {
+    findById: jest.fn(),
+    findAllUsers: jest.fn(),
+  };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -14,9 +18,43 @@ describe('AuthController', () => {
     }).compile();
 
     controller = module.get<AuthController>(AuthController);
+    jest.clearAllMocks();
   });
 
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  describe('getProfile', () => {
+    it('returns user profile for authenticated user', async () => {
+      const user = { id: 'u1', email: 'a@b.com' };
+      mockAuthService.findById.mockResolvedValue(user);
+
+      const result = await controller.getProfile({ user: { userId: 'u1' } });
+
+      expect(result).toEqual(user);
+      expect(mockAuthService.findById).toHaveBeenCalledWith('u1');
+    });
+  });
+
+  describe('getUsers', () => {
+    it('returns paginated users', async () => {
+      const response = new PaginatedResponseDto(
+        [{ id: 'u1' }],
+        20,
+        null,
+        false,
+        1,
+      );
+      mockAuthService.findAllUsers.mockResolvedValue(response);
+
+      const result = await controller.getUsers({ limit: 20, page: 1 });
+
+      expect(result).toEqual(response);
+      expect(mockAuthService.findAllUsers).toHaveBeenCalledWith({
+        limit: 20,
+        page: 1,
+      });
+    });
+  });
 });

backend/src/auth-module/auth.controller.ts

@@ -1,4 +1,50 @@
-import { Controller } from '@nestjs/common';
+import { Controller, Get, Query, UseGuards, Request } from '@nestjs/common';
+import { ApiOperation, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { AuthService } from './auth.service';
+import { JwtAuthGuard } from './guards/jwt-auth.guard';
+import { PaginationDto, PaginatedResponseDto } from '../common/dto';
 
+@ApiTags('auth')
 @Controller({ path: 'auth', version: '1' })
-export class AuthController {}
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Get('profile')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Get current user profile' })
+  @ApiResponse({ status: 200, description: 'Current user profile' })
+  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  async getProfile(@Request() req: any) {
+    return this.authService.findById(req.user.userId);
+  }
+
+  @Get('users')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'List users (paginated)' })
+  @ApiQuery({
+    name: 'cursor',
+    required: false,
+    description: 'Pagination cursor (nextCursor from previous page)',
+  })
+  @ApiQuery({
+    name: 'limit',
+    required: false,
+    description: 'Number of items per page (default 20, max 100)',
+  })
+  @ApiQuery({
+    name: 'page',
+    required: false,
+    description: 'Page number (1-based, default 1)',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Paginated list of users',
+    type: PaginatedResponseDto,
+  })
+  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  async getUsers(
+    @Query() pagination: PaginationDto,
+  ): Promise<PaginatedResponseDto<any>> {
+    return this.authService.findAllUsers(pagination);
+  }
+}

backend/src/auth-module/auth.service.ts

@@ -1,6 +1,8 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { RegisterDto } from './dto/register.dto';
 import { UsersService } from '../users/users.service';
+import { PaginationDto } from '../common/dto/pagination.dto';
+import { PaginatedResponseDto } from '../common/dto/paginated-response.dto';
 
 @Injectable()
 export class AuthService {
@@ -22,4 +24,15 @@ export class AuthService {
   async findById(id: string) {
     return this.usersService.findOne(id);
   }
+
+  async findAllUsers(
+    pagination: PaginationDto,
+  ): Promise<PaginatedResponseDto<any>> {
+    const { data, total } = await this.usersService.findAll(pagination);
+    const limit = pagination.limit ?? 20;
+    const page = pagination.page ?? 1;
+    const hasMore = page * limit < total;
+
+    return new PaginatedResponseDto(data, limit, null, hasMore, page);
+  }
 }

backend/src/users/users.service.ts

@@ -5,6 +5,7 @@ import { User } from './entities/user.entity';
 import { UpdateUserDto } from './dto';
 import { UpdateNotificationsDto } from './dto/update-notifications.dto';
 import { Creator } from './entities/creator.entity';
+import { PaginationDto } from '../common/dto/pagination.dto';
 import * as bcrypt from 'bcrypt';
 
 
@@ -17,6 +18,21 @@ export class UsersService {
     private creatorRepository: Repository<Creator>
   ) { }
 
+  async findAll(
+    pagination: PaginationDto,
+  ): Promise<{ data: User[]; total: number }> {
+    const limit = pagination.limit ?? 20;
+    const page = pagination.page ?? 1;
+    const skip = (page - 1) * limit;
+
+    const [data, total] = await this.usersRepository.findAndCount({
+      take: limit,
+      skip,
+      order: { created_at: 'DESC' },
+    });
+
+    return { data, total };
+  }
 
   async findOne(id: string): Promise<User> {
     const user = await this.usersRepository.findOne({ where: { id } });