nestforge-generator 0.1.0

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

@@ -0,0 +1,283 @@
+import { Body, Controller, Get, HttpCode, HttpStatus, Post, Query, Req, UseGuards } from '@nestjs/common';
+// nestforge:feature:swagger
+import { ApiExcludeEndpoint, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+// nestforge:feature:swagger:end
+import { Request } from 'express';
+import { AuthService } from './auth.service';
+// nestforge:feature:auth:password
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+// nestforge:feature:auth:password:end
+// nestforge:feature:auth:token
+import { RefreshTokenDto } from './dto/refresh-token.dto';
+// nestforge:feature:auth:token:end
+// nestforge:feature:redis,auth:password
+import { ForgotPasswordDto } from './dto/forgot-password.dto';
+import { ResetPasswordDto } from './dto/reset-password.dto';
+// nestforge:feature:redis,auth:password:end
+import { Public } from '../common/decorators/public.decorator';
+import { GoogleAuthGuard } from './guards/google-auth.guard';
+import { GithubAuthGuard } from './guards/github-auth.guard';
+import { OAuthProfile } from './strategies/google.strategy';
+// nestforge:feature:auth:token
+import { TokenService } from './token.service';
+// nestforge:feature:auth:token:end
+// nestforge:feature:auth:session
+import { SessionService } from './session.service';
+// nestforge:feature:auth:session:end
+
+// nestforge:feature:swagger,auth:token
+const TOKENS_EXAMPLE = {
+  accessToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+  refreshToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+};
+// nestforge:feature:swagger,auth:token:end
+
+// nestforge:feature:swagger
+@ApiTags('auth')
+// nestforge:feature:swagger:end
+@Controller('auth')
+export class AuthController {
+  constructor(
+    private readonly authService: AuthService,
+    // nestforge:feature:auth:token
+    private readonly tokenService: TokenService,
+    // nestforge:feature:auth:token:end
+    // nestforge:feature:auth:session
+    private readonly sessionService: SessionService,
+    // nestforge:feature:auth:session:end
+  ) { }
+
+  // nestforge:feature:auth:session
+  @Public()
+  @Get('csrf-token')
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Emite um token CSRF vinculado à sessão' })
+  @ApiResponse({
+    status: 200,
+    description: 'Token CSRF emitido',
+    schema: {
+      example: {
+        csrfToken: 'a1b2c3d4e5f6...',
+      },
+    },
+  })
+  // nestforge:feature:swagger:end
+  getCsrfToken(@Req() request: Request) {
+    return this.sessionService.issueCsrfToken(request);
+  }
+  // nestforge:feature:auth:session:end
+
+  // nestforge:feature:auth:token,auth:password
+  @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' } } })
+  // nestforge:feature:swagger:end
+  async register(@Body() dto: RegisterDto) {
+    const user = await this.authService.register(dto);
+    return this.tokenService.issueTokens(user.id, user.email, user.role);
+  }
+
+  @Public()
+  @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' } } })
+  // nestforge:feature:swagger:end
+  async login(@Body() dto: LoginDto) {
+    const user = await this.authService.login(dto);
+    return this.tokenService.issueTokens(user.id, user.email, user.role);
+  }
+  // nestforge:feature:auth:token,auth:password:end
+
+  // nestforge:feature:auth:session
+  @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' })
+  // nestforge:feature:swagger:end
+  async registerWithSession(
+    @Body() dto: RegisterDto,
+    @Req() request: Request,
+  ) {
+    const user = await this.authService.register(dto);
+    return this.sessionService.establish(request, user);
+  }
+
+  @Public()
+  @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' })
+  // nestforge:feature:swagger:end
+  async loginWithSession(
+    @Body() dto: LoginDto,
+    @Req() request: Request,
+  ) {
+    const user = await this.authService.login(dto);
+    return this.sessionService.establish(request, user);
+  }
+
+  @Post('logout')
+  @HttpCode(HttpStatus.OK)
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Encerra a sessão atual' })
+  @ApiResponse({ status: 200, description: 'Sessão encerrada com sucesso' })
+  // nestforge:feature:swagger:end
+  logoutSession(@Req() request: Request) {
+    return this.sessionService.destroy(request);
+  }
+  // nestforge:feature:auth:session:end
+
+  // nestforge:feature:auth:token
+  @Public()
+  @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' } } })
+  // nestforge:feature:swagger:end
+  refresh(@Body() dto: RefreshTokenDto) {
+    return this.tokenService.refresh(dto.refreshToken);
+  }
+
+  @Public()
+  @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' } } })
+  // nestforge:feature:swagger:end
+  logout(@Body() dto: RefreshTokenDto) {
+    return this.tokenService.logout(dto.refreshToken);
+  }
+  // nestforge:feature:auth:token:end
+
+  // nestforge:feature:redis,auth:password
+  @Public()
+  @Post('forgot-password')
+  @HttpCode(HttpStatus.OK)
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Envia um e-mail com instruções para redefinir a senha' })
+  @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' } },
+  })
+  // nestforge:feature:swagger:end
+  forgotPassword(@Body() dto: ForgotPasswordDto) {
+    return this.authService.forgotPassword(dto.email);
+  }
+
+  @Public()
+  @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' } } })
+  // nestforge:feature:swagger:end
+  resetPassword(@Body() dto: ResetPasswordDto) {
+    return this.authService.resetPassword(dto.token, dto.password);
+  }
+
+  @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' } } })
+  // nestforge:feature:swagger:end
+  verifyEmail(@Query('token') token: string) {
+    return this.authService.verifyEmail(token);
+  }
+  // nestforge:feature:redis,auth:password:end
+
+  @Public()
+  @Get('google')
+  @UseGuards(GoogleAuthGuard)
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Inicia o login via Google (redireciona)' })
+  // nestforge:feature:swagger:end
+  googleLogin() {
+    // o guard redireciona para o consentimento do Google; nada a fazer aqui
+  }
+
+  // nestforge:feature:auth:token
+  @Public()
+  @Get('google/callback')
+  @UseGuards(GoogleAuthGuard)
+  // nestforge:feature:swagger
+  @ApiExcludeEndpoint()
+  // nestforge:feature:swagger:end
+  async googleCallback(@Req() req: Request) {
+    const user = await this.authService.validateOAuthLogin(req.user as OAuthProfile);
+    return this.tokenService.issueTokens(user.id, user.email, user.role);
+  }
+  // nestforge:feature:auth:token:end
+
+  // nestforge:feature:auth:session
+  @Public()
+  @Get('google/callback')
+  @UseGuards(GoogleAuthGuard)
+  // nestforge:feature:swagger
+  @ApiExcludeEndpoint()
+  // nestforge:feature:swagger:end
+  async googleSessionCallback(@Req() request: Request) {
+    const user = await this.authService.validateOAuthLogin(
+      request.user as OAuthProfile,
+    );
+
+    return this.sessionService.establish(request, user);
+  }
+  // nestforge:feature:auth:session:end
+
+  @Public()
+  @Get('github')
+  @UseGuards(GithubAuthGuard)
+  // nestforge:feature:swagger
+  @ApiOperation({ summary: 'Inicia o login via GitHub (redireciona)' })
+  // nestforge:feature:swagger:end
+  githubLogin() {
+    // o guard redireciona para o consentimento do GitHub; nada a fazer aqui
+  }
+
+  // nestforge:feature:auth:token
+  @Public()
+  @Get('github/callback')
+  @UseGuards(GithubAuthGuard)
+  // nestforge:feature:swagger
+  @ApiExcludeEndpoint()
+  // nestforge:feature:swagger:end
+  async githubCallback(@Req() req: Request) {
+    const user = await this.authService.validateOAuthLogin(req.user as OAuthProfile);
+    return this.tokenService.issueTokens(user.id, user.email, user.role);
+  }
+  // nestforge:feature:auth:token:end
+
+  // nestforge:feature:auth:session
+  @Public()
+  @Get('github/callback')
+  @UseGuards(GithubAuthGuard)
+  // nestforge:feature:swagger
+  @ApiExcludeEndpoint()
+  // nestforge:feature:swagger:end
+  async githubSessionCallback(@Req() request: Request) {
+    const user = await this.authService.validateOAuthLogin(
+      request.user as OAuthProfile,
+    );
+
+    return this.sessionService.establish(request, user);
+  }
+  // nestforge:feature:auth:session:end
+}

