Capítulo 70 — Modelo de Dados

Este capítulo apresenta o modelo de dados da Plataforma de Relacionamento Digital com o Cidadão. O objetivo é documentar as principais entidades de cada domínio, seus atributos relevantes, chaves, relacionamentos e invar…

70.1 Objetivo

O modelo de dados complementa os capítulos de arquitetura de microsserviços (Capítulo 12) e persistência (Capítulo 34). Cada serviço de domínio possui propriedade exclusiva de seu banco ou schema — nenhum serviço acessa diretamente tabelas de outro. O que este capítulo documenta é a estrutura interna de cada domínio, não um modelo relacional centralizado.

A tecnologia de persistência operacional é PostgreSQL 14 ou superior, com isolamento multi-tenant garantido pela coluna tenant_id presente em todas as tabelas multi-tenant, índices compostos com tenant_id como coluna líder, e Row-Level Security como camada adicional de proteção onde aplicável.

70.2 Convenções do Modelo

As seguintes convenções se aplicam a todos os domínios documentados neste capítulo.

70.2.1 Tipos de Dados

Tipo Lógico	Tipo PostgreSQL	Observação
Identificador técnico	`UUID`	Gerado pela aplicação (UUID v4 ou v7), nunca pelo banco
Tenant discriminator	`VARCHAR(64)` NOT NULL	Primeira coluna dos índices compostos
Estado / Enum	`VARCHAR(64)` NOT NULL	Valores controlados pela aplicação, não por CHECK
Texto curto	`VARCHAR(255)`	Nomes, códigos, títulos
Texto longo	`TEXT`	Conteúdo, observações, comentários
Dados semi-estruturados	`JSONB`	Formulários dinâmicos, metadados configuráveis
Timestamp	`TIMESTAMPTZ` NOT NULL	Sempre com fuso horário (UTC armazenado)
Booleano	`BOOLEAN`	Nunca emulado com VARCHAR
Referência cruzada	`UUID` (sem FK entre bancos)	Referência por valor; integridade garantida por evento

70.2.2 Colunas de Auditoria Padrão

Toda tabela operacional inclui obrigatoriamente as seguintes colunas de auditoria:

created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
created_by      UUID          -- ID do usuário ou sistema que criou o registro
updated_by      UUID          -- ID do usuário ou sistema que realizou a última alteração

A coluna updated_at é atualizada por trigger automático a cada UPDATE. Nenhuma aplicação deve atualizar updated_at manualmente.

70.2.3 Padrão de Nomenclatura

Elemento	Padrão
Tabelas	`snake_case` plural (ex.: `service_requests`)
Colunas	`snake_case` (ex.: `protocol_code`)
Chaves primárias	`id UUID PRIMARY KEY`
Chaves estrangeiras internas	`{entidade}_id UUID NOT NULL`
Referências cruzadas (sem FK)	`{entidade}_ref UUID` — sem constraint
Índices	`idx_{tabela}_{colunas}`
Constraints de unicidade	`uq_{tabela}_{colunas}`

70.2.4 Isolamento Multi-Tenant

Toda tabela que contém dados de mais de um órgão inclui tenant_id VARCHAR(64) NOT NULL como coluna obrigatória. As constraints de unicidade e chaves estrangeiras são sempre compostas com tenant_id:

-- Correto: unicidade por tenant
CONSTRAINT uq_requests_tenant_protocol UNIQUE (tenant_id, protocol_code);

-- Correto: FK interna ao mesmo schema inclui tenant
FOREIGN KEY (tenant_id, citizen_ref) REFERENCES citizens(tenant_id, id);

70.3 Domínio: Identidade e Acesso (Identity Service)

O Identity Service gerencia credenciais, sessões e eventos de autenticação. Dados pessoais detalhados são de responsabilidade do Citizen Service.

70.3.1 Entidade: `identities`

Representa a conta de autenticação de um usuário — interno ou cidadão.

CREATE TABLE identities (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  email           VARCHAR(255)  NOT NULL,
  identity_type   VARCHAR(32)   NOT NULL,  -- INTERNAL | CITIZEN | SERVICE_ACCOUNT
  password_hash   TEXT,                    -- NULL para contas federadas
  status          VARCHAR(32)   NOT NULL,  -- PENDING | ACTIVE | BLOCKED | INACTIVE | DELETED
  mfa_enabled     BOOLEAN       NOT NULL DEFAULT FALSE,
  mfa_method      VARCHAR(32),             -- TOTP | SMS | EMAIL
  last_login_at   TIMESTAMPTZ,
  failed_attempts INTEGER       NOT NULL DEFAULT 0,
  locked_until    TIMESTAMPTZ,
  anonymized_at   TIMESTAMPTZ,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_identities_tenant_email UNIQUE (tenant_id, email)
);

CREATE INDEX idx_identities_tenant_status
  ON identities (tenant_id, status);
CREATE INDEX idx_identities_tenant_type
  ON identities (tenant_id, identity_type);

70.3.2 Entidade: `federated_identities`

Vincula uma identidade local a um provedor externo (GOV.BR / OIDC).

CREATE TABLE federated_identities (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  identity_id     UUID          NOT NULL,
  provider        VARCHAR(64)   NOT NULL,  -- GOVBR | AZURE_AD | GOOGLE
  provider_sub    TEXT          NOT NULL,  -- subject claim do provedor
  provider_email  VARCHAR(255),
  linked_at       TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  last_used_at    TIMESTAMPTZ,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_federated_provider_sub UNIQUE (provider, provider_sub),
  FOREIGN KEY (tenant_id, identity_id) REFERENCES identities(tenant_id, id)
);

CREATE INDEX idx_federated_tenant_identity
  ON federated_identities (tenant_id, identity_id);

70.3.3 Entidade: `sessions`

