@peopl-health/nexus 5.11.0-dev.1120 → 5.11.0-dev.1122

package/lib/fhir/resources/Observation.js

@@ -2,6 +2,7 @@ const { getSystems } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { SYMPTOM_GRADE_SLUG } = require('../constants/projectionSlugs');
+const { GRADE_EXT } = require('../constants/extensionSlugs');
 
 const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
 
@@ -61,7 +62,7 @@ class Observation {
       valueCodeableConcept: gradeConcept,
       method,
       extension: [
-        extension('grade-verification', { valueCode: 'provisional' }),
+        extension(GRADE_EXT.VERIFICATION, { valueCode: 'provisional' }),
         extension('grade-derivation', { valueCode: 'pro-ctcae-composite' }),
         extension('symptom-source', { valueString: String(sym.source || 'triage') }),
       ],
@@ -77,11 +78,11 @@ class Observation {
     const grade = assessment.grade;
     const gradeId = `${assessment.assessmentId}-grade`;
     const extensions = [];
-    if (grade.confidence !== null) extensions.push(extension('grade-confidence', { valueString: grade.confidence }));
-    if (grade.possibleRange !== null) extensions.push(extension('grade-range', { valueString: `${grade.possibleRange[0]}-${grade.possibleRange[1]}` }));
-    if (grade.reasoning) extensions.push(extension('grade-reasoning', { valueString: grade.reasoning }));
-    if (assessment.gradeVerification) extensions.push(extension('grade-verification', { valueString: assessment.gradeVerification }));
-    if (assessment.gradeThresholdClause) extensions.push(extension('grade-threshold-clause', { valueString: assessment.gradeThresholdClause }));
+    if (grade.confidence !== null) extensions.push(extension(GRADE_EXT.CONFIDENCE, { valueString: grade.confidence }));
+    if (grade.possibleRange !== null) extensions.push(extension(GRADE_EXT.RANGE, { valueString: `${grade.possibleRange[0]}-${grade.possibleRange[1]}` }));
+    if (grade.reasoning) extensions.push(extension(GRADE_EXT.REASONING, { valueString: grade.reasoning }));
+    if (assessment.gradeVerification) extensions.push(extension(GRADE_EXT.VERIFICATION, { valueString: assessment.gradeVerification }));
+    if (assessment.gradeThresholdClause) extensions.push(extension(GRADE_EXT.THRESHOLD_CLAUSE, { valueString: assessment.gradeThresholdClause }));
     const payload = {
       resourceType: 'Observation',
       id: fhirId(gradeId),

package/lib/fhir/resources/RiskAssessment.js

@@ -9,6 +9,7 @@ const {
   toIso,
 } = require('../helpers/elementHelper');
 const { PATIENT_RISK_SLUG, SAFETY_GATE_SLUG } = require('../constants/projectionSlugs');
+const { RISK_EXT } = require('../constants/extensionSlugs');
 
 const RISK_SEVERITY_CODESYSTEM = 'risk-severity';
 const PREDICTION_KIND_AE = 'ae';
@@ -39,11 +40,11 @@ function aePrediction(ae) {
       code: ae.severityIfConfirmed,
       system: codeSystemUrl(RISK_SEVERITY_CODESYSTEM),
     }),
-    extension: [extension('risk-prediction-kind', { valueString: PREDICTION_KIND_AE })],
+    extension: [extension(RISK_EXT.PREDICTION_KIND, { valueString: PREDICTION_KIND_AE })],
   };
   if (ae.why) prediction.rationale = ae.why;
   for (const symptom of ae.minimumSymptomSet) {
-    prediction.extension.push(extension('risk-minimum-symptom-set', { valueString: symptom }));
+    prediction.extension.push(extension(RISK_EXT.MINIMUM_SYMPTOM_SET, { valueString: symptom }));
   }
   return prediction;
 }
