nestforge-generator 0.1.0

package/templates/drizzle/src/database/schema/sqlite.schema.ts

@@ -0,0 +1,190 @@
+// nestforge:feature-file:database:sqlite
+import { randomUUID } from 'node:crypto';
+import { sql } from 'drizzle-orm';
+import {
+    index,
+    integer,
+    sqliteTable,
+    text,
+    uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+
+export const users = sqliteTable('users', {
+    id: text('id')
+        .$defaultFn(() => randomUUID())
+        .primaryKey(),
+    name: text('name').notNull(),
+    email: text('email').notNull().unique(),
+    passwordHash: text('password_hash'),
+    role: text('role', {
+        enum: ['ADMIN', 'MANAGER', 'USER'],
+    })
+        .default('USER')
+        .notNull(),
+    avatarUrl: text('avatar_url'),
+    emailVerifiedAt: integer('email_verified_at', {
+        mode: 'timestamp_ms',
+    }),
+    createdAt: integer('created_at', {
+        mode: 'timestamp_ms',
+    })
+        .default(sql`(unixepoch() * 1000)`)
+        .notNull(),
+    updatedAt: integer('updated_at', {
+        mode: 'timestamp_ms',
+    })
+        .default(sql`(unixepoch() * 1000)`)
+        .$onUpdate(() => new Date())
+        .notNull(),
+});
+
+export const oauthAccounts = sqliteTable(
+    'oauth_accounts',
+    {
+        id: text('id')
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        provider: text('provider').notNull(),
+        providerUserId: text(
+            'provider_user_id',
+        ).notNull(),
+        userId: text('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        createdAt: integer('created_at', {
+            mode: 'timestamp_ms',
+        })
+            .default(sql`(unixepoch() * 1000)`)
+            .notNull(),
+    },
+    (table) => [
+        uniqueIndex(
+            'oauth_accounts_provider_provider_user_id_key',
+        ).on(table.provider, table.providerUserId),
+        index('oauth_accounts_user_id_idx').on(table.userId),
+    ],
+);
+
+// nestforge:feature:auth:token
+export const refreshTokens = sqliteTable(
+    'refresh_tokens',
+    {
+        id: text('id')
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        tokenHash: text('token_hash').notNull().unique(),
+        userId: text('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: integer('expires_at', {
+            mode: 'timestamp_ms',
+        }).notNull(),
+        revokedAt: integer('revoked_at', {
+            mode: 'timestamp_ms',
+        }),
+        createdAt: integer('created_at', {
+            mode: 'timestamp_ms',
+        })
+            .default(sql`(unixepoch() * 1000)`)
+            .notNull(),
+    },
+    (table) => [
+        index('refresh_tokens_user_id_idx').on(table.userId),
+    ],
+);
+// nestforge:feature:auth:token:end
+
+// nestforge:feature:redis,auth:password
+export const passwordResetTokens = sqliteTable(
+    'password_reset_tokens',
+    {
+        id: text('id')
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        tokenHash: text('token_hash').notNull().unique(),
+        userId: text('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: integer('expires_at', {
+            mode: 'timestamp_ms',
+        }).notNull(),
+        usedAt: integer('used_at', {
+            mode: 'timestamp_ms',
+        }),
+        createdAt: integer('created_at', {
+            mode: 'timestamp_ms',
+        })
+            .default(sql`(unixepoch() * 1000)`)
+            .notNull(),
+    },
+    (table) => [
+        index('password_reset_tokens_user_id_idx').on(
+            table.userId,
+        ),
+    ],
+);
+
+export const emailVerificationTokens = sqliteTable(
+    'email_verification_tokens',
+    {
+        id: text('id')
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        tokenHash: text('token_hash').notNull().unique(),
+        userId: text('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: integer('expires_at', {
+            mode: 'timestamp_ms',
+        }).notNull(),
+        usedAt: integer('used_at', {
+            mode: 'timestamp_ms',
+        }),
+        createdAt: integer('created_at', {
+            mode: 'timestamp_ms',
+        })
+            .default(sql`(unixepoch() * 1000)`)
+            .notNull(),
+    },
+    (table) => [
+        index('email_verification_tokens_user_id_idx').on(
+            table.userId,
+        ),
+    ],
+);
+// nestforge:feature:redis,auth:password:end
+
+// nestforge:feature:auth:session
+export const sessions = sqliteTable(
+    'sessions',
+    {
+        id: text('id').primaryKey(),
+        expiredAt: integer('expired_at').notNull(),
+        json: text('json').notNull(),
+        destroyedAt: integer('destroyed_at', {
+            mode: 'timestamp_ms',
+        }),
+    },
+    (table) => [
+        index('sessions_expired_at_idx').on(
+            table.expiredAt,
+        ),
+    ],
+);
+// nestforge:feature:auth:session:end
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+
+export type OAuthAccount =
+    typeof oauthAccounts.$inferSelect;
+export type NewOAuthAccount =
+    typeof oauthAccounts.$inferInsert;

