nestforge-generator 0.3.0 → 0.4.0

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

@@ -57,9 +57,9 @@ export class UsersController {
   @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 } })
+  @ApiOperation({ summary: 'Creates a user (requires the user:create permission)' })
+  @ApiResponse({ status: 201, description: 'User created', schema: { example: USER_EXAMPLE } })
+  @ApiResponse({ status: 403, description: 'Missing the user:create permission', schema: { example: FORBIDDEN_EXAMPLE } })
   // nestforge:feature:swagger:end
   create(@Body() dto: CreateUserDto) {
     return this.usersService.create(dto);
@@ -70,10 +70,10 @@ export class UsersController {
   @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)' })
+  @ApiOperation({ summary: 'Lists users with pagination and filters (requires the user:read permission)' })
   @ApiResponse({
     status: 200,
-    description: 'Lista paginada',
+    description: 'Paginated list',
     schema: {
       example: {
         data: [USER_EXAMPLE],
@@ -88,8 +88,8 @@ export class UsersController {
 
   @Get('me')
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Retorna o usuário autenticado' })
-  @ApiResponse({ status: 200, description: 'Usuário autenticado', schema: { example: USER_EXAMPLE } })
+  @ApiOperation({ summary: 'Returns the authenticated user' })
+  @ApiResponse({ status: 200, description: 'Authenticated user', schema: { example: USER_EXAMPLE } })
   // nestforge:feature:swagger:end
   findMe(@CurrentUser() user: { id: string }) {
     return this.usersService.findOne(user.id);
@@ -97,17 +97,17 @@ export class UsersController {
 
   @Post('me/avatar')
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Faz upload do avatar do usuário autenticado' })
+  @ApiOperation({ summary: 'Uploads an avatar for the authenticated user' })
   @ApiConsumes('multipart/form-data')
   @ApiResponse({
     status: 201,
-    description: 'Avatar atualizado',
+    description: 'Avatar updated',
     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)' } },
+    description: 'Unsupported image format or file larger than 2 MB',
+    schema: { example: { statusCode: 400, message: 'Unsupported image format (use PNG, JPEG, or WEBP)' } },
   })
   // nestforge:feature:swagger:end
   @UseInterceptors(
@@ -129,9 +129,9 @@ export class UsersController {
   @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' } } })
+  @ApiOperation({ summary: 'Finds a user by ID (requires the user:read permission)' })
+  @ApiResponse({ status: 200, description: 'User found', schema: { example: USER_EXAMPLE } })
+  @ApiResponse({ status: 404, description: 'User not found', schema: { example: { statusCode: 404, message: 'User not found' } } })
   // nestforge:feature:swagger:end
   findOne(@Param('id') id: string) {
     return this.usersService.findOne(id);
@@ -142,9 +142,9 @@ export class UsersController {
   @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 } })
+  @ApiOperation({ summary: 'Updates a user (requires the user:update permission)' })
+  @ApiResponse({ status: 200, description: 'User updated', schema: { example: USER_EXAMPLE } })
+  @ApiResponse({ status: 403, description: 'Missing the user:update permission', schema: { example: FORBIDDEN_EXAMPLE } })
   // nestforge:feature:swagger:end
   update(@Param('id') id: string, @Body() dto: UpdateUserDto) {
     return this.usersService.update(id, dto);
@@ -155,11 +155,11 @@ export class UsersController {
   @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 } })
+  @ApiOperation({ summary: 'Deletes a user (requires the user:delete permission)' })
+  @ApiResponse({ status: 200, description: 'User deleted', schema: { example: { message: 'User deleted successfully' } } })
+  @ApiResponse({ status: 403, description: 'Missing the user:delete permission', schema: { example: FORBIDDEN_EXAMPLE } })
   // nestforge:feature:swagger:end
   remove(@Param('id') id: string) {
     return this.usersService.remove(id);
   }
-}
+}

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

@@ -37,35 +37,35 @@ describe('UsersService', () => {
         usersService = new UsersService(prisma as PrismaService);
     });
 
-    it('deve lançar ConflictException se o e-mail já existir ao criar', async () => {
+    it('throws ConflictException when the email already exists during creation', async () => {
         prisma.user.findUnique.mockResolvedValue(mockUser);
 
         await expect(
-            usersService.create({ name: 'Jeiel', email: 'jeiel@example.com', password: 'senhaForte123' }),
+            usersService.create({ name: 'Jeiel', email: 'jeiel@example.com', password: 'strongPassword123' }),
         ).rejects.toBeInstanceOf(ConflictException);
     });
 
-    it('deve criar um usuário e esconder o passwordHash na serialização', async () => {
+    it('creates a user and hides passwordHash during serialization', async () => {
         prisma.user.findUnique.mockResolvedValue(null);
         prisma.user.create.mockResolvedValue(mockUser);
 
         const result = await usersService.create({
             name: 'Jeiel',
             email: 'jeiel@example.com',
-            password: 'senhaForte123',
+            password: 'strongPassword123',
         });
 
         expect(result.email).toBe('jeiel@example.com');
         expect(instanceToPlain(result)).not.toHaveProperty('passwordHash');
     });
 
-    it('deve lançar NotFoundException se o usuário não existir', async () => {
+    it('throws NotFoundException when the user does not exist', async () => {
         prisma.user.findUnique.mockResolvedValue(null);
 
         await expect(usersService.findOne('id-invalido')).rejects.toBeInstanceOf(NotFoundException);
     });
 
-    it('deve retornar dados paginados em findAll', async () => {
+    it('returns paginated data from findAll', async () => {
         prisma.user.findMany.mockResolvedValue([mockUser]);
         prisma.user.count.mockResolvedValue(1);
 
@@ -75,7 +75,7 @@ describe('UsersService', () => {
         expect(result.data).toHaveLength(1);
     });
 
-    it('deve atualizar um usuário existente', async () => {
+    it('updates an existing user', async () => {
         prisma.user.findUnique.mockResolvedValue(mockUser);
         prisma.user.update.mockResolvedValue({ ...mockUser, name: 'Novo Nome' });
 
@@ -84,16 +84,16 @@ describe('UsersService', () => {
         expect(result.name).toBe('Novo Nome');
     });
 
-    it('deve remover um usuário existente', async () => {
+    it('deletes an existing user', async () => {
         prisma.user.findUnique.mockResolvedValue(mockUser);
         prisma.user.delete.mockResolvedValue(mockUser);
 
         const result = await usersService.remove('user-1');
 
-        expect(result).toEqual({ message: 'Usuário removido com sucesso' });
+        expect(result).toEqual({ message: 'User deleted successfully' });
     });
 
-    it('deve atualizar o avatar de um usuário', async () => {
+    it('updates a user avatar', async () => {
         prisma.user.findUnique.mockResolvedValue(mockUser);
         prisma.user.update.mockResolvedValue({ ...mockUser, avatarUrl: '/uploads/avatars/x.png' });
 
@@ -101,4 +101,4 @@ describe('UsersService', () => {
 
         expect(result.avatarUrl).toBe('/uploads/avatars/x.png');
     });
-});
+});

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

@@ -14,7 +14,7 @@ export class UsersService {
   async create(dto: CreateUserDto) {
     const existing = await this.prisma.user.findUnique({ where: { email: dto.email } });
     if (existing) {
-      throw new ConflictException('E-mail já cadastrado');
+      throw new ConflictException('Email already registered');
     }
 
     const passwordHash = await bcrypt.hash(dto.password, 10);
@@ -79,7 +79,7 @@ export class UsersService {
   async findOne(id: string) {
     const user = await this.prisma.user.findUnique({ where: { id } });
     if (!user) {
-      throw new NotFoundException('Usuário não encontrado');
+      throw new NotFoundException('User not found');
     }
     return new UserEntity(user);
   }
@@ -100,7 +100,7 @@ export class UsersService {
   async remove(id: string) {
     await this.findOne(id);
     await this.prisma.user.delete({ where: { id } });
-    return { message: 'Usuário removido com sucesso' };
+    return { message: 'User deleted successfully' };
   }
 
   async updateAvatar(id: string, avatarUrl: string) {
@@ -111,4 +111,4 @@ export class UsersService {
     });
     return new UserEntity(user);
   }
-}
+}

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

@@ -23,12 +23,12 @@ describe('Auth (e2e)', () => {
         await app.close();
     });
 
-    it('deve registrar, logar, renovar e revogar o token', async () => {
+    it('registers, logs in, refreshes, and revokes the token', async () => {
         const server = app.getHttpServer();
 
         const registerResponse = await request(server)
             .post('/auth/register')
-            .send({ name: 'Jeiel', email: 'jeiel.e2e@example.com', password: 'senhaForte123' })
+            .send({ name: 'Jeiel', email: 'jeiel.e2e@example.com', password: 'strongPassword123' })
             .expect(201);
 
         expect(registerResponse.body).toHaveProperty('accessToken');
@@ -36,7 +36,7 @@ describe('Auth (e2e)', () => {
 
         const loginResponse = await request(server)
             .post('/auth/login')
-            .send({ email: 'jeiel.e2e@example.com', password: 'senhaForte123' })
+            .send({ email: 'jeiel.e2e@example.com', password: 'strongPassword123' })
             .expect(200);
 
         const refreshResponse = await request(server)
@@ -51,25 +51,25 @@ describe('Auth (e2e)', () => {
             .send({ refreshToken: refreshResponse.body.refreshToken })
             .expect(200);
 
-        // o refresh token já foi revogado no logout, então não pode ser reutilizado
+        // The refresh token was revoked during logout and cannot be reused.
         await request(server)
             .post('/auth/refresh')
             .send({ refreshToken: refreshResponse.body.refreshToken })
             .expect(401);
     });
 
-    it('não deve permitir cadastro com e-mail duplicado', async () => {
+    it('rejects registration with a duplicate email', async () => {
         const server = app.getHttpServer();
-        const payload = { name: 'Jeiel', email: 'duplicado.e2e@example.com', password: 'senhaForte123' };
+        const payload = { name: 'Jeiel', email: 'duplicate.e2e@example.com', password: 'strongPassword123' };
 
         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 () => {
+    it('rejects login with invalid credentials', async () => {
         await request(app.getHttpServer())
             .post('/auth/login')
             .send({ email: 'naoexiste.e2e@example.com', password: 'qualquerSenha123' })
             .expect(401);
     });
-});
+});

package/templates/prisma/test/session-auth.e2e-spec.ts

@@ -28,7 +28,7 @@ describe('Session auth (e2e)', () => {
         }
     })
 
-    it('registra, autentica e encerra uma sessão protegida por CSRF', async () => {
+    it('registers, authenticates, and closes a CSRF-protected session', async () => {
         const agent = request.agent(app.getHttpServer());
 
         await agent
@@ -43,13 +43,13 @@ describe('Session auth (e2e)', () => {
 
         expect(csrfToken).toMatch(/^[a-f0-9]{64}$/);
 
-        // Requisições que alteram estado devem ser rejeitadas sem o token.
+        // State-changing requests must be rejected without the token.
         await agent
             .post('/auth/register')
             .send({
                 name: 'Jeiel',
                 email: 'jeiel.session@example.com',
-                password: 'senhaForte123',
+                password: 'strongPassword123',
             })
             .expect(403);
 
@@ -59,7 +59,7 @@ describe('Session auth (e2e)', () => {
             .send({
                 name: 'Jeiel',
                 email: 'jeiel.session@example.com',
-                password: 'senhaForte123',
+                password: 'strongPassword123',
             })
             .expect(201);
 
@@ -97,7 +97,7 @@ describe('Session auth (e2e)', () => {
             .expect(401);
     });
 
-    it('realiza login e renova o token CSRF da sessão', async () => {
+    it('logs in and refreshes the session CSRF token', async () => {
         const registrationAgent = request.agent(
             app.getHttpServer(),
         );
@@ -113,9 +113,9 @@ describe('Session auth (e2e)', () => {
             .post('/auth/register')
             .set('x-csrf-token', registrationCsrfToken)
             .send({
-                name: 'Usuário de sessão',
+                name: 'Session User',
                 email: 'login.session@example.com',
-                password: 'senhaForte123',
+                password: 'strongPassword123',
             })
             .expect(201);
 
@@ -141,7 +141,7 @@ describe('Session auth (e2e)', () => {
             .set('x-csrf-token', loginCsrfToken)
             .send({
                 email: 'login.session@example.com',
-                password: 'senhaForte123',
+                password: 'strongPassword123',
             })
             .expect(200);
 
@@ -160,4 +160,4 @@ describe('Session auth (e2e)', () => {
             .get('/users/me')
             .expect(200);
     });
-});
+});

package/templates/prisma/test/users.e2e-spec.ts

@@ -13,7 +13,7 @@ describe('Users (e2e)', () => {
     async function createUserWithRole(email: string, password: string, role: Role) {
         const passwordHash = await bcrypt.hash(password, 10);
         await prisma.user.create({
-            data: { name: 'Usuário de teste', email, passwordHash, role, emailVerifiedAt: new Date() },
+            data: { name: 'Test User', email, passwordHash, role, emailVerifiedAt: new Date() },
         });
     }
 
@@ -39,19 +39,19 @@ describe('Users (e2e)', () => {
         await app.close();
     });
 
-    it('rejeita acesso sem token', async () => {
+    it('rejects access without a token', async () => {
         await request(app.getHttpServer()).get('/users').expect(401);
     });
 
-    it('ADMIN consegue criar, listar, atualizar e remover um usuário', async () => {
-        await createUserWithRole('admin.e2e@example.com', 'senhaForte123', Role.ADMIN);
-        const token = await loginAndGetToken('admin.e2e@example.com', 'senhaForte123');
+    it('allows ADMIN to create, list, update, and delete a user', async () => {
+        await createUserWithRole('admin.e2e@example.com', 'strongPassword123', Role.ADMIN);
+        const token = await loginAndGetToken('admin.e2e@example.com', 'strongPassword123');
         const server = app.getHttpServer();
 
         const createResponse = await request(server)
             .post('/users')
             .set('Authorization', `Bearer ${token}`)
-            .send({ name: 'Novo Usuário', email: 'novo.e2e@example.com', password: 'senhaForte123' })
+            .send({ name: 'New User', email: 'new.e2e@example.com', password: 'strongPassword123' })
             .expect(201);
 
         expect(createResponse.body).not.toHaveProperty('passwordHash');
@@ -77,9 +77,9 @@ describe('Users (e2e)', () => {
     });
 
     // nestforge:feature:rbac
-    it('USER consegue ler mas não consegue criar usuário', async () => {
-        await createUserWithRole('user.e2e@example.com', 'senhaForte123', Role.USER);
-        const token = await loginAndGetToken('user.e2e@example.com', 'senhaForte123');
+    it('allows USER to read but not create users', async () => {
+        await createUserWithRole('user.e2e@example.com', 'strongPassword123', Role.USER);
+        const token = await loginAndGetToken('user.e2e@example.com', 'strongPassword123');
         const server = app.getHttpServer();
 
         await request(server).get('/users').set('Authorization', `Bearer ${token}`).expect(200);
@@ -87,14 +87,14 @@ describe('Users (e2e)', () => {
         await request(server)
             .post('/users')
             .set('Authorization', `Bearer ${token}`)
-            .send({ name: 'Não deveria criar', email: 'bloqueado.e2e@example.com', password: 'senhaForte123' })
+            .send({ name: 'Should Not Be Created', email: 'blocked.e2e@example.com', password: 'strongPassword123' })
             .expect(403);
     });
     // nestforge:feature:rbac:end
 
-    it('GET /users/me retorna o usuário autenticado', async () => {
-        await createUserWithRole('me.e2e@example.com', 'senhaForte123', Role.USER);
-        const token = await loginAndGetToken('me.e2e@example.com', 'senhaForte123');
+    it('returns the authenticated user from GET /users/me', async () => {
+        await createUserWithRole('me.e2e@example.com', 'strongPassword123', Role.USER);
+        const token = await loginAndGetToken('me.e2e@example.com', 'strongPassword123');
 
         const response = await request(app.getHttpServer())
             .get('/users/me')
@@ -103,4 +103,4 @@ describe('Users (e2e)', () => {
 
         expect(response.body.email).toBe('me.e2e@example.com');
     });
-});
+});

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

@@ -52,10 +52,10 @@ export class AuthController {
   @Public()
   @Get('csrf-token')
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Emite um token CSRF vinculado à sessão' })
+  @ApiOperation({ summary: 'Issues a CSRF token bound to the session' })
   @ApiResponse({
     status: 200,
-    description: 'Token CSRF emitido',
+    description: 'CSRF token issued',
     schema: {
       example: {
         csrfToken: 'a1b2c3d4e5f6...',
@@ -72,9 +72,9 @@ export class AuthController {
   @Public()
   @Post('register')
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Cria uma nova conta' })
-  @ApiResponse({ status: 201, description: 'Conta criada com sucesso', schema: { example: TOKENS_EXAMPLE } })
-  @ApiResponse({ status: 409, description: 'E-mail já cadastrado', schema: { example: { statusCode: 409, message: 'E-mail já cadastrado' } } })
+  @ApiOperation({ summary: 'Creates a new account' })
+  @ApiResponse({ status: 201, description: 'Account created successfully', schema: { example: TOKENS_EXAMPLE } })
+  @ApiResponse({ status: 409, description: 'Email already registered', schema: { example: { statusCode: 409, message: 'Email already registered' } } })
   // nestforge:feature:swagger:end
   async register(@Body() dto: RegisterDto) {
     const user = await this.authService.register(dto);
@@ -85,9 +85,9 @@ export class AuthController {
   @Post('login')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Autentica e retorna access/refresh token' })
-  @ApiResponse({ status: 200, description: 'Login realizado com sucesso', schema: { example: TOKENS_EXAMPLE } })
-  @ApiResponse({ status: 401, description: 'Credenciais inválidas', schema: { example: { statusCode: 401, message: 'Credenciais inválidas' } } })
+  @ApiOperation({ summary: 'Authenticates and returns access and refresh tokens' })
+  @ApiResponse({ status: 200, description: 'Login completed successfully', schema: { example: TOKENS_EXAMPLE } })
+  @ApiResponse({ status: 401, description: 'Invalid credentials', schema: { example: { statusCode: 401, message: 'Invalid credentials' } } })
   // nestforge:feature:swagger:end
   async login(@Body() dto: LoginDto) {
     const user = await this.authService.login(dto);
@@ -99,9 +99,9 @@ export class AuthController {
   @Public()
   @Post('register')
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Cria uma conta e inicia uma sessão' })
-  @ApiResponse({ status: 201, description: 'Conta criada e sessão iniciada' })
-  @ApiResponse({ status: 409, description: 'E-mail já cadastrado' })
+  @ApiOperation({ summary: 'Creates an account and starts a session' })
+  @ApiResponse({ status: 201, description: 'Account created and session started' })
+  @ApiResponse({ status: 409, description: 'Email already registered' })
   // nestforge:feature:swagger:end
   async registerWithSession(
     @Body() dto: RegisterDto,
@@ -115,9 +115,9 @@ export class AuthController {
   @Post('login')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Autentica e inicia uma sessão por cookie' })
-  @ApiResponse({ status: 200, description: 'Sessão iniciada com sucesso' })
-  @ApiResponse({ status: 401, description: 'Credenciais inválidas' })
+  @ApiOperation({ summary: 'Authenticates and starts a cookie-based session' })
+  @ApiResponse({ status: 200, description: 'Session started successfully' })
+  @ApiResponse({ status: 401, description: 'Invalid credentials' })
   // nestforge:feature:swagger:end
   async loginWithSession(
     @Body() dto: LoginDto,
@@ -130,8 +130,8 @@ export class AuthController {
   @Post('logout')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Encerra a sessão atual' })
-  @ApiResponse({ status: 200, description: 'Sessão encerrada com sucesso' })
+  @ApiOperation({ summary: 'Ends the current session' })
+  @ApiResponse({ status: 200, description: 'Session ended successfully' })
   // nestforge:feature:swagger:end
   logoutSession(@Req() request: Request) {
     return this.sessionService.destroy(request);
@@ -143,9 +143,9 @@ export class AuthController {
   @Post('refresh')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Renova o access token usando o refresh token' })
-  @ApiResponse({ status: 200, description: 'Novo par de tokens emitido', schema: { example: TOKENS_EXAMPLE } })
-  @ApiResponse({ status: 401, description: 'Refresh token inválido, expirado ou já usado', schema: { example: { statusCode: 401, message: 'Refresh token inválido ou expirado' } } })
+  @ApiOperation({ summary: 'Renews the access token using the refresh token' })
+  @ApiResponse({ status: 200, description: 'New token pair issued', schema: { example: TOKENS_EXAMPLE } })
+  @ApiResponse({ status: 401, description: 'Invalid, expired, or already used refresh token', schema: { example: { statusCode: 401, message: 'Invalid or expired refresh token' } } })
   // nestforge:feature:swagger:end
   refresh(@Body() dto: RefreshTokenDto) {
     return this.tokenService.refresh(dto.refreshToken);
@@ -155,8 +155,8 @@ export class AuthController {
   @Post('logout')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Revoga o refresh token informado' })
-  @ApiResponse({ status: 200, description: 'Logout realizado', schema: { example: { message: 'Logout realizado com sucesso' } } })
+  @ApiOperation({ summary: 'Revokes the provided refresh token' })
+  @ApiResponse({ status: 200, description: 'Logout completed', schema: { example: { message: 'Logout completed successfully' } } })
   // nestforge:feature:swagger:end
   logout(@Body() dto: RefreshTokenDto) {
     return this.tokenService.logout(dto.refreshToken);
@@ -168,11 +168,11 @@ export class AuthController {
   @Post('forgot-password')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Envia um e-mail com instruções para redefinir a senha' })
+  @ApiOperation({ summary: 'Sends an email with password reset instructions' })
   @ApiResponse({
     status: 200,
-    description: 'Resposta genérica — sempre a mesma, exista ou não o e-mail (evita enumeração de contas)',
-    schema: { example: { message: 'Se o e-mail existir, enviaremos instruções de redefinição de senha' } },
+    description: 'Generic response — always the same whether the email exists or not (prevents account enumeration)',
+    schema: { example: { message: 'If the email exists, password reset instructions will be sent' } },
   })
   // nestforge:feature:swagger:end
   forgotPassword(@Body() dto: ForgotPasswordDto) {
@@ -183,9 +183,9 @@ export class AuthController {
   @Post('reset-password')
   @HttpCode(HttpStatus.OK)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Redefine a senha usando o token recebido por e-mail' })
-  @ApiResponse({ status: 200, description: 'Senha redefinida', schema: { example: { message: 'Senha redefinida com sucesso' } } })
-  @ApiResponse({ status: 401, description: 'Token inválido, expirado ou já usado', schema: { example: { statusCode: 401, message: 'Token de redefinição inválido ou expirado' } } })
+  @ApiOperation({ summary: 'Resets the password using the token received by email' })
+  @ApiResponse({ status: 200, description: 'Password reset', schema: { example: { message: 'Password reset successfully' } } })
+  @ApiResponse({ status: 401, description: 'Invalid, expired, or already used token', schema: { example: { statusCode: 401, message: 'Invalid or expired password reset token' } } })
   // nestforge:feature:swagger:end
   resetPassword(@Body() dto: ResetPasswordDto) {
     return this.authService.resetPassword(dto.token, dto.password);
@@ -194,9 +194,9 @@ export class AuthController {
   @Public()
   @Get('verify-email')
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Confirma o e-mail usando o token recebido' })
-  @ApiResponse({ status: 200, description: 'E-mail verificado', schema: { example: { message: 'E-mail verificado com sucesso' } } })
-  @ApiResponse({ status: 401, description: 'Token inválido, expirado ou já usado', schema: { example: { statusCode: 401, message: 'Token de verificação inválido ou expirado' } } })
+  @ApiOperation({ summary: 'Verifies the email using the received token' })
+  @ApiResponse({ status: 200, description: 'Email verified', schema: { example: { message: 'Email verified successfully' } } })
+  @ApiResponse({ status: 401, description: 'Invalid, expired, or already used token', schema: { example: { statusCode: 401, message: 'Invalid or expired verification token' } } })
   // nestforge:feature:swagger:end
   verifyEmail(@Query('token') token: string) {
     return this.authService.verifyEmail(token);
@@ -207,10 +207,10 @@ export class AuthController {
   @Get('google')
   @UseGuards(GoogleAuthGuard)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Inicia o login via Google (redireciona)' })
+  @ApiOperation({ summary: 'Starts Google login (redirects)' })
   // nestforge:feature:swagger:end
   googleLogin() {
-    // o guard redireciona para o consentimento do Google; nada a fazer aqui
+    // The guard redirects to Google's consent screen; nothing to do here.
   }
 
   // nestforge:feature:auth:token
@@ -246,10 +246,10 @@ export class AuthController {
   @Get('github')
   @UseGuards(GithubAuthGuard)
   // nestforge:feature:swagger
-  @ApiOperation({ summary: 'Inicia o login via GitHub (redireciona)' })
+  @ApiOperation({ summary: 'Starts GitHub login (redirects)' })
   // nestforge:feature:swagger:end
   githubLogin() {
-    // o guard redireciona para o consentimento do GitHub; nada a fazer aqui
+    // The guard redirects to GitHub's consent screen; nothing to do here.
   }
 
   // nestforge:feature:auth:token
@@ -280,4 +280,4 @@ export class AuthController {
     return this.sessionService.establish(request, user);
   }
   // nestforge:feature:auth:session:end
-}
+}

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

@@ -81,7 +81,7 @@ describe('AuthService', () => {
     );
   });
 
-  it('deve lançar ConflictException se o e-mail já existir', async () => {
+  it('throws ConflictException when the email already exists', async () => {
     usersRepository.findOne.mockResolvedValue({
       id: 'user-1',
       email: 'jeiel@example.com',
@@ -91,12 +91,12 @@ describe('AuthService', () => {
       authService.register({
         name: 'Jeiel',
         email: 'jeiel@example.com',
-        password: 'senhaForte123',
+        password: 'strongPassword123',
       }),
     ).rejects.toBeInstanceOf(ConflictException);
   });
 
-  it('deve lançar UnauthorizedException com credenciais inválidas', async () => {
+  it('throws UnauthorizedException for invalid credentials', async () => {
     usersRepository.findOne.mockResolvedValue(null);
 
     await expect(
@@ -108,4 +108,4 @@ describe('AuthService', () => {
       UnauthorizedException,
     );
   });
-});
+});