kybernus 3.0.1 → 3.2.0

package/templates/ecommerce/apps/api/src/application/checkout/checkout.service.ts

@@ -0,0 +1,114 @@
+import { AppError } from '../../domain/shared/AppError';
+import { OrderEntity } from '../../domain/checkout/order.entity';
+import { IOrderRepository } from '../../domain/checkout/order.repository';
+import { IPaymentAdapter } from '../ports/payment.port';
+import { ICartRepository } from '../../domain/cart/cart.repository';
+import { IProductRepository } from '../../domain/catalog/product.repository';
+
+interface CheckoutDto {
+  userId: string;
+  shippingCost: number;
+  shippingAddress: Record<string, string> | null;
+}
+
+export class CheckoutService {
+  constructor(
+    private readonly orderRepo: IOrderRepository,
+    private readonly paymentAdapter: IPaymentAdapter,
+    private readonly cartRepo: ICartRepository,
+    private readonly productRepo: IProductRepository,
+  ) {}
+
+  async checkout(dto: CheckoutDto): Promise<{ orderId: string; clientSecret: string }> {
+    const { userId, shippingCost, shippingAddress } = dto;
+
+    // 1. Get cart — throw if empty
+    const cart = await this.cartRepo.findByUserId(userId);
+    if (!cart || cart.items.length === 0) {
+      throw new AppError('Carrinho vazio', 400);
+    }
+
+    // 2. Validate stock for every item and snapshot current levels
+    const stockSnapshot: Array<{
+      productId: string;
+      variantId: string;
+      currentStock: number;
+      newStock: number;
+    }> = [];
+
+    for (const item of cart.items) {
+      const product = await this.productRepo.findById(item.productId);
+      if (!product) throw new AppError('Produto não encontrado', 404);
+      const variant = product.variants.find((v) => v.id === item.variantId);
+      if (!variant) throw new AppError('Variante não encontrada', 404);
+      if (variant.stock < item.qty) {
+        throw new AppError('Estoque insuficiente', 409);
+      }
+      stockSnapshot.push({
+        productId: item.productId,
+        variantId: item.variantId,
+        currentStock: variant.stock,
+        newStock: variant.stock - item.qty,
+      });
+    }
+
+    // 3. Compute totals
+    const subtotal = cart.subtotal;
+    const discount = cart.discount;
+    const tax = 0; // TaxService placeholder — returns 0
+    const total = subtotal - discount + shippingCost + tax;
+
+    // 4. Create Order (PENDING)
+    const orderItems = cart.items.map((item) => ({
+      id: crypto.randomUUID(),
+      variantId: item.variantId,
+      productId: item.productId,
+      name: item.name,
+      sku: item.sku,
+      price: item.price,
+      qty: item.qty,
+      image: item.image,
+    }));
+
+    const order = OrderEntity.create({
+      userId,
+      items: orderItems,
+      subtotal,
+      discount,
+      shippingCost,
+      tax,
+      total,
+      couponCode: cart.coupon?.code ?? null,
+      paymentIntentId: null,
+      shippingAddress,
+    });
+    await this.orderRepo.create(order);
+
+    // 5. Decrement stock
+    for (const snap of stockSnapshot) {
+      await this.productRepo.updateVariantStock(snap.productId, snap.variantId, snap.newStock);
+    }
+
+    // 6. Create PaymentIntent — rollback on failure
+    try {
+      const pi = await this.paymentAdapter.createPaymentIntent(total, 'brl', { orderId: order.id });
+
+      // Attach paymentIntentId to order
+      const updatedOrder = order.withPaymentIntentId(pi.id);
+      await this.orderRepo.update(updatedOrder);
+
+      // 7. Clear cart
+      await this.cartRepo.delete({ userId });
+
+      return { orderId: order.id, clientSecret: pi.clientSecret };
+    } catch (err) {
+      // Rollback stock to previous levels
+      for (const snap of stockSnapshot) {
+        await this.productRepo.updateVariantStock(snap.productId, snap.variantId, snap.currentStock);
+      }
+      // Mark order as failed
+      await this.orderRepo.update(order.fail());
+      throw err;
+    }
+  }
+}

