Padrões de Desenvolvimento de CDSS para Saúde

Padrões para construir Sistemas de Apoio à Decisão Clínica que se integram em fluxos de trabalho de Prontuários Eletrônicos do Paciente (PEP). Módulos de 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 dosagem
• 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 de medicamentos com verificações de segurança
• Integrando interpretação de resultados de laboratório com contexto clínico

Como Funciona

O motor de CDSS é uma biblioteca de funções puras, sem efeitos colaterais. Entrada: dados clínicos; Saída: alertas. Isso o torna totalmente testável.

Três módulos principais:

1. checkInteractions(newDrug, currentMeds, allergies) — Verifica um novo medicamento contra medicações atuais e alergias conhecidas. Retorna InteractionAlert[] ordenados por gravidade. Usa o modelo de dados DrugInteractionPair.
2. validateDose(drug, dose, route, weight, age, renalFunction) — Valida uma dose prescrita contra regras baseadas em peso, ajustadas por idade e ajustadas por função renal. Retorna DoseValidationResult.
3. calculateNEWS2(vitals) — National Early Warning Score 2 de NEWS2Input. Retorna NEWS2Result com pontuação total, nível de risco e orientação para escalonamento.

EMR UI
  ↓ (user enters data)
CDSS Engine (pure functions, no side effects)
  ├── Drug Interaction Checker
  ├── Dose Validator
  ├── Clinical Scoring (NEWS2, qSOFA, etc.)
  └── Alert Classifier
  ↓ (returns alerts)
EMR UI (displays alerts inline, blocks if critical)

Verificação de Interações Medicamentosas

interface DrugInteractionPair {
  drugA: string;           // generic name
  drugB: string;           // generic name
  severity: 'critical' | 'major' | 'minor';
  mechanism: string;
  clinicalEffect: string;
  recommendation: string;
}

function checkInteractions(
  newDrug: string,
  currentMedications: string[],
  allergyList: string[]
): InteractionAlert[] {
  if (!newDrug) return [];
  const alerts: InteractionAlert[] = [];
  for (const current of currentMedications) {
    const interaction = findInteraction(newDrug, current);
    if (interaction) {
      alerts.push({ severity: interaction.severity, pair: [newDrug, current],
        message: interaction.clinicalEffect, recommendation: interaction.recommendation });
    }
  }
  for (const allergy of allergyList) {
    if (isCrossReactive(newDrug, allergy)) {
      alerts.push({ severity: 'critical', pair: [newDrug, allergy],
        message: `Cross-reactivity with documented allergy: ${allergy}`,
        recommendation: 'Do not prescribe without allergy consultation' });
    }
  }
  return alerts.sort((a, b) => severityOrder(a.severity) - severityOrder(b.severity));
}

Pares de interações 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 Dosagem

interface DoseValidationResult {
  valid: boolean;
  message: string;
  suggestedRange: { min: number; max: number; unit: string } | null;
  factors: string[];
}

function validateDose(
  drug: string,
  dose: number,
  route: 'oral' | 'iv' | 'im' | 'sc' | 'topical',
  patientWeight?: number,
  patientAge?: number,
  renalFunction?: number
): DoseValidationResult {
  const rules = getDoseRules(drug, route);
  if (!rules) return { valid: true, message: 'No validation rules available', suggestedRange: null, factors: [] };
  const factors: string[] = [];

  // SEGURANÇA: se as regras exigem peso, mas o peso está faltando, BLOQUEAR (não aprovar)
  if (rules.weightBased) {
    if (!patientWeight || patientWeight <= 0) {
      return { valid: false, message: `Weight required for ${drug} (mg/kg drug)`,
        suggestedRange: null, factors: ['weight_missing'] };
    }
    factors.push('weight');
    const maxDose = rules.maxPerKg * patientWeight;
    if (dose > maxDose) {
      return { valid: false, message: `Dose exceeds max for ${patientWeight}kg`,
        suggestedRange: { min: rules.minPerKg * patientWeight, max: maxDose, unit: rules.unit }, factors };
    }
  }

  // Ajuste baseado na idade (quando as regras definem faixas etárias e a idade é fornecida)
  if (rules.ageAdjusted && patientAge !== undefined) {
    factors.push('age');
    const ageMax = rules.getAgeAdjustedMax(patientAge);
    if (dose > ageMax) {
      return { valid: false, message: `Exceeds age-adjusted max for ${patientAge}yr`,
        suggestedRange: { min: rules.typicalMin, max: ageMax, unit: rules.unit }, factors };
    }
  }


…