package/templates/drizzle/src/auth/auth.module.ts

@@ -0,0 +1,81 @@
+import { Module } from '@nestjs/common';
+import { PassportModule } from '@nestjs/passport';
+import { APP_GUARD } from '@nestjs/core';
+
+// nestforge:feature:auth:token
+import { JwtModule } from '@nestjs/jwt';
+import { TokenService } from './token.service';
+import { JwtStrategy } from './strategies/jwt.strategy';
+import { JwtAuthGuard } from './guards/jwt-auth.guard';
+// nestforge:feature:auth:token:end
+
+// nestforge:feature:redis
+import { MailModule } from '../mail/mail.module';
+// nestforge:feature:redis:end
+
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { GoogleStrategy } from './strategies/google.strategy';
+import { GithubStrategy } from './strategies/github.strategy';
+
+// nestforge:feature:rbac
+import { RolesGuard } from '../common/guards/roles.guard';
+import { PermissionsGuard } from '../common/guards/permissions.guard';
+// nestforge:feature:rbac:end
+
+// nestforge:feature:auth:session
+import { SessionAuthGuard } from './guards/session-auth.guard';
+import { SessionService } from './session.service';
+import { DrizzleSessionStore } from './drizzle-session.store';
+// nestforge:feature:auth:session:end
+
+@Module({
+  imports: [
+    PassportModule,
+    // nestforge:feature:auth:token
+    JwtModule.register({}),
+    // nestforge:feature:auth:token:end
+    // nestforge:feature:redis
+    MailModule,
+    // nestforge:feature:redis:end
+  ],
+  controllers: [AuthController],
+  providers: [
+    AuthService,
+    // nestforge:feature:auth:token
+    TokenService,
+    JwtStrategy,
+    {
+      provide: APP_GUARD,
+      useClass: JwtAuthGuard,
+    },
+    // nestforge:feature:auth:token:end
+    // nestforge:feature:auth:session
+    DrizzleSessionStore,
+    SessionService,
+    {
+      provide: APP_GUARD,
+      useClass: SessionAuthGuard,
+    },
+    // nestforge:feature:auth:session:end
+    GoogleStrategy,
+    GithubStrategy,
+    // nestforge:feature:rbac
+    {
+      provide: APP_GUARD,
+      useClass: RolesGuard,
+    },
+    {
+      provide: APP_GUARD,
+      useClass: PermissionsGuard,
+    },
+    // nestforge:feature:rbac:end
+  ],
+  exports: [
+    AuthService,
+    // nestforge:feature:auth:session
+    DrizzleSessionStore,
+    // nestforge:feature:auth:session:end
+  ],
+})
+export class AuthModule { }

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

