@peopl-health/nexus 5.12.2 → 5.12.4

package/lib/fhir/constants/extensionSlugs.js

@@ -25,6 +25,18 @@ const GRADE_EXT = {
   THRESHOLD_CLAUSE: 'grade-threshold-clause',
 };
 
+const MENTION_EXT = {
+  ASSERTION_NEGATED: 'mention-assertion-negated',
+  ASSERTION_HEDGED: 'mention-assertion-hedged',
+  ASSERTION_EXPERIENCER: 'mention-assertion-experiencer',
+  ASSERTION_TEMPORAL: 'mention-assertion-temporal',
+  ASSERTION_CONFIDENCE: 'mention-assertion-confidence',
+  TEMPORALITY: 'mention-temporality',
+  TURN_ID: 'mention-turn-id',
+  SOURCE: 'mention-source',
+  EXTRACTOR_CONFIDENCE: 'mention-extractor-confidence',
+};
+
 const ROUTING_EXT = {
   TURN_ID: 'routing-turn-id',
   DECISION_ID: 'routing-decision-id',
@@ -35,6 +47,7 @@ const ROUTING_EXT = {
   FINDING_CASE_ID: 'routing-finding-case-id',
   FINDING_REASONING: 'routing-finding-reasoning',
   FINDING_ACTION: 'routing-finding-action',
+  PREVIOUS_ID: 'routing-previous-id',
 };
 
 const CLUSTER_EXT = {
@@ -46,6 +59,7 @@ const CLUSTER_EXT = {
   STATUS: 'cluster-status',
   CONSULTATION_ID: 'cluster-consultation-id',
   DISSOLVE_REASON: 'cluster-dissolve-reason',
+  MEMBER_CASE_ID: 'cluster-member-case-id',
 };
 
 const PALLIATIVE_EXT = {
@@ -87,6 +101,7 @@ const RISK_EXT = {
 
 module.exports = {
   SYMPTOM_CASE_EXT,
+  MENTION_EXT,
   ASSESSMENT_EXT,
   GRADE_EXT,
   ROUTING_EXT,

package/lib/fhir/helpers/elementHelper.js

@@ -34,6 +34,10 @@ function notes(...texts) {
   return present.length ? present : null;
 }
 
+function toInstant(value) {
+  return new Date(value).toISOString();
+}
+
 function toIso(value) {
   if (value instanceof Date) return value.toISOString().replace(/\.000Z$/, 'Z');
   const s = String(value);
@@ -50,5 +54,6 @@ module.exports = {
   codeableConcept,
   extension,
   notes,
+  toInstant,
   toIso,
 };

package/lib/fhir/helpers/fhirReadHelper.js

@@ -34,9 +34,20 @@ function extValues(resource, name) {
   return values;
 }
 
+function referencedId(node, slug, reference) {
+  return extValues(node, slug)[0] || refToId(reference);
+}
+
+function referencedIds(node, slug, references) {
+  const values = extValues(node, slug);
+  return values.length ? values : references.map(refToId).filter(Boolean);
+}
+
 module.exports = {
   extMap,
   identifierValue,
   refToId,
   extValues,
+  referencedId,
+  referencedIds,
 };

package/lib/fhir/helpers/resourceHelper.js

@@ -2,12 +2,12 @@ const { getDeviceId, getOrganizationId, getSystems } = require('../config/fhirCo
 const { fhirId } = require('./fhirHelper');
 const { identifier, patientReference, reference, codeableConcept, toIso } = require('./elementHelper');
 
-function baseResource(resourceType, id, slug, patientId) {
+function baseResource(resourceType, id, slug, patientId = null) {
   return {
     resourceType,
     id: fhirId(id),
     identifier: [identifier(slug, id)],
-    subject: patientReference(patientId),
+    ...(patientId ? { subject: patientReference(patientId) } : {}),
   };
 }
 
@@ -25,6 +25,11 @@ function provenance({ provenanceId, targetRefs, recordedAt, activity, agentDevic
   };
 }
 
+function problemListCategory() {
+  const code = 'problem-list-item';
+  return codeableConcept(code, { code, system: getSystems().conditionCategory });
+}
+
 function observationCategory(code) {
   const label = code.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
   return codeableConcept(label, { code, system: getSystems().observationCategory, display: label });
@@ -33,5 +38,6 @@ function observationCategory(code) {
 module.exports = {
   baseResource,
   provenance,
+  problemListCategory,
   observationCategory,
 };

package/lib/fhir/projections/clinicalMentionProjection.js

@@ -1,65 +1,195 @@
-const { getSystems } = require('../config/fhirConfig');
-const { codeableConcept, extension } = require('../helpers/elementHelper');
+const { getDeviceId, getOrganizationId, getSystems } = require('../config/fhirConfig');
+const { stringifyValue } = require('../utils/normalizeUtils');
+const { fhirId } = require('../helpers/fhirHelper');
+const { reference, patientReference, codeableConcept, extension, toInstant } = require('../helpers/elementHelper');
+const { baseResource, problemListCategory, observationCategory } = require('../helpers/resourceHelper');
 const { MENTION_SLUG } = require('../constants/projectionSlugs');
-const { Observation } = require('../resources/Observation');
-const { Condition } = require('../resources/Condition');
-const { MedicationStatement } = require('../resources/MedicationStatement');
-const { Procedure } = require('../resources/Procedure');
-const { Appointment } = require('../resources/Appointment');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'clinicalMention';
+const { MENTION_EXT } = require('../constants/extensionSlugs');
+
 const ACTIVITY_TEXT = 'clinical-mention-extraction';
+const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
 
 const DEDICATED_AGGREGATE = new Set(['comorbidity', 'allergy', 'performance_status']);
 
-function projectClinicalMention(mention) {
-  const { fact, provenance } = mention;
+const CATEGORY_TO_OBSERVATION_CATEGORY = {
+  symptom: 'survey',
+  lab_value: 'laboratory',
+  emotion: 'survey',
+  indication: 'exam',
+  diagnosis: 'exam',
+};
+
+const DIAGNOSIS_CATEGORIES = new Set(['diagnosis', 'indication']);
 
+function toFhir(mention) {
+  const { fact, provenance } = mention;
   if (DEDICATED_AGGREGATE.has(fact.category)) return [];
+  const primary = primaryResource(mention);
+  return [primary, mentionProvenance(primary, provenance)];
+}
 
-  const assertion = fact.assertion;
-  const extensions = [
-    extension('mention-assertion-negated', { valueBoolean: assertion.negated }),
-    extension('mention-assertion-hedged', { valueBoolean: assertion.hedged }),
-    extension('mention-assertion-experiencer', { valueString: assertion.experiencer }),
-    extension('mention-assertion-temporal', { valueString: assertion.temporal }),
-    extension('mention-assertion-confidence', { valueDecimal: assertion.confidence }),
-  ];
-  if (fact.temporality) {
-    extensions.push(extension('mention-temporality', { valueString: fact.temporality }));
-  }
+const BUILDER_BY_CATEGORY = {
+  medication: medicationStatementResource,
+  adherence: medicationStatementResource,
+  treatment: procedureResource,
+  appointment: appointmentResource,
+};
+
+function primaryResource(mention) {
+  const { fact } = mention;
+  const build = BUILDER_BY_CATEGORY[fact.category];
+  if (build) return build(mention);
+  const currentAffirmedDiagnosis = DIAGNOSIS_CATEGORIES.has(fact.category)
+    && fact.assertion.temporal === 'current'
+    && !fact.assertion.negated;
+  return currentAffirmedDiagnosis ? conditionResource(mention) : observationResource(mention);
+}
 
-  const code = fact.ctcaeTerm
+function mentionCode(fact) {
+  return fact.ctcaeTerm
     ? codeableConcept(fact.canonicalTerm, { code: fact.ctcaeTerm, system: getSystems().ctcae, display: fact.ctcaeTerm })
     : codeableConcept(fact.canonicalTerm);
-  const primary = primaryResource({ fact, provenance, code, extensions });
-  return [primary, Provenance.fromMentionProjection({ target: primary, provenance, activityText: ACTIVITY_TEXT })];
 }
 
-function primaryResource({ fact, provenance, code, extensions }) {
-  const assertion = fact.assertion;
-  const args = { fact, provenance, code, extensions, slug: MENTION_SLUG };
-  if (fact.category === 'medication' || fact.category === 'adherence') {
-    return MedicationStatement.fromMentionProjection(args);
-  }
-  if (fact.category === 'treatment') {
-    return Procedure.fromMentionProjection(args);
+function mentionExtensions(fact) {
+  const { assertion } = fact;
+  const out = [
+    extension(MENTION_EXT.ASSERTION_NEGATED, { valueBoolean: assertion.negated }),
+    extension(MENTION_EXT.ASSERTION_HEDGED, { valueBoolean: assertion.hedged }),
+    extension(MENTION_EXT.ASSERTION_EXPERIENCER, { valueString: assertion.experiencer }),
+    extension(MENTION_EXT.ASSERTION_TEMPORAL, { valueString: assertion.temporal }),
+    extension(MENTION_EXT.ASSERTION_CONFIDENCE, { valueDecimal: assertion.confidence }),
+  ];
+  if (fact.temporality) out.push(extension(MENTION_EXT.TEMPORALITY, { valueString: fact.temporality }));
+  return out;
+}
+
+const quoteNotes = (provenance) => {
+  const quotes = provenance.verbatimQuotes || [];
+  return quotes.length ? quotes.map((text) => ({ text })) : null;
+};
+
+function observationResource({ fact, provenance }) {
+  const categoryCode = CATEGORY_TO_OBSERVATION_CATEGORY[fact.category] || 'exam';
+  const payload = {
+    ...baseResource('Observation', fact.mentionId, MENTION_SLUG, fact.patientId),
+    status: 'preliminary',
+    category: [observationCategory(categoryCode)],
+    code: mentionCode(fact),
+    performer: [patientReference(fact.patientId)],
+    effectiveDateTime: toInstant(fact.reportedAt),
+    issued: toInstant(provenance.recordedAt),
+    extension: mentionExtensions(fact),
+  };
+  if (fact.assertion.negated) {
+    payload.interpretation = [codeableConcept('Negative', { code: 'NEG', system: getSystems().observationInterpretation, display: 'Negative' })];
+    payload.valueCodeableConcept = codeableConcept('Ausente (negado por el paciente)');
   }
-  if (fact.category === 'appointment') {
-    return Appointment.fromMentionProjection(args);
+  const quotes = quoteNotes(provenance);
+  const components = observedFieldComponents(fact.observedFields);
+  if (quotes) payload.note = quotes;
+  if (components.length) payload.component = components;
+  return payload;
+}
+
+function conditionResource({ fact, provenance }) {
+  const systems = getSystems();
+  const verification = fact.assertion.hedged ? 'unconfirmed' : 'provisional';
+  const payload = {
+    ...baseResource('Condition', fact.mentionId, MENTION_SLUG, fact.patientId),
+    clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
+    verificationStatus: codeableConcept(verification, { code: verification, system: systems.conditionVerStatus }),
+    category: [problemListCategory()],
+    code: mentionCode(fact),
+    recordedDate: toInstant(provenance.recordedAt),
+    extension: mentionExtensions(fact),
+  };
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function medicationStatementResource({ fact, provenance }) {
+  const payload = {
+    ...baseResource('MedicationStatement', fact.mentionId, MENTION_SLUG, fact.patientId),
+    status: 'recorded',
+    medication: { concept: mentionCode(fact) },
+    effectiveDateTime: toInstant(fact.reportedAt),
+    extension: mentionExtensions(fact),
+  };
+  const adherence = adherenceFor(fact.assertion);
+  if (adherence) {
+    payload.adherence = {
+      code: codeableConcept(adherence, { code: adherence, system: getSystems().medicationStatementAdherence }),
+    };
   }
-  const currentAffirmedDiagnosis =
-    (fact.category === 'diagnosis' || fact.category === 'indication') &&
-    assertion.temporal === 'current' &&
-    !assertion.negated;
-  if (currentAffirmedDiagnosis) {
-    return Condition.fromMentionProjection(args);
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function adherenceFor(assertion) {
+  if (assertion.negated) return 'not-taking';
+  if (assertion.temporal === 'historical') return 'stopped';
+  return null;
+}
+
+function procedureResource({ fact, provenance }) {
+  const payload = {
+    ...baseResource('Procedure', fact.mentionId, MENTION_SLUG, fact.patientId),
+    status: fact.assertion.negated ? 'not-done' : 'completed',
+    code: mentionCode(fact),
+    occurrenceDateTime: toInstant(fact.reportedAt),
+    recorder: patientReference(fact.patientId),
+    extension: mentionExtensions(fact),
+  };
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function appointmentResource({ fact, provenance }) {
+  const payload = {
+    ...baseResource('Appointment', fact.mentionId, MENTION_SLUG),
+    status: fact.assertion.negated ? 'cancelled' : 'proposed',
+    description: fact.canonicalTerm,
+    participant: [{ actor: patientReference(fact.patientId), status: 'accepted' }],
+    extension: mentionExtensions(fact),
+  };
+  const quotes = quoteNotes(provenance);
+  if (quotes) payload.note = quotes;
+  return payload;
+}
+
+function mentionProvenance(target, provenance) {
+  return {
+    resourceType: 'Provenance',
+    id: fhirId(`${provenance.mentionId}-prov`),
+    target: [reference(target.resourceType, target.id)],
+    recorded: toInstant(provenance.recordedAt),
+    agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
+    activity: codeableConcept(ACTIVITY_TEXT),
+    extension: [
+      extension(MENTION_EXT.TURN_ID, { valueString: provenance.turnId }),
+      extension(MENTION_EXT.SOURCE, { valueString: provenance.source }),
+      extension(MENTION_EXT.EXTRACTOR_CONFIDENCE, { valueDecimal: provenance.extractorConfidence }),
+    ],
+  };
+}
+
+function observedFieldComponents(observedFields) {
+  const components = [];
+  for (const [key, raw] of Object.entries(observedFields || {})) {
+    const text = stringifyValue(raw);
+    if (!text) continue;
+    components.push({
+      code: codeableConcept(key, { code: key, system: getSystems()[OBSERVED_FIELD_SYSTEM_KEY] }),
+      valueString: text,
+    });
   }
-  return Observation.fromMentionProjection(args);
+  return components;
 }
 
 module.exports = {
-  projectClinicalMention,
-  PROJECTOR_NAME,
+  toFhir,
 };

package/lib/fhir/projections/clusterProjection.js

@@ -3,7 +3,7 @@ const { ZodError } = require('zod');
 const { codeSystemUrl } = require('../helpers/fhirHelper');
 const { identifier, reference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { baseResource, provenance } = require('../helpers/resourceHelper');
-const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
+const { extMap, identifierValue, referencedIds } = require('../helpers/fhirReadHelper');
 const { CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG } = require('../constants/projectionSlugs');
 const { CLUSTER_EXT } = require('../constants/extensionSlugs');
 const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
@@ -54,6 +54,7 @@ function clusterExtensions(cluster) {
   if (cluster.weakensIf.length) {
     out.push(extension(CLUSTER_EXT.WEAKENS_IF, { valueString: cluster.weakensIf.join(LIST_SEPARATOR) }));
   }
+  for (const caseId of cluster.memberCaseIds) out.push(extension(CLUSTER_EXT.MEMBER_CASE_ID, { valueString: caseId }));
   out.push(extension(CLUSTER_EXT.STATUS, { valueString: cluster.status }));
   if (cluster.consultationId) out.push(extension(CLUSTER_EXT.CONSULTATION_ID, { valueString: cluster.consultationId }));
   if (cluster.dissolveReason) out.push(extension(CLUSTER_EXT.DISSOLVE_REASON, { valueString: cluster.dissolveReason }));
@@ -104,7 +105,7 @@ function reconstruct(resource, patientId) {
     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),
+    memberCaseIds: referencedIds(resource, CLUSTER_EXT.MEMBER_CASE_ID, (resource.problem || []).map((p) => p.reference)),
     consultationId: ext[CLUSTER_EXT.CONSULTATION_ID] || null,
     relationshipModel: resource.summary || '',
     strengthensIf: splitList(ext[CLUSTER_EXT.STRENGTHENS_IF]),

package/lib/fhir/projections/contingencyProjection.js

@@ -4,7 +4,7 @@ const { getOrganizationId } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
 const { patientReference, reference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { baseResource, provenance } = require('../helpers/resourceHelper');
-const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
+const { extMap, identifierValue, referencedId } = require('../helpers/fhirReadHelper');
 const { CONTINGENCY_PLAN_SLUG, CONTINGENCY_STEP_SLUG } = require('../constants/projectionSlugs');
 const { ContingencySafetyNet } = require('../../shared/dtos/ContingencySafetyNet');
 const { logger } = require('../../utils/logger');
@@ -18,6 +18,8 @@ const EXT = {
   WHY_THIS_MATTERS: 'contingency-why-this-matters',
   CREATION_REASONING: 'contingency-creation-reasoning',
   RESOLVED_REASON: 'contingency-resolved-reason',
+  RELATED_CASE_ID: 'contingency-related-case-id',
+  RELATED_CLUSTER_ID: 'contingency-related-cluster-id',
   STEP_PRIORITY: 'contingency-step-priority',
   ACTION_REQUESTED: 'contingency-action-requested',
   FIRES_AFTER_SILENCE_MINUTES: 'fires-after-silence-minutes',
@@ -89,6 +91,8 @@ function carePlanPeriod(carePlan) {
 
 function carePlanExtensions(carePlan) {
   const out = [extension(EXT.STATUS, { valueString: carePlan.status })];
+  if (carePlan.relatedCaseId) out.push(extension(EXT.RELATED_CASE_ID, { valueString: carePlan.relatedCaseId }));
+  if (carePlan.relatedClusterId) out.push(extension(EXT.RELATED_CLUSTER_ID, { valueString: carePlan.relatedClusterId }));
   if (carePlan.awaitingCharacterization) out.push(extension(EXT.AWAITING_CHARACTERIZATION, { valueString: carePlan.awaitingCharacterization }));
   if (carePlan.whyThisMatters) out.push(extension(EXT.WHY_THIS_MATTERS, { valueString: carePlan.whyThisMatters }));
   if (carePlan.creationReasoning) out.push(extension(EXT.CREATION_REASONING, { valueString: carePlan.creationReasoning }));
@@ -148,8 +152,8 @@ function reconstruct(plan, requests, patientId) {
     carePlan: {
       planId,
       patientId,
-      relatedCaseId: refToId(address && address.reference),
-      relatedClusterId: refToId(plan.supportingInfo && plan.supportingInfo[0] && plan.supportingInfo[0].reference),
+      relatedCaseId: referencedId(plan, EXT.RELATED_CASE_ID, address?.reference),
+      relatedClusterId: referencedId(plan, EXT.RELATED_CLUSTER_ID, plan.supportingInfo?.[0]?.reference),
       concern: plan.description || '',
       awaitingCharacterization: ext[EXT.AWAITING_CHARACTERIZATION] || '',
       whyThisMatters: ext[EXT.WHY_THIS_MATTERS] || '',

package/lib/fhir/projections/interventionProjection.js

@@ -2,9 +2,9 @@ const { ZodError } = require('zod');
 
 const { getDeviceId } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const { identifier, patientReference, reference, recipientReference, codeableConcept, extension, notes, toIso } = require('../helpers/elementHelper');
+const { patientReference, reference, recipientReference, codeableConcept, extension, notes, toIso } = require('../helpers/elementHelper');
 const { baseResource, provenance } = require('../helpers/resourceHelper');
-const { identifierValue, refToId, extValues } = require('../helpers/fhirReadHelper');
+const { identifierValue, refToId, extValues, referencedId } = require('../helpers/fhirReadHelper');
 const { INTERVENTION_SLUG, INTERVENTION_KIND_SLUG, INTERVENTION_OUTCOME_SLUG } = require('../constants/projectionSlugs');
 const { Intervention } = require('../../shared/dtos/Intervention');
 const { logger } = require('../../utils/logger');
@@ -13,6 +13,7 @@ const ACTIVITY_TEXT = 'intervention-record';
 const PROCEDURE_KINDS = new Set(['otc', 'self_care', 'other']);
 
 const EXT = {
+  CASE_ID: 'intervention-case-id',
   RATIONALE: 'intervention-rationale',
   OUTCOME_NOTES: 'intervention-outcome-notes',
   OUTCOME: 'intervention-outcome',
@@ -78,9 +79,7 @@ function communicationResource(intervention) {
 
 function taskResource(intervention) {
   const payload = withNote({
-    resourceType: 'Task',
-    id: fhirId(intervention.interventionId),
-    identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
+    ...baseResource('Task', intervention.interventionId, INTERVENTION_SLUG),
     status: intervention.outcome === 'pending' ? 'requested' : 'completed',
     intent: 'order',
     code: codeableConcept(intervention.interventionLabel, {
@@ -122,6 +121,7 @@ function communicationRequestResource(intervention) {
 
 function interventionExtensions(intervention, { withRecipient = false } = {}) {
   const out = [];
+  if (intervention.caseId) out.push(extension(EXT.CASE_ID, { valueString: intervention.caseId }));
   if (intervention.rationale) out.push(extension(EXT.RATIONALE, { valueString: intervention.rationale }));
   if (intervention.outcomeNotes) out.push(extension(EXT.OUTCOME_NOTES, { valueString: intervention.outcomeNotes }));
   if (intervention.outcome) out.push(extension(EXT.OUTCOME, { valueString: intervention.outcome }));
@@ -144,7 +144,7 @@ function reconstruct(resource, patientId) {
   const base = {
     interventionId: identifierValue(resource, INTERVENTION_SLUG),
     patientId,
-    caseId: refToId(reasonRef && reasonRef.reference),
+    caseId: referencedId(resource, EXT.CASE_ID, reasonRef?.reference),
     rationale: extValues(resource, EXT.RATIONALE)[0] ?? null,
     outcomeNotes: extValues(resource, EXT.OUTCOME_NOTES)[0] ?? null,
     outcomeExt: extValues(resource, EXT.OUTCOME)[0] ?? null,

package/lib/fhir/projections/registerProjectors.js

@@ -1,5 +1,4 @@
 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 { projectPatientRisk, PROJECTOR_NAME: RISK_PROJECTOR_NAME } = require('./riskProjection');
@@ -9,7 +8,6 @@ const { projectPalliativeAssessment, PROJECTOR_NAME: PALLIATIVE_PROJECTOR_NAME }
 const { projectPalliativeCarePlan, PROJECTOR_NAME: PALLIATIVE_CAREPLAN_PROJECTOR_NAME } = require('./palliativeCarePlanProjection');
 
 const PROJECTORS = [
-  { name: MENTION_PROJECTOR_NAME, project: projectClinicalMention },
   { name: ESCALATION_PROJECTOR_NAME, project: projectDispatchedEscalation },
   { name: REMINDER_PROJECTOR_NAME, project: projectReminder },
   { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },

package/lib/fhir/projections/routingProjection.js

@@ -3,7 +3,7 @@ const { ZodError } = require('zod');
 const { getDeviceId } = require('../config/fhirConfig');
 const { reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { baseResource, provenance } = require('../helpers/resourceHelper');
-const { extMap, extValues, identifierValue, refToId } = require('../helpers/fhirReadHelper');
+const { extMap, extValues, identifierValue, refToId, referencedId } = require('../helpers/fhirReadHelper');
 const { ROUTING_ASSESSMENT_SLUG, ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
 const { ROUTING_EXT } = require('../constants/extensionSlugs');
 const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
@@ -53,20 +53,17 @@ const DISPOSITION_CODECS = {
   },
   task: {
     resourceType: 'Task',
-    build: (d) => {
-      const { subject, ...rest } = dispositionBase('Task', d);
-      return {
-        ...rest,
-        status: 'requested',
-        intent: 'order',
-        code: codeableConcept(d.primaryAction),
-        description: d.primaryReason,
-        for: subject,
-        authoredOn: toIso(d.authoredAt),
-        requester: reference('Device', getDeviceId()),
-        ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
-      };
-    },
+    build: (d) => ({
+      ...baseResource('Task', d.dispositionId, ROUTING_DISPOSITION_SLUG),
+      status: 'requested',
+      intent: 'order',
+      code: codeableConcept(d.primaryAction),
+      description: d.primaryReason,
+      for: patientReference(d.patientId),
+      authoredOn: toIso(d.authoredAt),
+      requester: reference('Device', getDeviceId()),
+      ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
+    }),
     actionOf: (r) => ccText(r.code),
     reasonOf: (r) => r.description,
     authoredOf: (r) => r.authoredOn,
@@ -171,6 +168,7 @@ function assessmentExtensions(assessment, { decisionId, committedAt, disposition
   if (disposition.primaryCaseId) {
     out.push(extension(ROUTING_EXT.PRIMARY_CASE_ID, { valueString: disposition.primaryCaseId }));
   }
+  if (assessment.previousId) out.push(extension(ROUTING_EXT.PREVIOUS_ID, { valueString: assessment.previousId }));
   for (const deferred of disposition.deferredItems) {
     out.push(
       extension(ROUTING_EXT.DEFERRED_ITEM, { valueString: deferred.item }),
@@ -240,13 +238,13 @@ function reconstructAssessment(resource, patientId, turnId) {
     patientId,
     turnId,
     performedAt: resource.effectiveDateTime,
-    previousId: refToId(resource.previous?.reference),
+    previousId: referencedId(resource, ROUTING_EXT.PREVIOUS_ID, resource.previous?.reference),
     summary: resource.summary || '',
     notes: (resource.note || []).map((note) => note.text),
     findings: (resource.finding || []).map((finding) => {
       const findingExt = extMap(finding);
       return {
-        caseId: findingExt[ROUTING_EXT.FINDING_CASE_ID] || refToId(finding.item?.reference),
+        caseId: referencedId(finding, ROUTING_EXT.FINDING_CASE_ID, finding.item?.reference),
         clinicalReasoning: findingExt[ROUTING_EXT.FINDING_REASONING] || '',
         decisionAction: findingExt[ROUTING_EXT.FINDING_ACTION] || '',
       };

package/lib/fhir/projections/symptomCaseProjection.js

@@ -3,7 +3,7 @@ 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 { baseResource, provenance, problemListCategory, 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');
@@ -76,7 +76,7 @@ function conditionResource(condition, verification, headAssessmentId) {
     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 }),
+      problemListCategory(),
       codeableConcept('PRO-CTCAE patient-reported symptom (agent-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
     ],
     code,

package/lib/fhir/resources/Condition.js

@@ -1,35 +1,13 @@
 const { getSystems } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
+const { problemListCategory } = require('../helpers/resourceHelper');
 
 class Condition {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const verification = assertion.hedged ? 'unconfirmed' : 'provisional';
-    const systems = getSystems();
-    const payload = {
-      resourceType: 'Condition',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
-      verificationStatus: codeableConcept(verification, { code: verification, system: systems.conditionVerStatus }),
-      category: [codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory })],
-      code,
-      subject: patientReference(fact.patientId),
-      recordedDate: new Date(provenance.recordedAt).toISOString(),
-      extension: extensions,
-    };
-    if (notes) payload.note = notes;
-    return new Condition(payload);
-  }
-
   static fromTriageProjection({ sym, code }) {
     const caseId = `${sym.patientId}-${sym.term}`;
     const systems = getSystems();
@@ -40,7 +18,7 @@ class Condition {
       clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
       verificationStatus: codeableConcept('provisional', { code: 'provisional', system: systems.conditionVerStatus }),
       category: [
-        codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
+        problemListCategory(),
         codeableConcept('PRO-CTCAE patient-reported symptom (triage-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
       ],
       code,

package/lib/fhir/resources/Observation.js

@@ -1,53 +1,13 @@
-const { getSystems } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { observationCategory } = require('../helpers/resourceHelper');
 const { GRADE_EXT } = require('../constants/extensionSlugs');
 
-const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
-
-const CATEGORY_TO_OBSERVATION_CATEGORY = {
-  symptom: 'survey',
-  lab_value: 'laboratory',
-  emotion: 'survey',
-  indication: 'exam',
-  diagnosis: 'exam',
-};
-
 class Observation {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const categoryCode = CATEGORY_TO_OBSERVATION_CATEGORY[fact.category] || 'exam';
-    const payload = {
-      resourceType: 'Observation',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: 'preliminary',
-      category: [observationCategory(categoryCode)],
-      code,
-      subject: patientReference(fact.patientId),
-      performer: [patientReference(fact.patientId)],
-      effectiveDateTime: new Date(fact.reportedAt).toISOString(),
-      issued: new Date(provenance.recordedAt).toISOString(),
-      extension: extensions,
-    };
-    if (assertion.negated) {
-      payload.interpretation = [codeableConcept('Negative', { code: 'NEG', system: getSystems().observationInterpretation, display: 'Negative' })];
-      payload.valueCodeableConcept = codeableConcept('Ausente (negado por el paciente)');
-    }
-    if (notes) payload.note = notes;
-    const components = observedFieldComponents(fact.observedFields);
-    if (components.length) payload.component = components;
-    return new Observation(payload);
-  }
-
   static fromTriageProjection({ sym, code, aeCategoryConcept, components, gradeConcept, method, deviceId }) {
     const sid = String(sym.symptomId);
     const payload = {
@@ -95,28 +55,4 @@ class Observation {
   }
 }
 
-function observedFieldComponents(observedFields) {
-  const components = [];
-  for (const [key, raw] of Object.entries(observedFields || {})) {
-    const text = stringifyObserved(raw);
-    if (!text) continue;
-    components.push({
-      code: codeableConcept(key, { code: key, system: getSystems()[OBSERVED_FIELD_SYSTEM_KEY] }),
-      valueString: text,
-    });
-  }
-  return components;
-}
-
-function stringifyObserved(value) {
-  if (value === null || value === undefined) return '';
-  if (Array.isArray(value)) {
-    return value.filter((v) => v !== null && v !== undefined).map((v) => String(v).trim()).filter(Boolean).join('; ');
-  }
-  if (typeof value === 'object') {
-    return Object.entries(value).filter(([, v]) => v !== null && v !== undefined && String(v).trim()).map(([k, v]) => `${k}: ${v}`).join('; ');
-  }
-  return String(value).trim();
-}
-
 module.exports = { Observation };

package/lib/fhir/resources/Provenance.js

@@ -1,29 +1,12 @@
 const { getDeviceId, getOrganizationId } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
-const { extension, reference, codeableConcept, toIso } = require('../helpers/elementHelper');
+const { reference, codeableConcept, toIso } = require('../helpers/elementHelper');
 
 class Provenance {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromMentionProjection({ target, provenance, activityText }) {
-    const payload = {
-      resourceType: 'Provenance',
-      id: fhirId(`${provenance.mentionId}-prov`),
-      target: [{ reference: `${target.resourceType}/${target.id}` }],
-      recorded: new Date(provenance.recordedAt).toISOString(),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityText),
-      extension: [
-        extension('mention-turn-id', { valueString: provenance.turnId }),
-        extension('mention-source', { valueString: provenance.source }),
-        extension('mention-extractor-confidence', { valueDecimal: provenance.extractorConfidence }),
-      ],
-    };
-    return new Provenance(payload);
-  }
-
   static fromDispatchedEscalation({ target, recordedAt, activityText }) {
     return new Provenance({
       resourceType: 'Provenance',

package/lib/fhir/services/clinicalMentionService.js

@@ -1,5 +1,5 @@
-const { PROJECTOR_NAME } = require('../projections/clinicalMentionProjection');
-const { project, storeResources } = require('./fhirService');
+const { toFhir } = require('../projections/clinicalMentionProjection');
+const { storeResources } = require('./fhirService');
 
 async function storeClinicalMentions({ patientId, mentions }) {
   for (const mention of mentions) {
@@ -7,9 +7,7 @@ async function storeClinicalMentions({ patientId, mentions }) {
       throw new Error(`storeClinicalMentions patientId mismatch: expected ${patientId}`);
     }
   }
-  const bundle = project(mentions.map((mention) => ({ name: PROJECTOR_NAME, aggregate: mention })));
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
+  const { stored } = await storeResources(mentions.flatMap(toFhir));
   return { stored: stored.length, ids: stored, patientId };
 }
 

package/lib/fhir/utils/normalizeUtils.js

@@ -15,6 +15,17 @@ const parseList = (value) =>
     .map((entry) => entry.trim())
     .filter(Boolean);
 
+function stringifyValue(value) {
+  if (value === null || value === undefined) return '';
+  if (Array.isArray(value)) {
+    return value.filter((v) => v !== null && v !== undefined).map((v) => String(v).trim()).filter(Boolean).join('; ');
+  }
+  if (typeof value === 'object') {
+    return Object.entries(value).filter(([, v]) => v !== null && v !== undefined && String(v).trim()).map(([k, v]) => `${k}: ${v}`).join('; ');
+  }
+  return String(value).trim();
+}
+
 function termKey(name) {
   return String(name || '')
     .trim()
@@ -29,5 +40,6 @@ module.exports = {
   lookupValue,
   integerId,
   parseList,
+  stringifyValue,
   termKey,
 };

package/package.json

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

package/lib/fhir/resources/Appointment.js

@@ -1,28 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference } = require('../helpers/elementHelper');
-
-class Appointment {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromMentionProjection({ fact, provenance, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const payload = {
-      resourceType: 'Appointment',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: assertion.negated ? 'cancelled' : 'proposed',
-      description: fact.canonicalTerm,
-      participant: [{ actor: patientReference(fact.patientId), status: 'accepted' }],
-      extension: extensions,
-    };
-    if (notes) payload.note = notes;
-    return new Appointment(payload);
-  }
-}
-
-module.exports = { Appointment };

package/lib/fhir/resources/MedicationStatement.js

@@ -1,42 +0,0 @@
-const { getSystems } = require('../config/fhirConfig');
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
-
-class MedicationStatement {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const payload = {
-      resourceType: 'MedicationStatement',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: 'recorded',
-      medication: { concept: code },
-      subject: patientReference(fact.patientId),
-      effectiveDateTime: new Date(fact.reportedAt).toISOString(),
-      extension: extensions,
-    };
-    const adherence = adherenceFor(assertion);
-    if (adherence) {
-      payload.adherence = {
-        code: codeableConcept(adherence, { code: adherence, system: getSystems().medicationStatementAdherence }),
-      };
-    }
-    if (notes) payload.note = notes;
-    return new MedicationStatement(payload);
-  }
-}
-
-function adherenceFor(assertion) {
-  if (assertion.negated) return 'not-taking';
-  if (assertion.temporal === 'historical') return 'stopped';
-  return null;
-}
-
-module.exports = { MedicationStatement };

package/lib/fhir/resources/Procedure.js

@@ -1,30 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference } = require('../helpers/elementHelper');
-
-class Procedure {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
-    const assertion = fact.assertion;
-    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
-      ? provenance.verbatimQuotes.map((text) => ({ text }))
-      : null;
-    const payload = {
-      resourceType: 'Procedure',
-      id: fhirId(fact.mentionId),
-      identifier: [identifier(slug, fact.mentionId)],
-      status: assertion.negated ? 'not-done' : 'completed',
-      code,
-      subject: patientReference(fact.patientId),
-      occurrenceDateTime: new Date(fact.reportedAt).toISOString(),
-      recorder: patientReference(fact.patientId),
-      extension: extensions,
-    };
-    if (notes) payload.note = notes;
-    return new Procedure(payload);
-  }
-}
-
-module.exports = { Procedure };