@peopl-health/nexus 5.13.0-dev.1145 → 5.13.0-dev.1148

package/lib/clinical/tools/updateConditionStatusTool.js

@@ -1,6 +1,5 @@
 const { readSymptomCases, storeSymptomCase, readContingencies, storeContingency, readClusters, storeCluster } = require('../../fhir');
-const { ManagedSymptom, OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
-const { RESOLUTION_CLOSE_REASONS } = require('../../fhir/resources/Condition');
+const { ManagedSymptom, OPEN_STATUSES, RESOLUTION_CLOSE_REASONS } = require('../../shared/dtos/ManagedSymptom');
 const { ContingencySafetyNet, ACTIVE_CARE_PLAN_STATUSES } = require('../../shared/dtos/ContingencySafetyNet');
 const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
 const { ClusterHistoryRecord } = require('../../shared/dtos/ClusterHistoryRecord');

package/lib/fhir/helpers/resourceHelper.js

@@ -1,4 +1,4 @@
-const { getDeviceId, getOrganizationId } = require('../config/fhirConfig');
+const { getDeviceId, getOrganizationId, getSystems } = require('../config/fhirConfig');
 const { fhirId } = require('./fhirHelper');
 const { identifier, patientReference, reference, codeableConcept, toIso } = require('./elementHelper');
 
@@ -22,7 +22,13 @@ function provenance({ provenanceId, targetRefs, recordedAt, activityText }) {
   };
 }
 
+function observationCategory(code) {
+  const label = code.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+  return codeableConcept(label, { code, system: getSystems().observationCategory, display: label });
+}
+
 module.exports = {
   baseResource,
   provenance,
+  observationCategory,
 };

package/lib/fhir/models/envelopeModel.js