package/templates/drizzle/src/database/seed.ts

@@ -0,0 +1,152 @@
+// nestforge:feature-file:auth:password
+import {
+    randomUUID,
+} from 'node:crypto';
+import * as bcrypt from 'bcryptjs';
+import { eq } from 'drizzle-orm';
+import { Role } from '../common/constants/role.enum';
+import {
+    users,
+} from './schema';
+import * as schema from './schema';
+
+// nestforge:feature:database:postgres
+import { Pool } from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+// nestforge:feature:database:postgres:end
+
+// nestforge:feature:database:mysql
+import { createPool } from 'mysql2/promise';
+import { drizzle } from 'drizzle-orm/mysql2';
+// nestforge:feature:database:mysql:end
+
+// nestforge:feature:database:sqlite
+import BetterSqlite3 from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+// nestforge:feature:database:sqlite:end
+
+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,
+    },
+];
+
+const databaseUrl = process.env.DATABASE_URL;
+
+if (!databaseUrl) {
+    throw new Error(
+        'DATABASE_URL não foi definida',
+    );
+}
+
+// nestforge:feature:database:postgres
+const client = new Pool({
+    connectionString: databaseUrl,
+});
+
+const database = drizzle(client, {
+    schema,
+});
+// nestforge:feature:database:postgres:end
+
+// nestforge:feature:database:mysql
+const client = createPool(databaseUrl);
+
+const database = drizzle(client, {
+    schema,
+    mode: 'default',
+});
+// nestforge:feature:database:mysql:end
+
+// nestforge:feature:database:sqlite
+const databasePath = databaseUrl.replace(
+    /^file:/,
+    '',
+);
+
+const client = new BetterSqlite3(
+    databasePath,
+);
+
+const database = drizzle(client, {
+    schema,
+});
+// nestforge:feature:database:sqlite:end
+
+async function seed(): Promise<void> {
+    try {
+        for (const seedUser of SEED_USERS) {
+            const [existingUser] = await database
+                .select({
+                    id: users.id,
+                })
+                .from(users)
+                .where(eq(users.email, seedUser.email))
+                .limit(1);
+
+            if (!existingUser) {
+                const passwordHash =
+                    await bcrypt.hash(
+                        seedUser.password,
+                        10,
+                    );
+
+                await database.insert(users).values({
+                    id: randomUUID(),
+                    name: seedUser.name,
+                    email: seedUser.email,
+                    passwordHash,
+                    role: seedUser.role,
+                    emailVerifiedAt: new Date(),
+                });
+            }
+
+            console.log(
+                `Seed: ${seedUser.email} / ${seedUser.password} (${seedUser.role})`,
+            );
+        }
+    } finally {
+        // nestforge:feature:database:postgres
+        await client.end();
+        // nestforge:feature:database:postgres:end
+
+        // nestforge:feature:database:mysql
+        await client.end();
+        // nestforge:feature:database:mysql:end
+
+        // nestforge:feature:database:sqlite
+        client.close();
+        // nestforge:feature:database:sqlite:end
+    }
+}
+
+seed().catch((error: unknown) => {
+    console.error(
+        'Erro ao executar o seed:',
+        error,
+    );
+
+    process.exitCode = 1;
+});