Sessões ativas e históricas de autenticação.

CREATE TABLE sessions (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  identity_id     UUID          NOT NULL,
  token_jti       VARCHAR(128)  NOT NULL UNIQUE,  -- JWT ID
  channel         VARCHAR(32)   NOT NULL,          -- WEB | MOBILE | API
  ip_address      INET,
  user_agent      TEXT,
  issued_at       TIMESTAMPTZ   NOT NULL,
  expires_at      TIMESTAMPTZ   NOT NULL,
  revoked_at      TIMESTAMPTZ,
  revocation_reason VARCHAR(64),
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, identity_id) REFERENCES identities(tenant_id, id)
);

CREATE INDEX idx_sessions_tenant_identity
  ON sessions (tenant_id, identity_id, expires_at DESC);
CREATE INDEX idx_sessions_jti
  ON sessions (token_jti) WHERE revoked_at IS NULL;

70.4 Domínio: Tenant e Administração (Tenant Service)

70.4.1 Entidade: `tenants`

Representa cada organização participante da plataforma.

CREATE TABLE tenants (
  id              UUID          PRIMARY KEY,
  slug            VARCHAR(64)   NOT NULL UNIQUE,    -- identificador URL-friendly
  name            VARCHAR(255)  NOT NULL,
  official_name   VARCHAR(512),
  cnpj            VARCHAR(18),
  status          VARCHAR(32)   NOT NULL,  -- PROVISIONING | ACTIVE | SUSPENDED | DEACTIVATED
  tier            VARCHAR(32)   NOT NULL,  -- STANDARD | PREMIUM | ENTERPRISE
  primary_domain  VARCHAR(255),
  logo_url        TEXT,
  primary_color   VARCHAR(7),
  secondary_color VARCHAR(7),
  timezone        VARCHAR(64)   NOT NULL DEFAULT 'America/Sao_Paulo',
  locale          VARCHAR(10)   NOT NULL DEFAULT 'pt-BR',
  activated_at    TIMESTAMPTZ,
  suspended_at    TIMESTAMPTZ,
  deactivated_at  TIMESTAMPTZ,
  metadata        JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

CREATE INDEX idx_tenants_status ON tenants (status);
CREATE INDEX idx_tenants_slug   ON tenants (slug);

70.4.2 Entidade: `tenant_modules`

Controla quais módulos funcionais estão habilitados para cada tenant.

CREATE TABLE tenant_modules (
  id              UUID          PRIMARY KEY,
  tenant_id       UUID          NOT NULL REFERENCES tenants(id),
  module_code     VARCHAR(64)   NOT NULL,  -- CRM | BPM | ECM | OMBUDSMAN | SCHEDULING | ...
  enabled         BOOLEAN       NOT NULL DEFAULT TRUE,
  enabled_at      TIMESTAMPTZ,
  disabled_at     TIMESTAMPTZ,
  config          JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_tenant_module UNIQUE (tenant_id, module_code)
);

70.4.3 Entidade: `tenant_limits`

Define limites operacionais contratados por tenant.

CREATE TABLE tenant_limits (
  id                  UUID        PRIMARY KEY,
  tenant_id           UUID        NOT NULL UNIQUE REFERENCES tenants(id),
  max_users           INTEGER,
  max_citizens        INTEGER,
  max_requests_month  INTEGER,
  max_storage_gb      NUMERIC(10,2),
  max_ai_tokens_month BIGINT,
  custom_limits       JSONB,
  created_at          TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  updated_at          TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  created_by          UUID,
  updated_by          UUID
);

70.5 Domínio: Cidadão (Citizen Service)

O Citizen Service é o sistema de registro de dados pessoais. Armazena PII com política de retenção, auditoria e conformidade LGPD.

70.5.1 Entidade: `citizens`

Registro central do cidadão por tenant.

CREATE TABLE citizens (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  identity_ref    UUID,                    -- referência ao IAM (sem FK entre bancos)
  cpf_hash        VARCHAR(128),            -- hash SHA-256 do CPF para deduplicação
  name            VARCHAR(255)  NOT NULL,
  social_name     VARCHAR(255),
  birth_date      DATE,
  gender          VARCHAR(32),
  nationality     VARCHAR(64),
  status          VARCHAR(32)   NOT NULL DEFAULT 'ACTIVE',  -- ACTIVE | INACTIVE | ANONYMIZED
  govbr_verified  BOOLEAN       NOT NULL DEFAULT FALSE,
  anonymized_at   TIMESTAMPTZ,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_citizens_tenant_cpf UNIQUE (tenant_id, cpf_hash)
);

CREATE INDEX idx_citizens_tenant_status   ON citizens (tenant_id, status);
CREATE INDEX idx_citizens_tenant_name     ON citizens (tenant_id, name);
CREATE INDEX idx_citizens_identity_ref    ON citizens (tenant_id, identity_ref);

70.5.2 Entidade: `citizen_contacts`

Meios de contato do cidadão — e-mail, telefone, WhatsApp.

CREATE TABLE citizen_contacts (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  citizen_id      UUID          NOT NULL,
  contact_type    VARCHAR(32)   NOT NULL,  -- EMAIL | PHONE | WHATSAPP | PUSH_TOKEN
  value           VARCHAR(255)  NOT NULL,
  verified        BOOLEAN       NOT NULL DEFAULT FALSE,
  verified_at     TIMESTAMPTZ,
  primary_contact BOOLEAN       NOT NULL DEFAULT FALSE,
  opt_in          BOOLEAN       NOT NULL DEFAULT TRUE,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, citizen_id) REFERENCES citizens(tenant_id, id)
);

CREATE INDEX idx_citizen_contacts_tenant_citizen
  ON citizen_contacts (tenant_id, citizen_id);

70.5.3 Entidade: `citizen_consents`

