kybernus 3.0.1 → 3.2.0

package/templates/ecommerce/apps/api/src/modules/auth/__tests__/user.entity.unit.test.ts

@@ -0,0 +1,79 @@
+import { UserEntity } from '../user.entity';
+
+describe('UserEntity — Unit', () => {
+  describe('create()', () => {
+    it('deve criar um usuário com role CUSTOMER por padrão', () => {
+      const user = UserEntity.create({
+        name: 'João Silva',
+        email: 'joao@email.com',
+        passwordHash: 'hashed_password',
+      });
+
+      expect(user.role).toBe('CUSTOMER');
+      expect(user.email).toBe('joao@email.com');
+      expect(user.name).toBe('João Silva');
+    });
+
+    it('deve aceitar role ADMIN explicitamente', () => {
+      const user = UserEntity.create({
+        name: 'Admin User',
+        email: 'admin@email.com',
+        passwordHash: 'hashed_password',
+        role: 'ADMIN',
+      });
+
+      expect(user.role).toBe('ADMIN');
+    });
+
+    it('deve gerar um id único para cada usuário criado', () => {
+      const user1 = UserEntity.create({ name: 'A', email: 'a@a.com', passwordHash: 'h' });
+      const user2 = UserEntity.create({ name: 'B', email: 'b@b.com', passwordHash: 'h' });
+
+      expect(user1.id).not.toBe(user2.id);
+    });
+
+    it('deve lançar erro se email for inválido', () => {
+      expect(() =>
+        UserEntity.create({ name: 'A', email: 'not-an-email', passwordHash: 'h' }),
+      ).toThrow();
+    });
+
+    it('deve lançar erro se name for vazio', () => {
+      expect(() =>
+        UserEntity.create({ name: '  ', email: 'a@a.com', passwordHash: 'h' }),
+      ).toThrow();
+    });
+  });
+
+  describe('reconstitute()', () => {
+    it('deve reconstituir um usuário existente a partir de dados persistidos', () => {
+      const user = UserEntity.reconstitute({
+        id: 'existing-id',
+        name: 'João',
+        email: 'joao@email.com',
+        passwordHash: 'hashed',
+        role: 'CUSTOMER',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      expect(user.id).toBe('existing-id');
+      expect(user.role).toBe('CUSTOMER');
+    });
+  });
+
+  describe('toPublic()', () => {
+    it('NÃO deve expor passwordHash no retorno público', () => {
+      const user = UserEntity.create({
+        name: 'João',
+        email: 'joao@email.com',
+        passwordHash: 'secret_hash',
+      });
+
+      const pub = user.toPublic();
+
+      expect((pub as Record<string, unknown>)['passwordHash']).toBeUndefined();
+      expect(pub.email).toBe('joao@email.com');
+    });
+  });
+});

package/templates/ecommerce/apps/api/src/modules/auth/__tests__/user.prisma.repository.test.ts

@@ -0,0 +1,138 @@
+import { PrismaClient } from '@prisma/client';
+import { PrismaUserRepository } from '../user.prisma.repository';
+import { UserEntity } from '../user.entity';
+
+// DATABASE_URL is set to ecommerce_test by setup.db.ts (setupFiles)
+const db = new PrismaClient();
+const repo = new PrismaUserRepository(db);
+
+async function cleanDb() {
+  await db.$executeRaw`TRUNCATE TABLE password_reset_tokens, users RESTART IDENTITY CASCADE`;
+}
+
+beforeAll(async () => {
+  await db.$connect();
+});
+
+afterAll(async () => {
+  await cleanDb();
+  await db.$disconnect();
+});
+
+beforeEach(async () => {
+  await cleanDb();
+});
+
+describe('PrismaUserRepository', () => {
+  it('create: deve persistir e reconstituir UserEntity', async () => {
+    const user = UserEntity.create({
+      name: 'Alice',
+      email: 'alice@example.com',
+      passwordHash: '$2b$10$hashedpw',
+    });
+
+    const saved = await repo.create(user);
+
+    expect(saved.id).toBe(user.id);
+    expect(saved.name).toBe('Alice');
+    expect(saved.email).toBe('alice@example.com');
+    expect(saved.role).toBe('CUSTOMER');
+  });
+
+  it('findByEmail: deve retornar null para email inexistente', async () => {
+    const result = await repo.findByEmail('ghost@example.com');
+    expect(result).toBeNull();
+  });
+
+  it('findByEmail: deve retornar entidade para email existente', async () => {
+    const user = UserEntity.create({
+      name: 'Bob',
+      email: 'bob@example.com',
+      passwordHash: '$2b$10$hashedpw',
+    });
+    await repo.create(user);
+
+    const found = await repo.findByEmail('bob@example.com');
+
+    expect(found).not.toBeNull();
+    expect(found!.email).toBe('bob@example.com');
+    expect(found!.id).toBe(user.id);
+  });
+
+  it('findById: deve retornar null para id inexistente', async () => {
+    const result = await repo.findById('00000000-0000-0000-0000-000000000000');
+    expect(result).toBeNull();
+  });
+
+  it('findById: deve retornar entidade para id existente', async () => {
+    const user = UserEntity.create({
+      name: 'Carol',
+      email: 'carol@example.com',
+      passwordHash: '$2b$10$hashedpw',
+    });
+    await repo.create(user);
+
+    const found = await repo.findById(user.id);
+
+    expect(found).not.toBeNull();
+    expect(found!.id).toBe(user.id);
+  });
+
+  it('update: deve persistir alterações de role', async () => {
+    const user = UserEntity.create({
+      name: 'Dave',
+      email: 'dave@example.com',
+      passwordHash: '$2b$10$hashedpw',
+    });
+    await repo.create(user);
+
+    const promoted = user.withRole('ADMIN');
+    const updated = await repo.update(promoted);
+
+    expect(updated.role).toBe('ADMIN');
+
+    const fetched = await repo.findById(user.id);
+    expect(fetched!.role).toBe('ADMIN');
+  });
+
+  it('findAll: deve paginar com cursor', async () => {
+    const users = await Promise.all(
+      ['u1@test.com', 'u2@test.com', 'u3@test.com'].map((email) =>
+        repo.create(
+          UserEntity.create({ name: email, email, passwordHash: 'pw' }),
+        ),
+      ),
+    );
+
+    const page1 = await repo.findAll({ limit: 2 });
+    expect(page1.items).toHaveLength(2);
+    expect(page1.nextCursor).not.toBeNull();
+
+    const page2 = await repo.findAll({ cursor: page1.nextCursor!, limit: 2 });
+    expect(page2.items).toHaveLength(1);
+    expect(page2.nextCursor).toBeNull();
+
+    const allIds = [...page1.items, ...page2.items].map((u) => u.id);
+    expect(allIds).toEqual(expect.arrayContaining(users.map((u) => u.id)));
+  });
+
+  it('findAll: deve filtrar por role', async () => {
+    const customer = UserEntity.create({
+      name: 'Cust',
+      email: 'cust@test.com',
+      passwordHash: 'pw',
+    });
+    const admin = UserEntity.create({
+      name: 'Adm',
+      email: 'adm@test.com',
+      passwordHash: 'pw',
+    }).withRole('ADMIN');
+
+    await repo.create(customer);
+    await repo.create(admin);
+
+    const { items } = await repo.findAll({ role: 'ADMIN' });
+    expect(items).toHaveLength(1);
+    expect(items[0]!.role).toBe('ADMIN');
+  });
+});

package/templates/ecommerce/apps/api/src/modules/auth/auth.controller.ts

@@ -0,0 +1,148 @@
+import { Request, Response, NextFunction } from 'express';
+import { z } from 'zod';
+import { authService } from './auth.registry';
+
+// ── Validation schemas ────────────────────────────────────────────────────────
+const registerSchema = z.object({
+  name: z.string().min(1, 'Nome é obrigatório'),
+  email: z.string().email('Email inválido'),
+  password: z.string().min(8, 'Senha deve ter pelo menos 8 caracteres'),
+});
+
+const loginSchema = z.object({
+  email: z.string().email('Email inválido'),
+  password: z.string().min(1, 'Senha é obrigatória'),
+});
+
+// ── Cookie helpers ────────────────────────────────────────────────────────────
+const REFRESH_COOKIE = 'refreshToken';
+const COOKIE_OPTIONS = {
+  httpOnly: true,
+  secure: process.env['NODE_ENV'] === 'production',
+  sameSite: 'strict' as const,
+  maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days in ms
+};
+
+// ── Controllers ───────────────────────────────────────────────────────────────
+export async function register(req: Request, res: Response, next: NextFunction): Promise<void> {
+  const parsed = registerSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(422).json({ errors: parsed.error.flatten().fieldErrors });
+    return;
+  }
+
+  try {
+    const user = await authService.register(parsed.data);
+
+    // Generate tokens right away so the client is logged in after registration
+    const loginResult = await authService.login({
+      email: parsed.data.email,
+      password: parsed.data.password,
+    });
+
+    res.cookie(REFRESH_COOKIE, loginResult.refreshToken, COOKIE_OPTIONS);
+    res.status(201).json({ user, accessToken: loginResult.accessToken });
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function login(req: Request, res: Response, next: NextFunction): Promise<void> {
+  const parsed = loginSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(422).json({ errors: parsed.error.flatten().fieldErrors });
+    return;
+  }
+
+  try {
+    const { accessToken, refreshToken, user } = await authService.login(parsed.data);
+
+    res.cookie(REFRESH_COOKIE, refreshToken, COOKIE_OPTIONS);
+    res.status(200).json({ accessToken, user });
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function refresh(req: Request, res: Response, next: NextFunction): Promise<void> {
+  const token = (req.cookies as Record<string, string | undefined>)[REFRESH_COOKIE];
+  if (!token) {
+    res.status(401).json({ error: 'Refresh token não encontrado' });
+    return;
+  }
+
+  try {
+    const { accessToken } = await authService.refreshToken(token);
+    res.status(200).json({ accessToken });
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function logout(req: Request, res: Response, next: NextFunction): Promise<void> {
+  const token = (req.cookies as Record<string, string | undefined>)[REFRESH_COOKIE];
+
+  try {
+    if (token) {
+      await authService.logout(token);
+    }
+    res.clearCookie(REFRESH_COOKIE);
+    res.status(204).send();
+  } catch (err) {
+    next(err);
+  }
+}
+
+export function me(req: Request, res: Response): void {
+  res.status(200).json(req.user);
+}
+
+export function adminTest(_req: Request, res: Response): void {
+  res.status(200).json({ message: 'Admin access granted' });
+}
+
+export async function forgotPassword(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> {
+  const parsed = z
+    .object({ email: z.string().email('Email inválido') })
+    .safeParse(req.body);
+  if (!parsed.success) {
+    res.status(422).json({ errors: parsed.error.flatten().fieldErrors });
+    return;
+  }
+  try {
+    await authService.forgotPassword({ email: parsed.data.email });
+    // Always respond with the same message to prevent user enumeration
+    res
+      .status(200)
+      .json({ message: 'Se o email existir, você receberá as instruções em breve.' });
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function resetPassword(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> {
+  const parsed = z
+    .object({
+      token: z.string().min(1, 'Token é obrigatório'),
+      newPassword: z.string().min(6, 'A senha deve ter pelo menos 6 caracteres'),
+    })
+    .safeParse(req.body);
+  if (!parsed.success) {
+    res.status(422).json({ errors: parsed.error.flatten().fieldErrors });
+    return;
+  }
+  try {
+    await authService.resetPassword(parsed.data);
+    res.status(200).json({ message: 'Senha redefinida com sucesso.' });
+  } catch (err) {
+    next(err);
+  }
+}

package/templates/ecommerce/apps/api/src/modules/auth/auth.registry.ts

@@ -0,0 +1 @@
+export * from '../../infrastructure/config/registry/auth.registry';

package/templates/ecommerce/apps/api/src/modules/auth/auth.routes.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { authenticate } from '../../shared/middlewares/authenticate';
+import { authorize } from '../../shared/middlewares/authorize';
+import * as authController from './auth.controller';
+
+const router = Router();
+
+router.post('/register', authController.register);
+router.post('/login', authController.login);
+router.post('/refresh', authController.refresh);
+router.post('/logout', authController.logout);
+router.get('/me', authenticate, authController.me);
+router.get('/admin-test', authenticate, authorize('ADMIN'), authController.adminTest);
+router.post('/forgot-password', authController.forgotPassword);
+router.post('/reset-password', authController.resetPassword);
+
+export default router;

package/templates/ecommerce/apps/api/src/modules/auth/auth.service.ts

@@ -0,0 +1 @@
+export * from '../../application/auth/auth.service';

package/templates/ecommerce/apps/api/src/modules/auth/redis.token.blacklist.ts

@@ -0,0 +1 @@
+export * from '../../infrastructure/services/token/redis.token.blacklist';

package/templates/ecommerce/apps/api/src/modules/auth/token.blacklist.ts

@@ -0,0 +1,2 @@
+export * from '../../application/ports/token-blacklist.port';
+export * from '../../infrastructure/services/token/token.blacklist';

package/templates/ecommerce/apps/api/src/modules/auth/token.service.ts

@@ -0,0 +1,2 @@
+export * from '../../application/ports/token.port';
+export * from '../../infrastructure/services/token/token.service';

package/templates/ecommerce/apps/api/src/modules/auth/user.entity.ts

@@ -0,0 +1 @@
+export * from '../../domain/auth/user.entity';

package/templates/ecommerce/apps/api/src/modules/auth/user.prisma.repository.ts

@@ -0,0 +1 @@
+export * from '../../infrastructure/persistence/prisma/auth/user.prisma.repository';

package/templates/ecommerce/apps/api/src/modules/auth/user.repository.ts

@@ -0,0 +1,2 @@
+export * from '../../domain/auth/user.repository';
+export * from '../../infrastructure/persistence/in-memory/user.memory.repository';

package/templates/ecommerce/apps/api/src/modules/cart/__tests__/cart.entity.unit.test.ts

@@ -0,0 +1,144 @@
+import { CartEntity } from '../cart.entity';
+import { CouponEntity } from '../coupon.entity';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function makeItem(overrides: Partial<{
+  variantId: string;
+  productId: string;
+  name: string;
+  sku: string;
+  price: number;
+  qty: number;
+  image: string | null;
+}> = {}) {
+  return {
+    variantId: overrides.variantId ?? 'var-1',
+    productId: overrides.productId ?? 'prod-1',
+    name: overrides.name ?? 'Camiseta Básica',
+    sku: overrides.sku ?? 'CAM-P',
+    price: overrides.price ?? 100,
+    qty: overrides.qty ?? 1,
+    image: overrides.image ?? null,
+  };
+}
+
+// Coupon helpers
+const percentCoupon = CouponEntity.reconstitute({
+  id: 'coup-1',
+  code: 'PROMO10',
+  discountType: 'percent',
+  discountValue: 10, // 10%
+  minOrderValue: 0,
+  usageLimit: null,
+  usageCount: 0,
+  expiresAt: null,
+  createdAt: new Date(),
+});
+
+const fixedCoupon = CouponEntity.reconstitute({
+  id: 'coup-2',
+  code: 'FIXO20',
+  discountType: 'fixed',
+  discountValue: 20,
+  minOrderValue: 0,
+  usageLimit: null,
+  usageCount: 0,
+  expiresAt: null,
+  createdAt: new Date(),
+});
+
+const expiredCoupon = CouponEntity.reconstitute({
+  id: 'coup-3',
+  code: 'OLD',
+  discountType: 'percent',
+  discountValue: 5,
+  minOrderValue: 0,
+  usageLimit: null,
+  usageCount: 0,
+  expiresAt: new Date('2020-01-01'), // past
+  createdAt: new Date(),
+});
+
+const highMinCoupon = CouponEntity.reconstitute({
+  id: 'coup-4',
+  code: 'BIG500',
+  discountType: 'percent',
+  discountValue: 20,
+  minOrderValue: 500,
+  usageLimit: null,
+  usageCount: 0,
+  expiresAt: null,
+  createdAt: new Date(),
+});
+
+describe('CartEntity — Unit (pure domain)', () => {
+  let emptyCart: CartEntity;
+
+  beforeEach(() => {
+    emptyCart = CartEntity.create('user-1');
+  });
+
+  it('deve adicionar item ao carrinho', () => {
+    const cart = emptyCart.addItem(makeItem());
+    expect(cart.items).toHaveLength(1);
+    expect(cart.items[0]!.variantId).toBe('var-1');
+    expect(cart.items[0]!.qty).toBe(1);
+  });
+
+  it('deve incrementar quantidade se produto já existir', () => {
+    const cart = emptyCart.addItem(makeItem({ qty: 2 })).addItem(makeItem({ qty: 3 }));
+    expect(cart.items).toHaveLength(1);
+    expect(cart.items[0]!.qty).toBe(5);
+  });
+
+  it('deve remover item pelo variantId', () => {
+    const cart = emptyCart
+      .addItem(makeItem({ variantId: 'var-1' }))
+      .addItem(makeItem({ variantId: 'var-2', sku: 'CAM-G' }))
+      .removeItem('var-1');
+    expect(cart.items).toHaveLength(1);
+    expect(cart.items[0]!.variantId).toBe('var-2');
+  });
+
+  it('deve calcular subtotal corretamente', () => {
+    const cart = emptyCart
+      .addItem(makeItem({ price: 100, qty: 2 }))
+      .addItem(makeItem({ variantId: 'var-2', sku: 'CALCA-M', price: 150, qty: 1 }));
+    expect(cart.subtotal).toBe(350);
+  });
+
+  it('deve calcular total com desconto de cupom percentual', () => {
+    const cart = emptyCart
+      .addItem(makeItem({ price: 200, qty: 1 }))
+      .applyCoupon(percentCoupon); // 10% de 200 = 20
+    expect(cart.discount).toBe(20);
+    expect(cart.total).toBe(180);
+  });
+
+  it('deve calcular total com desconto de cupom de valor fixo', () => {
+    const cart = emptyCart
+      .addItem(makeItem({ price: 200, qty: 1 }))
+      .applyCoupon(fixedCoupon); // R$20 fixo
+    expect(cart.discount).toBe(20);
+    expect(cart.total).toBe(180);
+  });
+
+  it('deve rejeitar cupom expirado', () => {
+    expect(() => emptyCart.addItem(makeItem({ price: 100 })).applyCoupon(expiredCoupon))
+      .toThrow('Cupom expirado');
+  });
+
+  it('deve rejeitar cupom com valor mínimo não atingido', () => {
+    expect(() => emptyCart.addItem(makeItem({ price: 100 })).applyCoupon(highMinCoupon))
+      .toThrow('Valor mínimo');
+  });
+
+  it('deve ser imutável — cada operação retorna novo Cart', () => {
+    const cart1 = emptyCart.addItem(makeItem());
+    const cart2 = cart1.addItem(makeItem({ variantId: 'var-2', sku: 'X' }));
+    expect(cart1.items).toHaveLength(1);
+    expect(cart2.items).toHaveLength(2);
+    // original not mutated
+    expect(emptyCart.items).toHaveLength(0);
+  });
+});