@@ -0,0 +1,111 @@
+// nestforge:feature-file:auth:password
+import {
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest';
+import {
+  ConflictException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import type { DrizzleDatabase } from '../database/database.types';
+import { AuthService } from './auth.service';
+
+// nestforge:feature:redis
+import { MailService } from '../mail/mail.service';
+// nestforge:feature:redis:end
+
+function createSelectBuilder<T>(result: T[]) {
+  const builder: any = {};
+
+  builder.from = vi.fn(() => builder);
+  builder.innerJoin = vi.fn(() => builder);
+  builder.where = vi.fn(() => builder);
+  builder.limit = vi.fn(() => builder);
+
+  builder.then = (
+    resolve: (value: T[]) => unknown,
+    reject?: (reason: unknown) => unknown,
+  ) => Promise.resolve(result).then(resolve, reject);
+
+  return builder;
+}
+
+describe('AuthService', () => {
+  let authService: AuthService;
+  let database: any;
+
+  // nestforge:feature:redis
+  let mailService: MailService;
+  // nestforge:feature:redis:end
+
+  beforeEach(() => {
+    database = {
+      select: vi.fn(),
+      insert: vi.fn(),
+      update: vi.fn(),
+      transaction: vi.fn(),
+    };
+
+    // nestforge:feature:redis
+    mailService = {
+      queueVerificationEmail: vi.fn(),
+      queuePasswordResetEmail: vi.fn(),
+    } as unknown as MailService;
+    // nestforge:feature:redis:end
+
+    authService = new AuthService(
+      database as unknown as DrizzleDatabase,
+      // nestforge:feature:redis
+      mailService,
+      // nestforge:feature:redis:end
+    );
+  });
+
+  it('deve lançar ConflictException se o e-mail já existir', async () => {
+    database.select.mockReturnValueOnce(
+      createSelectBuilder([
+        {
+          id: 'user-1',
+          name: 'Jeiel',
+          email: 'jeiel@example.com',
+          passwordHash: 'hash-secreto',
+          role: 'USER',
+          avatarUrl: null,
+          emailVerifiedAt: null,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ]),
+    );
+
+    await expect(
+      authService.register({
+        name: 'Jeiel',
+        email: 'jeiel@example.com',
+        password: 'senhaForte123',
+      }),
+    ).rejects.toBeInstanceOf(
+      ConflictException,
+    );
+
+    expect(database.insert).not.toHaveBeenCalled();
+  });
+
+  it('deve lançar UnauthorizedException com credenciais inválidas', async () => {
+    database.select.mockReturnValueOnce(
+      createSelectBuilder([]),
+    );
+
+    await expect(
+      authService.login({
+        email: 'naoexiste@example.com',
+        password: 'qualquer123',
+      }),
+    ).rejects.toBeInstanceOf(
+      UnauthorizedException,
+    );
+  });
+});