@@ -23,6 +23,10 @@ const envelopeSchema = new mongoose.Schema(
 
 envelopeSchema.index({ 'index.patient': 1, 'index.date': -1 });
 envelopeSchema.index({ 'index.patient': 1, 'index.symptomTerm': 1, 'index.date': -1 });
+envelopeSchema.index(
+  { 'index.patient': 1, 'resource.identifier.system': 1, 'index.date': -1 },
+  { partialFilterExpression: { 'meta.deleted': false } },
+);
 envelopeSchema.index({ 'index.reference': 1 }, { partialFilterExpression: { 'index.reference': { $type: 'string' } } });
 envelopeSchema.index({ 'resource.status': 1 }, { sparse: true });
 

package/lib/fhir/projections/registerProjectors.js

@@ -2,7 +2,6 @@ const { registerProjector } = require('../services/fhirService');
 const { projectClinicalMention, PROJECTOR_NAME: MENTION_PROJECTOR_NAME } = require('./clinicalMentionProjection');
 const { projectDispatchedEscalation, PROJECTOR_NAME: ESCALATION_PROJECTOR_NAME } = require('./dispatchedEscalationProjection');
 const { projectReminder, PROJECTOR_NAME: REMINDER_PROJECTOR_NAME } = require('./reminderProjection');
-const { projectSymptomCase, PROJECTOR_NAME: SYMPTOM_CASE_PROJECTOR_NAME } = require('./symptomCaseProjection');
 const { projectPatientRisk, PROJECTOR_NAME: RISK_PROJECTOR_NAME } = require('./riskProjection');
 const { projectSafetyGate, PROJECTOR_NAME: SAFETY_GATE_PROJECTOR_NAME } = require('./safetyGateProjection');
 const { projectRecommendationPlan, PROJECTOR_NAME: RECOMMENDATION_PLAN_PROJECTOR_NAME } = require('./recommendationPlanProjection');
@@ -15,7 +14,6 @@ const PROJECTORS = [
   { name: MENTION_PROJECTOR_NAME, project: projectClinicalMention },
   { name: ESCALATION_PROJECTOR_NAME, project: projectDispatchedEscalation },
   { name: REMINDER_PROJECTOR_NAME, project: projectReminder },
-  { name: SYMPTOM_CASE_PROJECTOR_NAME, project: projectSymptomCase },
   { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },
   { name: SAFETY_GATE_PROJECTOR_NAME, project: projectSafetyGate },
   { name: RECOMMENDATION_PLAN_PROJECTOR_NAME, project: projectRecommendationPlan },

package/lib/fhir/projections/symptomCaseProjection.js

@@ -1,65 +1,289 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { ClinicalImpression } = require('../resources/ClinicalImpression');
-const { Condition } = require('../resources/Condition');
-const { Observation } = require('../resources/Observation');
-const { Provenance } = require('../resources/Provenance');
+const { ZodError } = require('zod');
+
+const { getSystems } = require('../config/fhirConfig');
+const { codeSystemUrl } = require('../helpers/fhirHelper');
+const { reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
+const { baseResource, provenance, observationCategory } = require('../helpers/resourceHelper');
+const { extMap, extValues, identifierValue } = require('../helpers/fhirReadHelper');
+const { SYMPTOM_CASE_SLUG, SYMPTOM_ASSESSMENT_SLUG, SYMPTOM_GRADE_SLUG } = require('../constants/projectionSlugs');
+const { SYMPTOM_CASE_EXT, ASSESSMENT_EXT, GRADE_EXT } = require('../constants/extensionSlugs');
+const { ManagedSymptom, RESOLUTION_CLOSE_REASONS } = require('../../shared/dtos/ManagedSymptom');
+const { logger } = require('../../utils/logger');
 
-const PROJECTOR_NAME = 'symptomCase';
 const ACTIVITY_TEXT = 'symptom-management';
 const PLACEHOLDER_DECISION_POSTURE = 'pending_initial_assessment';
+const PROVENANCE_PARTICIPANT_TYPE_SYSTEM = 'http://terminology.hl7.org/CodeSystem/provenance-participant-type';
 
-function assessmentResources(assessment, dropPreviousTo) {
-  const grade = assessment.grade;
-  const hasGradeSignal = grade.bestEstimate !== null
-    || grade.possibleRange !== null
-    || Boolean(grade.confidence)
-    || Boolean(grade.reasoning)
-    || Boolean(assessment.gradeThresholdClause);
-  const out = [ClinicalImpression.fromSymptomAssessment({ assessment, dropPreviousTo, hasGradeSignal })];
-  if (hasGradeSignal) out.push(Observation.fromSymptomGrade({ assessment }));
-  return out;
-}
+const CLINICAL_STATUS_TO_FHIR = { resolved: 'resolved', inactive: 'inactive' };
+const VALID_VERIFICATION = new Set(['confirmed', 'provisional', 'unconfirmed']);
 
-function projectSymptomCase(managedSymptom) {
+function toFhir(managedSymptom) {
   const { condition, latestAssessment, priorAssessments } = managedSymptom;
   const allAssessments = [latestAssessment, ...priorAssessments];
-  const placeholderIds = new Set(
-    allAssessments.filter((a) => a.decisionPosture === PLACEHOLDER_DECISION_POSTURE).map((a) => a.assessmentId),
-  );
-
-  const fhirCondition = Condition.fromSymptomCase({
-    condition,
-    verification: latestAssessment.gradeVerification,
-    headAssessmentId: latestAssessment.assessmentId,
-  });
-
-  const out = [fhirCondition, ...assessmentResources(latestAssessment, placeholderIds)];
-  const provenanceTargets = [
-    { reference: `Condition/${fhirId(condition.conditionId)}` },
-    { reference: `ClinicalImpression/${fhirId(latestAssessment.assessmentId)}` },
-  ];
-  out.push(Provenance.fromSymptomCase({
-    provenanceId: `${condition.conditionId}-prov`,
-    targetRefs: provenanceTargets,
-    recordedAt: latestAssessment.performedAt,
-    activityText: ACTIVITY_TEXT,
-  }));
+  const placeholderIds = new Set(allAssessments.filter((a) => a.decisionPosture === PLACEHOLDER_DECISION_POSTURE).map((a) => a.assessmentId));
 
+  const out = [
+    conditionResource(condition, latestAssessment.gradeVerification, latestAssessment.assessmentId),
+    ...assessmentResources(latestAssessment, placeholderIds),
+    caseProvenance(condition.conditionId, latestAssessment.performedAt, [
+      reference('Condition', condition.conditionId),
+      reference('ClinicalImpression', latestAssessment.assessmentId),
+    ]),
+  ];
   for (const prior of priorAssessments) {
     if (placeholderIds.has(prior.assessmentId)) continue;
-    out.push(...assessmentResources(prior, placeholderIds));
-    out.push(Provenance.fromSymptomCase({
-      provenanceId: `${prior.assessmentId}-prov`,
-      targetRefs: [{ reference: `ClinicalImpression/${fhirId(prior.assessmentId)}` }],
-      recordedAt: prior.performedAt,
-      activityText: ACTIVITY_TEXT,
-    }));
+    out.push(
+      ...assessmentResources(prior, placeholderIds),
+      caseProvenance(prior.assessmentId, prior.performedAt, [reference('ClinicalImpression', prior.assessmentId)]),
+    );
+  }
+  return out;
+}
+
+function caseProvenance(anchorId, recordedAt, targetRefs) {
+  return provenance({ provenanceId: `${anchorId}-prov`, targetRefs, recordedAt, activityText: ACTIVITY_TEXT });
+}
+
+function assessmentResources(assessment, placeholderIds) {
+  const grade = assessment.grade;
+  const hasGradeSignal = grade.bestEstimate !== null || grade.possibleRange !== null
+    || Boolean(grade.confidence) || Boolean(grade.reasoning) || Boolean(assessment.gradeThresholdClause);
+  const out = [impressionResource(assessment, placeholderIds, hasGradeSignal)];
+  if (hasGradeSignal) out.push(gradeResource(assessment));
+  return out;
+}
+
+function fhirClinicalStatusFor(condition) {
+  const status = condition.clinicalStatus;
+  if (status === 'characterizing' || status === 'monitoring') {
+    return condition.recurrenceCount > 0 ? 'recurrence' : 'active';
+  }
+  if (status === 'closed') {
+    return RESOLUTION_CLOSE_REASONS.has((condition.closeReason || '').trim().toLowerCase()) ? 'resolved' : 'inactive';
+  }
+  return CLINICAL_STATUS_TO_FHIR[status];
+}
+
+function conditionResource(condition, verification, headAssessmentId) {
+  const systems = getSystems();
+  const clinicalStatusCode = fhirClinicalStatusFor(condition);
+  const verificationCode = VALID_VERIFICATION.has(verification) ? verification : 'provisional';
+  const code = condition.ctcaeTerm && condition.ctcaeTerm !== 'other'
+    ? codeableConcept(condition.ctcaeTerm, { code: condition.ctcaeTerm, system: codeSystemUrl('pro-ctcae'), display: condition.ctcaeTerm })
+    : codeableConcept(condition.ctcaeTerm || 'other');
+  const payload = {
+    ...baseResource('Condition', condition.conditionId, SYMPTOM_CASE_SLUG, condition.patientId),
+    clinicalStatus: codeableConcept(clinicalStatusCode, { code: clinicalStatusCode, system: systems.conditionClinical }),
+    verificationStatus: codeableConcept(verificationCode, { code: verificationCode, system: systems.conditionVerStatus }),
+    category: [
+      codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
+      codeableConcept('PRO-CTCAE patient-reported symptom (agent-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
+    ],
+    code,
+    participant: [{
+      function: codeableConcept('Informant', { code: 'informant', system: PROVENANCE_PARTICIPANT_TYPE_SYSTEM }),
+      actor: patientReference(condition.patientId),
+    }],
+    onsetDateTime: toIso(condition.onsetAt),
+    extension: conditionExtensions(condition, clinicalStatusCode),
+  };
+  if (condition.abatementAt && clinicalStatusCode === 'resolved') payload.abatementDateTime = toIso(condition.abatementAt);
+  if (condition.lastTransitionReason) payload.note = [{ text: condition.lastTransitionReason }];
+  const evidence = [
+    ...condition.evidenceEpisodeIds.map((id) => ({ reference: reference('Observation', id) })),
+    ...condition.evidenceMentionIds.map((id) => ({ reference: reference('Observation', id) })),
+  ];
+  if (evidence.length) payload.evidence = evidence;
+  if (headAssessmentId) payload.stage = [{ assessment: [reference('ClinicalImpression', headAssessmentId)] }];
+  return payload;
+}
+
+function conditionExtensions(condition, clinicalStatusCode) {
+  const out = [extension(SYMPTOM_CASE_EXT.STATUS, { valueString: condition.clinicalStatus })];
+  if (condition.abatementAt && clinicalStatusCode !== 'resolved') {
+    out.push(extension(SYMPTOM_CASE_EXT.LEGACY_ABATEMENT, { valueDateTime: toIso(condition.abatementAt) }));
+  }
+  if (condition.closeReason) {
+    out.push(extension(SYMPTOM_CASE_EXT.CLOSE_REASON, { valueString: condition.closeReason }));
+    if (clinicalStatusCode === 'inactive' && condition.closeReason === 'stale_no_activity') {
+      out.push(extension('presumed-inactive-by-gap', { valueBoolean: true }));
+    }
+  }
+  if (condition.temporality) out.push(extension(SYMPTOM_CASE_EXT.TEMPORALITY, { valueString: condition.temporality }));
+  if (condition.currentEpisodeId) out.push(extension(SYMPTOM_CASE_EXT.CURRENT_EPISODE_ID, { valueString: condition.currentEpisodeId }));
+  for (const id of condition.evidenceEpisodeIds) out.push(extension(SYMPTOM_CASE_EXT.EVIDENCE_EPISODE_IDS, { valueString: id }));
+  for (const id of condition.evidenceMentionIds) out.push(extension(SYMPTOM_CASE_EXT.EVIDENCE_MENTION_IDS, { valueString: id }));
+  out.push(extension(SYMPTOM_CASE_EXT.RECURRENCE_COUNT, { valueInteger: condition.recurrenceCount }));
+  if (condition.reactivatedAt) out.push(extension(SYMPTOM_CASE_EXT.REACTIVATED_AT, { valueDateTime: toIso(condition.reactivatedAt) }));
+  return out;
+}
+
+function impressionResource(assessment, dropPreviousTo, hasGradeSignal) {
+  const payload = {
+    ...baseResource('ClinicalImpression', assessment.assessmentId, SYMPTOM_ASSESSMENT_SLUG, assessment.patientId),
+    status: 'completed',
+    effectiveDateTime: toIso(assessment.performedAt),
+    problem: [reference('Condition', assessment.conditionId)],
+    extension: assessmentExtensions(assessment),
+  };
+  if (hasGradeSignal) payload.finding = [{ item: { reference: reference('Observation', `${assessment.assessmentId}-grade`) } }];
+  if (assessment.problemRepresentation) payload.summary = assessment.problemRepresentation;
+  if (assessment.previousId && !dropPreviousTo?.has(assessment.previousId)) {
+    payload.previous = reference('ClinicalImpression', assessment.previousId);
   }
+  return payload;
+}
+
+function assessmentExtensions(assessment) {
+  const out = [];
+  if (assessment.trajectory) out.push(extension(ASSESSMENT_EXT.TRAJECTORY, { valueString: assessment.trajectory }));
+  if (assessment.decisionPosture) out.push(extension(ASSESSMENT_EXT.DECISION_POSTURE, { valueString: assessment.decisionPosture }));
+  if (assessment.postureReason) out.push(extension(ASSESSMENT_EXT.POSTURE_REASON, { valueString: assessment.postureReason }));
+  if (assessment.reasoning) out.push(extension(ASSESSMENT_EXT.REASONING, { valueString: assessment.reasoning }));
+  return out;
+}
+
+function gradeResource(assessment) {
+  const grade = assessment.grade;
+  const gradeId = `${assessment.assessmentId}-grade`;
+  const payload = {
+    ...baseResource('Observation', gradeId, SYMPTOM_GRADE_SLUG, assessment.patientId),
+    status: 'final',
+    category: [observationCategory('survey')],
+    code: codeableConcept('CTCAE severity grade'),
+    performer: [patientReference(assessment.patientId)],
+    effectiveDateTime: toIso(assessment.performedAt),
+  };
+  if (grade.bestEstimate !== null) payload.valueInteger = grade.bestEstimate;
+  const ext = gradeExtensions(assessment);
+  if (ext.length) payload.extension = ext;
+  return payload;
+}
 
+function gradeExtensions(assessment) {
+  const grade = assessment.grade;
+  const out = [];
+  if (grade.confidence !== null) out.push(extension(GRADE_EXT.CONFIDENCE, { valueString: grade.confidence }));
+  if (grade.possibleRange !== null) out.push(extension(GRADE_EXT.RANGE, { valueString: `${grade.possibleRange[0]}-${grade.possibleRange[1]}` }));
+  if (grade.reasoning) out.push(extension(GRADE_EXT.REASONING, { valueString: grade.reasoning }));
+  if (assessment.gradeVerification) out.push(extension(GRADE_EXT.VERIFICATION, { valueString: assessment.gradeVerification }));
+  if (assessment.gradeThresholdClause) out.push(extension(GRADE_EXT.THRESHOLD_CLAUSE, { valueString: assessment.gradeThresholdClause }));
   return out;
 }
 
+function fromFhir(resources, { patientId }) {
+  const byReference = new Map();
+  for (const resource of resources) {
+    if (resource.resourceType === 'ClinicalImpression' || resource.resourceType === 'Observation') {
+      byReference.set(`${resource.resourceType}/${resource.id}`, resource);
+    }
+  }
+  return resources
+    .filter((resource) => resource.resourceType === 'Condition'
+      && identifierValue(resource, SYMPTOM_CASE_SLUG)
+      && SYMPTOM_CASE_EXT.STATUS in extMap(resource))
+    .map((condition) => reconstruct(condition, byReference, patientId))
+    .filter(Boolean);
+}
+
+function reconstruct(condition, byReference, patientId) {
+  const conditionId = identifierValue(condition, SYMPTOM_CASE_SLUG);
+  const chain = assessmentChain(condition, byReference)
+    .map(({ impression, previousId }) => reconstructAssessment(impression, { patientId, conditionId, previousId }, byReference));
+  const [latestAssessment, ...priorAssessments] = chain;
+  const reconstructed = {
+    condition: reconstructCondition(condition, patientId, conditionId),
+    latestAssessment,
+    priorAssessments,
+  };
+  try {
+    return new ManagedSymptom(reconstructed);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      logger.warn({ conditionId }, 'skipping malformed symptom-case Condition');
+      return null;
+    }
+    throw error;
+  }
+}
+
+function assessmentChain(condition, byReference) {
+  const headRef = condition.stage?.[0]?.assessment?.[0]?.reference;
+  const impressions = [];
+  const seen = new Set();
+  let ref = headRef;
+  while (ref && !seen.has(ref)) {
+    seen.add(ref);
+    const impression = byReference.get(ref);
+    if (!impression) break;
+    impressions.push(impression);
+    ref = impression.previous?.reference;
+  }
+  return impressions.map((impression, i) => ({
+    impression,
+    previousId: impressions[i + 1] ? identifierValue(impressions[i + 1], SYMPTOM_ASSESSMENT_SLUG) : null,
+  }));
+}
+
+function reconstructAssessment(impression, { patientId, conditionId, previousId }, byReference) {
+  const ext = extMap(impression);
+  const findingRef = impression.finding?.[0]?.item?.reference?.reference;
+  const gradeObs = findingRef ? byReference.get(findingRef) : null;
+  const gradeExt = extMap(gradeObs || {});
+  return {
+    assessmentId: identifierValue(impression, SYMPTOM_ASSESSMENT_SLUG),
+    conditionId,
+    patientId,
+    performedAt: impression.effectiveDateTime,
+    previousId,
+    grade: reconstructGrade(gradeObs),
+    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_EXT.THRESHOLD_CLAUSE] || null,
+  };
+}
+
+function reconstructGrade(obs) {
+  const grade = { bestEstimate: null, confidence: null, possibleRange: null, reasoning: '' };
+  if (!obs) return grade;
+  const ext = extMap(obs);
+  if (typeof obs.valueInteger === 'number') grade.bestEstimate = obs.valueInteger;
+  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_EXT.REASONING]) grade.reasoning = ext[GRADE_EXT.REASONING];
+  return grade;
+}
+
+function reconstructCondition(condition, patientId, conditionId) {
+  const ext = extMap(condition);
+  const code = condition.code || {};
+  const coding = code.coding?.[0] || {};
+  return {
+    conditionId,
+    patientId,
+    ctcaeTerm: coding.code || code.text || null,
+    clinicalStatus: ext[SYMPTOM_CASE_EXT.STATUS],
+    onsetAt: condition.onsetDateTime,
+    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?.[0]?.text || null,
+    recurrenceCount: ext[SYMPTOM_CASE_EXT.RECURRENCE_COUNT] ?? 0,
+    reactivatedAt: ext[SYMPTOM_CASE_EXT.REACTIVATED_AT] || null,
+  };
+}
+
 module.exports = {
-  projectSymptomCase,
-  PROJECTOR_NAME,
+  toFhir,
+  fromFhir,
 };

package/lib/fhir/resources/ClinicalImpression.js

@@ -1,7 +1,7 @@
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { SYMPTOM_ASSESSMENT_SLUG, CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, ROUTING_ASSESSMENT_SLUG, RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
-const { ASSESSMENT_EXT, ROUTING_EXT, CLUSTER_EXT, PALLIATIVE_EXT } = require('../constants/extensionSlugs');
+const { CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, ROUTING_ASSESSMENT_SLUG, RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
+const { ROUTING_EXT, CLUSTER_EXT, PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 
 const CLUSTER_STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
 const CLUSTER_LIST_SEPARATOR = '; ';
@@ -51,32 +51,6 @@ class ClinicalImpression {
     return new ClinicalImpression(payload);
   }
 
-  static fromSymptomAssessment({ assessment, dropPreviousTo = null, hasGradeSignal = false }) {
-    const extensions = [];
-    if (assessment.trajectory) extensions.push(extension(ASSESSMENT_EXT.TRAJECTORY, { valueString: assessment.trajectory }));
-    if (assessment.decisionPosture) extensions.push(extension(ASSESSMENT_EXT.DECISION_POSTURE, { valueString: assessment.decisionPosture }));
-    if (assessment.postureReason) extensions.push(extension(ASSESSMENT_EXT.POSTURE_REASON, { valueString: assessment.postureReason }));
-    if (assessment.reasoning) extensions.push(extension(ASSESSMENT_EXT.REASONING, { valueString: assessment.reasoning }));
-    const payload = {
-      resourceType: 'ClinicalImpression',
-      id: fhirId(assessment.assessmentId),
-      identifier: [identifier(SYMPTOM_ASSESSMENT_SLUG, assessment.assessmentId)],
-      status: 'completed',
-      subject: patientReference(assessment.patientId),
-      effectiveDateTime: toIso(assessment.performedAt),
-      problem: [reference('Condition', assessment.conditionId)],
-      extension: extensions,
-    };
-    if (hasGradeSignal) {
-      payload.finding = [{ item: { reference: reference('Observation', `${assessment.assessmentId}-grade`) } }];
-    }
-    if (assessment.problemRepresentation) payload.summary = assessment.problemRepresentation;
-    if (assessment.previousId && !(dropPreviousTo && dropPreviousTo.has(assessment.previousId))) {
-      payload.previous = reference('ClinicalImpression', assessment.previousId);
-    }
-    return new ClinicalImpression(payload);
-  }
-
   static fromRecommendationPlan({ plan }) {
     const finding = [...plan.elements]
       .sort((a, b) => a.rank - b.rank)

package/lib/fhir/resources/Condition.js

@@ -1,96 +1,12 @@
 const { getSystems } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { SYMPTOM_CASE_SLUG } = require('../constants/projectionSlugs');
-const { SYMPTOM_CASE_EXT } = require('../constants/extensionSlugs');
-
-const CLINICAL_STATUS_TO_FHIR = {
-  resolved: 'resolved',
-  inactive: 'inactive',
-};
-
-const RESOLUTION_CLOSE_REASONS = new Set([
-  'resolved', 'team_resolved', 'resolved_spontaneously', 'resolved_by_intervention',
-]);
-
-const VALID_VERIFICATION = new Set(['confirmed', 'provisional', 'unconfirmed']);
-
-const PROVENANCE_PARTICIPANT_TYPE_SYSTEM = 'http://terminology.hl7.org/CodeSystem/provenance-participant-type';
-
-function fhirClinicalStatusFor(condition) {
-  const status = condition.clinicalStatus;
-  if (status === 'characterizing' || status === 'monitoring') {
-    return condition.recurrenceCount > 0 ? 'recurrence' : 'active';
-  }
-  if (status === 'closed') {
-    return RESOLUTION_CLOSE_REASONS.has((condition.closeReason || '').trim().toLowerCase()) ? 'resolved' : 'inactive';
-  }
-  return CLINICAL_STATUS_TO_FHIR[status];
-}
 
 class Condition {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromSymptomCase({ condition, verification, headAssessmentId = null }) {
-    const systems = getSystems();
-    const clinicalStatusCode = fhirClinicalStatusFor(condition);
-    const verificationCode = VALID_VERIFICATION.has(verification) ? verification : 'provisional';
-    const code = condition.ctcaeTerm && condition.ctcaeTerm !== 'other'
-      ? codeableConcept(condition.ctcaeTerm, { code: condition.ctcaeTerm, system: codeSystemUrl('pro-ctcae'), display: condition.ctcaeTerm })
-      : codeableConcept(condition.ctcaeTerm || 'other');
-    const extensions = [extension(SYMPTOM_CASE_EXT.STATUS, { valueString: condition.clinicalStatus })];
-    const payload = {
-      resourceType: 'Condition',
-      id: fhirId(condition.conditionId),
-      identifier: [identifier(SYMPTOM_CASE_SLUG, condition.conditionId)],
-      clinicalStatus: codeableConcept(clinicalStatusCode, { code: clinicalStatusCode, system: systems.conditionClinical }),
-      verificationStatus: codeableConcept(verificationCode, { code: verificationCode, system: systems.conditionVerStatus }),
-      category: [
-        codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
-        codeableConcept('PRO-CTCAE patient-reported symptom (agent-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
-      ],
-      code,
-      subject: patientReference(condition.patientId),
-      participant: [{
-        function: codeableConcept('Informant', { code: 'informant', system: PROVENANCE_PARTICIPANT_TYPE_SYSTEM }),
-        actor: patientReference(condition.patientId),
-      }],
-      onsetDateTime: toIso(condition.onsetAt),
-      extension: extensions,
-    };
-    if (condition.abatementAt) {
-      if (clinicalStatusCode === 'resolved') {
-        payload.abatementDateTime = toIso(condition.abatementAt);
-      } else {
-        extensions.push(extension(SYMPTOM_CASE_EXT.LEGACY_ABATEMENT, { valueDateTime: toIso(condition.abatementAt) }));
-      }
-    }
-    if (condition.closeReason) {
-      extensions.push(extension(SYMPTOM_CASE_EXT.CLOSE_REASON, { valueString: condition.closeReason }));
-      if (clinicalStatusCode === 'inactive' && condition.closeReason === 'stale_no_activity') {
-        extensions.push(extension('presumed-inactive-by-gap', { valueBoolean: true }));
-      }
-    }
-    if (condition.temporality) extensions.push(extension(SYMPTOM_CASE_EXT.TEMPORALITY, { valueString: condition.temporality }));
-    if (condition.currentEpisodeId) extensions.push(extension(SYMPTOM_CASE_EXT.CURRENT_EPISODE_ID, { valueString: condition.currentEpisodeId }));
-    for (const id of condition.evidenceEpisodeIds) extensions.push(extension(SYMPTOM_CASE_EXT.EVIDENCE_EPISODE_IDS, { valueString: id }));
-    for (const id of condition.evidenceMentionIds) extensions.push(extension(SYMPTOM_CASE_EXT.EVIDENCE_MENTION_IDS, { valueString: id }));
-    extensions.push(extension(SYMPTOM_CASE_EXT.RECURRENCE_COUNT, { valueInteger: condition.recurrenceCount }));
-    if (condition.reactivatedAt) extensions.push(extension(SYMPTOM_CASE_EXT.REACTIVATED_AT, { valueDateTime: toIso(condition.reactivatedAt) }));
-    if (condition.lastTransitionReason) payload.note = [{ text: condition.lastTransitionReason }];
-    const evidence = [
-      ...condition.evidenceEpisodeIds.map((id) => ({ reference: reference('Observation', id) })),
-      ...condition.evidenceMentionIds.map((id) => ({ reference: reference('Observation', id) })),
-    ];
-    if (evidence.length) payload.evidence = evidence;
-    if (headAssessmentId) {
-      payload.stage = [{ assessment: [reference('ClinicalImpression', headAssessmentId)] }];
-    }
-    return new Condition(payload);
-  }
-
   static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
     const assertion = fact.assertion;
     const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
@@ -137,4 +53,4 @@ class Condition {
   }
 }
 
-module.exports = { Condition, RESOLUTION_CLOSE_REASONS };
+module.exports = { Condition };

package/lib/fhir/resources/Observation.js

@@ -1,7 +1,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 { observationCategory } = require('../helpers/resourceHelper');
 const { GRADE_EXT } = require('../constants/extensionSlugs');
 
 const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
@@ -74,31 +74,6 @@ class Observation {
     return new Observation(payload);
   }
 
-  static fromSymptomGrade({ assessment }) {
-    const grade = assessment.grade;
-    const gradeId = `${assessment.assessmentId}-grade`;
-    const extensions = [];
-    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),
-      identifier: [identifier(SYMPTOM_GRADE_SLUG, gradeId)],
-      status: 'final',
-      category: [observationCategory('survey')],
-      code: codeableConcept('CTCAE severity grade'),
-      subject: patientReference(assessment.patientId),
-      performer: [patientReference(assessment.patientId)],
-      effectiveDateTime: toIso(assessment.performedAt),
-    };
-    if (grade.bestEstimate !== null) payload.valueInteger = grade.bestEstimate;
-    if (extensions.length) payload.extension = extensions;
-    return new Observation(payload);
-  }
-
   static fromResultObservation({ patientId, obsId, code, value, unit, category, effective, now, slug }) {
     const payload = {
       resourceType: 'Observation',
@@ -120,11 +95,6 @@ class Observation {
   }
 }
 
-function observationCategory(code) {
-  const label = code.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
-  return codeableConcept(label, { code, system: getSystems().observationCategory, display: label });
-}
-
 function observedFieldComponents(observedFields) {
   const components = [];
   for (const [key, raw] of Object.entries(observedFields || {})) {

package/lib/fhir/services/symptomCaseService.js

@@ -1,137 +1,27 @@
-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 { SYMPTOM_ASSESSMENT_SLUG, SYMPTOM_GRADE_SLUG } = require('../constants/projectionSlugs');
 const { getFhirStore } = require('../stores/fhirStore');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
+const { toFhir, fromFhir } = require('../projections/symptomCaseProjection');
+const { storeResources } = require('./fhirService');
 
 async function storeSymptomCase({ patientId, managedSymptom }) {
   if (managedSymptom.condition.patientId !== patientId) {
     throw new Error(`storeSymptomCase patientId mismatch: expected ${patientId}`);
   }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: managedSymptom }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
+  const { stored } = await storeResources(toFhir(managedSymptom));
   return { count: stored.length, ids: stored };
 }
 
 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_EXT.STATUS in extMap(condition) && identifierValue(condition, SYMPTOM_CASE_SLUG));
-  const cases = [];
-  for (const condition of conditions) {
-    let managed;
-    try {
-      managed = new ManagedSymptom(await reconstructSymptomCase(condition, patientId, store));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ conditionId: condition.id }, 'skipping malformed symptom-case Condition');
-        continue;
-      }
-      throw error;
-    }
-    if (status && managed.condition.clinicalStatus !== status) continue;
-    cases.push(managed);
-  }
-  return cases;
-}
-
-async function reconstructSymptomCase(condition, patientId, store) {
-  const conditionId = identifierValue(condition, SYMPTOM_CASE_SLUG);
-  const chain = await readAssessmentChain(condition, { patientId, conditionId }, store);
-  const [latestAssessment, ...priorAssessments] = chain;
-  return {
-    condition: reconstructCondition(condition, patientId, conditionId),
-    latestAssessment,
-    priorAssessments,
-  };
-}
-
-function reconstructCondition(condition, patientId, conditionId) {
-  const ext = extMap(condition);
-  const code = condition.code || {};
-  const coding = (code.coding && code.coding[0]) || {};
-  return {
-    conditionId,
-    patientId,
-    ctcaeTerm: coding.code || code.text || null,
-    clinicalStatus: ext[SYMPTOM_CASE_EXT.STATUS],
-    onsetAt: condition.onsetDateTime,
-    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_CASE_EXT.RECURRENCE_COUNT] ?? 0,
-    reactivatedAt: ext[SYMPTOM_CASE_EXT.REACTIVATED_AT] || null,
-  };
-}
-
-async function readAssessmentChain(condition, ids, store) {
-  const headRef = condition.stage && condition.stage[0] && condition.stage[0].assessment
-    && condition.stage[0].assessment[0] && condition.stage[0].assessment[0].reference;
-  const impressions = [];
-  const seen = new Set();
-  let ref = headRef;
-  while (ref && !seen.has(ref)) {
-    seen.add(ref);
-    const impression = await store.getByReference(ref);
-    if (!impression) break;
-    impressions.push(impression);
-    ref = impression.previous && impression.previous.reference;
-  }
-  const chain = [];
-  for (let i = 0; i < impressions.length; i++) {
-    const previousId = impressions[i + 1] ? identifierValue(impressions[i + 1], SYMPTOM_ASSESSMENT_SLUG) : null;
-    chain.push(await reconstructAssessment(impressions[i], { ...ids, previousId }, store));
-  }
-  return chain;
-}
-
-async function reconstructAssessment(impression, { patientId, conditionId, previousId }, store) {
-  const ext = extMap(impression);
-  const findingRef = impression.finding && impression.finding[0] && impression.finding[0].item
-    && impression.finding[0].item.reference && impression.finding[0].item.reference.reference;
-  const gradeObs = findingRef ? await store.getByReference(findingRef) : null;
-  const gradeExt = extMap(gradeObs || {});
-  return {
-    assessmentId: identifierValue(impression, SYMPTOM_ASSESSMENT_SLUG),
-    conditionId,
-    patientId,
-    performedAt: impression.effectiveDateTime,
-    previousId,
-    grade: reconstructGrade(gradeObs),
-    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_EXT.THRESHOLD_CLAUSE] || null,
-  };
-}
-
-function reconstructGrade(obs) {
-  const grade = { bestEstimate: null, confidence: null, possibleRange: null, reasoning: '' };
-  if (!obs) return grade;
-  const ext = extMap(obs);
-  if (typeof obs.valueInteger === 'number') grade.bestEstimate = obs.valueInteger;
-  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_EXT.REASONING]) grade.reasoning = ext[GRADE_EXT.REASONING];
-  return grade;
+  const [conditions, impressions, grades] = await Promise.all([
+    store.find({ patient, resourceType: 'Condition', symptomTerm: ctcaeTerm }),
+    store.find({ patient, resourceType: 'ClinicalImpression', identifierSlug: SYMPTOM_ASSESSMENT_SLUG }),
+    store.find({ patient, resourceType: 'Observation', identifierSlug: SYMPTOM_GRADE_SLUG }),
+  ]);
+  return fromFhir([...conditions, ...impressions, ...grades], { patientId })
+    .filter((managed) => !status || managed.condition.clinicalStatus === status);
 }
 
 module.exports = {

package/lib/fhir/stores/fhirStore.js

@@ -82,10 +82,11 @@ class FhirStore {
     return envelope ? envelope.resource : null;
   }
 
-  async find({ patient = null, resourceType = null, symptomTerm = null } = {}) {
+  async find({ patient = null, resourceType = null, symptomTerm = null, identifierSlug = null } = {}) {
     const query = { 'meta.deleted': false };
     if (patient) query['index.patient'] = patient;
     if (symptomTerm) query['index.symptomTerm'] = symptomTerm;
+    if (identifierSlug) query['resource.identifier.system'] = identifierSystem(identifierSlug);
     if (resourceType) {
       const model = await this._modelFor(resourceType);
       const envelopes = await model.find(query, null, { sort: NEWEST_FIRST }).lean();

package/lib/shared/dtos/ManagedSymptom.js

@@ -8,6 +8,9 @@ const OPEN_STATUSES = ['characterizing', 'monitoring'];
 const CLOSED_STATUSES = ['resolved', 'inactive', 'closed'];
 const CLINICAL_STATUSES = [...OPEN_STATUSES, ...CLOSED_STATUSES];
 const GRADE_CONFIDENCE_LEVELS = ['low', 'moderate', 'high'];
+const RESOLUTION_CLOSE_REASONS = new Set([
+  'resolved', 'team_resolved', 'resolved_spontaneously', 'resolved_by_intervention',
+]);
 
 const gradeEstimateSchema = z.strictObject({
   bestEstimate: z.number().int().min(1).max(5).nullable().default(null),
@@ -82,4 +85,5 @@ module.exports = {
   CLINICAL_STATUSES,
   OPEN_STATUSES,
   CLOSED_STATUSES,
+  RESOLUTION_CLOSE_REASONS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "5.13.0-dev.1145",
+  "version": "5.13.0-dev.1148",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",