nestforge-generator 0.1.0

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

@@ -0,0 +1,49 @@
+import { Controller, Get } from '@nestjs/common';
+import {
+    DiskHealthIndicator,
+    HealthCheck,
+    HealthCheckService,
+    MemoryHealthIndicator,
+} from '@nestjs/terminus';
+// nestforge:feature:swagger
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+// nestforge:feature:swagger:end
+import { Public } from '../common/decorators/public.decorator';
+import { PrismaHealthIndicator } from './indicators/prisma-health.indicator';
+// nestforge:feature:redis
+import { RedisHealthIndicator } from './indicators/redis-health.indicator';
+// nestforge:feature:redis:end
+
+// nestforge:feature:swagger
+@ApiTags('health')
+// nestforge:feature:swagger:end
+@Controller('health')
+export class HealthController {
+    constructor(
+        private readonly health: HealthCheckService,
+        private readonly prismaIndicator: PrismaHealthIndicator,
+        // nestforge:feature:redis
+        private readonly redisIndicator: RedisHealthIndicator,
+        // nestforge:feature:redis:end
+        private readonly memory: MemoryHealthIndicator,
+        private readonly disk: DiskHealthIndicator,
+    ) { }
+
+    @Public()
+    @Get()
+    @HealthCheck()
+    // nestforge:feature:swagger
+    @ApiOperation({ summary: 'Verifica a saúde da API (banco, memória, disco e demais dependências configuradas)' })
+    // nestforge:feature:swagger:end
+    check() {
+        return this.health.check([
+            () => this.prismaIndicator.isHealthy('database'),
+            // nestforge:feature:redis
+            () => this.redisIndicator.isHealthy('redis'),
+            // nestforge:feature:redis:end
+            () => this.memory.checkHeap('memory_heap', 300 * 1024 * 1024),
+            () => this.memory.checkRSS('memory_rss', 300 * 1024 * 1024),
+            () => this.disk.checkStorage('disk', { path: '/', thresholdPercent: 0.9 }),
+        ]);
+    }
+}

package/templates/prisma/src/health/health.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HealthController } from './health.controller';
+import { PrismaHealthIndicator } from './indicators/prisma-health.indicator';
+// nestforge:feature:redis
+import { RedisHealthIndicator } from './indicators/redis-health.indicator';
+// nestforge:feature:redis:end
+
+@Module({
+    imports: [TerminusModule],
+    controllers: [HealthController],
+    providers: [
+        PrismaHealthIndicator,
+        // nestforge:feature:redis
+        RedisHealthIndicator,
+        // nestforge:feature:redis:end
+    ],
+})
+export class HealthModule { }

package/templates/prisma/src/health/indicators/prisma-health.indicator.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import { HealthCheckError } from '@nestjs/terminus';
+import { PrismaHealthIndicator } from './prisma-health.indicator';
+import { PrismaService } from '../../database/prisma.service';
+
+describe('PrismaHealthIndicator', () => {
+    it('retorna status up quando a query executa com sucesso', async () => {
+        const prisma = { $queryRaw: vi.fn().mockResolvedValue([{ '?column?': 1 }]) };
+        const indicator = new PrismaHealthIndicator(prisma as unknown as PrismaService);
+
+        const result = await indicator.isHealthy('database');
+
+        expect(result).toEqual({ database: { status: 'up' } });
+    });
+
+    it('lança HealthCheckError quando a query falha', async () => {
+        const prisma = { $queryRaw: vi.fn().mockRejectedValue(new Error('conexão recusada')) };
+        const indicator = new PrismaHealthIndicator(prisma as unknown as PrismaService);
+
+        await expect(indicator.isHealthy('database')).rejects.toBeInstanceOf(HealthCheckError);
+    });
+});

package/templates/prisma/src/health/indicators/prisma-health.indicator.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { HealthIndicatorResult, HealthCheckError } from '@nestjs/terminus';
+import { PrismaService } from '../../database/prisma.service';
+
+@Injectable()
+export class PrismaHealthIndicator {
+    constructor(private readonly prisma: PrismaService) { }
+
+    async isHealthy(key: string): Promise<HealthIndicatorResult> {
+        try {
+            await this.prisma.$queryRaw`SELECT 1`;
+            return { [key]: { status: 'up' } };
+        } catch (error) {
+            throw new HealthCheckError('Banco de dados indisponível', {
+                [key]: { status: 'down', message: (error as Error).message },
+            });
+        }
+    }
+}

