nestforge-generator 0.3.0 → 0.4.1

package/templates/prisma/prisma/seed.ts

@@ -1,46 +1,46 @@
-import { PrismaClient, Role } from '@prisma/client';
-import * as bcrypt from 'bcryptjs';
-
-const prisma = new PrismaClient();
-
-interface SeedUser {
-  name: string;
-  email: string;
-  password: string;
-  role: Role;
-}
-
-const SEED_USERS: SeedUser[] = [
-  { name: 'Admin', email: 'admin@nestforge.dev', password: 'admin123', role: Role.ADMIN },
-  { name: 'Manager', email: 'manager@nestforge.dev', password: 'manager123', role: Role.MANAGER },
-  { name: 'Usuário', email: 'user@nestforge.dev', password: 'user1234', role: Role.USER },
-];
-
-async function main() {
-  for (const seedUser of SEED_USERS) {
-    const passwordHash = await bcrypt.hash(seedUser.password, 10);
-
-    await prisma.user.upsert({
-      where: { email: seedUser.email },
-      update: {},
-      create: {
-        name: seedUser.name,
-        email: seedUser.email,
-        passwordHash,
-        role: seedUser.role,
-        emailVerifiedAt: new Date(),
-      },
-    });
-
-    console.log(`Seed: ${seedUser.email} / ${seedUser.password} (${seedUser.role})`);
-  }
-}
-
-main()
-  .catch((error) => {
-    console.error(error);
-    process.exit(1);
-  })
-  .finally(async () => {
-    await prisma.$disconnect();
-  });
+import { PrismaClient, Role } from '@prisma/client';
+import * as bcrypt from 'bcryptjs';
+
+const prisma = new PrismaClient();
+
+interface SeedUser {
+  name: string;
+  email: string;
+  password: string;
+  role: Role;
+}
+
+const SEED_USERS: SeedUser[] = [
+  { name: 'Admin', email: 'admin@nestforge.dev', password: 'admin123', role: Role.ADMIN },
+  { name: 'Manager', email: 'manager@nestforge.dev', password: 'manager123', role: Role.MANAGER },
+  { name: 'User', email: 'user@nestforge.dev', password: 'user1234', role: Role.USER },
+];
+
+async function main() {
+  for (const seedUser of SEED_USERS) {
+    const passwordHash = await bcrypt.hash(seedUser.password, 10);
+
+    await prisma.user.upsert({
+      where: { email: seedUser.email },
+      update: {},
+      create: {
+        name: seedUser.name,
+        email: seedUser.email,
+        passwordHash,
+        role: seedUser.role,
+        emailVerifiedAt: new Date(),
+      },
+    });
+
+    console.log(`Seed: ${seedUser.email} / ${seedUser.password} (${seedUser.role})`);
+  }
+}
+
+main()
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

package/templates/prisma/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/prisma/src/auth/auth.service.spec.ts

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

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

@@ -31,7 +31,7 @@ export class AuthService {
     });
 
     if (existing) {
-      throw new ConflictException('E-mail já cadastrado');
+      throw new ConflictException('Email already registered');
     }
 
     const passwordHash = await bcrypt.hash(dto.password, 10);
@@ -53,11 +53,11 @@ export class AuthService {
     });
 
     if (!user || !user.passwordHash) {
-      throw new UnauthorizedException('Credenciais inválidas');
+      throw new UnauthorizedException('Invalid credentials');
     }
 
     if (!(await bcrypt.compare(dto.password, user.passwordHash))) {
-      throw new UnauthorizedException('Credenciais inválidas');
+      throw new UnauthorizedException('Invalid credentials');
     }
 
     return this.toAuthenticatedUser(user);
@@ -106,9 +106,9 @@ export class AuthService {
   async forgotPassword(email: string) {
     const user = await this.prisma.user.findUnique({ where: { email } });
 
-    // resposta genérica sempre, pra não revelar se o e-mail existe na base
+    // Always return a generic response to avoid revealing whether the email exists.
     const genericResponse = {
-      message: 'Se o e-mail existir, enviaremos instruções de redefinição de senha',
+      message: 'If the email exists, password reset instructions will be sent',
     };
 
     if (!user) {
@@ -140,7 +140,7 @@ export class AuthService {
     });
 
     if (!stored || stored.usedAt || stored.expiresAt < new Date()) {
-      throw new UnauthorizedException('Token de redefinição inválido ou expirado');
+      throw new UnauthorizedException('Invalid or expired password reset token');
     }
 
     const passwordHash = await bcrypt.hash(newPassword, 10);
@@ -154,14 +154,14 @@ export class AuthService {
         where: { id: stored.id },
         data: { usedAt: new Date() },
       }),
-      // por segurança, revoga todas as sessões ativas ao trocar a senha
+      // Revoke every active session after a password change for security.
       this.prisma.refreshToken.updateMany({
         where: { userId: stored.userId, revokedAt: null },
         data: { revokedAt: new Date() },
       }),
     ]);
 
