nestforge-generator 0.1.0

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

@@ -0,0 +1,301 @@
+import {
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from 'vitest';
+import {
+    ConflictException,
+    NotFoundException,
+} from '@nestjs/common';
+import { instanceToPlain } from 'class-transformer';
+import { Role } from '../common/constants/role.enum';
+import type { DrizzleDatabase } from '../database/database.types';
+import { UsersService } from './users.service';
+import { UserEntity } from './entities/user.entity';
+
+function createSelectBuilder<T>(result: T[]) {
+    const builder: any = {};
+
+    builder.from = vi.fn(() => builder);
+    builder.where = vi.fn(() => builder);
+    builder.orderBy = vi.fn(() => builder);
+    builder.limit = vi.fn(() => builder);
+    builder.offset = vi.fn(() => builder);
+
+    builder.then = (
+        resolve: (value: T[]) => unknown,
+        reject?: (reason: unknown) => unknown,
+    ) => Promise.resolve(result).then(resolve, reject);
+
+    return builder;
+}
+
+describe('UsersService', () => {
+    let usersService: UsersService;
+    let database: any;
+    let insertValues: ReturnType<typeof vi.fn>;
+    let updateSet: ReturnType<typeof vi.fn>;
+    let updateWhere: ReturnType<typeof vi.fn>;
+    let deleteWhere: ReturnType<typeof vi.fn>;
+    let mockUser: UserEntity;
+
+    beforeEach(() => {
+        mockUser = new UserEntity({
+            id: 'user-1',
+            name: 'Jeiel',
+            email: 'jeiel@example.com',
+            passwordHash: 'hash-secreto',
+            role: Role.USER,
+            avatarUrl: null,
+            emailVerifiedAt: null,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        });
+
+        insertValues = vi.fn().mockResolvedValue(undefined);
+
+        updateWhere = vi.fn().mockResolvedValue(undefined);
+        updateSet = vi.fn(() => ({
+            where: updateWhere,
+        }));
+
+        deleteWhere = vi.fn().mockResolvedValue(undefined);
+
+        database = {
+            select: vi.fn(),
+            insert: vi.fn(() => ({
+                values: insertValues,
+            })),
+            update: vi.fn(() => ({
+                set: updateSet,
+            })),
+            delete: vi.fn(() => ({
+                where: deleteWhere,
+            })),
+        };
+
+        usersService = new UsersService(
+            database as unknown as DrizzleDatabase,
+        );
+    });
+
+    it('deve lançar ConflictException se o e-mail já existir ao criar', async () => {
+        database.select.mockReturnValueOnce(
+            createSelectBuilder([
+                {
+                    id: mockUser.id,
+                },
+            ]),
+        );
+
+        await expect(
+            usersService.create({
+                name: 'Jeiel',
+                email: 'jeiel@example.com',
+                password: 'senhaForte123',
+            }),
+        ).rejects.toBeInstanceOf(ConflictException);
+
+        expect(database.insert).not.toHaveBeenCalled();
+    });
+
+    it('deve criar um usuário e esconder o passwordHash na serialização', async () => {
+        database.select
+            .mockReturnValueOnce(createSelectBuilder([]))
+            .mockReturnValueOnce(
+                createSelectBuilder([mockUser]),
+            );
+
+        const result = await usersService.create({
+            name: 'Jeiel',
+            email: 'jeiel@example.com',
+            password: 'senhaForte123',
+        });
+
+        expect(result.email).toBe(
+            'jeiel@example.com',
+        );
+
+        expect(
+            instanceToPlain(result),
+        ).not.toHaveProperty('passwordHash');
+
+        expect(database.insert).toHaveBeenCalled();
+        expect(insertValues).toHaveBeenCalledWith(
+            expect.objectContaining({
+                name: 'Jeiel',
+                email: 'jeiel@example.com',
+                role: Role.USER,
+                passwordHash: expect.any(String),
+            }),
+        );
+    });
+
+    it('deve lançar NotFoundException se o usuário não existir', async () => {
+        database.select.mockReturnValueOnce(
+            createSelectBuilder([]),
+        );
+
+        await expect(
+            usersService.findOne('id-invalido'),
+        ).rejects.toBeInstanceOf(NotFoundException);
+    });
+
+    it('deve retornar dados paginados em findAll', async () => {
+        const usersBuilder = createSelectBuilder([
+            mockUser,
+        ]);
+
+        const countBuilder = createSelectBuilder([
+            {
+                value: 1,
+            },
+        ]);
+
+        database.select
+            .mockReturnValueOnce(usersBuilder)
+            .mockReturnValueOnce(countBuilder);
+
+        const result = await usersService.findAll({
+            page: 1,
+            limit: 10,
+        });
+
+        expect(result.meta).toEqual({
+            total: 1,
+            page: 1,
+            limit: 10,
+            totalPages: 1,
+        });
+
+        expect(result.data).toHaveLength(1);
+        expect(usersBuilder.offset).toHaveBeenCalledWith(
+            0,
+        );
+        expect(usersBuilder.limit).toHaveBeenCalledWith(
+            10,
+        );
+    });
+
+    it('deve aplicar busca e filtro por role em findAll', async () => {
+        const usersBuilder = createSelectBuilder([
+            mockUser,
+        ]);
+
+        const countBuilder = createSelectBuilder([
+            {
+                value: 1,
+            },
+        ]);
+
+        database.select
+            .mockReturnValueOnce(usersBuilder)
+            .mockReturnValueOnce(countBuilder);
+
+        await usersService.findAll({
+            page: 1,
+            limit: 10,
+            search: 'jeiel',
+            role: Role.USER,
+        });
+
+        expect(
+            usersBuilder.where,
+        ).toHaveBeenCalledWith(
+            expect.anything(),
+        );
+
+        expect(
+            countBuilder.where,
+        ).toHaveBeenCalledWith(
+            expect.anything(),
+        );
+    });
+
+    it('deve atualizar um usuário existente', async () => {
+        const updatedUser = new UserEntity({
+            ...mockUser,
+            name: 'Novo Nome',
+            updatedAt: new Date(),
+        });
+
+        database.select
+            .mockReturnValueOnce(
+                createSelectBuilder([mockUser]),
+            )
+            .mockReturnValueOnce(
+                createSelectBuilder([updatedUser]),
+            );
+
+        const result = await usersService.update(
+            'user-1',
+            {
+                name: 'Novo Nome',
+            },
+        );
+
+        expect(result.name).toBe('Novo Nome');
+
+        expect(updateSet).toHaveBeenCalledWith(
+            expect.objectContaining({
+                name: 'Novo Nome',
+                updatedAt: expect.any(Date),
+            }),
+        );
+
+        expect(updateWhere).toHaveBeenCalled();
+    });
+
+    it('deve remover um usuário existente', async () => {
+        database.select.mockReturnValueOnce(
+            createSelectBuilder([mockUser]),
+        );
+
+        const result = await usersService.remove(
+            'user-1',
+        );
+
+        expect(database.delete).toHaveBeenCalled();
+        expect(deleteWhere).toHaveBeenCalled();
+
+        expect(result).toEqual({
+            message: 'Usuário removido com sucesso',
+        });
+    });
+
+    it('deve atualizar o avatar de um usuário', async () => {
+        const updatedUser = new UserEntity({
+            ...mockUser,
+            avatarUrl: '/uploads/avatars/x.png',
+            updatedAt: new Date(),
+        });
+
+        database.select
+            .mockReturnValueOnce(
+                createSelectBuilder([mockUser]),
+            )
+            .mockReturnValueOnce(
+                createSelectBuilder([updatedUser]),
+            );
+
+        const result = await usersService.updateAvatar(
+            'user-1',
+            '/uploads/avatars/x.png',
+        );
+
+        expect(result.avatarUrl).toBe(
+            '/uploads/avatars/x.png',
+        );
+
+        expect(updateSet).toHaveBeenCalledWith(
+            expect.objectContaining({
+                avatarUrl: '/uploads/avatars/x.png',
+                updatedAt: expect.any(Date),
+            }),
+        );
+
+        expect(updateWhere).toHaveBeenCalled();
+    });
+});

package/templates/drizzle/src/users/users.service.ts

@@ -0,0 +1,213 @@
+import { randomUUID } from 'node:crypto';
+import {
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import {
+  and,
+  count,
+  desc,
+  eq,
+  or,
+  sql,
+  type SQL,
+} from 'drizzle-orm';
+import * as bcrypt from 'bcryptjs';
+import { InjectDatabase } from '../database/database.decorators';
+import type { DrizzleDatabase } from '../database/database.types';
+import {
+  users,
+  type NewUser,
+} from '../database/schema';
+import { Role } from '../common/constants/role.enum';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+import { FindUsersQueryDto } from './dto/find-users-query.dto';
+import { UserEntity } from './entities/user.entity';
+
+@Injectable()
+export class UsersService {
+  constructor(
+    @InjectDatabase()
+    private readonly database: DrizzleDatabase,
+  ) { }
+
+  async create(
+    dto: CreateUserDto,
+  ): Promise<UserEntity> {
+    const [existing] = await this.database
+      .select({ id: users.id })
+      .from(users)
+      .where(eq(users.email, dto.email))
+      .limit(1);
+
+    if (existing) {
+      throw new ConflictException(
+        'E-mail já cadastrado',
+      );
+    }
+
+    const id = randomUUID();
+    const passwordHash = await bcrypt.hash(
+      dto.password,
+      10,
+    );
+
+    await this.database.insert(users).values({
+      id,
+      name: dto.name,
+      email: dto.email,
+      passwordHash,
+      role: dto.role ?? Role.USER,
+    });
+
+    return this.findOne(id);
+  }
+
+  async findAll(query: FindUsersQueryDto) {
+    const {
+      page = 1,
+      limit = 10,
+      search,
+      role,
+    } = query;
+
+    const filters: SQL[] = [];
+
+    if (role) {
+      filters.push(eq(users.role, role));
+    }
+
+    if (search) {
+      const searchValue = `%${search}%`;
+
+      const searchCondition = or(
+        sql<boolean>`
+            lower(${users.name})
+            like lower(${searchValue})
+          `,
+        sql<boolean>`
+            lower(${users.email})
+            like lower(${searchValue})
+          `,
+      );
+
+      if (searchCondition) {
+        filters.push(searchCondition);
+      }
+    }
+
+    const where =
+      filters.length > 0
+        ? and(...filters)
+        : undefined;
+
+    const [data, totalResult] = await Promise.all([
+      this.database
+        .select()
+        .from(users)
+        .where(where)
+        .orderBy(desc(users.createdAt))
+        .limit(limit)
+        .offset((page - 1) * limit),
+
+      this.database
+        .select({
+          value: count(),
+        })
+        .from(users)
+        .where(where),
+    ]);
+
+    const total = totalResult[0]?.value ?? 0;
+
+    return {
+      data: data.map(
+        (user) => new UserEntity(user),
+      ),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async findOne(id: string): Promise<UserEntity> {
+    const [user] = await this.database
+      .select()
+      .from(users)
+      .where(eq(users.id, id))
+      .limit(1);
+
+    if (!user) {
+      throw new NotFoundException(
+        'Usuário não encontrado',
+      );
+    }
+
+    return new UserEntity(user);
+  }
+
+  async update(
+    id: string,
+    dto: UpdateUserDto,
+  ): Promise<UserEntity> {
+    await this.findOne(id);
+
+    const {
+      password,
+      ...updateFields
+    } = dto;
+
+    const data: Partial<NewUser> = {
+      ...updateFields,
+      updatedAt: new Date(),
+    };
+
+    if (password) {
+      data.passwordHash = await bcrypt.hash(
+        password,
+        10,
+      );
+    }
+
+    await this.database
+      .update(users)
+      .set(data)
+      .where(eq(users.id, id));
+
+    return this.findOne(id);
+  }
+
+  async remove(id: string) {
+    await this.findOne(id);
+
+    await this.database
+      .delete(users)
+      .where(eq(users.id, id));
+
+    return {
+      message: 'Usuário removido com sucesso',
+    };
+  }
+
+  async updateAvatar(
+    id: string,
+    avatarUrl: string,
+  ): Promise<UserEntity> {
+    await this.findOne(id);
+
+    await this.database
+      .update(users)
+      .set({
+        avatarUrl,
+        updatedAt: new Date(),
+      })
+      .where(eq(users.id, id));
+
+    return this.findOne(id);
+  }
+}

package/templates/drizzle/test/auth.e2e-spec.ts

@@ -0,0 +1,114 @@
+// nestforge:feature-file:auth:password,auth:token
+import { INestApplication } from '@nestjs/common';
+import { DRIZZLE_DATABASE } from '../src/database/database.constants';
+import type { DrizzleDatabase } from '../src/database/database.types';
+import request from 'supertest';
+import { createTestApp } from './utils/e2e-setup';
+import { cleanDatabase } from './utils/clean-database';
+
+describe('Auth (e2e)', () => {
+    let app: INestApplication;
+    let database: DrizzleDatabase;
+
+    beforeAll(async () => {
+        app = await createTestApp();
+        database = app.get<DrizzleDatabase>(
+            DRIZZLE_DATABASE,
+        );
+    });
+
+    beforeEach(async () => {
+        await cleanDatabase(database);
+    });
+
+    afterAll(async () => {
+        await app.close();
+    });
+
+    it('deve registrar, logar, renovar e revogar o token', async () => {
+        const server = app.getHttpServer();
+
+        const registerResponse = await request(server)
+            .post('/auth/register')
+            .send({
+                name: 'Jeiel',
+                email: 'jeiel.e2e@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(201);
+
+        expect(registerResponse.body).toHaveProperty(
+            'accessToken',
+        );
+
+        expect(registerResponse.body).toHaveProperty(
+            'refreshToken',
+        );
+
+        const loginResponse = await request(server)
+            .post('/auth/login')
+            .send({
+                email: 'jeiel.e2e@example.com',
+                password: 'senhaForte123',
+            })
+            .expect(200);
+
+        const refreshResponse = await request(server)
+            .post('/auth/refresh')
+            .send({
+                refreshToken:
+                    loginResponse.body.refreshToken,
+            })
+            .expect(200);
+
+        expect(refreshResponse.body).toHaveProperty(
+            'accessToken',
+        );
+
+        await request(server)
+            .post('/auth/logout')
+            .send({
+                refreshToken:
+                    refreshResponse.body.refreshToken,
+            })
+            .expect(200);
+
+        await request(server)
+            .post('/auth/refresh')
+            .send({
+                refreshToken:
+                    refreshResponse.body.refreshToken,
+            })
+            .expect(401);
+    });
+
+    it('não deve permitir cadastro com e-mail duplicado', async () => {
+        const server = app.getHttpServer();
+
+        const payload = {
+            name: 'Jeiel',
+            email: 'duplicado.e2e@example.com',
+            password: 'senhaForte123',
+        };
+
+        await request(server)
+            .post('/auth/register')
+            .send(payload)
+            .expect(201);
+
+        await request(server)
+            .post('/auth/register')
+            .send(payload)
+            .expect(409);
+    });
+
+    it('deve rejeitar login com credenciais inválidas', async () => {
+        await request(app.getHttpServer())
+            .post('/auth/login')
+            .send({
+                email: 'naoexiste.e2e@example.com',
+                password: 'qualquerSenha123',
+            })
+            .expect(401);
+    });
+});