nestforge-generator 0.1.0

package/templates/typeorm/src/users/users.controller.ts

@@ -0,0 +1,165 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+// nestforge:feature:swagger
+import { ApiBearerAuth, ApiConsumes, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+// nestforge:feature:swagger:end
+import { UsersService } from './users.service';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+import { FindUsersQueryDto } from './dto/find-users-query.dto';
+// nestforge:feature:rbac
+import { Permissions } from '../common/decorators/permissions.decorator';
+import { Permission } from '../common/constants/permissions';
+// nestforge:feature:rbac:end
+import { CurrentUser } from '../common/decorators/current-user.decorator';
+import {
+  AVATAR_MAX_SIZE_BYTES,
+  avatarFileFilter,
+  avatarStorage,
+} from '../common/utils/avatar-storage.util';
+
+// nestforge:feature:swagger
+const USER_EXAMPLE = {
+  id: 'a1b2c3d4-e5f6-47a8-9b01-234567890abc',
+  name: 'Jeiel Alves',
+  email: 'jeiel@example.com',
+  role: 'USER',
+  avatarUrl: null,
+  emailVerifiedAt: '2026-01-15T12:00:00.000Z',
+  createdAt: '2026-01-10T09:30:00.000Z',
+  updatedAt: '2026-01-15T12:00:00.000Z',
+};
+
+const FORBIDDEN_EXAMPLE = { statusCode: 403, message: 'Forbidden resource' };
+// nestforge:feature:swagger:end
+
+// nestforge:feature:swagger
+@ApiTags('users')
+@ApiBearerAuth()
+// nestforge:feature:swagger:end
+@Controller('users')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) { }
+
+  @Post()
+  // nestforge:feature:rbac
+  @Permissions(Permission.UserCreate)
+  // nestforge:feature:rbac:end
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Cria um usuário (requer permissão user:create)' })
+  @ApiResponse({ status: 201, description: 'Usuário criado', schema: { example: USER_EXAMPLE } })
+  @ApiResponse({ status: 403, description: 'Sem a permissão user:create', schema: { example: FORBIDDEN_EXAMPLE } })
+  // nestforge:feature:swagger:end
+  create(@Body() dto: CreateUserDto) {
+    return this.usersService.create(dto);
+  }
+
+  @Get()
+  // nestforge:feature:rbac
+  @Permissions(Permission.UserRead)
+  // nestforge:feature:rbac:end
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Lista usuários com paginação e filtros (requer permissão user:read)' })
+  @ApiResponse({
+    status: 200,
+    description: 'Lista paginada',
+    schema: {
+      example: {
+        data: [USER_EXAMPLE],
+        meta: { total: 1, page: 1, limit: 10, totalPages: 1 },
+      },
+    },
+  })
+  // nestforge:feature:swagger:end
+  findAll(@Query() query: FindUsersQueryDto) {
+    return this.usersService.findAll(query);
+  }
+
+  @Get('me')
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Retorna o usuário autenticado' })
+  @ApiResponse({ status: 200, description: 'Usuário autenticado', schema: { example: USER_EXAMPLE } })
+  // nestforge:feature:swagger:end
+  findMe(@CurrentUser() user: { id: string }) {
+    return this.usersService.findOne(user.id);
+  }
+
+  @Post('me/avatar')
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Faz upload do avatar do usuário autenticado' })
+  @ApiConsumes('multipart/form-data')
+  @ApiResponse({
+    status: 201,
+    description: 'Avatar atualizado',
+    schema: { example: { ...USER_EXAMPLE, avatarUrl: '/uploads/avatars/f47ac10b.png' } },
+  })
+  @ApiResponse({
+    status: 400,
+    description: 'Formato de imagem não suportado ou arquivo maior que 2MB',
+    schema: { example: { statusCode: 400, message: 'Formato de imagem não suportado (use PNG, JPEG ou WEBP)' } },
+  })
+  // nestforge:feature:swagger:end
+  @UseInterceptors(
+    FileInterceptor('file', {
+      storage: avatarStorage,
+      fileFilter: avatarFileFilter,
+      limits: { fileSize: AVATAR_MAX_SIZE_BYTES },
+    }),
+  )
+  uploadAvatar(
+    @CurrentUser() user: { id: string },
+    @UploadedFile() file: Express.Multer.File,
+  ) {
+    return this.usersService.updateAvatar(user.id, `/uploads/avatars/${file.filename}`);
+  }
+
+  @Get(':id')
+  // nestforge:feature:rbac
+  @Permissions(Permission.UserRead)
+  // nestforge:feature:rbac:end
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Busca um usuário por id (requer permissão user:read)' })
+  @ApiResponse({ status: 200, description: 'Usuário encontrado', schema: { example: USER_EXAMPLE } })
+  @ApiResponse({ status: 404, description: 'Usuário não encontrado', schema: { example: { statusCode: 404, message: 'Usuário não encontrado' } } })
+  // nestforge:feature:swagger:end
+  findOne(@Param('id') id: string) {
+    return this.usersService.findOne(id);
+  }
+
+  @Patch(':id')
+  // nestforge:feature:rbac
+  @Permissions(Permission.UserUpdate)
+  // nestforge:feature:rbac:end
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Atualiza um usuário (requer permissão user:update)' })
+  @ApiResponse({ status: 200, description: 'Usuário atualizado', schema: { example: USER_EXAMPLE } })
+  @ApiResponse({ status: 403, description: 'Sem a permissão user:update', schema: { example: FORBIDDEN_EXAMPLE } })
+  // nestforge:feature:swagger:end
+  update(@Param('id') id: string, @Body() dto: UpdateUserDto) {
+    return this.usersService.update(id, dto);
+  }
+
+  @Delete(':id')
+  // nestforge:feature:rbac
+  @Permissions(Permission.UserDelete)
+  // nestforge:feature:rbac:end
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Remove um usuário (requer permissão user:delete)' })
+  @ApiResponse({ status: 200, description: 'Usuário removido', schema: { example: { message: 'Usuário removido com sucesso' } } })
+  @ApiResponse({ status: 403, description: 'Sem a permissão user:delete', schema: { example: FORBIDDEN_EXAMPLE } })
+  // nestforge:feature:swagger:end
+  remove(@Param('id') id: string) {
+    return this.usersService.remove(id);
+  }
+}