-    return { message: 'Senha redefinida com sucesso' };
+    return { message: 'Password reset successfully' };
   }
 
   async verifyEmail(rawToken: string) {
@@ -172,7 +172,7 @@ export class AuthService {
     });
 
     if (!stored || stored.usedAt || stored.expiresAt < new Date()) {
-      throw new UnauthorizedException('Token de verificação inválido ou expirado');
+      throw new UnauthorizedException('Invalid or expired verification token');
     }
 
     await this.prisma.$transaction([
@@ -186,7 +186,7 @@ export class AuthService {
       }),
     ]);
 
-    return { message: 'E-mail verificado com sucesso' };
+    return { message: 'Email verified successfully' };
   }
 
   private async sendEmailVerification(userId: string, email: string, name: string) {
@@ -221,4 +221,4 @@ export class AuthService {
   private hashToken(token: string): string {
     return createHash('sha256').update(token).digest('hex');
   }
-}
+}

package/templates/prisma/src/auth/dto/forgot-password.dto.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { createZodDto } from 'nestjs-zod';
 
 export const forgotPasswordSchema = z.object({
-    email: z.string().email().describe('E-mail da conta a ser recuperada'),
+    email: z.string().email().describe('Email of the account to recover'),
 });
 
-export class ForgotPasswordDto extends createZodDto(forgotPasswordSchema) { }
+export class ForgotPasswordDto extends createZodDto(forgotPasswordSchema) { }

package/templates/prisma/src/auth/dto/login.dto.ts

@@ -3,8 +3,8 @@ import { z } from 'zod';
 import { createZodDto } from 'nestjs-zod';
 
 export const loginSchema = z.object({
-  email: z.string().email().describe('E-mail do usuário'),
-  password: z.string().min(8).describe('Senha'),
+  email: z.string().email().describe('User email'),
+  password: z.string().min(8).describe('Password'),
 });
 
-export class LoginDto extends createZodDto(loginSchema) { }
+export class LoginDto extends createZodDto(loginSchema) { }

package/templates/prisma/src/auth/dto/register.dto.ts

@@ -3,9 +3,9 @@ import { z } from 'zod';
 import { createZodDto } from 'nestjs-zod';
 
 export const registerSchema = z.object({
-  name: z.string().min(2).describe('Nome completo do usuário'),
-  email: z.string().email().describe('E-mail do usuário'),
-  password: z.string().min(8).describe('Senha (mínimo 8 caracteres)'),
+  name: z.string().min(2).describe('User full name'),
+  email: z.string().email().describe('User email'),
+  password: z.string().min(8).describe('Password (minimum 8 characters)'),
 });
 
-export class RegisterDto extends createZodDto(registerSchema) { }
+export class RegisterDto extends createZodDto(registerSchema) { }

package/templates/prisma/src/auth/dto/reset-password.dto.ts

@@ -3,8 +3,8 @@ import { z } from 'zod';
 import { createZodDto } from 'nestjs-zod';
 
 export const resetPasswordSchema = z.object({
-    token: z.string().describe('Token recebido por e-mail'),
-    password: z.string().min(8).describe('Nova senha (mínimo 8 caracteres)'),
+    token: z.string().describe('Token received by email'),
+    password: z.string().min(8).describe('New password (minimum 8 characters)'),
 });
 
-export class ResetPasswordDto extends createZodDto(resetPasswordSchema) { }
+export class ResetPasswordDto extends createZodDto(resetPasswordSchema) { }

package/templates/prisma/src/auth/guards/github-auth.guard.ts