package/templates/ecommerce/apps/api/src/application/orders/order.service.ts

@@ -0,0 +1,93 @@
+import { AppError } from '../../domain/shared/AppError';
+import { OrderEntity } from '../../domain/checkout/order.entity';
+import type { OrderStatus } from '../../domain/checkout/order.entity';
+import { IOrderRepository } from '../../domain/checkout/order.repository';
+import { IEmailService } from '../ports/email.port';
+import { IUserRepository } from '../../domain/auth/user.repository';
+
+export class OrderService {
+  constructor(
+    private readonly orderRepo: IOrderRepository,
+    private readonly emailService?: IEmailService,
+    private readonly userRepo?: IUserRepository,
+  ) {}
+
+  async getOrdersByUser(
+    userId: string,
+    opts?: { cursor?: string; limit?: number },
+  ): Promise<{ items: OrderEntity[]; nextCursor: string | null }> {
+    return this.orderRepo.findByUserId(userId, opts);
+  }
+
+  async getOrderById(orderId: string, userId: string): Promise<OrderEntity> {
+    const order = await this.orderRepo.findById(orderId);
+    if (!order) throw new AppError('Pedido não encontrado', 404);
+    if (order.userId !== userId) throw new AppError('Acesso negado', 403);
+    return order;
+  }
+
+  async updateOrderStatus(
+    orderId: string,
+    newStatus: OrderStatus,
+    trackingCode?: string,
+  ): Promise<OrderEntity> {
+    const order = await this.orderRepo.findById(orderId);
+    if (!order) throw new AppError('Pedido não encontrado', 404);
+
+    let updated: OrderEntity;
+    switch (newStatus) {
+      case 'PAID':
+        updated = order.pay();
+        break;
+      case 'FAILED':
+        updated = order.fail();
+        break;
+      case 'SHIPPED':
+        updated = order.ship(trackingCode);
+        break;
+      case 'DELIVERED':
+        updated = order.deliver();
+        break;
+      case 'CANCELLED':
+        updated = order.cancel();
+        break;
+      default:
+        throw new AppError(`Status desconhecido: ${newStatus}`, 400);
+    }
+
+    const saved = await this.orderRepo.update(updated);
+    await this._sendStatusEmail(saved, newStatus);
+    return saved;
+  }
+
+  private async _sendStatusEmail(order: OrderEntity, status: OrderStatus): Promise<void> {
+    if (!this.emailService || !this.userRepo) return;
+    if (status !== 'SHIPPED' && status !== 'DELIVERED') return;
+    try {
+      const user = await this.userRepo.findById(order.userId);
+      if (!user) return;
+      if (status === 'SHIPPED') {
+        const html = `
+          <h2>Seu pedido foi enviado! 🚚</h2>
+          <p>Olá ${user.name}, seu pedido <strong>#${order.id.slice(0, 8)}</strong> está a caminho.</p>
+          <p>Código de rastreio: <strong>${order.trackingCode ?? '—'}</strong></p>
+        `;
+        await this.emailService.send(user.email, 'Pedido enviado 🚚', html);
+      } else {
+        const html = `
+          <h2>Pedido entregue! ✅</h2>
+          <p>Olá ${user.name}, seu pedido <strong>#${order.id.slice(0, 8)}</strong> foi entregue. Aproveite!</p>
+        `;
+        await this.emailService.send(user.email, 'Pedido entregue ✅', html);
+      }
+    } catch {
+      // Email failure must never break the order update flow
+    }
+  }
+
+  async getAllOrders(
+    opts?: { status?: OrderStatus; cursor?: string; limit?: number },
+  ): Promise<{ items: OrderEntity[]; nextCursor: string | null }> {
+    return this.orderRepo.findAll(opts);
+  }
+}

package/templates/ecommerce/apps/api/src/application/ports/email.port.ts

@@ -0,0 +1,3 @@
+export interface IEmailService {
+  send(to: string, subject: string, html: string): Promise<void>;
+}

package/templates/ecommerce/apps/api/src/application/ports/payment.port.ts