Registro de consentimentos LGPD do cidadão.

CREATE TABLE citizen_consents (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  citizen_id      UUID          NOT NULL,
  purpose_code    VARCHAR(128)  NOT NULL,  -- finalidade específica (ex: MARKETING_EMAIL)
  granted         BOOLEAN       NOT NULL,
  granted_at      TIMESTAMPTZ,
  revoked_at      TIMESTAMPTZ,
  channel         VARCHAR(64),             -- canal onde o consentimento foi coletado
  legal_basis     VARCHAR(128),            -- base legal LGPD
  version         VARCHAR(32),             -- versão da política de privacidade
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, citizen_id) REFERENCES citizens(tenant_id, id)
);

CREATE INDEX idx_consents_tenant_citizen_purpose
  ON citizen_consents (tenant_id, citizen_id, purpose_code);

70.6 Domínio: Catálogo de Serviços (Service Catalog Service)

70.6.1 Entidade: `services`

Define os serviços públicos digitais disponibilizados pelos tenants.

CREATE TABLE services (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  code            VARCHAR(128)  NOT NULL,
  name            VARCHAR(255)  NOT NULL,
  description     TEXT,
  category_id     UUID,
  organ_id        UUID,
  status          VARCHAR(32)   NOT NULL,  -- DRAFT | REVIEW | APPROVED | PUBLISHED | SUSPENDED | DISCONTINUED
  auth_level      VARCHAR(32)   NOT NULL,  -- ANONYMOUS | IDENTIFIED | VERIFIED_GOVBR
  estimated_days  INTEGER,
  free_of_charge  BOOLEAN       NOT NULL DEFAULT TRUE,
  tags            JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_services_tenant_code UNIQUE (tenant_id, code)
);

CREATE INDEX idx_services_tenant_status   ON services (tenant_id, status);
CREATE INDEX idx_services_tenant_category ON services (tenant_id, category_id);

70.6.2 Entidade: `service_versions`

Versões publicadas de um serviço — preservadas para garantir integridade das solicitações em andamento.

CREATE TABLE service_versions (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  service_id      UUID          NOT NULL,
  version_number  INTEGER       NOT NULL,
  snapshot        JSONB         NOT NULL,  -- snapshot completo da definição do serviço
  published_at    TIMESTAMPTZ,
  deprecated_at   TIMESTAMPTZ,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_service_versions_tenant_service_version
    UNIQUE (tenant_id, service_id, version_number),
  FOREIGN KEY (tenant_id, service_id) REFERENCES services(tenant_id, id)
);

70.7 Domínio: Solicitações e Protocolos (Request Service)

Este é um dos domínios de maior criticidade operacional da plataforma.

70.7.1 Entidade: `service_requests`

Registro central de cada solicitação de serviço público.

CREATE TABLE service_requests (
  id                  UUID          PRIMARY KEY,
  tenant_id           VARCHAR(64)   NOT NULL,
  protocol_code       VARCHAR(64)   NOT NULL,
  citizen_ref         UUID          NOT NULL,    -- referência ao Citizen Service
  service_ref         UUID          NOT NULL,    -- referência ao Service Catalog
  service_version_ref UUID          NOT NULL,    -- versão do serviço aplicada
  form_version_ref    UUID,                       -- versão do formulário preenchido
  status              VARCHAR(64)   NOT NULL,
  -- DRAFT | SUBMITTED | RECEIVED | UNDER_REVIEW | AWAITING_COMPLEMENT
  -- | IN_PROCESSING | APPROVED | REJECTED | CANCELLED | COMPLETED
  channel             VARCHAR(32)   NOT NULL,    -- WEB | MOBILE | IN_PERSON | API
  submitted_at        TIMESTAMPTZ,
  completed_at        TIMESTAMPTZ,
  cancelled_at        TIMESTAMPTZ,
  cancellation_reason TEXT,
  external_ref        VARCHAR(255),              -- protocolo em sistema externo (ex.: SEI)
  form_data           JSONB,                     -- dados do formulário submetido
  metadata            JSONB,
  created_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by          UUID,
  updated_by          UUID,
  CONSTRAINT uq_requests_tenant_protocol UNIQUE (tenant_id, protocol_code)
);

CREATE INDEX idx_requests_tenant_citizen
  ON service_requests (tenant_id, citizen_ref, created_at DESC);
CREATE INDEX idx_requests_tenant_status
  ON service_requests (tenant_id, status);
CREATE INDEX idx_requests_tenant_submitted
  ON service_requests (tenant_id, submitted_at DESC)
  WHERE submitted_at IS NOT NULL;

70.7.2 Entidade: `request_status_history`

Trilha imutável de todas as transições de status de uma solicitação.

CREATE TABLE request_status_history (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  request_id      UUID          NOT NULL,
  from_status     VARCHAR(64),               -- NULL na criação
  to_status       VARCHAR(64)   NOT NULL,
  changed_by      UUID,
  changed_by_type VARCHAR(32)   NOT NULL,    -- USER | SYSTEM | INTEGRATION
  reason          TEXT,
  occurred_at     TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  FOREIGN KEY (tenant_id, request_id) REFERENCES service_requests(tenant_id, id)
);

CREATE INDEX idx_request_history_tenant_request
  ON request_status_history (tenant_id, request_id, occurred_at DESC);

70.7.3 Entidade: `request_complements`

Complementações solicitadas ao cidadão durante o processo.

CREATE TABLE request_complements (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  request_id      UUID          NOT NULL,
  description     TEXT          NOT NULL,
  requested_by    UUID          NOT NULL,
  requested_at    TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  deadline        TIMESTAMPTZ,
  submitted_at    TIMESTAMPTZ,
  form_data       JSONB,
  status          VARCHAR(32)   NOT NULL DEFAULT 'PENDING',  -- PENDING | SUBMITTED | ACCEPTED | REJECTED
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, request_id) REFERENCES service_requests(tenant_id, id)
);