@@ -1,10 +1,10 @@
-import { Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-
-@Injectable()
-export class GithubAuthGuard extends AuthGuard('github') {
-    constructor() {
-        // API stateless (Bearer token) — não usamos sessão do Passport/Express
-        super({ session: false });
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class GithubAuthGuard extends AuthGuard('github') {
+    constructor() {
+        // Stateless API (Bearer token) — Passport/Express sessions are not used.
+        super({ session: false });
+    }
+}

package/templates/prisma/src/auth/guards/google-auth.guard.ts

@@ -1,10 +1,10 @@
-import { Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-
-@Injectable()
-export class GoogleAuthGuard extends AuthGuard('google') {
-    constructor() {
-        // API stateless (Bearer token) — não usamos sessão do Passport/Express
-        super({ session: false });
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class GoogleAuthGuard extends AuthGuard('google') {
+    constructor() {
+        // Stateless API (Bearer token) — Passport/Express sessions are not used.
+        super({ session: false });
+    }
+}

package/templates/prisma/src/auth/guards/session-auth.guard.spec.ts

@@ -44,14 +44,14 @@ describe('SessionAuthGuard', () => {
         return { context, request };
     }
 
-    it('permite acesso a rotas públicas sem sessão', () => {
+    it('allows access to public routes without a session', () => {
         reflector.getAllAndOverride.mockReturnValue(true);
         const { context } = createContext();
 
         expect(guard.canActivate(context)).toBe(true);
     });
 
-    it('rejeita acesso quando não existe usuário na sessão', () => {
+    it('rejects access when the session has no user', () => {
         reflector.getAllAndOverride.mockReturnValue(false);
         const { context } = createContext();
 
@@ -60,7 +60,7 @@ describe('SessionAuthGuard', () => {
         );
     });
 
-    it('permite acesso e disponibiliza o usuário autenticado', () => {
+    it('allows access and exposes the authenticated user', () => {
         reflector.getAllAndOverride.mockReturnValue(false);
 
         const user = {
@@ -74,4 +74,4 @@ describe('SessionAuthGuard', () => {
         expect(guard.canActivate(context)).toBe(true);
         expect(request.user).toEqual(user);
     });
-});
+});

package/templates/prisma/src/auth/guards/session-auth.guard.ts

@@ -27,11 +27,11 @@ export class SessionAuthGuard implements CanActivate {
         const user = request.session?.user;
 
         if (!user) {
-            throw new UnauthorizedException('Sessão inválida ou expirada');
+            throw new UnauthorizedException('Invalid or expired session');
         }
 
         request.user = user;
 
         return true;
     }
-}
+}

package/templates/prisma/src/auth/session.service.spec.ts

@@ -31,7 +31,7 @@ describe('SessionService', () => {
         };
     }
 
-    it('regenera, preenche e salva a sessão', async () => {
+    it('regenerates, populates, and saves the session', async () => {
         const { request, session } = createRequest();
         const user: SessionUser = {
             id: 'user-1',
@@ -51,7 +51,7 @@ describe('SessionService', () => {
         });
     });
 
-    it('emite e salva um novo token CSRF', async () => {
+    it('issues and saves a new CSRF token', async () => {
         const { request, session } = createRequest();
 
         const result = await sessionService.issueCsrfToken(request);
@@ -61,14 +61,14 @@ describe('SessionService', () => {
         expect(session.save).toHaveBeenCalledOnce();
     });
 
-    it('destrói a sessão atual', async () => {
+    it('destroys the current session', async () => {
         const { request, session } = createRequest();
 
         const result = await sessionService.destroy(request);
 
         expect(session.destroy).toHaveBeenCalledOnce();
         expect(result).toEqual({
-            message: 'Logout realizado com sucesso',
+            message: 'Logout completed successfully',
         });
     });
-});
+});

package/templates/prisma/src/auth/session.service.ts

@@ -47,7 +47,7 @@ export class SessionService {
                 if (error) {
                     reject(
                         new InternalServerErrorException(
-                            'Não foi possível encerrar a sessão',
+                            'Unable to end the session',
                         ),
                     );
                     return;
@@ -57,7 +57,7 @@ export class SessionService {
             });
         });
 
-        return { message: 'Logout realizado com sucesso' };
+        return { message: 'Logout completed successfully' };
     }
 
     private async regenerate(request: Request): Promise<void> {
@@ -66,7 +66,7 @@ export class SessionService {
                 if (error) {
                     reject(
                         new InternalServerErrorException(
-                            'Não foi possível iniciar a sessão',
+                            'Unable to start the session',
                         ),
                     );
                     return;
@@ -83,7 +83,7 @@ export class SessionService {
                 if (error) {
                     reject(
                         new InternalServerErrorException(
-                            'Não foi possível salvar a sessão',
+                            'Unable to save the session',
                         ),
                     );
                     return;
@@ -93,4 +93,4 @@ export class SessionService {
             });
         });
     }
-}
+}

package/templates/prisma/src/auth/strategies/github.strategy.ts

@@ -25,7 +25,7 @@ export class GithubStrategy extends PassportStrategy(Strategy, 'github') {
         profile: Profile,
         done: (error: unknown, user?: OAuthProfile) => void,
     ) {
-        // o e-mail pode vir vazio se o usuário deixou o e-mail privado no GitHub
+        // The email may be missing when the user keeps it private on GitHub.
         const email =
             profile.emails?.[0]?.value ?? `${profile.username}@users.noreply.github.com`;
 
@@ -33,9 +33,9 @@ export class GithubStrategy extends PassportStrategy(Strategy, 'github') {
             provider: 'github',
             providerUserId: profile.id,
             email,
-            name: profile.displayName || profile.username || 'Usuário GitHub',
+            name: profile.displayName || profile.username || 'GitHub User',
         };
 
         done(null, oauthProfile);
     }
-}
+}

package/templates/prisma/src/auth/token.service.ts

@@ -56,7 +56,7 @@ export class TokenService {
         });
 
         if (!stored || stored.revokedAt || stored.expiresAt < new Date()) {
-            throw new UnauthorizedException('Refresh token inválido ou expirado');
+            throw new UnauthorizedException('Invalid or expired refresh token');
         }
 
         await this.prisma.refreshToken.update({
@@ -84,7 +84,7 @@ export class TokenService {
             },
         });
 
-        return { message: 'Logout realizado com sucesso' };
+        return { message: 'Logout completed successfully' };
     }
 
     private hashToken(token: string): string {