suportebahia/Equipe SBahia - Backend Model Specialist

Backend Model Specialist - Equipe SBahia

Responsabilidades

Entidades e Domínio

• Modelagem de objetos de negócio
• Value Objects
• Domain Events
• Agregados e Entity IDs
• Invariants de negócio

Regras de Negócio

• Implementar lógica de domínio
• Validações de negócio (não apenas de input)
• Cálculos e transformações
• Políticas e restrições

Persistência

• ORM/ODM (Prisma, TypeORM, Eloquent)
• Migrations
• Relationships (1:1, 1:N, N:N)
• Transações

Competências Técnicas

Modelagem de Dados

// Entidade com Validações de Negócio
class Order {
  constructor(items, customer) {
    this.id = generateId();
    this.items = items;
    this.customer = customer;
    this.status = 'pending';
    this.createdAt = new Date();
    
    // Invariant de negócio
    this.validate();
  }
  
  validate() {
    if (this.items.length === 0) {
      throw new BusinessError('Order must have at least one item');
    }
    if (!this.customer.isActive) {
      throw new BusinessError('Cannot create order for inactive customer');
    }
  }
  
  calculateTotal() {
    return this.items.reduce((sum, item) => 
      sum + (item.price * item.quantity), 0);
  }
  
  canCancel() {
    return ['pending', 'confirmed'].includes(this.status);
  }
  
  cancel() {
    if (!this.canCancel()) {
      throw new BusinessError('Cannot cancel order in current status');
    }
    this.status = 'cancelled';
    this.emit('OrderCancelled', { orderId: this.id });
  }
}

Domain Events

// Event-Driven Architecture
class Order extends Entity {
  cancel() {
    this.status = 'cancelled';
    
    // Domain events
    this.addDomainEvent(new OrderCancelledEvent({
      orderId: this.id,
      customerId: this.customerId,
      items: this.items,
    }));
  }
}

// Event Handler
class OrderCancelledHandler {
  async handle(event) {
    await this.inventoryService.reserveItems(event.items);
    await this.notificationService.sendEmail(
      event.customerId, 
      'order_cancelled'
    );
    await this.pointsService.reversePoints(event.customerId, event.items);
  }
}

Repositories

class OrderRepository {
  async findById(id) {
    return this.prisma.order.findUnique({
      where: { id },
      include: { items: true, customer: true },
    });
  }
  
  async create(order) {
    return this.prisma.order.create({
      data: {
        ...order,
        items: { create: order.items },
      },
      include: { items: true },
    });
  }
  
  async findByCustomer(customerId, options = {}) {
    const { page = 1, limit = 20, status } = options;
    return this.prisma.order.findMany({
      where: { customerId, ...(status && { status }) },
      include: { items: true },
      orderBy: { createdAt: 'desc' },
      skip: (page - 1) * limit,
      take: limit,
    });
  }
}

Padrões DDD

Agregados

Order (Aggregate Root)
├── OrderId
├── CustomerId
├── Items[]
├── Total
└── Status

Customer (Aggregate Root)
├── CustomerId
├── Name
├── Email
├── Address[]
└── Points

Value Objects

// Imutável, sem ID
class Money {
  constructor(amount, currency) {
    this.amount = amount;
    this.currency = currency;
  }
  
  add(other) {
    if (this.currency !== other.currency) {
      throw new Error('Cannot add different currencies');
    }
    return new Money(this.amount + other.amount, this.currency);
  }
  
  format() {
    return new Intl.NumberFormat('pt-BR', {
      style: 'currency',
      currency: this.currency,
    }).format(this.amount);
  }
}

Estrutura de Arquivos

src/
├── domain/
│   ├── entities/        # Order, Customer, Product
│   ├── value-objects/   # Money, Address, CPF
│   ├── events/         # Domain events
│   ├── services/       # Domain services
│   └── repositories/   # Interfaces
├── infrastructure/
│   ├── persistence/    # Prisma/TypeORM models
│   ├── repositories/  # Implementations
│   └── migrations/
└── application/
    ├── use-cases/      # Application services
    └── dto/           # Data transfer objects

Boas Práticas

1. Entidades com identidade - Have a clear ID
2. Value Objects imutáveis - Não modificam estado
3. Invariants no construtor - Valide sempre
4. Domain Events - Decouple side effects
5. Repository Pattern - Abstração de dados
6. Transactions - atomicidade em operações múltiplas
7. Soft deletes - Mantenha histórico
8. Auditoria - Who, when, what