package/templates/prisma/src/health/indicators/redis-health.indicator.spec.ts

@@ -0,0 +1,54 @@
+// nestforge:feature-file:redis
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { HealthCheckError } from '@nestjs/terminus';
+
+const connectMock = vi.fn();
+const pingMock = vi.fn();
+const disconnectMock = vi.fn();
+
+vi.mock('ioredis', () => ({
+    default: vi.fn().mockImplementation(() => ({
+        connect: connectMock,
+        ping: pingMock,
+        disconnect: disconnectMock,
+    })),
+}));
+
+// precisa ser importado depois do vi.mock, senão pega o ioredis real
+const { RedisHealthIndicator } = await import('./redis-health.indicator');
+
+describe('RedisHealthIndicator', () => {
+    beforeEach(() => {
+        connectMock.mockReset();
+        pingMock.mockReset();
+        disconnectMock.mockReset();
+    });
+
+    it('retorna status up quando o PING responde PONG', async () => {
+        connectMock.mockResolvedValue(undefined);
+        pingMock.mockResolvedValue('PONG');
+
+        const indicator = new RedisHealthIndicator();
+        const result = await indicator.isHealthy('redis');
+
+        expect(result).toEqual({ redis: { status: 'up' } });
+        expect(disconnectMock).toHaveBeenCalled();
+    });
+
+    it('lança HealthCheckError quando o PING não responde PONG', async () => {
+        connectMock.mockResolvedValue(undefined);
+        pingMock.mockResolvedValue('ALGO_INESPERADO');
+
+        const indicator = new RedisHealthIndicator();
+
+        await expect(indicator.isHealthy('redis')).rejects.toBeInstanceOf(HealthCheckError);
+    });
+
+    it('lança HealthCheckError quando a conexão falha', async () => {
+        connectMock.mockRejectedValue(new Error('ECONNREFUSED'));
+
+        const indicator = new RedisHealthIndicator();
+
+        await expect(indicator.isHealthy('redis')).rejects.toBeInstanceOf(HealthCheckError);
+    });
+});

package/templates/prisma/src/health/indicators/redis-health.indicator.ts

@@ -0,0 +1,33 @@
+// nestforge:feature-file:redis
+import { Injectable } from '@nestjs/common';
+import { HealthIndicatorResult, HealthCheckError } from '@nestjs/terminus';
+import Redis from 'ioredis';
+
+@Injectable()
+export class RedisHealthIndicator {
+    async isHealthy(key: string): Promise<HealthIndicatorResult> {
+        const client = new Redis({
+            host: process.env.REDIS_HOST ?? 'localhost',
+            port: Number(process.env.REDIS_PORT ?? 6379),
+            lazyConnect: true,
+            maxRetriesPerRequest: 1,
+        });
+
+        try {
+            await client.connect();
+            const response = await client.ping();
+
+            if (response !== 'PONG') {
+                throw new Error('Resposta inesperada do Redis');
+            }
+
+            return { [key]: { status: 'up' } };
+        } catch (error) {
+            throw new HealthCheckError('Redis indisponível', {
+                [key]: { status: 'down', message: (error as Error).message },
+            });
+        } finally {
+            client.disconnect();
+        }
+    }
+}

package/templates/prisma/src/mail/mail.module.ts

@@ -0,0 +1,12 @@
+// nestforge:feature-file:redis
+import { Module } from '@nestjs/common';
+import { BullModule } from '@nestjs/bullmq';
+import { MailService, MAIL_QUEUE } from './mail.service';
+import { MailProcessor } from './mail.processor';
+
+@Module({
+    imports: [BullModule.registerQueue({ name: MAIL_QUEUE })],
+    providers: [MailService, MailProcessor],
+    exports: [MailService],
+})
+export class MailModule { }

package/templates/prisma/src/mail/mail.processor.ts