70.8 Domínio: Processos e Workflow (Workflow Service)

70.8.1 Entidade: `process_definitions`

Definições versionadas dos processos de negócio modelados no BPM.

CREATE TABLE process_definitions (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  key             VARCHAR(128)  NOT NULL,
  name            VARCHAR(255)  NOT NULL,
  description     TEXT,
  status          VARCHAR(32)   NOT NULL,  -- DRAFT | PUBLISHED | DEPRECATED
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_process_def_tenant_key UNIQUE (tenant_id, key)
);

70.8.2 Entidade: `process_versions`

Versões executáveis de uma definição de processo.

CREATE TABLE process_versions (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  definition_id   UUID          NOT NULL,
  version_number  INTEGER       NOT NULL,
  bpmn_xml        TEXT          NOT NULL,   -- definição BPMN serializada
  status          VARCHAR(32)   NOT NULL,   -- DRAFT | PUBLISHED | DEPRECATED
  published_at    TIMESTAMPTZ,
  deprecated_at   TIMESTAMPTZ,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT uq_process_version_tenant_def_ver
    UNIQUE (tenant_id, definition_id, version_number),
  FOREIGN KEY (tenant_id, definition_id) REFERENCES process_definitions(tenant_id, id)
);

70.8.3 Entidade: `process_instances`

Instâncias de execução de processos, uma por solicitação ou evento iniciador.

CREATE TABLE process_instances (
  id                  UUID          PRIMARY KEY,
  tenant_id           VARCHAR(64)   NOT NULL,
  process_version_id  UUID          NOT NULL,
  correlation_key     VARCHAR(255),           -- referência externa (ex.: request_id)
  status              VARCHAR(32)   NOT NULL,
  -- RUNNING | SUSPENDED | COMPLETED | FAILED | CANCELLED
  current_step        VARCHAR(128),
  variables           JSONB,                  -- variáveis de contexto do processo
  started_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  completed_at        TIMESTAMPTZ,
  failed_at           TIMESTAMPTZ,
  error_message       TEXT,
  created_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by          UUID,
  updated_by          UUID
);

CREATE INDEX idx_process_instances_tenant_status
  ON process_instances (tenant_id, status);
CREATE INDEX idx_process_instances_tenant_correlation
  ON process_instances (tenant_id, correlation_key);

70.9 Domínio: Tarefas Humanas (Task Service)

70.9.1 Entidade: `tasks`

Tarefas humanas geradas por processos BPM ou criadas diretamente.

CREATE TABLE tasks (
  id                  UUID          PRIMARY KEY,
  tenant_id           VARCHAR(64)   NOT NULL,
  process_instance_ref UUID,                   -- referência ao Workflow Service
  request_ref          UUID,                   -- referência ao Request Service
  task_type           VARCHAR(64)   NOT NULL,
  title               VARCHAR(255)  NOT NULL,
  description         TEXT,
  priority            VARCHAR(32)   NOT NULL DEFAULT 'NORMAL',  -- LOW | NORMAL | HIGH | CRITICAL
  status              VARCHAR(32)   NOT NULL,
  -- PENDING | ASSIGNED | IN_PROGRESS | COMPLETED | CANCELLED | EXPIRED
  assigned_to         UUID,                   -- usuário atribuído
  assigned_group      UUID,                   -- grupo de trabalho
  assigned_at         TIMESTAMPTZ,
  due_at              TIMESTAMPTZ,
  sla_deadline        TIMESTAMPTZ,
  sla_breached        BOOLEAN       NOT NULL DEFAULT FALSE,
  started_at          TIMESTAMPTZ,
  completed_at        TIMESTAMPTZ,
  result              VARCHAR(64),             -- APPROVED | REJECTED | FORWARDED | ...
  result_notes        TEXT,
  form_data           JSONB,
  created_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at          TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by          UUID,
  updated_by          UUID
);

CREATE INDEX idx_tasks_tenant_status_due
  ON tasks (tenant_id, status, due_at ASC);
CREATE INDEX idx_tasks_tenant_assigned
  ON tasks (tenant_id, assigned_to, status)
  WHERE assigned_to IS NOT NULL;
CREATE INDEX idx_tasks_tenant_sla_breach
  ON tasks (tenant_id, sla_deadline)
  WHERE sla_breached = FALSE AND status NOT IN ('COMPLETED', 'CANCELLED');

70.10 Domínio: Atendimento e CRM (CRM Service)

70.10.1 Entidade: `interactions`

Registro de cada interação de atendimento ao cidadão.

CREATE TABLE interactions (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  citizen_ref     UUID,                      -- NULL para interações anônimas
  channel         VARCHAR(32)   NOT NULL,    -- CHAT | EMAIL | PHONE | IN_PERSON | WHATSAPP
  queue_id        UUID,
  assigned_to     UUID,
  status          VARCHAR(32)   NOT NULL,
  -- QUEUED | ASSIGNED | IN_PROGRESS | TRANSFERRED | CLOSED | ABANDONED
  opened_at       TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  first_response_at TIMESTAMPTZ,
  closed_at       TIMESTAMPTZ,
  closure_reason  VARCHAR(64),
  sla_deadline    TIMESTAMPTZ,
  sla_breached    BOOLEAN       NOT NULL DEFAULT FALSE,
  classification  VARCHAR(128),
  protocol_ref    UUID,                      -- referência ao Request Service
  tags            JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

CREATE INDEX idx_interactions_tenant_status
  ON interactions (tenant_id, status, opened_at DESC);
CREATE INDEX idx_interactions_tenant_citizen
  ON interactions (tenant_id, citizen_ref)
  WHERE citizen_ref IS NOT NULL;
CREATE INDEX idx_interactions_tenant_assigned
  ON interactions (tenant_id, assigned_to, status)
  WHERE assigned_to IS NOT NULL;

70.10.2 Entidade: `interaction_messages`

Mensagens trocadas em uma interação de atendimento.

CREATE TABLE interaction_messages (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  interaction_id  UUID          NOT NULL,
  direction       VARCHAR(16)   NOT NULL,    -- INBOUND | OUTBOUND
  sender_type     VARCHAR(32)   NOT NULL,    -- CITIZEN | AGENT | ASSISTANT | SYSTEM
  sender_ref      UUID,
  content         TEXT          NOT NULL,
  content_type    VARCHAR(32)   NOT NULL DEFAULT 'TEXT',  -- TEXT | HTML | TEMPLATE
  sent_at         TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  read_at         TIMESTAMPTZ,
  metadata        JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, interaction_id) REFERENCES interactions(tenant_id, id)
);

