nestforge-generator 0.1.0

package/templates/typeorm/test/session-auth.e2e-spec.ts

@@ -0,0 +1,159 @@
+// nestforge:feature-file:auth:password,auth:session
+import { INestApplication } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import request from 'supertest';
+import { createTestApp } from './utils/e2e-setup';
+import { cleanDatabase } from './utils/clean-database';
+
+describe('Session auth (e2e)', () => {
+    let app: INestApplication;
+    let dataSource: DataSource;
+
+    beforeAll(async () => {
+        app = await createTestApp();
+        dataSource = app.get(DataSource);
+    })
+
+    beforeEach(async () => {
+        await cleanDatabase(dataSource);
+    });
+
+    afterAll(async () => {
+        if (app) {
+            await app.close();
+        }
+    });
+
+    it('registra, autentica e encerra uma sessão protegida por CSRF', async () => {
+        const agent = request.agent(app.getHttpServer());
+
+        await agent
+            .get('/users/me')
+            .expect(401);
+
+        const csrfResponse = await agent
+            .get('/auth/csrf-token')
+            .expect(200);
+
+        const csrfToken = csrfResponse.body.csrfToken as string;
+
+        expect(csrfToken).toMatch(/^[a-f0-9]{64}$/);
+
+        // Requisições que alteram estado devem ser rejeitadas sem o token.
+        await agent
+            .post('/auth/register')
+            .send({
+                name: 'Jeiel',
+                email: 'jeiel.session@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(403);
+
+        const registerResponse = await agent
+            .post('/auth/register')
+            .set('x-csrf-token', csrfToken)
+            .send({
+                name: 'Jeiel',
+                email: 'jeiel.session@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(201);
+
+        expect(registerResponse.body.user).toMatchObject({
+            email: 'jeiel.session@example.com',
+        });
+
+        expect(registerResponse.headers['set-cookie']).toEqual(
+            expect.arrayContaining([
+                expect.stringContaining('nestforge.sid='),
+            ]),
+        );
+
+        const authenticatedCsrfToken =
+            registerResponse.body.csrfToken as string;
+
+        expect(authenticatedCsrfToken).toMatch(/^[a-f0-9]{64}$/);
+        expect(authenticatedCsrfToken).not.toBe(csrfToken);
+
+        const authenticatedResponse = await agent
+            .get('/users/me')
+            .expect(200);
+
+        expect(authenticatedResponse.body.email).toBe(
+            'jeiel.session@example.com',
+        );
+
+        await agent
+            .post('/auth/logout')
+            .set('x-csrf-token', authenticatedCsrfToken)
+            .expect(200);
+
+        await agent
+            .get('/users/me')
+            .expect(401);
+    });
+
+    it('realiza login e renova o token CSRF da sessão', async () => {
+        const registrationAgent = request.agent(
+            app.getHttpServer(),
+        );
+
+        const registrationCsrfResponse = await registrationAgent
+            .get('/auth/csrf-token')
+            .expect(200);
+
+        const registrationCsrfToken =
+            registrationCsrfResponse.body.csrfToken as string;
+
+        const registrationResponse = await registrationAgent
+            .post('/auth/register')
+            .set('x-csrf-token', registrationCsrfToken)
+            .send({
+                name: 'Usuário de sessão',
+                email: 'login.session@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(201);
+
+        await registrationAgent
+            .post('/auth/logout')
+            .set(
+                'x-csrf-token',
+                registrationResponse.body.csrfToken,
+            )
+            .expect(200);
+
+        const loginAgent = request.agent(app.getHttpServer());
+
+        const loginCsrfResponse = await loginAgent
+            .get('/auth/csrf-token')
+            .expect(200);
+
+        const loginCsrfToken =
+            loginCsrfResponse.body.csrfToken as string;
+
+        const loginResponse = await loginAgent
+            .post('/auth/login')
+            .set('x-csrf-token', loginCsrfToken)
+            .send({
+                email: 'login.session@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(200);
+
+        expect(loginResponse.body.user.email).toBe(
+            'login.session@example.com',
+        );
+
+        expect(loginResponse.body.csrfToken).toMatch(
+            /^[a-f0-9]{64}$/,
+        );
+        expect(loginResponse.body.csrfToken).not.toBe(
+            loginCsrfToken,
+        );
+
+        await loginAgent
+            .get('/users/me')
+            .expect(200);
+    });
+});

package/templates/typeorm/test/users.e2e-spec.ts

@@ -0,0 +1,183 @@
+// nestforge:feature-file:auth:password,auth:token
+import { INestApplication } from '@nestjs/common';
+import {
+    DataSource,
+    Repository,
+} from 'typeorm';
+import * as bcrypt from 'bcryptjs';
+import request from 'supertest';
+import { Role } from '../src/common/constants/role.enum';
+import { UserEntity } from '../src/users/entities/user.entity';
+import { createTestApp } from './utils/e2e-setup';
+import { cleanDatabase } from './utils/clean-database';
+
+describe('Users (e2e)', () => {
+    let app: INestApplication;
+    let dataSource: DataSource;
+    let usersRepository: Repository<UserEntity>;
+
+    async function createUserWithRole(
+        email: string,
+        password: string,
+        role: Role,
+    ) {
+        const passwordHash = await bcrypt.hash(
+            password,
+            10,
+        );
+
+        const user = usersRepository.create({
+            name: 'Usuário de teste',
+            email,
+            passwordHash,
+            role,
+            emailVerifiedAt: new Date(),
+        });
+
+        await usersRepository.save(user);
+    }
+
+    async function loginAndGetToken(
+        email: string,
+        password: string,
+    ) {
+        const response = await request(
+            app.getHttpServer(),
+        )
+            .post('/auth/login')
+            .send({ email, password })
+            .expect(200);
+
+        return response.body.accessToken as string;
+    }
+
+    beforeAll(async () => {
+        app = await createTestApp();
+        dataSource = app.get(DataSource);
+        usersRepository =
+            dataSource.getRepository(UserEntity);
+    });
+
+    beforeEach(async () => {
+        await cleanDatabase(dataSource);
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    it('rejeita acesso sem token', async () => {
+        await request(app.getHttpServer())
+            .get('/users')
+            .expect(401);
+    });
+
+    it('ADMIN consegue criar, listar, atualizar e remover um usuário', async () => {
+        await createUserWithRole(
+            'admin.e2e@example.com',
+            'senhaForte123',
+            Role.ADMIN,
+        );
+
+        const token = await loginAndGetToken(
+            'admin.e2e@example.com',
+            'senhaForte123',
+        );
+
+        const server = app.getHttpServer();
+
+        const createResponse = await request(server)
+            .post('/users')
+            .set('Authorization', `Bearer ${token}`)
+            .send({
+                name: 'Novo Usuário',
+                email: 'novo.e2e@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(201);
+
+        expect(createResponse.body).not.toHaveProperty(
+            'passwordHash',
+        );
+
+        const userId = createResponse.body.id;
+
+        const listResponse = await request(server)
+            .get('/users')
+            .set('Authorization', `Bearer ${token}`)
+            .expect(200);
+
+        expect(
+            listResponse.body.meta.total,
+        ).toBeGreaterThanOrEqual(1);
+
+        await request(server)
+            .patch(`/users/${userId}`)
+            .set('Authorization', `Bearer ${token}`)
+            .send({
+                name: 'Nome Atualizado',
+            })
+            .expect(200);
+
+        await request(server)
+            .delete(`/users/${userId}`)
+            .set('Authorization', `Bearer ${token}`)
+            .expect(200);
+    });
+
+    // nestforge:feature:rbac
+    it('USER consegue ler mas não consegue criar usuário', async () => {
+        await createUserWithRole(
+            'user.e2e@example.com',
+            'senhaForte123',
+            Role.USER,
+        );
+
+        const token = await loginAndGetToken(
+            'user.e2e@example.com',
+            'senhaForte123',
+        );
+
+        const server = app.getHttpServer();
+
+        await request(server)
+            .get('/users')
+            .set('Authorization', `Bearer ${token}`)
+            .expect(200);
+
+        await request(server)
+            .post('/users')
+            .set('Authorization', `Bearer ${token}`)
+            .send({
+                name: 'Não deveria criar',
+                email: 'bloqueado.e2e@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(403);
+    });
+    // nestforge:feature:rbac:end
+
+    it('GET /users/me retorna o usuário autenticado', async () => {
+        await createUserWithRole(
+            'me.e2e@example.com',
+            'senhaForte123',
+            Role.USER,
+        );
+
+        const token = await loginAndGetToken(
+            'me.e2e@example.com',
+            'senhaForte123',
+        );
+
+        const response = await request(
+            app.getHttpServer(),
+        )
+            .get('/users/me')
+            .set('Authorization', `Bearer ${token}`)
+            .expect(200);
+
+        expect(response.body.email).toBe(
+            'me.e2e@example.com',
+        );
+    });
+});

package/templates/typeorm/test/utils/clean-database.ts

@@ -0,0 +1,65 @@
+// nestforge:feature-file:auth:enabled
+import { DataSource } from 'typeorm';
+import { UserEntity } from '../../src/users/entities/user.entity';
+import { OAuthAccountEntity } from '../../src/auth/entities/oauth-account.entity';
+
+// nestforge:feature:auth:token
+import { RefreshTokenEntity } from '../../src/auth/entities/refresh-token.entity';
+// nestforge:feature:auth:token:end
+
+// nestforge:feature:redis,auth:password
+import { PasswordResetTokenEntity } from '../../src/auth/entities/password-reset-token.entity';
+import { EmailVerificationTokenEntity } from '../../src/auth/entities/email-verification-token.entity';
+// nestforge:feature:redis,auth:password:end
+
+// nestforge:feature:auth:session
+import { SessionEntity } from '../../src/auth/entities/session.entity';
+// nestforge:feature:auth:session:end
+
+export async function cleanDatabase(
+    dataSource: DataSource,
+) {
+    await dataSource.transaction(async (manager) => {
+        // nestforge:feature:auth:session
+        await manager
+            .createQueryBuilder()
+            .delete()
+            .from(SessionEntity)
+            .execute();
+        // nestforge:feature:auth:session:end
+
+        // nestforge:feature:auth:token
+        await manager
+            .createQueryBuilder()
+            .delete()
+            .from(RefreshTokenEntity)
+            .execute();
+        // nestforge:feature:auth:token:end
+
+        // nestforge:feature:redis,auth:password
+        await manager
+            .createQueryBuilder()
+            .delete()
+            .from(PasswordResetTokenEntity)
+            .execute();
+
+        await manager
+            .createQueryBuilder()
+            .delete()
+            .from(EmailVerificationTokenEntity)
+            .execute();
+        // nestforge:feature:redis,auth:password:end
+
+        await manager
+            .createQueryBuilder()
+            .delete()
+            .from(OAuthAccountEntity)
+            .execute();
+
+        await manager
+            .createQueryBuilder()
+            .delete()
+            .from(UserEntity)
+            .execute();
+    });
+}

package/templates/typeorm/test/utils/e2e-setup.ts

@@ -0,0 +1,77 @@
+import {
+    ClassSerializerInterceptor,
+    INestApplication,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Test } from '@nestjs/testing';
+import { NestExpressApplication } from '@nestjs/platform-express';
+
+// nestforge:feature:validation
+import { ZodValidationPipe } from 'nestjs-zod';
+// nestforge:feature:validation:end
+
+import { AppModule } from '../../src/app.module';
+import { HttpExceptionFilter } from '../../src/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 '../../src/auth/entities/session.entity';
+// nestforge:feature:auth:session:end
+
+export async function createTestApp(): Promise<INestApplication> {
+    const moduleRef = await Test.createTestingModule({
+        imports: [AppModule],
+    }).compile();
+
+    const app =
+        moduleRef.createNestApplication<NestExpressApplication>();
+
+    // 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,
+    );
+
+    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: false,
+                sameSite: 'lax',
+                maxAge: sessionMaxAge,
+            },
+        }),
+    );
+    // nestforge:feature:auth:session:end
+
+    // nestforge:feature:validation
+    app.useGlobalPipes(new ZodValidationPipe());
+    // nestforge:feature:validation:end
+
+    app.useGlobalFilters(new HttpExceptionFilter());
+
+    app.useGlobalInterceptors(
+        new ClassSerializerInterceptor(
+            app.get(Reflector),
+        ),
+    );
+
+    await app.init();
+
+    return app;
+}

package/templates/typeorm/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/templates/typeorm/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2022",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "noImplicitAny": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  }
+}

package/templates/typeorm/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config';
+import swc from 'unplugin-swc';
+
+export default defineConfig({
+  plugins: [
+    swc.vite({
+      module: { type: 'es6' },
+    }),
+  ],
+  test: {
+    globals: true,
+    root: './',
+    environment: 'node',
+    include: ['src/**/*.spec.ts'],
+    coverage: {
+      reporter: ['text', 'html'],
+      exclude: ['**/*.module.ts', '**/main.ts'],
+    },
+  },
+});

package/templates/typeorm/vitest.e2e.config.ts

@@ -0,0 +1,19 @@
+import swc from 'unplugin-swc';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    plugins: [
+        swc.vite({
+            module: { type: 'es6' },
+        }),
+    ],
+    test: {
+        globals: true,
+        root: './',
+        environment: 'node',
+        include: ['test/**/*.e2e-spec.ts'],
+        testTimeout: 30000,
+        hookTimeout: 30000,
+        fileParallelism: false,
+    },
+});