package/templates/drizzle/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 { DrizzleHealthIndicator } from './indicators/drizzle-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 databaseIndicator: DrizzleHealthIndicator,
+        // 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.databaseIndicator.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/drizzle/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 { DrizzleHealthIndicator } from './indicators/drizzle-health.indicator';
+// nestforge:feature:redis
+import { RedisHealthIndicator } from './indicators/redis-health.indicator';
+// nestforge:feature:redis:end
+
+@Module({
+    imports: [TerminusModule],
+    controllers: [HealthController],
+    providers: [
+        DrizzleHealthIndicator,
+        // nestforge:feature:redis
+        RedisHealthIndicator,
+        // nestforge:feature:redis:end
+    ],
+})
+export class HealthModule { }

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

@@ -0,0 +1,71 @@
+import {
+    describe,
+    expect,
+    it,
+    vi,
+} from 'vitest';
+import { HealthCheckError } from '@nestjs/terminus';
+import type { DatabaseClient } from '../../database/database.types';
+import { DrizzleHealthIndicator } from './drizzle-health.indicator';
+
+describe('DrizzleHealthIndicator', () => {
+    it('retorna status up quando a consulta executa com sucesso', async () => {
+        const get = vi.fn().mockReturnValue({
+            result: 1,
+        });
+
+        const databaseClient = {
+            query: vi.fn().mockResolvedValue([
+                {
+                    result: 1,
+                },
+            ]),
+            prepare: vi.fn(() => ({
+                get,
+            })),
+        };
+
+        const indicator =
+            new DrizzleHealthIndicator(
+                databaseClient as unknown as DatabaseClient,
+            );
+
+        const result = await indicator.isHealthy(
+            'database',
+        );
+
+        expect(result).toEqual({
+            database: {
+                status: 'up',
+            },
+        });
+    });
+
+    it('lança HealthCheckError quando a consulta falha', async () => {
+        const get = vi.fn(() => {
+            throw new Error('conexão recusada');
+        });
+
+        const databaseClient = {
+            query: vi
+                .fn()
+                .mockRejectedValue(
+                    new Error('conexão recusada'),
+                ),
+            prepare: vi.fn(() => ({
+                get,
+            })),
+        };
+
+        const indicator =
+            new DrizzleHealthIndicator(
+                databaseClient as unknown as DatabaseClient,
+            );
+
+        await expect(
+            indicator.isHealthy('database'),
+        ).rejects.toBeInstanceOf(
+            HealthCheckError,
+        );
+    });
+});

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

@@ -0,0 +1,52 @@
+import {
+    Inject,
+    Injectable,
+} from '@nestjs/common';
+import {
+    HealthCheckError,
+    HealthIndicatorResult,
+} from '@nestjs/terminus';
+import { DATABASE_CLIENT } from '../../database/database.constants';
+import type { DatabaseClient } from '../../database/database.types';
+
+@Injectable()
+export class DrizzleHealthIndicator {
+    constructor(
+        @Inject(DATABASE_CLIENT)
+        private readonly client: DatabaseClient,
+    ) { }
+
+    async isHealthy(
+        key: string,
+    ): Promise<HealthIndicatorResult> {
+        try {
+            // nestforge:feature:database:postgres
+            await this.client.query('SELECT 1');
+            // nestforge:feature:database:postgres:end
+
+            // nestforge:feature:database:mysql
+            await this.client.query('SELECT 1');
+            // nestforge:feature:database:mysql:end
+
+            // nestforge:feature:database:sqlite
+            this.client.prepare('SELECT 1').get();
+            // nestforge:feature:database:sqlite:end
+
+            return {
+                [key]: {
+                    status: 'up',
+                },
+            };
+        } catch (error) {
+            throw new HealthCheckError(
+                'Banco de dados indisponível',
+                {
+                    [key]: {
+                        status: 'down',
+                        message: (error as Error).message,
+                    },
+                },
+            );
+        }
+    }
+}

package/templates/drizzle/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/drizzle/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/drizzle/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/drizzle/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,
+        });
+    }
+}