package/templates/typeorm/src/users/users.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserEntity } from './entities/user.entity';
+import { UsersService } from './users.service';
+import { UsersController } from './users.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([UserEntity])],
+  controllers: [UsersController],
+  providers: [UsersService],
+  exports: [UsersService],
+})
+export class UsersModule { }

package/templates/typeorm/src/users/users.service.spec.ts

@@ -0,0 +1,183 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+    ConflictException,
+    NotFoundException,
+} from '@nestjs/common';
+import { instanceToPlain } from 'class-transformer';
+import { Repository } from 'typeorm';
+import { Role } from '../common/constants/role.enum';
+import { UsersService } from './users.service';
+import { UserEntity } from './entities/user.entity';
+
+describe('UsersService', () => {
+    let usersService: UsersService;
+    let usersRepository: any;
+    let queryBuilder: any;
+    let mockUser: UserEntity;
+
+    beforeEach(() => {
+        mockUser = new UserEntity({
+            id: 'user-1',
+            name: 'Jeiel',
+            email: 'jeiel@example.com',
+            passwordHash: 'hash-secreto',
+            role: Role.USER,
+            avatarUrl: null,
+            emailVerifiedAt: null,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        });
+
+        queryBuilder = {
+            orderBy: vi.fn().mockReturnThis(),
+            skip: vi.fn().mockReturnThis(),
+            take: vi.fn().mockReturnThis(),
+            andWhere: vi.fn().mockReturnThis(),
+            getManyAndCount: vi.fn(),
+        };
+
+        usersRepository = {
+            findOne: vi.fn(),
+            create: vi.fn(),
+            save: vi.fn(),
+            remove: vi.fn(),
+            createQueryBuilder: vi.fn().mockReturnValue(queryBuilder),
+        };
+
+        usersService = new UsersService(
+            usersRepository as unknown as Repository<UserEntity>,
+        );
+    });
+
+    it('deve lançar ConflictException se o e-mail já existir ao criar', async () => {
+        usersRepository.findOne.mockResolvedValue(mockUser);
+
+        await expect(
+            usersService.create({
+                name: 'Jeiel',
+                email: 'jeiel@example.com',
+                password: 'senhaForte123',
+            }),
+        ).rejects.toBeInstanceOf(ConflictException);
+    });
+
+    it('deve criar um usuário e esconder o passwordHash na serialização', async () => {
+        usersRepository.findOne.mockResolvedValue(null);
+        usersRepository.create.mockReturnValue(mockUser);
+        usersRepository.save.mockResolvedValue(mockUser);
+
+        const result = await usersService.create({
+            name: 'Jeiel',
+            email: 'jeiel@example.com',
+            password: 'senhaForte123',
+        });
+
+        expect(result.email).toBe('jeiel@example.com');
+        expect(instanceToPlain(result)).not.toHaveProperty('passwordHash');
+        expect(usersRepository.create).toHaveBeenCalled();
+        expect(usersRepository.save).toHaveBeenCalledWith(mockUser);
+    });
+
+    it('deve lançar NotFoundException se o usuário não existir', async () => {
+        usersRepository.findOne.mockResolvedValue(null);
+
+        await expect(
+            usersService.findOne('id-invalido'),
+        ).rejects.toBeInstanceOf(NotFoundException);
+    });
+
+    it('deve retornar dados paginados em findAll', async () => {
+        queryBuilder.getManyAndCount.mockResolvedValue([[mockUser], 1]);
+
+        const result = await usersService.findAll({
+            page: 1,
+            limit: 10,
+        });
+
+        expect(result.meta).toEqual({
+            total: 1,
+            page: 1,
+            limit: 10,
+            totalPages: 1,
+        });
+        expect(result.data).toHaveLength(1);
+        expect(queryBuilder.skip).toHaveBeenCalledWith(0);
+        expect(queryBuilder.take).toHaveBeenCalledWith(10);
+    });
+
+    it('deve aplicar busca e filtro por role em findAll', async () => {
+        queryBuilder.getManyAndCount.mockResolvedValue([[mockUser], 1]);
+
+        await usersService.findAll({
+            page: 1,
+            limit: 10,
+            search: 'jeiel',
+            role: Role.USER,
+        });
+
+        expect(queryBuilder.andWhere).toHaveBeenCalledWith(
+            'user.role = :role',
+            { role: Role.USER },
+        );
+
+        expect(queryBuilder.andWhere).toHaveBeenCalledWith(
+            expect.stringContaining('LOWER(user.name)'),
+            { search: '%jeiel%' },
+        );
+    });
+
+    it('deve atualizar um usuário existente', async () => {
+        usersRepository.findOne.mockResolvedValue(mockUser);
+        usersRepository.save.mockImplementation(
+            async (user: UserEntity) => user,
+        );
+
+        const result = await usersService.update('user-1', {
+            name: 'Novo Nome',
+        });
+
+        expect(result.name).toBe('Novo Nome');
+        expect(
+            usersRepository.save,
+        ).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: 'user-1',
+                name: 'Novo Nome',
+            }),
+        );
+    });
+
+    it('deve remover um usuário existente', async () => {
+        usersRepository.findOne.mockResolvedValue(mockUser);
+        usersRepository.remove.mockResolvedValue(mockUser);
+
+        const result = await usersService.remove('user-1');
+
+        expect(usersRepository.remove).toHaveBeenCalledWith(mockUser);
+        expect(result).toEqual({
+            message: 'Usuário removido com sucesso',
+        });
+    });
+
+    it('deve atualizar o avatar de um usuário', async () => {
+        usersRepository.findOne.mockResolvedValue(mockUser);
+        usersRepository.save.mockImplementation(
+            async (user: UserEntity) => user,
+        );
+
+        const result = await usersService.updateAvatar(
+            'user-1',
+            '/uploads/avatars/x.png',
+        );
+
+        expect(result.avatarUrl).toBe('/uploads/avatars/x.png');
+        expect(
+            usersRepository.save,
+        ).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: 'user-1',
+                avatarUrl: '/uploads/avatars/x.png',
+            }),
+        );
+    });
+});