@@ -0,0 +1,48 @@
+// nestforge:feature-file:redis
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import { Job } from 'bullmq';
+import * as nodemailer from 'nodemailer';
+import { MAIL_QUEUE, MailJob } from './mail.service';
+import { resetPasswordTemplate, verifyEmailTemplate } from './templates/email-templates';
+
+interface MailJobData {
+    to: string;
+    name: string;
+    token: string;
+}
+
+@Processor(MAIL_QUEUE)
+export class MailProcessor extends WorkerHost {
+    private readonly logger = new Logger(MailProcessor.name);
+
+    private readonly transporter = nodemailer.createTransport({
+        host: process.env.MAIL_HOST,
+        port: Number(process.env.MAIL_PORT ?? 1025),
+        secure: false,
+    });
+
+    async process(job: Job<MailJobData>) {
+        const { to, name, token } = job.data;
+
+        switch (job.name) {
+            case MailJob.VerifyEmail:
+                await this.send(to, 'Confirme seu e-mail', verifyEmailTemplate(name, token));
+                break;
+            case MailJob.ResetPassword:
+                await this.send(to, 'Redefinição de senha', resetPasswordTemplate(name, token));
+                break;
+            default:
+                this.logger.warn(`Job de e-mail desconhecido: ${job.name}`);
+        }
+    }
+
+    private async send(to: string, subject: string, html: string) {
+        await this.transporter.sendMail({
+            from: process.env.MAIL_FROM,
+            to,
+            subject,
+            html,
+        });
+    }
+}

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

@@ -0,0 +1,24 @@
+// nestforge:feature-file:redis
+import { Injectable } from '@nestjs/common';
+import { InjectQueue } from '@nestjs/bullmq';
+import { Queue } from 'bullmq';
+
+export const MAIL_QUEUE = 'mail';
+
+export enum MailJob {
+    VerifyEmail = 'verify-email',
+    ResetPassword = 'reset-password',
+}
+
+@Injectable()
+export class MailService {
+    constructor(@InjectQueue(MAIL_QUEUE) private readonly mailQueue: Queue) { }
+
+    queueVerificationEmail(to: string, name: string, token: string) {
+        return this.mailQueue.add(MailJob.VerifyEmail, { to, name, token });
+    }
+
+    queuePasswordResetEmail(to: string, name: string, token: string) {
+        return this.mailQueue.add(MailJob.ResetPassword, { to, name, token });
+    }
+}

package/templates/prisma/src/mail/templates/email-templates.ts

@@ -0,0 +1,28 @@
+// nestforge:feature-file:redis
+const appUrl = process.env.APP_URL ?? 'http://localhost:3000';
+
+export function verifyEmailTemplate(name: string, token: string): string {
+    const link = `${appUrl}/auth/verify-email?token=${token}`;
+
+    return `
+    <div style="font-family: sans-serif; line-height: 1.5;">
+      <h2>Olá, ${name}!</h2>
+      <p>Confirme seu e-mail clicando no link abaixo:</p>
+      <p><a href="${link}">${link}</a></p>
+      <p>Esse link expira em 24 horas.</p>
+    </div>
+  `;
+}
+
+export function resetPasswordTemplate(name: string, token: string): string {
+    const link = `${appUrl}/auth/reset-password?token=${token}`;
+
+    return `
+    <div style="font-family: sans-serif; line-height: 1.5;">
+      <h2>Olá, ${name}!</h2>
+      <p>Recebemos um pedido para redefinir sua senha. Clique no link abaixo para continuar:</p>
+      <p><a href="${link}">${link}</a></p>
+      <p>Se você não pediu isso, pode ignorar este e-mail. O link expira em 1 hora.</p>
+    </div>
+  `;
+}

package/templates/prisma/src/main.ts

