Domain Layer - Camada de Domínio

A camada de domínio centraliza todos os tipos, interfaces e constantes relacionados às entidades de negócio. Isso garante consistência de tipos em toda a aplicação.

---

Estrutura do Domain

src/domain/
├── common/              # Tipos compartilhados entre domínios
│   ├── types.ts         # BaseEntity, Person, APIResponse
│   └── index.ts
├── contract/            # Domínio de Contratos
│   ├── types.ts         # Contract, ContractPart, ContractStatus
│   ├── constants.ts     # CONTRACT_STATUS, CONTRACT_PART_ROLES
│   └── index.ts
├── template/            # Domínio de Templates
│   ├── types.ts         # Template, TemplateVariable, TemplateStatus
│   ├── constants.ts     # TEMPLATE_STATUS, COMMON_VARIABLES
│   └── index.ts
└── index.ts             # Export central de todos os domínios

---

Tipos Comuns (common)

// src/domain/common/types.ts
export type APIResponse<T> = {
  success: boolean
  content: T
  status?: number
}

export type BaseEntity = {
  id: string
  createdAt?: Date
  updatedAt?: Date
}

export type Person = NaturalPerson | LegalPerson

---

Tipos de Domínio

// src/domain/template/types.ts
import type { BaseEntity } from '../common'

export type Template = BaseEntity & {
  name: string
  content: string
  variables: TemplateVariable[]
  status: TemplateStatus
}

---

Constantes de Domínio

// src/domain/contract/constants.ts
// Ver docs/business/contratos.md para lista completa de status
export const CONTRACT_STATUS: Record<ContractStatus, ContractStatus> = { ... }

---

Uso no Código

// Importação direta do domínio específico
import type { Contract, ContractStatus } from '@/domain/contract'
import { CONTRACT_STATUS } from '@/domain/contract'

// Ou importação do index central
import type { Contract, Template, Person } from '@/domain'

---

Regras do Domain

Regra	Descrição
Sem lógica	Domain contém apenas tipos e constantes, nunca lógica de negócio
Imutável	Tipos devem representar estruturas imutáveis de dados
Exportação central	Cada domínio deve ter um index.ts que exporta tudo
Dependência unidirecional	Domain não importa de modules, stores ou services

---

Utils (Funções Utilitárias)

Funções utilitárias puras que podem ser usadas em qualquer parte da aplicação.

Estrutura

src/utils/
├── string.ts            # Formatação e manipulação de strings
└── index.ts             # Export central

Funções Disponíveis

// src/utils/string.ts
export const getPersonInitials = (name: string): string => { ... }
export const getCompanyInitials = (name: string): string => { ... }
export const formatCnpj = (cnpj: string): string => { ... }
export const formatCpf = (cpf: string): string => { ... }
export const formatPhone = (phone: string): string => { ... }

Uso

import { getPersonInitials, formatCnpj } from '@/utils'

const initials = getPersonInitials('João Silva') // 'JS'
const cnpj = formatCnpj('12345678000190') // '12.345.678/0001-90'

Regras dos Utils

Regra	Descrição
Funções puras	Utils não devem ter side effects ou dependências de estado
Sem Vue	Não usar refs, computed ou qualquer API do Vue
Testáveis	Funções devem ser facilmente testáveis de forma isolada
Genéricas	Funções devem ser reutilizáveis em diferentes contextos