nestforge-generator 0.1.0

package/templates/typeorm/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/typeorm/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/typeorm/src/health/indicators/typeorm-health.indicator.spec.ts

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

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

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import {
+    HealthCheckError,
+    HealthIndicatorResult,
+} from '@nestjs/terminus';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class TypeOrmHealthIndicator {
+    constructor(
+        private readonly dataSource: DataSource,
+    ) { }
+
+    async isHealthy(
+        key: string,
+    ): Promise<HealthIndicatorResult> {
+        try {
+            await this.dataSource.query('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/typeorm/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/typeorm/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/typeorm/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/typeorm/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/typeorm/src/main.ts

@@ -0,0 +1,107 @@
+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 { TypeormStore } from 'connect-typeorm';
+import { DataSource } from 'typeorm';
+import { SessionEntity } from './auth/entities/session.entity';
+// 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 dataSource = app.get(DataSource);
+  const sessionsRepository =
+    dataSource.getRepository(SessionEntity);
+
+  const sessionMaxAge = Number(
+    process.env.SESSION_MAX_AGE ??
+    7 * 24 * 60 * 60 * 1000,
+  );
+
+  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 TypeormStore({
+        cleanupLimit: 2,
+        limitSubquery: false,
+        ttl: Math.floor(sessionMaxAge / 1000),
+      }).connect(sessionsRepository),
+      cookie: {
+        httpOnly: true,
+        secure:
+          process.env.NODE_ENV === 'production',
+        sameSite: 'lax',
+        maxAge: sessionMaxAge,
+      },
+    }),
+  );
+  // 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/typeorm/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/typeorm/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/typeorm/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/typeorm/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/typeorm/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/typeorm/src/users/dto/create-user.dto.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+import { Role } from '../../common/constants/role.enum';
+
+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/typeorm/src/users/dto/find-users-query.dto.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+import { Role } from '../../common/constants/role.enum';
+
+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/typeorm/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/typeorm/src/users/entities/user.entity.ts

@@ -0,0 +1,113 @@
+import { Exclude } from 'class-transformer';
+import {
+    Column,
+    CreateDateColumn,
+    Entity,
+    PrimaryGeneratedColumn,
+    UpdateDateColumn,
+    OneToMany,
+} from 'typeorm';
+import { Role } from '../../common/constants/role.enum';
+// nestforge:feature:auth:token
+import { RefreshTokenEntity } from '../../auth/entities/refresh-token.entity';
+// nestforge:feature:auth:token:end
+import { OAuthAccountEntity } from '../../auth/entities/oauth-account.entity';
+// nestforge:feature:redis,auth:password
+import { PasswordResetTokenEntity } from '../../auth/entities/password-reset-token.entity';
+import { EmailVerificationTokenEntity } from '../../auth/entities/email-verification-token.entity';
+// nestforge:feature:redis,auth:password:end
+
+@Entity({ name: 'users' })
+export class UserEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id!: string;
+
+    @Column({ type: 'varchar', length: 120 })
+    name!: string;
+
+    @Column({
+        type: 'varchar',
+        length: 255,
+        unique: true,
+    })
+    email!: string;
+
+    @Exclude()
+    @Column({
+        name: 'password_hash',
+        type: 'varchar',
+        length: 255,
+        nullable: true,
+    })
+    passwordHash!: string | null;
+
+    @Column({
+        type: 'varchar',
+        length: 20,
+        default: Role.USER,
+    })
+    role!: Role;
+
+    @Column({
+        name: 'avatar_url',
+        type: 'varchar',
+        length: 500,
+        nullable: true,
+    })
+    avatarUrl!: string | null;
+
+    @Column({
+        name: 'email_verified_at',
+        nullable: true,
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    emailVerifiedAt!: Date | null;
+
+    @CreateDateColumn({ name: 'created_at' })
+    createdAt!: Date;
+
+    @UpdateDateColumn({ name: 'updated_at' })
+    updatedAt!: Date;
+
+    // nestforge:feature:auth:token
+    @OneToMany(
+        () => RefreshTokenEntity,
+        (refreshToken) => refreshToken.user,
+    )
+    refreshTokens!: RefreshTokenEntity[];
+    // nestforge:feature:auth:token:end
+
+    @OneToMany(
+        () => OAuthAccountEntity,
+        (oauthAccount) => oauthAccount.user,
+    )
+    oauthAccounts!: OAuthAccountEntity[];
+
+    // nestforge:feature:redis,auth:password
+    @OneToMany(
+        () => PasswordResetTokenEntity,
+        (token) => token.user,
+    )
+    passwordResetTokens!: PasswordResetTokenEntity[];
+
+    @OneToMany(
+        () => EmailVerificationTokenEntity,
+        (token) => token.user,
+    )
+    emailVerificationTokens!: EmailVerificationTokenEntity[];
+    // nestforge:feature:redis,auth:password:end
+
+    constructor(partial?: Partial<UserEntity>) {
+        if (partial) {
+            Object.assign(this, partial);
+        }
+    }
+}