@@ -0,0 +1,92 @@
+import { NestFactory, Reflector } from '@nestjs/core';
+import { NestExpressApplication } from '@nestjs/platform-express';
+import { join } from 'path';
+import { Logger } from 'nestjs-pino';
+import helmet from 'helmet';
+import { ClassSerializerInterceptor } from '@nestjs/common';
+// nestforge:feature:validation
+import { ZodValidationPipe } from 'nestjs-zod';
+// nestforge:feature:validation:end
+// nestforge:feature:swagger
+import { patchNestJsSwagger } from 'nestjs-zod';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+// nestforge:feature:swagger:end
+import { AppModule } from './app.module';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter';
+// nestforge:feature:auth:session
+import session from 'express-session';
+import { PrismaSessionStore } from '@quixo3/prisma-session-store';
+import { PrismaService } from './database/prisma.service';
+// nestforge:feature:auth:session:end
+
+async function bootstrap() {
+  const app = await NestFactory.create<NestExpressApplication>(AppModule, {
+    bufferLogs: true,
+  });
+
+  app.useStaticAssets(join(process.cwd(), 'uploads'), { prefix: '/uploads' });
+
+  app.useLogger(app.get(Logger));
+  app.use(helmet());
+  // nestforge:feature:auth:session
+  const prisma = app.get(PrismaService);
+
+  if (process.env.NODE_ENV === 'production') {
+    app.set('trust proxy', 1);
+  }
+
+  app.use(
+    session({
+      name: 'nestforge.sid',
+      secret: process.env.SESSION_SECRET as string,
+      resave: false,
+      saveUninitialized: false,
+      store: new PrismaSessionStore(prisma, {
+        checkPeriod: 2 * 60 * 1000,
+        dbRecordIdIsSessionId: true,
+        dbRecordIdFunction: undefined,
+      }),
+      cookie: {
+        httpOnly: true,
+        secure: process.env.NODE_ENV === 'production',
+        sameSite: 'lax',
+        maxAge: Number(process.env.SESSION_MAX_AGE ?? 7 * 24 * 60 * 60 * 1000),
+      },
+    }),
+  );
+  // nestforge:feature:auth:session:end
+  const corsOrigins = (
+    process.env.CORS_ORIGINS ?? 'http://localhost:5173'
+  )
+    .split(',')
+    .map((origin) => origin.trim())
+    .filter(Boolean);
+
+  app.enableCors({
+    origin: corsOrigins,
+    credentials: true,
+  });
+  // nestforge:feature:validation
+  app.useGlobalPipes(new ZodValidationPipe());
+  // nestforge:feature:validation:end
+  app.useGlobalFilters(new HttpExceptionFilter());
+  app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)));
+
+  // nestforge:feature:swagger
+  patchNestJsSwagger();
+
+  const config = new DocumentBuilder()
+    .setTitle('NestForge API')
+    .setDescription('Production-ready NestJS starter API docs')
+    .setVersion('0.1.0')
+    .addBearerAuth()
+    .build();
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('docs', app, document);
+  // nestforge:feature:swagger:end
+
+  const port = process.env.PORT ?? 3000;
+  await app.listen(port);
+}
+
+bootstrap();

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

@@ -0,0 +1,22 @@
+import { Controller, Get, Res } from '@nestjs/common';
+import { Response } from 'express';
+// nestforge:feature:swagger
+import { ApiExcludeController } from '@nestjs/swagger';
+// nestforge:feature:swagger:end
+import { Public } from '../common/decorators/public.decorator';
+import { MetricsService } from './metrics.service';
+
+// nestforge:feature:swagger
+@ApiExcludeController()
+// nestforge:feature:swagger:end
+@Controller('metrics')
+export class MetricsController {
+    constructor(private readonly metricsService: MetricsService) { }
+
+    @Public()
+    @Get()
+    async getMetrics(@Res() res: Response) {
+        res.set('Content-Type', this.metricsService.getContentType());
+        res.send(await this.metricsService.getMetrics());
+    }
+}

package/templates/prisma/src/metrics/metrics.interceptor.ts

@@ -0,0 +1,30 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { Observable, tap } from 'rxjs';
+import { MetricsService } from './metrics.service';
+
+@Injectable()
+export class MetricsInterceptor implements NestInterceptor {
+    constructor(private readonly metricsService: MetricsService) { }
+
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const start = process.hrtime();
+        const route = request.route?.path ?? request.url;
+
+        return next.handle().pipe(
+            tap(() => {
+                const [seconds, nanoseconds] = process.hrtime(start);
+                const duration = seconds + nanoseconds / 1e9;
+                const labels = {
+                    method: request.method,
+                    route,
+                    status_code: String(response.statusCode),
+                };
+
+                this.metricsService.httpRequestDuration.observe(labels, duration);
+                this.metricsService.httpRequestsTotal.inc(labels);
+            }),
+        );
+    }
+}