@@ -51,16 +52,16 @@ function aePrediction(ae) {
 function diseasePrediction(risk) {
   const prediction = {
     outcome: codeableConcept(risk.bodySite),
-    extension: [extension('risk-prediction-kind', { valueString: PREDICTION_KIND_DISEASE })],
+    extension: [extension(RISK_EXT.PREDICTION_KIND, { valueString: PREDICTION_KIND_DISEASE })],
   };
   for (const complication of risk.complications) {
-    prediction.extension.push(extension('risk-disease-complication', { valueString: complication }));
+    prediction.extension.push(extension(RISK_EXT.DISEASE_COMPLICATION, { valueString: complication }));
   }
   for (const symptom of risk.warningSymptoms) {
-    prediction.extension.push(extension('risk-disease-warning-symptom', { valueString: symptom }));
+    prediction.extension.push(extension(RISK_EXT.DISEASE_WARNING_SYMPTOM, { valueString: symptom }));
   }
   for (const comorbidity of risk.amplifierComorbidities) {
-    prediction.extension.push(extension('risk-disease-amplifier', { valueString: comorbidity }));
+    prediction.extension.push(extension(RISK_EXT.DISEASE_AMPLIFIER, { valueString: comorbidity }));
   }
   return prediction;
 }
@@ -69,10 +70,10 @@ function comorbidityPrediction(amplifier) {
   const prediction = {
     outcome: codeableConcept(amplifier.comorbidity),
     rationale: amplifier.interaction,
-    extension: [extension('risk-prediction-kind', { valueString: PREDICTION_KIND_COMORBIDITY })],
+    extension: [extension(RISK_EXT.PREDICTION_KIND, { valueString: PREDICTION_KIND_COMORBIDITY })],
   };
   if (amplifier.clinicalNote) {
-    prediction.extension.push(extension('risk-comorbidity-clinical-note', { valueString: amplifier.clinicalNote }));
+    prediction.extension.push(extension(RISK_EXT.COMORBIDITY_CLINICAL_NOTE, { valueString: amplifier.clinicalNote }));
   }
   return prediction;
 }
@@ -99,10 +100,10 @@ class RiskAssessment {
     ];
     if (prediction.length) payload.prediction = prediction;
     const extensions = [];
-    if (assessment.sourceRegimen) extensions.push(extension('assessed-source-regimen', { valueString: assessment.sourceRegimen }));
-    if (assessment.sourceDiagnosis) extensions.push(extension('assessed-source-diagnosis', { valueString: assessment.sourceDiagnosis }));
-    if (assessment.sourcePhase) extensions.push(extension('assessed-source-phase', { valueString: assessment.sourcePhase }));
-    if (assessment.assessedByModel) extensions.push(extension('assessed-by-model', { valueString: assessment.assessedByModel }));
+    if (assessment.sourceRegimen) extensions.push(extension(RISK_EXT.SOURCE_REGIMEN, { valueString: assessment.sourceRegimen }));
+    if (assessment.sourceDiagnosis) extensions.push(extension(RISK_EXT.SOURCE_DIAGNOSIS, { valueString: assessment.sourceDiagnosis }));
+    if (assessment.sourcePhase) extensions.push(extension(RISK_EXT.SOURCE_PHASE, { valueString: assessment.sourcePhase }));
+    if (assessment.assessedByModel) extensions.push(extension(RISK_EXT.ASSESSED_BY_MODEL, { valueString: assessment.assessedByModel }));
     if (extensions.length) payload.extension = extensions;
     return new RiskAssessment(payload);
   }

package/lib/fhir/resources/Task.js

@@ -20,6 +20,7 @@ const {
   PALLIATIVE_ESCALATION_SLUG,
   PALLIATIVE_CAREPLAN_REC_SLUG,
 } = require('../constants/projectionSlugs');