CREATE INDEX idx_messages_tenant_interaction
  ON interaction_messages (tenant_id, interaction_id, sent_at ASC);

70.11 Domínio: Comunicação Omnichannel (Communication Service)

70.11.1 Entidade: `communications`

Registro de cada envio ou recebimento de comunicação.

CREATE TABLE communications (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  citizen_ref     UUID,
  channel         VARCHAR(32)   NOT NULL,    -- EMAIL | SMS | PUSH | WHATSAPP | PORTAL
  direction       VARCHAR(16)   NOT NULL,    -- OUTBOUND | INBOUND
  purpose         VARCHAR(64)   NOT NULL,    -- TRANSACTIONAL | CAMPAIGN | NOTIFICATION
  template_id     UUID,
  template_version INTEGER,
  subject         VARCHAR(512),
  body            TEXT,
  rendered_body   TEXT,                      -- corpo após renderização com variáveis
  recipient_address VARCHAR(255) NOT NULL,
  status          VARCHAR(32)   NOT NULL,
  -- QUEUED | SENDING | SENT | DELIVERED | READ | FAILED | BOUNCED
  provider        VARCHAR(64),               -- provedor externo utilizado
  provider_ref    VARCHAR(255),              -- ID de rastreamento do provedor
  scheduled_at    TIMESTAMPTZ,
  sent_at         TIMESTAMPTZ,
  delivered_at    TIMESTAMPTZ,
  read_at         TIMESTAMPTZ,
  failed_at       TIMESTAMPTZ,
  failure_reason  TEXT,
  attempt_count   INTEGER       NOT NULL DEFAULT 0,
  campaign_ref    UUID,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

CREATE INDEX idx_communications_tenant_citizen
  ON communications (tenant_id, citizen_ref, sent_at DESC)
  WHERE citizen_ref IS NOT NULL;
CREATE INDEX idx_communications_tenant_status
  ON communications (tenant_id, status, scheduled_at ASC);
CREATE INDEX idx_communications_tenant_campaign
  ON communications (tenant_id, campaign_ref)
  WHERE campaign_ref IS NOT NULL;

70.12 Domínio: Gestão Documental (Document Service)

70.12.1 Entidade: `documents`

Metadados dos documentos gerenciados pela plataforma. O binário é armazenado em object storage separado.

CREATE TABLE documents (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  owner_ref       UUID          NOT NULL,   -- cidadão ou usuário proprietário
  owner_type      VARCHAR(32)   NOT NULL,   -- CITIZEN | USER | SYSTEM
  name            VARCHAR(255)  NOT NULL,
  original_name   VARCHAR(512),
  document_type   VARCHAR(128)  NOT NULL,   -- RG | CPF | COMPROVANTE_RESIDENCIA | ...
  mime_type       VARCHAR(128)  NOT NULL,
  size_bytes      BIGINT        NOT NULL,
  storage_key     TEXT          NOT NULL,   -- chave no object storage
  hash_sha256     VARCHAR(128)  NOT NULL,   -- integridade do binário
  status          VARCHAR(32)   NOT NULL,
  -- UPLOADING | PROCESSING | ACTIVE | ARCHIVED | DELETED
  ocr_extracted   BOOLEAN       NOT NULL DEFAULT FALSE,
  ocr_text        TEXT,
  classification  VARCHAR(128),
  sensitivity     VARCHAR(32)   NOT NULL DEFAULT 'CONFIDENTIAL',
  expires_at      TIMESTAMPTZ,
  deleted_at      TIMESTAMPTZ,
  metadata        JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

CREATE INDEX idx_documents_tenant_owner
  ON documents (tenant_id, owner_ref, owner_type);
CREATE INDEX idx_documents_tenant_type
  ON documents (tenant_id, document_type, status);

70.12.2 Entidade: `document_associations`

Vincula documentos a solicitações, processos ou outras entidades.

CREATE TABLE document_associations (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  document_id     UUID          NOT NULL,
  entity_type     VARCHAR(64)   NOT NULL,   -- REQUEST | PROCESS_INSTANCE | INTERACTION
  entity_ref      UUID          NOT NULL,
  role            VARCHAR(64),              -- REQUIRED_DOC | SUPPORTING | OUTPUT
  associated_at   TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, document_id) REFERENCES documents(tenant_id, id)
);

CREATE INDEX idx_doc_associations_tenant_entity
  ON document_associations (tenant_id, entity_type, entity_ref);

70.13 Domínio: Agendamentos (Scheduling Service)

70.13.1 Entidade: `agendas`

Define uma agenda de atendimento por unidade e serviço.

CREATE TABLE agendas (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  unit_ref        UUID          NOT NULL,   -- referência à unidade de atendimento
  service_ref     UUID          NOT NULL,   -- referência ao serviço
  name            VARCHAR(255)  NOT NULL,
  status          VARCHAR(32)   NOT NULL DEFAULT 'ACTIVE',
  advance_days    INTEGER       NOT NULL DEFAULT 30,
  slot_duration_minutes INTEGER NOT NULL,
  daily_capacity  INTEGER,
  auto_confirm    BOOLEAN       NOT NULL DEFAULT FALSE,
  config          JSONB,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

70.13.2 Entidade: `agenda_slots`

Vagas disponíveis em uma agenda — geradas antecipadamente.

CREATE TABLE agenda_slots (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  agenda_id       UUID          NOT NULL,
  slot_date       DATE          NOT NULL,
  slot_time       TIME          NOT NULL,
  total_capacity  INTEGER       NOT NULL DEFAULT 1,
  booked_count    INTEGER       NOT NULL DEFAULT 0,
  blocked         BOOLEAN       NOT NULL DEFAULT FALSE,
  block_reason    TEXT,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  CONSTRAINT chk_booked_capacity CHECK (booked_count <= total_capacity),
  CONSTRAINT uq_slot_agenda_datetime UNIQUE (tenant_id, agenda_id, slot_date, slot_time)
);

CREATE INDEX idx_slots_tenant_agenda_date
  ON agenda_slots (tenant_id, agenda_id, slot_date, slot_time)
  WHERE blocked = FALSE;

70.13.3 Entidade: `appointments`

Agendamentos confirmados pelos cidadãos.

CREATE TABLE appointments (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  slot_id         UUID          NOT NULL,
  citizen_ref     UUID          NOT NULL,
  service_ref     UUID          NOT NULL,
  status          VARCHAR(32)   NOT NULL,
  -- RESERVED | CONFIRMED | ATTENDED | MISSED | CANCELLED | RESCHEDULED
  reserved_at     TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  reservation_expires_at TIMESTAMPTZ,         -- expiração da reserva temporária
  confirmed_at    TIMESTAMPTZ,
  cancelled_at    TIMESTAMPTZ,
  cancellation_reason TEXT,
  rescheduled_to  UUID,                        -- novo appointment após reagendamento
  notes           TEXT,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID,
  FOREIGN KEY (tenant_id, slot_id) REFERENCES agenda_slots(tenant_id, id)
);

CREATE INDEX idx_appointments_tenant_citizen
  ON appointments (tenant_id, citizen_ref, confirmed_at DESC);
CREATE INDEX idx_appointments_tenant_status
  ON appointments (tenant_id, status);
CREATE INDEX idx_appointments_reservations_expiring
  ON appointments (reservation_expires_at)
  WHERE status = 'RESERVED';

70.14 Domínio: Ouvidoria e Manifestações (Ombudsman Service)

70.14.1 Entidade: `manifestations`

Registro de manifestações recebidas pela ouvidoria.

CREATE TABLE manifestations (
  id                UUID          PRIMARY KEY,
  tenant_id         VARCHAR(64)   NOT NULL,
  protocol_code     VARCHAR(64)   NOT NULL,
  manifestation_type VARCHAR(32)  NOT NULL,
  -- COMPLAINT | REPORT | SUGGESTION | COMPLIMENT | REQUEST | INFO_REQUEST
  citizen_ref       UUID,                      -- NULL para manifestações anônimas
  anonymous         BOOLEAN       NOT NULL DEFAULT FALSE,
  subject           VARCHAR(512)  NOT NULL,
  description       TEXT          NOT NULL,
  channel           VARCHAR(32)   NOT NULL,
  status            VARCHAR(32)   NOT NULL,
  -- RECEIVED | TRIAGED | FORWARDED | AWAITING_COMPLEMENT | RESPONDED | CLOSED
  confidential      BOOLEAN       NOT NULL DEFAULT FALSE,
  classification    VARCHAR(128),
  forwarded_to      UUID,                      -- unidade responsável
  legal_deadline    TIMESTAMPTZ,               -- prazo legal de resposta
  internal_deadline TIMESTAMPTZ,
  deadline_breached BOOLEAN       NOT NULL DEFAULT FALSE,
  received_at       TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  closed_at         TIMESTAMPTZ,
  external_ref      VARCHAR(255),              -- referência no MG-Ouv ou sistema externo
  metadata          JSONB,
  created_at        TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at        TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by        UUID,
  updated_by        UUID,
  CONSTRAINT uq_manifestations_tenant_protocol UNIQUE (tenant_id, protocol_code)
);

CREATE INDEX idx_manifestations_tenant_status
  ON manifestations (tenant_id, status, received_at DESC);
CREATE INDEX idx_manifestations_tenant_deadline
  ON manifestations (tenant_id, legal_deadline)
  WHERE status NOT IN ('CLOSED');

70.15 Domínio: Avaliação e Satisfação (Satisfaction Service)

70.15.1 Entidade: `feedbacks`

Avaliações coletadas de cidadãos após atendimentos e serviços.

CREATE TABLE feedbacks (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  citizen_ref     UUID,
  context_type    VARCHAR(32)   NOT NULL,   -- REQUEST | INTERACTION | APPOINTMENT | OMBUDSMAN
  context_ref     UUID          NOT NULL,
  service_ref     UUID,
  channel         VARCHAR(32),
  score           SMALLINT,                  -- 1 a 5 (CSAT) ou 0 a 10 (NPS)
  score_type      VARCHAR(16)   NOT NULL DEFAULT 'CSAT',  -- CSAT | NPS | STARS
  comment         TEXT,
  tags            JSONB,
  collected_at    TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

CREATE INDEX idx_feedbacks_tenant_context
  ON feedbacks (tenant_id, context_type, context_ref);
CREATE INDEX idx_feedbacks_tenant_service_date
  ON feedbacks (tenant_id, service_ref, collected_at DESC)
  WHERE service_ref IS NOT NULL;

70.16 Domínio: Segmentação e Campanhas

70.16.1 Entidade: `segments`

Definição de segmentos de cidadãos para campanhas e personalização.

CREATE TABLE segments (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  name            VARCHAR(255)  NOT NULL,
  description     TEXT,
  criteria        JSONB         NOT NULL,   -- critérios de filtragem estruturados
  audience_count  INTEGER,                  -- contagem após último cálculo
  calculated_at   TIMESTAMPTZ,
  status          VARCHAR(32)   NOT NULL DEFAULT 'ACTIVE',
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

70.16.2 Entidade: `campaigns`

Campanhas de comunicação segmentada.

CREATE TABLE campaigns (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  name            VARCHAR(255)  NOT NULL,
  description     TEXT,
  segment_id      UUID          NOT NULL,
  channel         VARCHAR(32)   NOT NULL,
  template_id     UUID          NOT NULL,
  status          VARCHAR(32)   NOT NULL,
  -- DRAFT | SCHEDULED | RUNNING | PAUSED | COMPLETED | CANCELLED
  scheduled_at    TIMESTAMPTZ,
  started_at      TIMESTAMPTZ,
  completed_at    TIMESTAMPTZ,
  total_recipients INTEGER,
  sent_count      INTEGER       NOT NULL DEFAULT 0,
  delivered_count INTEGER       NOT NULL DEFAULT 0,
  failed_count    INTEGER       NOT NULL DEFAULT 0,
  created_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  created_by      UUID,
  updated_by      UUID
);

CREATE INDEX idx_campaigns_tenant_status
  ON campaigns (tenant_id, status, scheduled_at ASC);

70.17 Domínio: Auditoria (Audit Service)

O Audit Service consome eventos de todos os domínios e persiste trilha imutável de ações sensíveis.

70.17.1 Entidade: `audit_events`

Registro imutável de eventos de auditoria. Nenhum UPDATE ou DELETE é permitido nesta tabela.

CREATE TABLE audit_events (
  id              UUID          PRIMARY KEY,
  tenant_id       VARCHAR(64)   NOT NULL,
  correlation_id  UUID,                      -- rastreabilidade da requisição origem
  event_type      VARCHAR(128)  NOT NULL,    -- ex.: citizen.data-accessed | request.status-changed
  actor_id        UUID,
  actor_type      VARCHAR(32)   NOT NULL,    -- USER | CITIZEN | SYSTEM | INTEGRATION
  actor_ip        INET,
  resource_type   VARCHAR(64)   NOT NULL,    -- ex.: citizen | request | document
  resource_id     UUID,
  action          VARCHAR(64)   NOT NULL,    -- CREATE | READ | UPDATE | DELETE | EXPORT | LOGIN | ...
  result          VARCHAR(16)   NOT NULL,    -- SUCCESS | FAILURE | DENIED
  before_state    JSONB,
  after_state     JSONB,
  reason          TEXT,
  occurred_at     TIMESTAMPTZ   NOT NULL DEFAULT NOW(),
  ingested_at     TIMESTAMPTZ   NOT NULL DEFAULT NOW()
)
PARTITION BY RANGE (occurred_at);

-- Partição mensal (criadas automaticamente por job de manutenção)
CREATE TABLE audit_events_2026_07
  PARTITION OF audit_events
  FOR VALUES FROM ('2026-07-01') TO ('2026-08-01');

CREATE INDEX idx_audit_tenant_type_date
  ON audit_events (tenant_id, event_type, occurred_at DESC);
CREATE INDEX idx_audit_tenant_resource
  ON audit_events (tenant_id, resource_type, resource_id, occurred_at DESC);
CREATE INDEX idx_audit_tenant_actor
  ON audit_events (tenant_id, actor_id, occurred_at DESC)
  WHERE actor_id IS NOT NULL;

A tabela audit_events é particionada por data (occurred_at) para suportar política de retenção e gestão de ciclo de vida sem impacto na performance de inserção e consulta.

70.18 Relacionamentos entre Domínios

Como cada microsserviço possui banco ou schema próprio, não existem chaves estrangeiras físicas entre domínios. A integridade referencial entre serviços é garantida por contratos de evento e pela consistência eventual.

O diagrama abaixo representa os relacionamentos lógicos — referências por valor sem FK física:

┌─────────────────────────────────────────────────────────────────────────────┐
│                    REFERÊNCIAS CRUZADAS ENTRE DOMÍNIOS                      │
│                  (sem FK física — integridade por contrato)                 │
│                                                                             │
│   Identity Service ──────────► Tenant Service                              │
│         │                      (identity.tenant_id → tenant.id)            │
│         │                                                                   │
│   Citizen Service ◄───────────── Identity Service                          │
│         │           (citizen.identity_ref → identity.id)                   │
│         │                                                                   │
│   Request Service ────────────► Citizen Service                            │
│         │     └──────────────► Service Catalog Service                     │
│         │                      (request.citizen_ref, service_ref)          │
│         │                                                                   │
│   Workflow Service ◄────────── Request Service                             │
│         │           (process_instance.correlation_key = request.id)        │
│         │                                                                   │
│   Task Service ◄──────────────── Workflow Service                          │
│                   (task.process_instance_ref → process_instance.id)        │
│                                                                             │
│   CRM Service ─────────────────► Citizen Service                           │
│         │            (interaction.citizen_ref → citizen.id)                │
│         └──────────────────────► Request Service                           │
│                       (interaction.protocol_ref → request.id)              │
│                                                                             │
│   Document Service ────────────► Citizen Service                           │
│         │           (document.owner_ref → citizen.id)                      │
│         └──────────────────────► Request Service (via associations)        │
│                                                                             │
│   Scheduling Service ──────────► Citizen Service                           │
│         │            (appointment.citizen_ref → citizen.id)                │
│         └──────────────────────► Service Catalog Service                   │
│                       (appointment.service_ref → service.id)               │
│                                                                             │
│   Feedback Service ────────────► Request / CRM / Scheduling Service        │
│                       (feedback.context_ref → entidade do contexto)        │
│                                                                             │
│   Audit Service ◄──────────────── Todos os domínios                        │
│                       (consome eventos; registra tenant_id, resource_id)   │
└─────────────────────────────────────────────────────────────────────────────┘

70.19 Padrões de Indexação

A estratégia de indexação segue três princípios fundamentais:

Princípio 1 — Tenant como coluna líder. Todo índice em tabela multi-tenant inclui tenant_id como primeira coluna. Sem isso, qualquer query com filtro de tenant pode resultar em sequential scan.

Princípio 2 — Orientação à query real. Índices são criados para as queries efetivamente executadas pela aplicação, não por antecipação especulativa. EXPLAIN ANALYZE é executado para validar o uso do índice em consultas críticas.

Princípio 3 — Índices parciais para subconjuntos. Quando apenas um subconjunto das linhas é consultado frequentemente (ex.: status = 'ACTIVE'), índices parciais com cláusula WHERE reduzem tamanho e aumentam eficiência.

-- Exemplo: tarefas SLA pendentes — apenas o subconjunto relevante
CREATE INDEX idx_tasks_sla_monitoring
  ON tasks (tenant_id, sla_deadline ASC)
  WHERE sla_breached = FALSE
    AND status NOT IN ('COMPLETED', 'CANCELLED', 'EXPIRED');

-- Exemplo: agendamentos com reserva expirando — job de limpeza
CREATE INDEX idx_appointments_expiring_reservations
  ON appointments (reservation_expires_at ASC)
  WHERE status = 'RESERVED';

70.20 Retenção e Ciclo de Vida dos Dados

Cada domínio possui política de retenção configurável por tenant:

Domínio	Dados Operacionais	Dados de Auditoria	Dados Pessoais (LGPD)
Cidadão	Enquanto conta ativa + 5 anos	10 anos	Anonimização após solicitação ou inatividade prolongada
Solicitações	10 anos após encerramento	10 anos	Dados do formulário seguem política do serviço
Atendimento CRM	5 anos	10 anos	Conteúdo de mensagens segue política do tenant
Documentos	Conforme tipo do documento	10 anos	Exclusão após prazo de retenção do documento
Agendamentos	3 anos após realização	5 anos	Dados do cidadão anonimizados após período
Ouvidoria	10 anos (prazo legal)	10 anos	Anonimização conforme tipo da manifestação
Satisfação	5 anos	5 anos	Comentários anonimizados após 2 anos
Auditoria	Imutável — 10 anos mínimos	N/A	Dados pessoais em `before_state`/`after_state` anonimizados conforme LGPD
Comunicações	2 anos	5 anos	Destinatário anonimizado após período de retenção

A execução das políticas de retenção é automatizada por jobs periódicos com rastreabilidade completa no Audit Service.

70.21 Considerações sobre LGPD

O modelo de dados foi projetado para conformidade com a Lei Geral de Proteção de Dados em quatro dimensões:

Minimização. PII é armazenada apenas onde funcionalmente necessário. O CRM Service, por exemplo, armazena apenas citizen_ref (UUID de referência) — os dados pessoais são compostos dinamicamente a partir do Citizen Service no momento do atendimento, sem cópia local.

Finalidade. A tabela citizen_consents registra consentimentos por finalidade específica (purpose_code), com base legal declarada e versionamento da política de privacidade. Toda operação de marketing verifica consentimento antes do envio.

Direito ao Esquecimento. O campo anonymized_at na tabela citizens e a estratégia de anonimização documentada no Capítulo 34 permitem a execução do direito previsto no art. 18, VI da LGPD: dados identificáveis são substituídos por valores neutros, preservando o ID técnico para rastreabilidade de auditoria sem exposição de PII.

Rastreabilidade. O Audit Service registra toda operação sensível sobre dados pessoais — acesso, alteração, exportação, anonimização e exclusão — com identificação de ator, finalidade, data e resultado.

70.22 Resumo

O Capítulo 70 apresenta o modelo de dados dos 13 domínios principais da plataforma: Identidade e Acesso, Tenant e Administração, Cidadão, Catálogo de Serviços, Solicitações e Protocolos, Processos e Workflow, Tarefas Humanas, Atendimento e CRM, Comunicação Omnichannel, Gestão Documental, Agendamentos, Ouvidoria, Avaliação e Satisfação, Segmentação e Campanhas, e Auditoria.

O modelo adota as seguintes invariantes estruturais: (a) cada serviço de domínio possui banco ou schema próprio, sem acesso cruzado por SQL; (b) toda tabela multi-tenant inclui tenant_id como discriminador obrigatório e coluna líder de índices; (c) referências entre domínios são feitas por valor (UUID) sem FK física, com integridade garantida por contratos de evento; (d) dados pessoais são gerenciados com minimização, finalidade declarada e política de retenção; (e) o Audit Service persiste trilha imutável e particionada de todas as ações sensíveis.

70.23 Próximo Capítulo

O Capítulo 71 — Contratos de API documenta as especificações OpenAPI 3.1 dos principais endpoints de cada serviço de domínio, com exemplos de request/response, códigos de status, schemas de erro padronizados e políticas de versionamento, complementando o modelo de dados apresentado neste capítulo.

70.24 Controle de Versão

Campo	Valor
Documento	Documento Mestre — Plataforma de Relacionamento Digital com o Cidadão
Capítulo	70 — Modelo de Dados
Versão	1.0
Situação	Concluído
Última atualização	17/07/2026
Status de Aprovação	Aprovado

Capítulo 70 — Modelo de Dados

Nesta página