package/templates/prisma/src/metrics/metrics.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { MetricsService } from './metrics.service';
+import { MetricsController } from './metrics.controller';
+import { MetricsInterceptor } from './metrics.interceptor';
+
+@Module({
+    controllers: [MetricsController],
+    providers: [MetricsService, { provide: APP_INTERCEPTOR, useClass: MetricsInterceptor }],
+    exports: [MetricsService],
+})
+export class MetricsModule { }

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import * as client from 'prom-client';
+
+@Injectable()
+export class MetricsService {
+    readonly registry = new client.Registry();
+
+    readonly httpRequestDuration = new client.Histogram({
+        name: 'http_request_duration_seconds',
+        help: 'Duração das requisições HTTP em segundos',
+        labelNames: ['method', 'route', 'status_code'],
+        buckets: [0.05, 0.1, 0.3, 0.5, 1, 2, 5],
+        registers: [this.registry],
+    });
+
+    readonly httpRequestsTotal = new client.Counter({
+        name: 'http_requests_total',
+        help: 'Total de requisições HTTP recebidas',
+        labelNames: ['method', 'route', 'status_code'],
+        registers: [this.registry],
+    });
+
+    constructor() {
+        client.collectDefaultMetrics({ register: this.registry });
+    }
+
+    async getMetrics(): Promise<string> {
+        return this.registry.metrics();
+    }
+
+    getContentType(): string {
+        return this.registry.contentType;
+    }
+}

package/templates/prisma/src/types/express-session.d.ts

@@ -0,0 +1,13 @@
+// nestforge:feature-file:auth:session
+import 'express-session';
+
+declare module 'express-session' {
+    interface SessionData {
+        user?: {
+            id: string;
+            email: string;
+            role: string;
+        };
+        csrfToken?: string;
+    }
+}

package/templates/prisma/src/users/dto/create-user.dto.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+import { Role } from '@prisma/client';
+
+export const createUserSchema = z.object({
+  name: z.string().min(2).describe('Nome completo'),
+  email: z.string().email().describe('E-mail do usuário'),
+  password: z.string().min(8).describe('Senha (mínimo 8 caracteres)'),
+  role: z.nativeEnum(Role).optional().describe('Role do usuário (padrão: USER)'),
+});
+
+export class CreateUserDto extends createZodDto(createUserSchema) { }

package/templates/prisma/src/users/dto/find-users-query.dto.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+import { Role } from '@prisma/client';
+
+export const findUsersQuerySchema = z.object({
+    page: z.coerce.number().int().min(1).default(1).describe('Página atual'),
+    limit: z.coerce.number().int().min(1).max(100).default(10).describe('Itens por página (máx. 100)'),
+    search: z.string().optional().describe('Busca por nome ou e-mail'),
+    role: z.nativeEnum(Role).optional().describe('Filtra por role'),
+});
+
+export class FindUsersQueryDto extends createZodDto(findUsersQuerySchema) { }

package/templates/prisma/src/users/dto/update-user.dto.ts

@@ -0,0 +1,6 @@
+import { createZodDto } from 'nestjs-zod';
+import { createUserSchema } from './create-user.dto';
+
+export const updateUserSchema = createUserSchema.partial();
+
+export class UpdateUserDto extends createZodDto(updateUserSchema) { }

package/templates/prisma/src/users/entities/user.entity.ts

@@ -0,0 +1,20 @@
+import { Exclude } from 'class-transformer';
+import { Role } from '@prisma/client';
+
+export class UserEntity {
+    id!: string;
+    name!: string;
+    email!: string;
+    role!: Role;
+    avatarUrl!: string | null;
+    emailVerifiedAt!: Date | null;
+    createdAt!: Date;
+    updatedAt!: Date;
+
+    @Exclude()
+    passwordHash?: string | null;
+
+    constructor(partial: Partial<UserEntity>) {
+        Object.assign(this, partial);
+    }
+}