+const { PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
 const { interventionExtensions } = require('./interventionExtensions');
 
@@ -133,7 +134,7 @@ class Task {
       authoredOn: toIso(committedAt),
       requester: reference('Device', deviceId),
       restriction: { period: { end: toIso(end) } },
-      extension: [extension('palliative-escalation-rank', { valueInteger: finding.rank })],
+      extension: [extension(PALLIATIVE_EXT.ESCALATION_RANK, { valueInteger: finding.rank })],
     };
     if (escalation.escalationRoutes.length) {
       payload.requestedPerformer = escalation.escalationRoutes.map((route) => ({ concept: codeableConcept(route) }));
@@ -158,10 +159,10 @@ class Task {
       for: patientReference(patientId),
       authoredOn: toIso(committedAt),
       requester: reference('Device', deviceId),
-      extension: [extension('palliative-careplan-rec-rank', { valueInteger: recommendation.rank })],
+      extension: [extension(PALLIATIVE_EXT.CAREPLAN_REC_RANK, { valueInteger: recommendation.rank })],
     };
     if (recommendation.otcOffer && recommendation.otcOffer.label) {
-      payload.extension.push(extension('palliative-careplan-otc-offer', { valueString: JSON.stringify(recommendation.otcOffer) }));
+      payload.extension.push(extension(PALLIATIVE_EXT.CAREPLAN_OTC_OFFER, { valueString: JSON.stringify(recommendation.otcOffer) }));
     }
     if (recommendation.mainRecommendation) payload.description = recommendation.mainRecommendation;
     const noteTexts = [];

package/lib/fhir/services/clusterService.js

@@ -4,6 +4,7 @@ const { fhirId, identifierSystem } = require('../helpers/fhirHelper');
 const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
 const { CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG } = require('../constants/projectionSlugs');
 const { CLUSTER_LIST_SEPARATOR } = require('../resources/ClinicalImpression');
+const { CLUSTER_EXT } = require('../constants/extensionSlugs');
 const { PROJECTOR_NAME } = require('../projections/clusterProjection');
 const { getFhirStore } = require('../stores/fhirStore');
 const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
@@ -54,19 +55,19 @@ function reconstructCluster(resource, patientId) {
     clusterId: identifierValue(resource, CLUSTER_IMPRESSION_SLUG),
     patientId,
     label: identifierValue(resource, CLUSTER_LABEL_SLUG) || '',
-    hypothesisType: ext.clusterHypothesisType,
-    status: ext['cluster-status'],
-    confidence: ext.clusterHypothesisConfidence,
-    clinicalSignificance: ext.clusterClinicalSignificance,
+    hypothesisType: ext[CLUSTER_EXT.HYPOTHESIS_TYPE],
+    status: ext[CLUSTER_EXT.STATUS],
+    confidence: ext[CLUSTER_EXT.CONFIDENCE],
+    clinicalSignificance: ext[CLUSTER_EXT.CLINICAL_SIGNIFICANCE],
     memberCaseIds: (resource.problem || []).map((problemRef) => refToId(problemRef.reference)).filter(Boolean),
-    consultationId: ext['cluster-consultation-id'] || null,
+    consultationId: ext[CLUSTER_EXT.CONSULTATION_ID] || null,
     relationshipModel: resource.summary || '',
-    strengthensIf: ext.clusterStrengthensIf ? ext.clusterStrengthensIf.split(CLUSTER_LIST_SEPARATOR) : [],
-    weakensIf: ext.clusterWeakensIf ? ext.clusterWeakensIf.split(CLUSTER_LIST_SEPARATOR) : [],
+    strengthensIf: ext[CLUSTER_EXT.STRENGTHENS_IF] ? ext[CLUSTER_EXT.STRENGTHENS_IF].split(CLUSTER_LIST_SEPARATOR) : [],
+    weakensIf: ext[CLUSTER_EXT.WEAKENS_IF] ? ext[CLUSTER_EXT.WEAKENS_IF].split(CLUSTER_LIST_SEPARATOR) : [],
     openingReasoning: resource.description || '',
     openedAt: resource.effectiveDateTime || period.start,
     dissolvedAt: period.end || null,
-    dissolveReason: ext['cluster-dissolve-reason'] || null,
+    dissolveReason: ext[CLUSTER_EXT.DISSOLVE_REASON] || null,
     dissolveCategory: (resource.statusReason && resource.statusReason.text) || null,
   };
 }

package/lib/fhir/services/contingencyService.js

@@ -6,10 +6,11 @@ const {
   CONTINGENCY_PLAN_SLUG,
   CONTINGENCY_STEP_SLUG,
 } = require('../constants/projectionSlugs');
+const { CONTINGENCY_EXT, CONTINGENCY_CATEGORY_PREFIX } = require('../constants/extensionSlugs');
 const { CONTINGENCY_STATUS_TO_FHIR } = require('../resources/CarePlan');
 const { PROJECTOR_NAME } = require('../projections/contingencyProjection');
 const { getFhirStore } = require('../stores/fhirStore');
-const { ContingencySafetyNet } = require('../../shared/dtos/ContingencySafetyNet');
+const { ContingencySafetyNet, RECIPIENTS } = require('../../shared/dtos/ContingencySafetyNet');
 const { logger } = require('../../utils/logger');
 const { project, storeResources } = require('./fhirService');
 
@@ -69,13 +70,13 @@ function reconstructContingency(plan, requests, patientId) {
       relatedCaseId: refToId(address && address.reference),
       relatedClusterId: refToId(plan.supportingInfo && plan.supportingInfo[0] && plan.supportingInfo[0].reference),
       concern: plan.description || '',
-      awaitingCharacterization: ext['contingency-awaiting-characterization'] || '',
-      whyThisMatters: ext['contingency-why-this-matters'] || '',
-      creationReasoning: ext['contingency-creation-reasoning'] || '',
-      status: ext['contingency-status'] || FHIR_TO_CONTINGENCY_STATUS[plan.status] || 'armed',
+      awaitingCharacterization: ext[CONTINGENCY_EXT.AWAITING_CHARACTERIZATION] || '',
+      whyThisMatters: ext[CONTINGENCY_EXT.WHY_THIS_MATTERS] || '',
+      creationReasoning: ext[CONTINGENCY_EXT.CREATION_REASONING] || '',
+      status: ext[CONTINGENCY_EXT.STATUS] || FHIR_TO_CONTINGENCY_STATUS[plan.status] || 'armed',
       createdAt: plan.created,
       resolvedAt: (plan.period && plan.period.end) || null,
-      resolvedReason: ext['contingency-resolved-reason'] || null,
+      resolvedReason: ext[CONTINGENCY_EXT.RESOLVED_REASON] || null,
     },
     teamEscalation,
     patientReminder,
@@ -84,21 +85,23 @@ function reconstructContingency(plan, requests, patientId) {
 
 function reconstructStep(resource) {
   const ext = extMap(resource);
-  const silence = ext['fires-after-silence-minutes'];
+  const silence = ext[CONTINGENCY_EXT.FIRES_AFTER_SILENCE_MINUTES];
   const firstPayload = resource.payload && resource.payload[0];
   return {
     recipient: recipientOf(resource),
     message: (firstPayload && firstPayload.contentCodeableConcept && firstPayload.contentCodeableConcept.text) || null,
-    priority: ext['contingency-step-priority'] || resource.priority || null,
-    actionRequested: ext['contingency-action-requested'] || null,
+    priority: ext[CONTINGENCY_EXT.STEP_PRIORITY] || resource.priority || null,
+    actionRequested: ext[CONTINGENCY_EXT.ACTION_REQUESTED] || null,
     firesAfterSilenceMinutes: typeof silence === 'number' ? silence : null,
   };
 }
 
 function recipientOf(resource) {
   const category = resource.category && resource.category[0] && resource.category[0].text;
-  if (category === 'contingency-patient') return 'patient';
-  if (category === 'contingency-care_team') return 'care_team';
+  if (category && category.startsWith(CONTINGENCY_CATEGORY_PREFIX)) {
+    const recipient = category.slice(CONTINGENCY_CATEGORY_PREFIX.length);
+    if (RECIPIENTS.includes(recipient)) return recipient;
+  }
   const ref = resource.recipient && resource.recipient[0] && resource.recipient[0].reference;
   return ref && ref.startsWith('Organization/') ? 'care_team' : 'patient';
 }

package/lib/fhir/services/palliativeService.js

@@ -3,6 +3,7 @@ const { ZodError } = require('zod');
 const { fhirId } = require('../helpers/fhirHelper');
 const { extMap, extValues, identifierValue } = require('../helpers/fhirReadHelper');
 const { PALLIATIVE_ASSESSMENT_SLUG, PALLIATIVE_ESCALATION_SLUG, PALLIATIVE_CAREPLAN_SLUG } = require('../constants/projectionSlugs');
+const { PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 const { PROJECTOR_NAME } = require('../projections/palliativeProjection');
 const { PROJECTOR_NAME: CAREPLAN_PROJECTOR_NAME } = require('../projections/palliativeCarePlanProjection');
 const { getFhirStore } = require('../stores/fhirStore');
@@ -46,7 +47,7 @@ async function readPalliativeCarePlanByTurn({ patientId, turnId }) {
   const patient = `Patient/${fhirId(patientId)}`;
   const plans = (await store.find({ patient, resourceType: 'CarePlan' }))
     .filter((resource) => identifierValue(resource, PALLIATIVE_CAREPLAN_SLUG));
-  const plan = plans.find((resource) => extMap(resource)['palliative-turn-id'] === turnId) || null;
+  const plan = plans.find((resource) => extMap(resource)[PALLIATIVE_EXT.TURN_ID] === turnId) || null;
   if (!plan) return null;
   const careplanId = identifierValue(plan, PALLIATIVE_CAREPLAN_SLUG);
   const provenance = await store.getByReference(`Provenance/${fhirId(`${careplanId}-prov`)}`);
@@ -56,7 +57,7 @@ async function readPalliativeCarePlanByTurn({ patientId, turnId }) {
 
 async function reconstructCarePlan(store, plan, patientId, turnId) {
   const careplanId = identifierValue(plan, PALLIATIVE_CAREPLAN_SLUG);
-  const assessmentId = extMap(plan)['palliative-assessment-id'];
+  const assessmentId = extMap(plan)[PALLIATIVE_EXT.ASSESSMENT_ID];
   const taskRefs = (plan.activity || [])
     .map((activity) => activity.plannedActivityReference && activity.plannedActivityReference.reference)
     .filter(Boolean);
@@ -98,12 +99,12 @@ function reconstructRecommendation(task) {
   const ext = extMap(task);
   const ctcaeTerms = ((task.code && task.code.coding) || []).map((coding) => coding.code).filter(Boolean);
   return {
-    rank: ext['palliative-careplan-rec-rank'],
+    rank: ext[PALLIATIVE_EXT.CAREPLAN_REC_RANK],
     elementNameShort: (task.code && task.code.text) || 'recommendation',
     isPharmacologicalMedNeeded: medsText === undefined ? null : medsText === 'true',
     ctcaeTerms,
     mainRecommendation: task.description || null,
-    otcOffer: parseOtcOffer(ext['palliative-careplan-otc-offer']),
+    otcOffer: parseOtcOffer(ext[PALLIATIVE_EXT.CAREPLAN_OTC_OFFER]),
     whenToEscalate: noteMap.when_to_escalate || null,
     expectedEffectiveness: noteMap.expected_effectiveness || null,
     followup,
@@ -124,7 +125,7 @@ async function findImpression(store, patientId, turnId) {
   const patient = `Patient/${fhirId(patientId)}`;
   const impressions = (await store.find({ patient, resourceType: 'ClinicalImpression' }))
     .filter((resource) => identifierValue(resource, PALLIATIVE_ASSESSMENT_SLUG));
-  return impressions.find((impression) => extMap(impression)['palliative-turn-id'] === turnId) || null;
+  return impressions.find((impression) => extMap(impression)[PALLIATIVE_EXT.TURN_ID] === turnId) || null;
 }
 
 async function reconstruct(store, impression, provenance, patientId, turnId) {
@@ -158,7 +159,7 @@ async function readEscalations(store, provenance, patientId) {
   for (const ref of taskRefs) {
     const task = await store.getByReference(ref);
     if (!task) continue;
-    const rank = extMap(task)['palliative-escalation-rank'];
+    const rank = extMap(task)[PALLIATIVE_EXT.ESCALATION_RANK];
     if (rank === undefined || rank === null) continue;
     byRank[rank] = reconstructEscalation(task, patientId);
   }
@@ -168,25 +169,25 @@ async function readEscalations(store, provenance, patientId) {
 function reconstructFinding(finding, escalations) {
   const ext = extMap(finding);
   const nameShort = ccText(finding.item && finding.item.concept);
-  const rank = ext['palliative-finding-rank'];
+  const rank = ext[PALLIATIVE_EXT.FINDING_RANK];
   return {
     rank,
-    elementType: ext['palliative-finding-element-type'],
+    elementType: ext[PALLIATIVE_EXT.FINDING_ELEMENT_TYPE],
     nameShort,
-    timeWindow: ext['palliative-finding-time-window'] || '',
-    symptomTerms: extValues(finding, 'palliative-finding-symptom-term'),
-    clinicalDescription: ext['palliative-finding-clinical-description'] || '',
-    whyRelevant: ext['palliative-finding-why-relevant'] || '',
-    qolImpact: ext['palliative-finding-qol-impact'] || null,
-    qolCriteria: ext['palliative-finding-qol-criteria'] || '',
-    improvementCapacity: ext['palliative-finding-improvement-capacity'] || null,
-    improvementCriteria: ext['palliative-finding-improvement-criteria'] || '',
-    areMedsNeeded: ext['palliative-finding-are-meds-needed'] ?? null,
-    needsCharacterization: ext['palliative-finding-needs-characterization'] ?? null,
-    characterizationCriteria: ext['palliative-finding-characterization-criteria'] || '',
-    probeQuestions: extValues(finding, 'palliative-finding-probe-question'),
-    auditNotes: ext['palliative-finding-audit-notes'] || '',
-    clusterNote: ext['palliative-finding-cluster-note'] ?? null,
+    timeWindow: ext[PALLIATIVE_EXT.FINDING_TIME_WINDOW] || '',
+    symptomTerms: extValues(finding, PALLIATIVE_EXT.FINDING_SYMPTOM_TERM),
+    clinicalDescription: ext[PALLIATIVE_EXT.FINDING_CLINICAL_DESCRIPTION] || '',
+    whyRelevant: ext[PALLIATIVE_EXT.FINDING_WHY_RELEVANT] || '',
+    qolImpact: ext[PALLIATIVE_EXT.FINDING_QOL_IMPACT] || null,
+    qolCriteria: ext[PALLIATIVE_EXT.FINDING_QOL_CRITERIA] || '',
+    improvementCapacity: ext[PALLIATIVE_EXT.FINDING_IMPROVEMENT_CAPACITY] || null,
+    improvementCriteria: ext[PALLIATIVE_EXT.FINDING_IMPROVEMENT_CRITERIA] || '',
+    areMedsNeeded: ext[PALLIATIVE_EXT.FINDING_ARE_MEDS_NEEDED] ?? null,
+    needsCharacterization: ext[PALLIATIVE_EXT.FINDING_NEEDS_CHARACTERIZATION] ?? null,
+    characterizationCriteria: ext[PALLIATIVE_EXT.FINDING_CHARACTERIZATION_CRITERIA] || '',
+    probeQuestions: extValues(finding, PALLIATIVE_EXT.FINDING_PROBE_QUESTION),
+    auditNotes: ext[PALLIATIVE_EXT.FINDING_AUDIT_NOTES] || '',
+    clusterNote: ext[PALLIATIVE_EXT.FINDING_CLUSTER_NOTE] ?? null,
     escalation: escalations[rank] || null,
   };
 }

package/lib/fhir/services/riskService.js

@@ -3,6 +3,7 @@ const { ZodError } = require('zod');
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifierValue, extValues } = require('../helpers/fhirReadHelper');
 const { PATIENT_RISK_SLUG } = require('../constants/projectionSlugs');
+const { RISK_EXT } = require('../constants/extensionSlugs');
 const { PROJECTOR_NAME } = require('../projections/riskProjection');
 const { PROJECTOR_NAME: SAFETY_GATE_PROJECTOR_NAME } = require('../projections/safetyGateProjection');
 const {
@@ -67,14 +68,14 @@ function reconstructRisk(resource, patientId) {
     assessmentId: identifierValue(resource, PATIENT_RISK_SLUG),
     patientId,
     status: resource.status,
-    sourceRegimen: extValues(resource, 'assessed-source-regimen')[0] || null,
-    sourceDiagnosis: extValues(resource, 'assessed-source-diagnosis')[0] || null,
-    sourcePhase: extValues(resource, 'assessed-source-phase')[0] || null,
+    sourceRegimen: extValues(resource, RISK_EXT.SOURCE_REGIMEN)[0] || null,
+    sourceDiagnosis: extValues(resource, RISK_EXT.SOURCE_DIAGNOSIS)[0] || null,
+    sourcePhase: extValues(resource, RISK_EXT.SOURCE_PHASE)[0] || null,
     predictedAes: predictions.filter((prediction) => predictionKind(prediction) === PREDICTION_KIND_AE).map(reconstructAe),
     diseaseRisks: predictions.filter((prediction) => predictionKind(prediction) === PREDICTION_KIND_DISEASE).map(reconstructDisease),
     comorbidityAmplifiers: predictions.filter((prediction) => predictionKind(prediction) === PREDICTION_KIND_COMORBIDITY).map(reconstructComorbidity),
     assessedAt: resource.occurrenceDateTime,
-    assessedByModel: extValues(resource, 'assessed-by-model')[0] || null,
+    assessedByModel: extValues(resource, RISK_EXT.ASSESSED_BY_MODEL)[0] || null,
   };
 }
 
@@ -86,7 +87,7 @@ function reconstructAe(prediction) {
         && prediction.qualitativeRisk.coding
         && prediction.qualitativeRisk.coding[0]
         && prediction.qualitativeRisk.coding[0].code) || null,
-    minimumSymptomSet: extValues(prediction, 'risk-minimum-symptom-set'),
+    minimumSymptomSet: extValues(prediction, RISK_EXT.MINIMUM_SYMPTOM_SET),
     why: prediction.rationale || null,
   };
 }
@@ -94,9 +95,9 @@ function reconstructAe(prediction) {
 function reconstructDisease(prediction) {
   return {
     bodySite: outcomeText(prediction),
-    complications: extValues(prediction, 'risk-disease-complication'),
-    warningSymptoms: extValues(prediction, 'risk-disease-warning-symptom'),
-    amplifierComorbidities: extValues(prediction, 'risk-disease-amplifier'),
+    complications: extValues(prediction, RISK_EXT.DISEASE_COMPLICATION),
+    warningSymptoms: extValues(prediction, RISK_EXT.DISEASE_WARNING_SYMPTOM),
+    amplifierComorbidities: extValues(prediction, RISK_EXT.DISEASE_AMPLIFIER),
   };
 }
 
@@ -104,11 +105,11 @@ function reconstructComorbidity(prediction) {
   return {
     comorbidity: outcomeText(prediction),
     interaction: prediction.rationale,
-    clinicalNote: extValues(prediction, 'risk-comorbidity-clinical-note')[0] || null,
+    clinicalNote: extValues(prediction, RISK_EXT.COMORBIDITY_CLINICAL_NOTE)[0] || null,
   };
 }
 
-const predictionKind = (prediction) => extValues(prediction, 'risk-prediction-kind')[0] || null;
+const predictionKind = (prediction) => extValues(prediction, RISK_EXT.PREDICTION_KIND)[0] || null;
 
 const outcomeText = (prediction) => (prediction.outcome && prediction.outcome.text) || null;
 

package/lib/fhir/services/routingService.js

@@ -3,6 +3,7 @@ const { ZodError } = require('zod');
 const { fhirId } = require('../helpers/fhirHelper');
 const { extMap, extValues, identifierValue, refToId } = require('../helpers/fhirReadHelper');
 const { ROUTING_ASSESSMENT_SLUG, ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
+const { ROUTING_EXT } = require('../constants/extensionSlugs');
 const { PROJECTOR_NAME } = require('../projections/routingProjection');
 const { getFhirStore } = require('../stores/fhirStore');
 const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
@@ -32,7 +33,7 @@ async function readRoutingByTurn({ patientId, turnId }) {
   const patient = `Patient/${fhirId(patientId)}`;
   const impressions = (await store.find({ patient, resourceType: 'ClinicalImpression' }))
     .filter((resource) => identifierValue(resource, ROUTING_ASSESSMENT_SLUG));
-  const assessment = impressions.find((impression) => extMap(impression)['routing-turn-id'] === turnId);
+  const assessment = impressions.find((impression) => extMap(impression)[ROUTING_EXT.TURN_ID] === turnId);
   if (!assessment) return null;
   const provenance = await store.getByReference(`Provenance/${fhirId(`${assessment.id}-prov`)}`);
   if (!provenance) return null;
@@ -62,10 +63,10 @@ function reconstructRouting(assessment, disposition, provenance, patientId, turn
   const agent = (provenance.agent || [])[0] || {};
   return {
     schemaVersion: '1',
-    decisionId: ext['routing-decision-id'],
+    decisionId: ext[ROUTING_EXT.DECISION_ID],
     patientId,
     turnId,
-    committedAt: ext['routing-committed-at'],
+    committedAt: ext[ROUTING_EXT.COMMITTED_AT],
     assessment: reconstructAssessment(assessment, patientId, turnId),
     disposition: reconstructDisposition(disposition, assessment, patientId),
     provenance: {
@@ -92,9 +93,9 @@ function reconstructAssessment(resource, patientId, turnId) {
 function reconstructFinding(finding) {
   const ext = extMap(finding);
   return {
-    caseId: ext['routing-finding-case-id'] || refToId(finding.item && finding.item.reference),
-    clinicalReasoning: ext['routing-finding-reasoning'] || '',
-    decisionAction: ext['routing-finding-action'] || '',
+    caseId: ext[ROUTING_EXT.FINDING_CASE_ID] || refToId(finding.item && finding.item.reference),
+    clinicalReasoning: ext[ROUTING_EXT.FINDING_REASONING] || '',
+    decisionAction: ext[ROUTING_EXT.FINDING_ACTION] || '',
   };
 }
 
@@ -105,7 +106,7 @@ function reconstructDisposition(resource, assessment, patientId) {
     kind: DISPOSITION_KIND_BY_RESOURCE[resource.resourceType],
     primaryAction: dispositionAction(resource),
     primaryReason: dispositionReason(resource),
-    primaryCaseId: extMap(assessment)['routing-primary-case-id'] || null,
+    primaryCaseId: extMap(assessment)[ROUTING_EXT.PRIMARY_CASE_ID] || null,
     secondaryActions: (resource.action || []).slice(1).map(reconstructSecondary),
     deferredItems: reconstructDeferredItems(assessment),
     authoredAt: resource.sent || resource.authoredOn || resource.created,
@@ -113,8 +114,8 @@ function reconstructDisposition(resource, assessment, patientId) {
 }
 
 function reconstructDeferredItems(assessment) {
-  const items = extValues(assessment, 'routing-deferred-item');
-  const reasons = extValues(assessment, 'routing-deferred-reason');
+  const items = extValues(assessment, ROUTING_EXT.DEFERRED_ITEM);
+  const reasons = extValues(assessment, ROUTING_EXT.DEFERRED_REASON);
   return items.map((item, i) => ({ item, deferReason: reasons[i] }));
 }
 

package/lib/fhir/services/symptomCaseService.js

@@ -3,6 +3,7 @@ const { ZodError } = require('zod');
 const { fhirId } = require('../helpers/fhirHelper');
 const { extMap, extValues, identifierValue } = require('../helpers/fhirReadHelper');
 const { SYMPTOM_CASE_SLUG, SYMPTOM_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
+const { SYMPTOM_CASE_EXT, ASSESSMENT_EXT, GRADE_EXT } = require('../constants/extensionSlugs');
 const { PROJECTOR_NAME } = require('../projections/symptomCaseProjection');
 const { getFhirStore } = require('../stores/fhirStore');
 const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
@@ -23,7 +24,7 @@ async function readSymptomCases({ patientId, ctcaeTerm = null, status = null })
   const store = getFhirStore();
   const patient = `Patient/${fhirId(patientId)}`;
   const conditions = (await store.find({ patient, resourceType: 'Condition', symptomTerm: ctcaeTerm }))
-    .filter((condition) => 'symptom-case-status' in extMap(condition) && identifierValue(condition, SYMPTOM_CASE_SLUG));
+    .filter((condition) => SYMPTOM_CASE_EXT.STATUS in extMap(condition) && identifierValue(condition, SYMPTOM_CASE_SLUG));
   const cases = [];
   for (const condition of conditions) {
     let managed;
@@ -61,17 +62,17 @@ function reconstructCondition(condition, patientId, conditionId) {
     conditionId,
     patientId,
     ctcaeTerm: coding.code || code.text || null,
-    clinicalStatus: ext['symptom-case-status'],
+    clinicalStatus: ext[SYMPTOM_CASE_EXT.STATUS],
     onsetAt: condition.onsetDateTime,
-    abatementAt: condition.abatementDateTime || ext['legacy-abatement'] || null,
-    closeReason: ext['symptom-close-reason'] || null,
-    temporality: ext['symptom-temporality'] || null,
-    evidenceEpisodeIds: extValues(condition, 'symptom-evidence-episode-ids'),
-    currentEpisodeId: ext['symptom-current-episode-id'] || null,
-    evidenceMentionIds: extValues(condition, 'symptom-evidence-mention-ids'),
+    abatementAt: condition.abatementDateTime || ext[SYMPTOM_CASE_EXT.LEGACY_ABATEMENT] || null,
+    closeReason: ext[SYMPTOM_CASE_EXT.CLOSE_REASON] || null,
+    temporality: ext[SYMPTOM_CASE_EXT.TEMPORALITY] || null,
+    evidenceEpisodeIds: extValues(condition, SYMPTOM_CASE_EXT.EVIDENCE_EPISODE_IDS),
+    currentEpisodeId: ext[SYMPTOM_CASE_EXT.CURRENT_EPISODE_ID] || null,
+    evidenceMentionIds: extValues(condition, SYMPTOM_CASE_EXT.EVIDENCE_MENTION_IDS),
     lastTransitionReason: (condition.note && condition.note[0] && condition.note[0].text) || null,
-    recurrenceCount: ext['symptom-recurrence-count'] ?? 0,
-    reactivatedAt: ext['symptom-reactivated-at'] || null,
+    recurrenceCount: ext[SYMPTOM_CASE_EXT.RECURRENCE_COUNT] ?? 0,
+    reactivatedAt: ext[SYMPTOM_CASE_EXT.REACTIVATED_AT] || null,
   };
 }
 
@@ -109,13 +110,13 @@ async function reconstructAssessment(impression, { patientId, conditionId, previ
     performedAt: impression.effectiveDateTime,
     previousId,
     grade: reconstructGrade(gradeObs),
-    trajectory: ext.trajectory || null,
-    decisionPosture: ext['decision-posture'] || null,
-    gradeVerification: gradeExt['grade-verification'] || 'provisional',
-    reasoning: ext['assessment-reasoning'] || null,
-    postureReason: ext['posture-reason'] || null,
+    trajectory: ext[ASSESSMENT_EXT.TRAJECTORY] || null,
+    decisionPosture: ext[ASSESSMENT_EXT.DECISION_POSTURE] || null,
+    gradeVerification: gradeExt[GRADE_EXT.VERIFICATION] || 'provisional',
+    reasoning: ext[ASSESSMENT_EXT.REASONING] || null,
+    postureReason: ext[ASSESSMENT_EXT.POSTURE_REASON] || null,
     problemRepresentation: impression.summary || null,
-    gradeThresholdClause: gradeExt['grade-threshold-clause'] || null,
+    gradeThresholdClause: gradeExt[GRADE_EXT.THRESHOLD_CLAUSE] || null,
   };
 }
 
@@ -124,12 +125,12 @@ function reconstructGrade(obs) {
   if (!obs) return grade;
   const ext = extMap(obs);
   if (typeof obs.valueInteger === 'number') grade.bestEstimate = obs.valueInteger;
-  if (ext['grade-confidence']) grade.confidence = ext['grade-confidence'];
-  if (ext['grade-range']) {
-    const [lo, hi] = ext['grade-range'].split('-').map((n) => Number.parseInt(n, 10));
+  if (ext[GRADE_EXT.CONFIDENCE]) grade.confidence = ext[GRADE_EXT.CONFIDENCE];
+  if (ext[GRADE_EXT.RANGE]) {
+    const [lo, hi] = ext[GRADE_EXT.RANGE].split('-').map((n) => Number.parseInt(n, 10));
     if (Number.isInteger(lo) && Number.isInteger(hi)) grade.possibleRange = [lo, hi];
   }
-  if (ext['grade-reasoning']) grade.reasoning = ext['grade-reasoning'];
+  if (ext[GRADE_EXT.REASONING]) grade.reasoning = ext[GRADE_EXT.REASONING];
   return grade;
 }
 

package/lib/shared/dtos/ClusterImpression.js

@@ -4,15 +4,20 @@ const { BaseDto } = require('./BaseDto');
 
 const dateTime = z.iso.datetime({ offset: true });
 
+const HYPOTHESIS_TYPES = ['ae_profile', 'symptom_syndrome', 'disease_complication', 'relational_causal'];
+const CLUSTER_STATUSES = ['active', 'dissolved'];
+const CONFIDENCE_LEVELS = ['speculative', 'moderate', 'strong'];
+const CLINICAL_SIGNIFICANCE = ['benign', 'moderate', 'safety_relevant', 'emergency'];
+
 const schema = z.strictObject({
   schemaVersion: z.string().default('1'),
   clusterId: z.string(),
   patientId: z.string(),
   label: z.string(),
-  hypothesisType: z.enum(['ae_profile', 'symptom_syndrome', 'disease_complication', 'relational_causal']),
-  status: z.enum(['active', 'dissolved']).default('active'),
-  confidence: z.enum(['speculative', 'moderate', 'strong']),
-  clinicalSignificance: z.enum(['benign', 'moderate', 'safety_relevant', 'emergency']),
+  hypothesisType: z.enum(HYPOTHESIS_TYPES),
+  status: z.enum(CLUSTER_STATUSES).default('active'),
+  confidence: z.enum(CONFIDENCE_LEVELS),
+  clinicalSignificance: z.enum(CLINICAL_SIGNIFICANCE),
   memberCaseIds: z.array(z.string()).min(1),
   consultationId: z.string().nullable().default(null),
   relationshipModel: z.string(),
@@ -37,4 +42,10 @@ class ClusterImpression extends BaseDto {}
 
 ClusterImpression.schema = schema;
 
-module.exports = { ClusterImpression };
+module.exports = {
+  ClusterImpression,
+  HYPOTHESIS_TYPES,
+  CLUSTER_STATUSES,
+  CONFIDENCE_LEVELS,
+  CLINICAL_SIGNIFICANCE,
+};

package/lib/shared/dtos/ContingencySafetyNet.js

@@ -6,9 +6,10 @@ const dateTime = z.iso.datetime({ offset: true });
 
 const ESCALATION_PRIORITIES = ['critical', 'high', 'medium', 'low', 'routine', 'urgent', 'asap', 'stat'];
 const ACTIVE_CARE_PLAN_STATUSES = ['armed', 'fired_reminder', 'fired_team'];
+const RECIPIENTS = ['patient', 'care_team'];
 
 const escalationStepSchema = z.strictObject({
-  recipient: z.enum(['patient', 'care_team']),
+  recipient: z.enum(RECIPIENTS),
   message: z.string(),
   priority: z.enum(ESCALATION_PRIORITIES).nullable().default(null),
   actionRequested: z.string().nullable().default(null),
@@ -51,4 +52,5 @@ module.exports = {
   ContingencySafetyNet,
   ESCALATION_PRIORITIES,
   ACTIVE_CARE_PLAN_STATUSES,
+  RECIPIENTS,
 };

package/lib/shared/dtos/Intervention.js

@@ -4,16 +4,19 @@ const { BaseDto } = require('./BaseDto');
 
 const dateTime = z.iso.datetime({ offset: true });
 
+const KINDS = ['otc', 'self_care', 'other', 'education', 'team_escalation', 'follow_up_check'];
+const OUTCOMES = ['pending', 'improved', 'no_relief', 'side_effects', 'worsened', 'unknown'];
+
 const schema = z.strictObject({
   schemaVersion: z.string().default('1'),
-  kind: z.enum(['otc', 'self_care', 'other', 'education', 'team_escalation', 'follow_up_check']),
+  kind: z.enum(KINDS),
   interventionId: z.string(),
   patientId: z.string(),
   caseId: z.string(),
   interventionLabel: z.string(),
   rationale: z.string().nullable().default(null),
   deliveredAt: dateTime,
-  outcome: z.enum(['pending', 'improved', 'no_relief', 'side_effects', 'worsened', 'unknown']).default('pending'),
+  outcome: z.enum(OUTCOMES).default('pending'),
   outcomeNotes: z.string().nullable().default(null),
   recipientKind: z.enum(['patient', 'related_person']).default('patient'),
   recipientRefId: z.string().nullable().default(null),
@@ -26,4 +29,8 @@ class Intervention extends BaseDto {}
 
 Intervention.schema = schema;
 
-module.exports = { Intervention };
+module.exports = {
+  Intervention,
+  KINDS,
+  OUTCOMES,
+};