package/templates/typeorm/src/users/users.service.ts

@@ -0,0 +1,124 @@
+import {
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import * as bcrypt from 'bcryptjs';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+import { FindUsersQueryDto } from './dto/find-users-query.dto';
+import { UserEntity } from './entities/user.entity';
+
+@Injectable()
+export class UsersService {
+  constructor(
+    @InjectRepository(UserEntity)
+    private readonly usersRepository: Repository<UserEntity>,
+  ) { }
+
+  async create(dto: CreateUserDto) {
+    const existing = await this.usersRepository.findOne({
+      where: { email: dto.email },
+    });
+
+    if (existing) {
+      throw new ConflictException('E-mail já cadastrado');
+    }
+
+    const passwordHash = await bcrypt.hash(dto.password, 10);
+
+    const user = this.usersRepository.create({
+      name: dto.name,
+      email: dto.email,
+      passwordHash,
+      ...(dto.role ? { role: dto.role } : {}),
+    });
+
+    const savedUser = await this.usersRepository.save(user);
+
+    return new UserEntity(savedUser);
+  }
+
+  async findAll(query: FindUsersQueryDto) {
+    const { page = 1, limit = 10, search, role } = query;
+
+    const queryBuilder = this.usersRepository
+      .createQueryBuilder('user')
+      .orderBy('user.createdAt', 'DESC')
+      .skip((page - 1) * limit)
+      .take(limit);
+
+    if (role) {
+      queryBuilder.andWhere('user.role = :role', { role });
+    }
+
+    if (search) {
+      queryBuilder.andWhere(
+        `(
+            LOWER(user.name) LIKE LOWER(:search)
+            OR LOWER(user.email) LIKE LOWER(:search)
+          )`,
+        { search: `%${search}%` },
+      );
+    }
+
+    const [users, total] = await queryBuilder.getManyAndCount();
+
+    return {
+      data: users.map((user) => new UserEntity(user)),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async findOne(id: string) {
+    const user = await this.usersRepository.findOne({
+      where: { id },
+    });
+
+    if (!user) {
+      throw new NotFoundException('Usuário não encontrado');
+    }
+
+    return new UserEntity(user);
+  }
+
+  async update(id: string, dto: UpdateUserDto) {
+    const user = await this.findOne(id);
+    const { password, ...data } = dto;
+
+    Object.assign(user, data);
+
+    if (password) {
+      user.passwordHash = await bcrypt.hash(password, 10);
+    }
+
+    const updatedUser = await this.usersRepository.save(user);
+
+    return new UserEntity(updatedUser);
+  }
+
+  async remove(id: string) {
+    const user = await this.findOne(id);
+
+    await this.usersRepository.remove(user);
+
+    return { message: 'Usuário removido com sucesso' };
+  }
+
+  async updateAvatar(id: string, avatarUrl: string) {
+    const user = await this.findOne(id);
+
+    user.avatarUrl = avatarUrl;
+
+    const updatedUser = await this.usersRepository.save(user);
+
+    return new UserEntity(updatedUser);
+  }
+}

package/templates/typeorm/test/auth.e2e-spec.ts

@@ -0,0 +1,111 @@
+// nestforge:feature-file:auth:password,auth:token
+import { INestApplication } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import request from 'supertest';
+import { createTestApp } from './utils/e2e-setup';
+import { cleanDatabase } from './utils/clean-database';
+
+describe('Auth (e2e)', () => {
+    let app: INestApplication;
+    let dataSource: DataSource;
+
+    beforeAll(async () => {
+        app = await createTestApp();
+        dataSource = app.get(DataSource);
+    });
+
+    beforeEach(async () => {
+        await cleanDatabase(dataSource);
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    it('deve registrar, logar, renovar e revogar o token', async () => {
+        const server = app.getHttpServer();
+
+        const registerResponse = await request(server)
+            .post('/auth/register')
+            .send({
+                name: 'Jeiel',
+                email: 'jeiel.e2e@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(201);
+
+        expect(registerResponse.body).toHaveProperty(
+            'accessToken',
+        );
+
+        expect(registerResponse.body).toHaveProperty(
+            'refreshToken',
+        );
+
+        const loginResponse = await request(server)
+            .post('/auth/login')
+            .send({
+                email: 'jeiel.e2e@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(200);
+
+        const refreshResponse = await request(server)
+            .post('/auth/refresh')
+            .send({
+                refreshToken:
+                    loginResponse.body.refreshToken,
+            })
+            .expect(200);
+
+        expect(refreshResponse.body).toHaveProperty(
+            'accessToken',
+        );
+
+        await request(server)
+            .post('/auth/logout')
+            .send({
+                refreshToken:
+                    refreshResponse.body.refreshToken,
+            })
+            .expect(200);
+
+        await request(server)
+            .post('/auth/refresh')
+            .send({
+                refreshToken:
+                    refreshResponse.body.refreshToken,
+            })
+            .expect(401);
+    });
+
+    it('não deve permitir cadastro com e-mail duplicado', async () => {
+        const server = app.getHttpServer();
+
+        const payload = {
+            name: 'Jeiel',
+            email: 'duplicado.e2e@example.com',
+            password: 'senhaForte123',
+        };
+
+        await request(server)
+            .post('/auth/register')
+            .send(payload)
+            .expect(201);
+
+        await request(server)
+            .post('/auth/register')
+            .send(payload)
+            .expect(409);
+    });
+
+    it('deve rejeitar login com credenciais inválidas', async () => {
+        await request(app.getHttpServer())
+            .post('/auth/login')
+            .send({
+                email: 'naoexiste.e2e@example.com',
+                password: 'qualquerSenha123',
+            })
+            .expect(401);
+    });
+});