healthcare-cdss-patterns

Padrões de Desenvolvimento de CDSS em Saúde

Padrões para a construção de Sistemas de Apoio à Decisão Clínica (CDSS) que se integram em fluxos de trabalho de prontuário eletrônico (EMR). Módulos CDSS são críticos para a segurança do paciente — tolerância zero para falsos negativos.

Quando Usar

• Implementando verificação de interações medicamentosas
• Construindo motores de validação de doses
• Implementando sistemas de pontuação clínica (NEWS2, qSOFA, APACHE, GCS)
• Projetando sistemas de alerta para valores clínicos anormais
• Construindo entrada de prescrição com verificações de segurança
• Integrando interpretação de resultados laboratoriais com contexto clínico

Como Funciona

O motor CDSS é uma biblioteca de funções puras com zero efeitos colaterais. Insira dados clínicos, obtenha alertas. Isso o torna totalmente testável.

Três módulos principais:

1. checkInteractions(novoMedicamento, medicamentosAtuais, alergias) — Verifica um novo medicamento contra medicamentos atuais e alergias conhecidas. Retorna InteractionAlert[] ordenados por gravidade. Usa o modelo de dados DrugInteractionPair.
2. validateDose(medicamento, dose, via, peso, idade, funcaoRenal) — Valida uma dose prescrita com base em regras ajustadas por peso, idade e função renal. Retorna DoseValidationResult.
3. calculateNEWS2(sinaisVitais) — National Early Warning Score 2 a partir de NEWS2Input. Retorna NEWS2Result com pontuação total, nível de risco e orientação de escalonamento.

Interface do EMR
  ↓ (usuário insere dados)
Motor CDSS (funções puras, sem efeitos colaterais)
  ├── Verificador de Interações Medicamentosas
  ├── Validador de Dose
  ├── Pontuação Clínica (NEWS2, qSOFA, etc.)
  └── Classificador de Alertas
  ↓ (retorna alertas)
Interface do EMR (exibe alertas inline, bloqueia se crítico)

Verificação de Interações Medicamentosas

interface ParInteracaoMedicamentosa {
  medicamentoA: string;           // nome genérico
  medicamentoB: string;           // nome genérico
  gravidade: 'critico' | 'major' | 'menor';
  mecanismo: string;
  efeitoClinico: string;
  recomendacao: string;
}

function checkInteractions(
  novoMedicamento: string,
  medicamentosAtuais: string[],
  listaAlergias: string[]
): AlertaInteracao[] {
  if (!novoMedicamento) return [];
  const alertas: AlertaInteracao[] = [];
  for (const atual of medicamentosAtuais) {
    const interacao = findInteraction(novoMedicamento, atual);
    if (interacao) {
      alertas.push({ gravidade: interacao.gravidade, par: [novoMedicamento, atual],
        mensagem: interacao.efeitoClinico, recomendacao: interacao.recomendacao });
    }
  }
  for (const alergia of listaAlergias) {
    if (isCrossReactive(novoMedicamento, alergia)) {
      alertas.push({ gravidade: 'critico', par: [novoMedicamento, alergia],
        mensagem: `Reatividade cruzada com alergia documentada: ${alergia}`,
        recomendacao: 'Não prescrever sem consulta de alergia' });
    }
  }
  return alertas.sort((a, b) => ordemGravidade(a.gravidade) - ordemGravidade(b.gravidade));
}

Os pares de interação devem ser bidirecionais: se o Medicamento A interage com o Medicamento B, então o Medicamento B interage com o Medicamento A.

Validação de Dose

interface ResultadoValidacaoDose {
  valido: boolean;
  mensagem: string;
  faixaSugerida: { minimo: number; maximo: number; unidade: string } | null;
  fatores: string[];
}

function validateDose(
  medicamento: string,
  dose: number,
  via: 'oral' | 'iv' | 'im' | 'sc' | 'topico',
  pesoPaciente?: number,
  idadePaciente?: number,
  funcaoRenal?: number
): ResultadoValidacaoDose {
  const regras = getRegrasDose(medicamento, via);
  if (!regras) return { valido: true, mensagem: 'Nenhuma regra de validação disponível', faixaSugerida: null, fatores: [] };
  const fatores: string[] = [];

  // SEGURANÇA: se as regras exigem peso e o peso está ausente, BLOQUEAR (não passar)
  if (regras.baseadoPeso) {
    if (!pesoPaciente || pesoPaciente <= 0) {
      return { valido: false, mensagem: `Peso obrigatório para ${medicamento} (mg/kg)`,
        faixaSugerida: null, fatores: ['peso_ausente'] };
    }
    fatores.push('peso');
    const maxDose = regras.maxPorKg * pesoPaciente;
    if (dose > maxDose) {
      return { valido: false, mensagem: `Dose excede o máximo para ${pesoPaciente}kg`,
        faixaSugerida: { minimo: regras.minPorKg * pesoPaciente, maximo: maxDose, unidade: regras.unidade }, fatores };
    }
  }

  // Ajuste por idade (quando as regras definem faixas etárias e a idade é fornecida)
  if (regras.ajustadoIdade && idadePaciente !== undefined) {
    fatores.push('idade');
    const maxIdade = regras.obterMaxAjustadoIdade(idadePaciente);
    if (dose > maxIdade) {
      return { valido: false, mensagem: `Excede máximo ajustado por idade para ${idadePaciente} anos`,
        faixaSugerida: { minimo: regras.typicalMin, maximo: maxIdade, unidade: regras.unidade }, fatores };
    }
  }

  // Ajuste renal (quando as regras definem faixas de eGFR e eGFR é fornecido)
  if (regras.ajustadoRenal && funcaoRenal !== undefined) {
    fatores.push('renal');
    const maxRenal = regras.obterMaxAjustadoRenal(funcaoRenal);
    if (dose > maxRenal) {
      return { valido: false, mensagem: `Excede máximo ajustado renal para eGFR ${funcaoRenal}`,
        faixaSugerida: { minimo: regras.typicalMin, maximo: maxRenal, unidade: regras.unidade }, fatores };
    }
  }

  // Máximo absoluto
  if (dose > regras.maximoAbsoluto) {
    return { valido: false, mensagem: `Excede máximo absoluto ${regras.maximoAbsoluto}${regras.unidade}`,
      faixaSugerida: { minimo: regras.typicalMin, maximo: regras.maximoAbsoluto, unidade: regras.unidade },
      fatores: [...fatores, 'maximo_absoluto'] };
  }
  return { valido: true, mensagem: 'Dentro da faixa',
    faixaSugerida: { minimo: regras.typicalMin, maximo: regras.typicalMax, unidade: regras.unidade }, fatores };
}