@@ -0,0 +1,24 @@
+// ── PaymentError ──────────────────────────────────────────────────────────────
+export class PaymentError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'PaymentError';
+  }
+}
+
+// ── IPaymentAdapter ───────────────────────────────────────────────────────────
+export interface PaymentIntentResult {
+  id: string;
+  clientSecret: string;
+}
+
+export interface IPaymentAdapter {
+  createPaymentIntent(
+    amount: number,
+    currency: string,
+    metadata: Record<string, string>,
+  ): Promise<PaymentIntentResult>;
+}

package/templates/ecommerce/apps/api/src/application/ports/shipping.port.ts

@@ -0,0 +1,9 @@
+export interface ShippingOption {
+  name: string;
+  price: number;
+  estimatedDays: number;
+}
+
+export interface IShippingService {
+  calculate(cep: string, items: Array<{ qty: number; weight?: number }>): Promise<ShippingOption[]>;
+}

package/templates/ecommerce/apps/api/src/application/ports/storage.port.ts

@@ -0,0 +1,3 @@
+export interface IStorageService {
+  upload(key: string, buffer: Buffer, mimetype: string): Promise<string>;
+}

package/templates/ecommerce/apps/api/src/application/ports/token-blacklist.port.ts

@@ -0,0 +1,4 @@
+export interface ITokenBlacklist {
+  add(jti: string, ttlSeconds: number): Promise<void>;
+  has(jti: string): Promise<boolean>;
+}

package/templates/ecommerce/apps/api/src/application/ports/token.port.ts

@@ -0,0 +1,18 @@
+export interface TokenPayload {
+  sub: string;
+  email: string;
+  role?: string;
+  jti?: string;
+}
+
+export interface ITokenService {
+  generateAccessToken(payload: TokenPayload): string;
+  generateRefreshToken(payload: TokenPayload): string;
+  verifyAccessToken(token: string): TokenPayload;
+  verifyRefreshToken(token: string): TokenPayload;
+  invalidateRefreshToken(token: string): Promise<undefined>;
+  isRefreshTokenBlacklisted(token: string): Promise<boolean>;
+  generatePasswordResetToken(userId: string): Promise<string>;
+  verifyPasswordResetToken(token: string): Promise<string>;
+  invalidatePasswordResetToken(token: string): Promise<undefined>;
+}

package/templates/ecommerce/apps/api/src/application/profile/profile.service.ts

@@ -0,0 +1,76 @@
+import { compare, hash } from 'bcryptjs';
+import { IUserRepository } from '../../domain/auth/user.repository';
+import { PublicUser } from '../../domain/auth/user.entity';
+import { AppError } from '../../domain/shared/AppError';
+
+export interface UpdateProfileDto {
+  name?: string;
+  email?: string;
+}
+
+export interface ChangePasswordDto {
+  currentPassword: string;
+  newPassword: string;
+}
+
+const BCRYPT_ROUNDS = 10;
+
+export class ProfileService {
+  constructor(private readonly userRepository: IUserRepository) {}
+
+  async getProfile(userId: string): Promise<PublicUser> {
+    const user = await this.userRepository.findById(userId);
+    if (!user) throw new AppError('Usuário não encontrado', 404);
+    return user.toPublic();
+  }
+
+  async updateProfile(userId: string, dto: UpdateProfileDto): Promise<PublicUser> {
+    const user = await this.userRepository.findById(userId);
+    if (!user) throw new AppError('Usuário não encontrado', 404);
+
+    let updated = user;
+
+    if (dto.name !== undefined) {
+      const name = dto.name.trim();
+      if (name.length < 2) throw new AppError('Nome deve ter pelo menos 2 caracteres', 400);
+      updated = updated.withName(name);
+    }
+
+    if (dto.email !== undefined) {
+      const email = dto.email.toLowerCase();
+      if (email !== user.email) {
+        const existing = await this.userRepository.findByEmail(email);
+        if (existing) throw new AppError('Email já está em uso', 409);
+      }
+      updated = updated.withEmail(email);
+    }
+
+    const saved = await this.userRepository.update(updated);
+    return saved.toPublic();
+  }
+
+  async changePassword(userId: string, dto: ChangePasswordDto): Promise<void> {
+    const user = await this.userRepository.findById(userId);
+    if (!user) throw new AppError('Usuário não encontrado', 404);
+
+    const valid = await compare(dto.currentPassword, user.passwordHash);
+    if (!valid) throw new AppError('Senha atual incorreta', 401);
+
+    if (dto.newPassword.length < 8) {
+      throw new AppError('Nova senha deve ter pelo menos 8 caracteres', 400);
+    }
+
+    const newHash = await hash(dto.newPassword, BCRYPT_ROUNDS);
+    await this.userRepository.update(user.withPasswordHash(newHash));
+  }
+
+  async deleteAccount(userId: string, password: string): Promise<void> {
+    const user = await this.userRepository.findById(userId);
+    if (!user) throw new AppError('Usuário não encontrado', 404);
+
+    const valid = await compare(password, user.passwordHash);
+    if (!valid) throw new AppError('Senha incorreta', 401);
+
+    await this.userRepository.delete(userId);
+  }
+}

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