Pontuação Clínica: NEWS2

interface EntradaNEWS2 {
  frequenciaRespiratoria: number; saturacaoOxigenio: number; oxigenioSuplementar: boolean;
  temperatura: number; pressaoSistolica: number; frequenciaCardiaca: number;
  consciencia: 'alerta' | 'voz' | 'dor' | 'nao_responsivo';
}
interface ResultadoNEWS2 {
  total: number;           // 0-20
  risco: 'baixo' | 'baixo-medio' | 'medio' | 'alto';
  componentes: Record<string, number>;
  escalonamento: string;
}

As tabelas de pontuação devem corresponder exatamente à especificação do Royal College of Physicians.

Gravidade do Alerta e Comportamento da UI

Gravidade	Comportamento da UI	Ação Clínica Obrigatória
Crítico	Bloquear ação. Modal não dispensável. Vermelho.	Deve documentar o motivo da exceção para prosseguir
Major	Banner de aviso inline. Laranja.	Deve confirmar antes de prosseguir
Menor	Nota informativa inline. Amarelo.	Apenas ciência, nenhuma ação obrigatória

Alertas críticos NUNCA devem ser descartados automaticamente ou implementados como notificações toast. Os motivos da exceção devem ser armazenados na trilha de auditoria.

Testando CDSS (Tolerância Zero para Falsos Negativos)

describe('CDSS — Segurança do Paciente', () => {
  PARES_INTERACAO.forEach(({ medicamentoA, medicamentoB, gravidade }) => {
    it(`detecta ${medicamentoA} + ${medicamentoB} (${gravidade})`, () => {
      const alertas = checkInteractions(medicamentoA, [medicamentoB], []);
      expect(alertas.length).toBeGreaterThan(0);
      expect(alertas[0].gravidade).toBe(gravidade);
    });
    it(`detecta ${medicamentoB} + ${medicamentoA} (reverso)`, () => {
      const alertas = checkInteractions(medicamentoB, [medicamentoA], []);
      expect(alertas.length).toBeGreaterThan(0);
    });
  });
  it('bloqueia mg/kg quando peso está ausente', () => {
    const resultado = validateDose('gentamicina', 300, 'iv');
    expect(resultado.valido).toBe(false);
    expect(resultado.fatores).toContain('peso_ausente');
  });
  it('lida graciosamente com dados de medicamento malformados', () => {
    expect(() => checkInteractions('', [], [])).not.toThrow();
  });
});

Critério de aprovação: 100%. Uma única interação perdida é um evento de segurança do paciente.

Anti-Padrões

• Tornar as verificações CDSS opcionais ou ignoráveis sem motivo documentado
• Implementar verificações de interação como notificações toast
• Usar tipos any para dados de medicamentos ou clínicos
• Codificar pares de interação em vez de usar uma estrutura de dados sustentável
• Silenciar erros no motor CDSS (deve relatar falhas ruidosamente)
• Ignorar a validação baseada em peso quando o peso não está disponível (deve bloquear, não passar)

Exemplos

Exemplo 1: Verificação de Interação Medicamentosa

const alertas = checkInteractions('varfarina', ['aspirina', 'metformina'], ['penicilina']);
// [{ gravidade: 'critico', par: ['varfarina', 'aspirina'],
//    mensagem: 'Aumento do risco de sangramento', recomendacao: 'Evitar combinação' }]

Exemplo 2: Validação de Dose

const ok = validateDose('paracetamol', 1000, 'oral', 70, 45);
// { valido: true, faixaSugerida: { minimo: 500, maximo: 4000, unidade: 'mg' } }

const ruim = validateDose('paracetamol', 5000, 'oral', 70, 45);
// { valido: false, mensagem: 'Excede máximo absoluto 4000mg' }

const semPeso = validateDose('gentamicina', 300, 'iv');
// { valido: false, fatores: ['peso_ausente'] }

Exemplo 3: Pontuação NEWS2

const resultado = calculateNEWS2({
  frequenciaRespiratoria: 24, saturacaoOxigenio: 93, oxigenioSuplementar: true,
  temperatura: 38.5, pressaoSistolica: 100, frequenciaCardiaca: 110, consciencia: 'voz'
});
// { total: 13, risco: 'alto', escalonamento: 'Revisão clínica urgente. Considerar UTI.' }