@@ -0,0 +1,109 @@
+import { randomUUID } from 'crypto';
+import { z } from 'zod';
+import { AppError } from '../shared/AppError';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+export type UserRole = 'CUSTOMER' | 'ADMIN';
+
+export interface UserProps {
+  id: string;
+  name: string;
+  email: string;
+  passwordHash: string;
+  role: UserRole;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateUserInput {
+  name: string;
+  email: string;
+  passwordHash: string;
+  role?: UserRole;
+}
+
+export interface PublicUser {
+  id: string;
+  name: string;
+  email: string;
+  role: UserRole;
+  createdAt: Date;
+  // Allow casting to Record<string, unknown> in tests to verify absent keys
+  [key: string]: unknown;
+}
+
+// ── Validation schemas ────────────────────────────────────────────────────────
+const emailSchema = z.string().email('Email inválido');
+const nameSchema = z.string().trim().min(1, 'Nome não pode ser vazio');
+
+// ── Entity ────────────────────────────────────────────────────────────────────
+export class UserEntity {
+  private constructor(private readonly props: UserProps) {}
+
+  // ── Factories ──────────────────────────────────────────────────────────────
+  static create(input: CreateUserInput): UserEntity {
+    const emailResult = emailSchema.safeParse(input.email);
+    if (!emailResult.success) {
+      throw new AppError(emailResult.error.errors[0]?.message ?? 'Email inválido', 422);
+    }
+
+    const nameResult = nameSchema.safeParse(input.name);
+    if (!nameResult.success) {
+      throw new AppError(nameResult.error.errors[0]?.message ?? 'Nome inválido', 422);
+    }
+
+    return new UserEntity({
+      id: randomUUID(),
+      name: input.name.trim(),
+      email: input.email.toLowerCase(),
+      passwordHash: input.passwordHash,
+      role: input.role ?? 'CUSTOMER',
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  static reconstitute(props: UserProps): UserEntity {
+    return new UserEntity(props);
+  }
+
+  // ── Getters ────────────────────────────────────────────────────────────────
+  get id(): string { return this.props.id; }
+  get name(): string { return this.props.name; }
+  get email(): string { return this.props.email; }
+  get passwordHash(): string { return this.props.passwordHash; }
+  get role(): UserRole { return this.props.role; }
+  get createdAt(): Date { return this.props.createdAt; }
+  get updatedAt(): Date { return this.props.updatedAt; }
+
+  withPasswordHash(hash: string): UserEntity {
+    return new UserEntity({ ...this.props, passwordHash: hash, updatedAt: new Date() });
+  }
+
+  withName(name: string): UserEntity {
+    return new UserEntity({ ...this.props, name: name.trim(), updatedAt: new Date() });
+  }
+
+  withEmail(email: string): UserEntity {
+    return new UserEntity({ ...this.props, email: email.toLowerCase(), updatedAt: new Date() });
+  }
+
+  withRole(role: UserRole): UserEntity {
+    return new UserEntity({ ...this.props, role, updatedAt: new Date() });
+  }
+
+  // ── Projections ────────────────────────────────────────────────────────────
+  toPublic(): PublicUser {
+    return {
+      id: this.props.id,
+      name: this.props.name,
+      email: this.props.email,
+      role: this.props.role,
+      createdAt: this.props.createdAt,
+    };
+  }
+
+  toRecord(): UserProps {
+    return { ...this.props };
+  }
+}

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

@@ -0,0 +1,11 @@
+import { UserEntity } from './user.entity';
+import type { UserRole } from './user.entity';
+
+export interface IUserRepository {
+  findByEmail(email: string): Promise<UserEntity | null>;
+  findById(id: string): Promise<UserEntity | null>;
+  create(user: UserEntity): Promise<UserEntity>;
+  update(user: UserEntity): Promise<UserEntity>;
+  delete(id: string): Promise<void>;
+  findAll(opts?: { role?: UserRole; cursor?: string; limit?: number }): Promise<{ items: UserEntity[]; nextCursor: string | null }>;
+}

package/templates/ecommerce/apps/api/src/domain/cart/cart.entity.ts

@@ -0,0 +1,136 @@
+import { AppError } from '../shared/AppError';
+import type { CouponEntity } from './coupon.entity';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+export interface CartItemProps {
+  variantId: string;
+  productId: string;
+  name: string;
+  sku: string;
+  price: number;
+  qty: number;
+  image: string | null;
+}
+
+export interface CartProps {
+  id: string;
+  userId: string | null;
+  sessionId: string | null;
+  items: CartItemProps[];
+  coupon: CouponEntity | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// ── CartEntity ────────────────────────────────────────────────────────────────
+export class CartEntity {
+  private constructor(private readonly props: CartProps) {}
+
+  // ── Factory ───────────────────────────────────────────────────────────────
+  static create(userId: string | null, sessionId?: string | null): CartEntity {
+    return new CartEntity({
+      id: crypto.randomUUID(),
+      userId: userId ?? null,
+      sessionId: sessionId ?? null,
+      items: [],
+      coupon: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  static reconstitute(props: CartProps): CartEntity {
+    return new CartEntity({ ...props });
+  }
+
+  // ── Getters ───────────────────────────────────────────────────────────────
+  get id(): string { return this.props.id; }
+  get userId(): string | null { return this.props.userId; }
+  get sessionId(): string | null { return this.props.sessionId; }
+  get items(): ReadonlyArray<CartItemProps> { return this.props.items; }
+  get coupon(): CouponEntity | null { return this.props.coupon; }
+  get createdAt(): Date { return this.props.createdAt; }
+
+  get subtotal(): number {
+    return this.props.items.reduce((sum, item) => sum + item.price * item.qty, 0);
+  }
+
+  get discount(): number {
+    if (!this.props.coupon) return 0;
+    const coupon = this.props.coupon;
+    if (coupon.discountType === 'percent') {
+      return Math.round(this.subtotal * coupon.discountValue) / 100;
+    }
+    return Math.min(coupon.discountValue, this.subtotal);
+  }
+
+  get total(): number {
+    return Math.max(0, this.subtotal - this.discount);
+  }
+
+  // ── Operations (immutable) ────────────────────────────────────────────────
+  addItem(item: CartItemProps): CartEntity {
+    const existing = this.props.items.find((i) => i.variantId === item.variantId);
+    let newItems: CartItemProps[];
+    if (existing) {
+      newItems = this.props.items.map((i) =>
+        i.variantId === item.variantId ? { ...i, qty: i.qty + item.qty } : i,
+      );
+    } else {
+      newItems = [...this.props.items, { ...item }];
+    }
+    return new CartEntity({ ...this.props, items: newItems, updatedAt: new Date() });
+  }
+
+  updateItem(variantId: string, qty: number): CartEntity {
+    if (qty <= 0) {
+      return this.removeItem(variantId);
+    }
+    const newItems = this.props.items.map((i) =>
+      i.variantId === variantId ? { ...i, qty } : i,
+    );
+    return new CartEntity({ ...this.props, items: newItems, updatedAt: new Date() });
+  }
+
+  removeItem(variantId: string): CartEntity {
+    const newItems = this.props.items.filter((i) => i.variantId !== variantId);
+    return new CartEntity({ ...this.props, items: newItems, updatedAt: new Date() });
+  }
+
+  applyCoupon(coupon: CouponEntity): CartEntity {
+    if (coupon.isExpired()) {
+      throw new AppError('Cupom expirado', 400);
+    }
+    if (this.subtotal < coupon.minOrderValue) {
+      throw new AppError(
+        `Valor mínimo para este cupom é R$${coupon.minOrderValue.toFixed(2)}`,
+        400,
+      );
+    }
+    return new CartEntity({ ...this.props, coupon, updatedAt: new Date() });
+  }
+
+  removeCoupon(): CartEntity {
+    return new CartEntity({ ...this.props, coupon: null, updatedAt: new Date() });
+  }
+
+  withUserId(userId: string): CartEntity {
+    return new CartEntity({ ...this.props, userId, updatedAt: new Date() });
+  }
+
+  // ── Serialization ─────────────────────────────────────────────────────────
+  toRecord() {
+    return {
+      id: this.props.id,
+      userId: this.props.userId,
+      sessionId: this.props.sessionId,
+      items: [...this.props.items],
+      couponCode: this.props.coupon?.code ?? null,
+      subtotal: this.subtotal,
+      discount: this.discount,
+      total: this.total,
+      createdAt: this.props.createdAt,
+      updatedAt: this.props.updatedAt,
+    };
+  }
+}

package/templates/ecommerce/apps/api/src/domain/cart/cart.repository.ts

@@ -0,0 +1,8 @@
+import { CartEntity } from './cart.entity';
+
+export interface ICartRepository {
+  findByUserId(userId: string): Promise<CartEntity | null>;
+  findBySessionId(sessionId: string): Promise<CartEntity | null>;
+  save(cart: CartEntity): Promise<CartEntity>;
+  delete(key: { userId?: string; sessionId?: string }): Promise<void>;
+}

package/templates/ecommerce/apps/api/src/domain/cart/coupon.entity.ts

@@ -0,0 +1,58 @@
+// ── Types ─────────────────────────────────────────────────────────────────────
+export type DiscountType = 'percent' | 'fixed';
+
+export interface CouponProps {
+  id: string;
+  code: string;
+  discountType: DiscountType;
+  discountValue: number;
+  minOrderValue: number;
+  usageLimit: number | null;
+  usageCount: number;
+  expiresAt: Date | null;
+  createdAt: Date;
+}
+
+// ── CouponEntity ──────────────────────────────────────────────────────────────
+export class CouponEntity {
+  private constructor(private readonly props: CouponProps) {}
+
+  static create(input: Omit<CouponProps, 'id' | 'usageCount' | 'createdAt'>): CouponEntity {
+    return new CouponEntity({
+      ...input,
+      id: crypto.randomUUID(),
+      usageCount: 0,
+      createdAt: new Date(),
+    });
+  }
+
+  static reconstitute(props: CouponProps): CouponEntity {
+    return new CouponEntity({ ...props });
+  }
+
+  // ── Getters ───────────────────────────────────────────────────────────────
+  get id(): string { return this.props.id; }
+  get code(): string { return this.props.code; }
+  get discountType(): DiscountType { return this.props.discountType; }
+  get discountValue(): number { return this.props.discountValue; }
+  get minOrderValue(): number { return this.props.minOrderValue; }
+  get usageLimit(): number | null { return this.props.usageLimit; }
+  get usageCount(): number { return this.props.usageCount; }
+  get expiresAt(): Date | null { return this.props.expiresAt; }
+
+  // ── Business rules ────────────────────────────────────────────────────────
+  isExpired(): boolean {
+    if (!this.props.expiresAt) return false;
+    return this.props.expiresAt < new Date();
+  }
+
+  isUsageLimitReached(): boolean {
+    if (this.props.usageLimit === null) return false;
+    return this.props.usageCount >= this.props.usageLimit;
+  }
+
+  // ── Serialization ─────────────────────────────────────────────────────────
+  toRecord(): CouponProps {
+    return { ...this.props };
+  }
+}