@peopl-health/nexus 5.13.0-dev.1149 → 5.13.0-dev.1151

package/lib/clinical/tools/submitRoutingDecisionTool.js

@@ -1,6 +1,6 @@
 const crypto = require('node:crypto');
 
-const { storeRoutingDecision, readRoutingByTurn } = require('../../fhir');
+const { storeRoutingDecision, readRoutingDecisions } = require('../../fhir');
 const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
 
 const _ROUTING_ACTIONS = [
@@ -273,7 +273,7 @@ async function handler(args = {}, context = {}) {
     const patientId = runtime.patientCode;
     const turnId = runtime.turnId;
 
-    const existing = await readRoutingByTurn({ patientId, turnId });
+    const [existing] = await readRoutingDecisions({ patientId, turnId });
     if (existing) {
       return fail('decision_already_committed_for_turn', { existing_decision_id: existing.decisionId, committed_at: existing.committedAt });
     }

package/lib/fhir/helpers/resourceHelper.js

@@ -11,13 +11,16 @@ function baseResource(resourceType, id, slug, patientId) {
   };
 }
 
-function provenance({ provenanceId, targetRefs, recordedAt, activityText }) {
+function provenance({ provenanceId, targetRefs, recordedAt, activityText, agentDevice = null, onBehalfOf = null }) {
   return {
     resourceType: 'Provenance',
     id: fhirId(provenanceId),
     target: targetRefs,
     recorded: toIso(recordedAt),
-    agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
+    agent: [{
+      who: reference('Device', agentDevice || getDeviceId()),
+      onBehalfOf: reference('Organization', onBehalfOf || getOrganizationId()),
+    }],
     activity: codeableConcept(activityText),
   };
 }

package/lib/fhir/index.js

@@ -12,7 +12,7 @@ const {
 const { storeContingency, readContingencies } = require('./services/contingencyService');
 const { storeIntervention, readInterventions } = require('./services/interventionService');
 const { storeCluster, readClusters } = require('./services/clusterService');
-const { storeRoutingDecision, readRoutingByTurn } = require('./services/routingService');
+const { storeRoutingDecision, readRoutingDecisions } = require('./services/routingService');
 const {
   storePalliativeAssessment,
   readPalliativeByTurn,
@@ -55,7 +55,7 @@ module.exports = {
   storeCluster,
   readClusters,
   storeRoutingDecision,
-  readRoutingByTurn,
+  readRoutingDecisions,
   storePalliativeAssessment,
   readPalliativeByTurn,
   storePalliativeCarePlan,

package/lib/fhir/models/envelopeModel.js

@@ -1,6 +1,7 @@
 const mongoose = require('mongoose');
 
 const SYMPTOM_SYSTEM_SUFFIX = '/pro-ctcae';
+const TURN_ID_EXT_SUFFIX = '-turn-id';
 
 const envelopeSchema = new mongoose.Schema(
   {
@@ -11,6 +12,7 @@ const envelopeSchema = new mongoose.Schema(
       date: { type: Date, default: null },
       reference: { type: String, default: null },
       symptomTerm: { type: String, default: null },
+      turnId: { type: String, default: null },
     },
     resource: { type: mongoose.Schema.Types.Mixed, required: true },
     meta: {
@@ -27,6 +29,10 @@ envelopeSchema.index(
   { 'index.patient': 1, 'resource.identifier.system': 1, 'index.date': -1 },
   { partialFilterExpression: { 'meta.deleted': false } },
 );
+envelopeSchema.index(
+  { 'index.patient': 1, 'index.turnId': 1, 'index.date': -1 },
+  { partialFilterExpression: { 'meta.deleted': false, 'index.turnId': { $type: 'string' } } },
+);
 envelopeSchema.index({ 'index.reference': 1 }, { partialFilterExpression: { 'index.reference': { $type: 'string' } } });
 envelopeSchema.index({ 'resource.status': 1 }, { sparse: true });
 
@@ -67,6 +73,7 @@ envelopeSchema.statics.deriveIndex = function deriveIndex(resource) {
     date: instantOf(date),
     reference: resource.resourceType && resource.id ? `${resource.resourceType}/${resource.id}` : null,
     symptomTerm: symptomTermOf(resource),
+    turnId: turnIdOf(resource),
   };
 };
 
@@ -93,6 +100,14 @@ function symptomTermOf(resource) {
   return null;
 }
 
+function turnIdOf(resource) {
+  for (const ext of resource.extension || []) {
+    const url = (ext || {}).url;
+    if (typeof url === 'string' && url.endsWith(TURN_ID_EXT_SUFFIX)) return ext.valueString || null;
+  }
+  return null;
+}
+
 function businessIdentifier(resource) {
   for (const identifier of resource.identifier || []) {
     const system = (identifier || {}).system;

package/lib/fhir/projections/registerProjectors.js

@@ -6,7 +6,6 @@ const { projectPatientRisk, PROJECTOR_NAME: RISK_PROJECTOR_NAME } = require('./r
 const { projectSafetyGate, PROJECTOR_NAME: SAFETY_GATE_PROJECTOR_NAME } = require('./safetyGateProjection');
 const { projectRecommendationPlan, PROJECTOR_NAME: RECOMMENDATION_PLAN_PROJECTOR_NAME } = require('./recommendationPlanProjection');
 const { projectCluster, PROJECTOR_NAME: CLUSTER_PROJECTOR_NAME } = require('./clusterProjection');
-const { projectRoutingDecision, PROJECTOR_NAME: ROUTING_PROJECTOR_NAME } = require('./routingProjection');
 const { projectPalliativeAssessment, PROJECTOR_NAME: PALLIATIVE_PROJECTOR_NAME } = require('./palliativeProjection');
 const { projectPalliativeCarePlan, PROJECTOR_NAME: PALLIATIVE_CAREPLAN_PROJECTOR_NAME } = require('./palliativeCarePlanProjection');
 
@@ -18,7 +17,6 @@ const PROJECTORS = [
   { name: SAFETY_GATE_PROJECTOR_NAME, project: projectSafetyGate },
   { name: RECOMMENDATION_PLAN_PROJECTOR_NAME, project: projectRecommendationPlan },
   { name: CLUSTER_PROJECTOR_NAME, project: projectCluster },
-  { name: ROUTING_PROJECTOR_NAME, project: projectRoutingDecision },
   { name: PALLIATIVE_PROJECTOR_NAME, project: projectPalliativeAssessment },
   { name: PALLIATIVE_CAREPLAN_PROJECTOR_NAME, project: projectPalliativeCarePlan },
 ];

package/lib/fhir/projections/routingProjection.js

@@ -1,48 +1,284 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { ClinicalImpression } = require('../resources/ClinicalImpression');
-const { Communication } = require('../resources/Communication');
-const { CommunicationRequest } = require('../resources/CommunicationRequest');
-const { Task } = require('../resources/Task');
-const { RequestOrchestration } = require('../resources/RequestOrchestration');
-const { CarePlan } = require('../resources/CarePlan');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'routing';
+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 { ROUTING_ASSESSMENT_SLUG, ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
+const { ROUTING_EXT } = require('../constants/extensionSlugs');
+const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
+const { logger } = require('../../utils/logger');
+
 const ACTIVITY_TEXT = 'routing-decision';
+const COMPOSE_AS_PREFIX = 'compose_as: ';
+
+const ccText = (concept) => concept?.text || null;
+const caseReason = (caseId) => [{ reference: reference('Condition', caseId) }];
+
+function dispositionBase(resourceType, disposition) {
+  return baseResource(resourceType, disposition.dispositionId, ROUTING_DISPOSITION_SLUG, disposition.patientId);
+}
 
-const DISPOSITION_BY_KIND = {
-  communication: Communication,
-  communication_request: CommunicationRequest,
-  task: Task,
-  orchestration: RequestOrchestration,
-  care_plan: CarePlan,
+const DISPOSITION_CODECS = {
+  communication: {
+    resourceType: 'Communication',
+    build: (d) => ({
+      ...dispositionBase('Communication', d),
+      status: 'completed',
+      category: [codeableConcept(d.primaryAction)],
+      sent: toIso(d.authoredAt),
+      payload: [{ contentCodeableConcept: codeableConcept(d.primaryReason) }],
+      recipient: [patientReference(d.patientId)],
+      ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
+    }),
+    actionOf: (r) => ccText(r.category?.[0]),
+    reasonOf: (r) => ccText(r.payload?.[0]?.contentCodeableConcept),
+    authoredOf: (r) => r.sent,
+  },
+  communication_request: {
+    resourceType: 'CommunicationRequest',
+    build: (d) => ({
+      ...dispositionBase('CommunicationRequest', d),
+      status: 'active',
+      intent: 'plan',
+      category: [codeableConcept(d.primaryAction)],
+      authoredOn: toIso(d.authoredAt),
+      payload: [{ contentCodeableConcept: codeableConcept(d.primaryReason) }],
+      recipient: [patientReference(d.patientId)],
+      ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
+    }),
+    actionOf: (r) => ccText(r.category?.[0]),
+    reasonOf: (r) => ccText(r.payload?.[0]?.contentCodeableConcept),
+    authoredOf: (r) => r.authoredOn,
+  },
+  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) } : {}),
+      };
+    },
+    actionOf: (r) => ccText(r.code),
+    reasonOf: (r) => r.description,
+    authoredOf: (r) => r.authoredOn,
+  },
+  orchestration: {
+    resourceType: 'RequestOrchestration',
+    build: (d) => ({
+      ...dispositionBase('RequestOrchestration', d),
+      status: 'active',
+      intent: 'plan',
+      authoredOn: toIso(d.authoredAt),
+      action: [
+        { title: d.primaryAction, description: d.primaryReason, code: [codeableConcept(d.primaryAction)] },
+        ...d.secondaryActions.map((secondary) => ({
+          title: secondary.action,
+          description: `${COMPOSE_AS_PREFIX}${secondary.composeAs}`,
+          code: [codeableConcept(secondary.action)],
+        })),
+      ],
+      ...(d.primaryCaseId ? { reason: caseReason(d.primaryCaseId) } : {}),
+    }),
+    actionOf: (r) => r.action?.[0]?.title,
+    reasonOf: (r) => r.action?.[0]?.description,
+    authoredOf: (r) => r.authoredOn,
+  },
+  care_plan: {
+    resourceType: 'CarePlan',
+    build: (d) => ({
+      ...dispositionBase('CarePlan', d),
+      status: 'active',
+      intent: 'plan',
+      category: [codeableConcept(d.primaryAction)],
+      created: toIso(d.authoredAt),
+      description: d.primaryReason,
+      ...(d.primaryCaseId ? { addresses: caseReason(d.primaryCaseId) } : {}),
+    }),
+    actionOf: (r) => ccText(r.category?.[0]),
+    reasonOf: (r) => r.description,
+    authoredOf: (r) => r.created,
+  },
 };
 
-function projectRoutingDecision(routingDecision) {
-  const { decisionId, committedAt, assessment, disposition, provenance } = routingDecision;
-  const impression = ClinicalImpression.fromRoutingAssessment({
-    assessment,
-    decisionId,
-    committedAt,
-    deferredItems: disposition.deferredItems,
-    primaryCaseId: disposition.primaryCaseId,
-  });
-  const resourceClass = DISPOSITION_BY_KIND[disposition.kind];
-  if (!resourceClass) throw new Error(`unknown routing-disposition kind: ${disposition.kind}`);
-  const dispositionResource = resourceClass.fromRoutingDisposition({ disposition });
-  const provenanceResource = Provenance.fromRoutingDecision({
-    provenanceId: `${assessment.assessmentId}-prov`,
-    targetRefs: [
-      { reference: `ClinicalImpression/${fhirId(assessment.assessmentId)}` },
-      { reference: `${dispositionResource.resourceType}/${fhirId(disposition.dispositionId)}` },
-    ],
-    provenance,
-    activityText: ACTIVITY_TEXT,
-  });
-  return [impression, dispositionResource, provenanceResource];
+const KIND_BY_RESOURCE_TYPE = Object.fromEntries(
+  Object.entries(DISPOSITION_CODECS).map(([kind, codec]) => [codec.resourceType, kind]),
+);
+
+function toFhir(routingDecision) {
+  const { decisionId, committedAt, assessment, disposition, provenance: prov } = routingDecision;
+  const codec = DISPOSITION_CODECS[disposition.kind];
+  if (!codec) throw new Error(`unknown routing-disposition kind: ${disposition.kind}`);
+  const dispositionResource = codec.build(disposition);
+  return [
+    assessmentResource(assessment, { decisionId, committedAt, disposition }),
+    dispositionResource,
+    provenance({
+      provenanceId: `${assessment.assessmentId}-prov`,
+      targetRefs: [
+        reference('ClinicalImpression', assessment.assessmentId),
+        reference(dispositionResource.resourceType, disposition.dispositionId),
+      ],
+      recordedAt: prov.recordedAt,
+      activityText: ACTIVITY_TEXT,
+      agentDevice: prov.agentDevice,
+      onBehalfOf: prov.onBehalfOf,
+    }),
+  ];
+}
+
+function assessmentResource(assessment, { decisionId, committedAt, disposition }) {
+  const payload = {
+    ...baseResource('ClinicalImpression', assessment.assessmentId, ROUTING_ASSESSMENT_SLUG, assessment.patientId),
+    status: 'completed',
+    effectiveDateTime: toIso(assessment.performedAt),
+    finding: assessment.findings.map((finding) => {
+      const entry = {};
+      const extensions = [];
+      if (finding.caseId) {
+        entry.item = reference('Condition', finding.caseId);
+        extensions.push(extension(ROUTING_EXT.FINDING_CASE_ID, { valueString: finding.caseId }));
+      }
+      extensions.push(
+        extension(ROUTING_EXT.FINDING_REASONING, { valueString: finding.clinicalReasoning }),
+        extension(ROUTING_EXT.FINDING_ACTION, { valueString: finding.decisionAction }),
+      );
+      entry.extension = extensions;
+      return entry;
+    }),
+    extension: assessmentExtensions(assessment, { decisionId, committedAt, disposition }),
+  };
+  if (assessment.summary) payload.summary = assessment.summary;
+  if (assessment.previousId) payload.previous = reference('ClinicalImpression', assessment.previousId);
+  if (assessment.notes.length) payload.note = assessment.notes.map((text) => ({ text }));
+  return payload;
+}
+
+function assessmentExtensions(assessment, { decisionId, committedAt, disposition }) {
+  const out = [
+    extension(ROUTING_EXT.TURN_ID, { valueString: assessment.turnId }),
+    extension(ROUTING_EXT.DECISION_ID, { valueString: decisionId }),
+    extension(ROUTING_EXT.COMMITTED_AT, { valueDateTime: toIso(committedAt) }),
+  ];
+  if (disposition.primaryCaseId) {
+    out.push(extension(ROUTING_EXT.PRIMARY_CASE_ID, { valueString: disposition.primaryCaseId }));
+  }
+  for (const deferred of disposition.deferredItems) {
+    out.push(
+      extension(ROUTING_EXT.DEFERRED_ITEM, { valueString: deferred.item }),
+      extension(ROUTING_EXT.DEFERRED_REASON, { valueString: deferred.deferReason }),
+    );
+  }
+  return out;
+}
+
+function fromFhir(resources, { patientId }) {
+  const assessments = new Map();
+  const dispositions = new Map();
+  const provenanceByTarget = new Map();
+  for (const resource of resources) {
+    if (resource.resourceType === 'ClinicalImpression' && identifierValue(resource, ROUTING_ASSESSMENT_SLUG)) {
+      assessments.set(`ClinicalImpression/${resource.id}`, resource);
+    } else if (resource.resourceType === 'Provenance') {
+      for (const target of resource.target || []) provenanceByTarget.set(target.reference, resource);
+    } else if (KIND_BY_RESOURCE_TYPE[resource.resourceType] && identifierValue(resource, ROUTING_DISPOSITION_SLUG)) {
+      dispositions.set(`${resource.resourceType}/${resource.id}`, resource);
+    }
+  }
+
+  const out = [];
+  for (const [assessmentRef, assessment] of assessments) {
+    const prov = provenanceByTarget.get(assessmentRef);
+    if (!prov) continue;
+    const dispositionRef = (prov.target || []).find((target) => dispositions.has(target.reference));
+    if (!dispositionRef) continue;
+    const disposition = dispositions.get(dispositionRef.reference);
+    try {
+      out.push(new RoutingDecision(reconstruct(assessment, disposition, prov, patientId)));
+    } catch (error) {
+      if (error instanceof ZodError) {
+        logger.warn({ assessmentId: assessment.id }, 'skipping malformed routing ClinicalImpression');
+        continue;
+      }
+      throw error;
+    }
+  }
+  return out;
+}
+
+function reconstruct(assessment, disposition, prov, patientId) {
+  const ext = extMap(assessment);
+  const turnId = ext[ROUTING_EXT.TURN_ID];
+  const agent = prov.agent?.[0] || {};
+  return {
+    schemaVersion: '1',
+    decisionId: ext[ROUTING_EXT.DECISION_ID],
+    patientId,
+    turnId,
+    committedAt: ext[ROUTING_EXT.COMMITTED_AT],
+    assessment: reconstructAssessment(assessment, patientId, turnId),
+    disposition: reconstructDisposition(disposition, assessment, patientId),
+    provenance: {
+      agentDevice: refToId(agent.who?.reference),
+      onBehalfOf: refToId(agent.onBehalfOf?.reference),
+      recordedAt: prov.recorded,
+    },
+  };
+}
+
+function reconstructAssessment(resource, patientId, turnId) {
+  return {
+    assessmentId: identifierValue(resource, ROUTING_ASSESSMENT_SLUG),
+    patientId,
+    turnId,
+    performedAt: resource.effectiveDateTime,
+    previousId: refToId(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),
+        clinicalReasoning: findingExt[ROUTING_EXT.FINDING_REASONING] || '',
+        decisionAction: findingExt[ROUTING_EXT.FINDING_ACTION] || '',
+      };
+    }),
+  };
+}
+
+function reconstructDisposition(resource, assessment, patientId) {
+  const kind = KIND_BY_RESOURCE_TYPE[resource.resourceType];
+  const codec = DISPOSITION_CODECS[kind];
+  const deferReasons = extValues(assessment, ROUTING_EXT.DEFERRED_REASON);
+  return {
+    dispositionId: identifierValue(resource, ROUTING_DISPOSITION_SLUG),
+    patientId,
+    kind,
+    primaryAction: codec.actionOf(resource),
+    primaryReason: codec.reasonOf(resource),
+    primaryCaseId: extMap(assessment)[ROUTING_EXT.PRIMARY_CASE_ID] || null,
+    secondaryActions: (resource.action || []).slice(1).map((action) => {
+      const description = action.description || '';
+      return {
+        action: action.title,
+        composeAs: description.startsWith(COMPOSE_AS_PREFIX) ? description.slice(COMPOSE_AS_PREFIX.length) : description,
+      };
+    }),
+    deferredItems: extValues(assessment, ROUTING_EXT.DEFERRED_ITEM)
+      .map((item, i) => ({ item, deferReason: deferReasons[i] })),
+    authoredAt: codec.authoredOf(resource),
+  };
 }
 
 module.exports = {
-  projectRoutingDecision,
-  PROJECTOR_NAME,
+  toFhir,
+  fromFhir,
 };

package/lib/fhir/resources/CarePlan.js

@@ -7,7 +7,7 @@ const {
   extension,
   toIso,
 } = require('../helpers/elementHelper');
-const { ROUTING_DISPOSITION_SLUG, RECOMMENDATION_PLAN_SLUG, PALLIATIVE_CAREPLAN_SLUG } = require('../constants/projectionSlugs');
+const { RECOMMENDATION_PLAN_SLUG, PALLIATIVE_CAREPLAN_SLUG } = require('../constants/projectionSlugs');
 const { PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 
 class CarePlan {
@@ -60,23 +60,6 @@ class CarePlan {
     return new CarePlan(payload);
   }
 
-  static fromRoutingDisposition({ disposition }) {
-    const payload = {
-      resourceType: 'CarePlan',
-      id: fhirId(disposition.dispositionId),
-      identifier: [identifier(ROUTING_DISPOSITION_SLUG, disposition.dispositionId)],
-      status: 'active',
-      intent: 'plan',
-      category: [codeableConcept(disposition.primaryAction)],
-      subject: patientReference(disposition.patientId),
-      created: toIso(disposition.authoredAt),
-      description: disposition.primaryReason,
-    };
-    if (disposition.primaryCaseId) {
-      payload.addresses = [{ reference: reference('Condition', disposition.primaryCaseId) }];
-    }
-    return new CarePlan(payload);
-  }
 }
 
 module.exports = {

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 { 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_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
+const { CLUSTER_EXT, PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 
 const CLUSTER_STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
 const CLUSTER_LIST_SEPARATOR = '; ';
@@ -75,47 +75,6 @@ class ClinicalImpression {
     return new ClinicalImpression(payload);
   }
 
-  static fromRoutingAssessment({ assessment, decisionId, committedAt, deferredItems = [], primaryCaseId = null }) {
-    const extensions = [
-      extension(ROUTING_EXT.TURN_ID, { valueString: assessment.turnId }),
-      extension(ROUTING_EXT.DECISION_ID, { valueString: decisionId }),
-      extension(ROUTING_EXT.COMMITTED_AT, { valueDateTime: toIso(committedAt) }),
-    ];
-    if (primaryCaseId) extensions.push(extension(ROUTING_EXT.PRIMARY_CASE_ID, { valueString: primaryCaseId }));
-    for (const deferred of deferredItems) {
-      extensions.push(extension(ROUTING_EXT.DEFERRED_ITEM, { valueString: deferred.item }));
-      extensions.push(extension(ROUTING_EXT.DEFERRED_REASON, { valueString: deferred.deferReason }));
-    }
-    const payload = {
-      resourceType: 'ClinicalImpression',
-      id: fhirId(assessment.assessmentId),
-      identifier: [identifier(ROUTING_ASSESSMENT_SLUG, assessment.assessmentId)],
-      status: 'completed',
-      subject: patientReference(assessment.patientId),
-      effectiveDateTime: toIso(assessment.performedAt),
-      finding: assessment.findings.map((finding) => {
-        const findingExts = [];
-        const projected = {};
-        // A caseless mention (caseId null) has no case to point at: no Condition item and no case-id extension, so absence stays absence in the FHIR.
-        if (finding.caseId) {
-          projected.item = reference('Condition', finding.caseId);
-          findingExts.push(extension(ROUTING_EXT.FINDING_CASE_ID, { valueString: finding.caseId }));
-        }
-        findingExts.push(
-          extension(ROUTING_EXT.FINDING_REASONING, { valueString: finding.clinicalReasoning }),
-          extension(ROUTING_EXT.FINDING_ACTION, { valueString: finding.decisionAction }),
-        );
-        projected.extension = findingExts;
-        return projected;
-      }),
-      extension: extensions,
-    };
-    if (assessment.summary) payload.summary = assessment.summary;
-    if (assessment.previousId) payload.previous = reference('ClinicalImpression', assessment.previousId);
-    if (assessment.notes.length) payload.note = assessment.notes.map((text) => ({ text }));
-    return new ClinicalImpression(payload);
-  }
-
   static fromPalliativeAssessment({ assessment }) {
     const payload = {
       resourceType: 'ClinicalImpression',

package/lib/fhir/resources/CommunicationRequest.js

@@ -1,7 +1,6 @@
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
 const {
   identifier,
-  reference,
   patientReference,
   recipientReference,
   codeableConcept,
@@ -15,7 +14,6 @@ const {
   REMINDER_SLUG,
   REMINDER_KIND_SLUG,
   COMMUNICATION_CHANNEL_SLUG,
-  ROUTING_DISPOSITION_SLUG,
 } = require('../constants/projectionSlugs');
 const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
 
@@ -88,24 +86,6 @@ class CommunicationRequest {
     return new CommunicationRequest(payload);
   }
 
-  static fromRoutingDisposition({ disposition }) {
-    const payload = {
-      resourceType: 'CommunicationRequest',
-      id: fhirId(disposition.dispositionId),
-      identifier: [identifier(ROUTING_DISPOSITION_SLUG, disposition.dispositionId)],
-      status: 'active',
-      intent: 'plan',
-      category: [codeableConcept(disposition.primaryAction)],
-      subject: patientReference(disposition.patientId),
-      authoredOn: toIso(disposition.authoredAt),
-      payload: [{ contentCodeableConcept: codeableConcept(disposition.primaryReason) }],
-      recipient: [patientReference(disposition.patientId)],
-    };
-    if (disposition.primaryCaseId) {
-      payload.reason = [{ reference: reference('Condition', disposition.primaryCaseId) }];
-    }
-    return new CommunicationRequest(payload);
-  }
 }
 
 module.exports = { CommunicationRequest };

package/lib/fhir/resources/Provenance.js

@@ -56,17 +56,6 @@ class Provenance {
     });
   }
 
-  static fromRoutingDecision({ provenanceId, targetRefs, provenance, activityText }) {
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(provenanceId),
-      target: targetRefs,
-      recorded: toIso(provenance.recordedAt),
-      agent: [{ who: reference('Device', provenance.agentDevice), onBehalfOf: reference('Organization', provenance.onBehalfOf) }],
-      activity: codeableConcept(activityText),
-    });
-  }
-
   static fromSymptomCase({ provenanceId, targetRefs, recordedAt, activityText }) {
     return new Provenance({
       resourceType: 'Provenance',

package/lib/fhir/resources/Task.js

@@ -12,7 +12,6 @@ const {
 const {
   ESCALATION_SLUG,
   ESCALATION_KIND_SLUG,
-  ROUTING_DISPOSITION_SLUG,
   RECOMMENDATION_REC_SLUG,
   PALLIATIVE_ESCALATION_SLUG,
   PALLIATIVE_CAREPLAN_REC_SLUG,
@@ -148,24 +147,6 @@ class Task {
     return new Task(payload);
   }
 
-  static fromRoutingDisposition({ disposition }) {
-    const payload = {
-      resourceType: 'Task',
-      id: fhirId(disposition.dispositionId),
-      identifier: [identifier(ROUTING_DISPOSITION_SLUG, disposition.dispositionId)],
-      status: 'requested',
-      intent: 'order',
-      code: codeableConcept(disposition.primaryAction),
-      description: disposition.primaryReason,
-      for: patientReference(disposition.patientId),
-      authoredOn: toIso(disposition.authoredAt),
-      requester: reference('Device', getDeviceId()),
-    };
-    if (disposition.primaryCaseId) {
-      payload.reason = [{ reference: reference('Condition', disposition.primaryCaseId) }];
-    }
-    return new Task(payload);
-  }
 }
 
 module.exports = { Task };

package/lib/fhir/services/routingService.js

@@ -1,148 +1,36 @@
-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 { ROUTING_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
 const { getFhirStore } = require('../stores/fhirStore');
-const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-const DISPOSITION_KIND_BY_RESOURCE = {
-  Communication: 'communication',
-  CommunicationRequest: 'communication_request',
-  Task: 'task',
-  RequestOrchestration: 'orchestration',
-  CarePlan: 'care_plan',
-};
+const { toFhir, fromFhir } = require('../projections/routingProjection');
+const { storeResources } = require('./fhirService');
 
 async function storeRoutingDecision({ patientId, routingDecision }) {
   if (routingDecision.patientId !== patientId) {
     throw new Error(`storeRoutingDecision patientId mismatch: expected ${patientId}`);
   }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: routingDecision }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
+  const { stored } = await storeResources(toFhir(routingDecision));
   return { count: stored.length, ids: stored };
 }
 
-async function readRoutingByTurn({ patientId, turnId }) {
+async function readRoutingDecisions({ patientId, turnId = null }) {
   const store = getFhirStore();
   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_EXT.TURN_ID] === turnId);
-  if (!assessment) return null;
-  const provenance = await store.getByReference(`Provenance/${fhirId(`${assessment.id}-prov`)}`);
-  if (!provenance) return null;
-  const disposition = await findDisposition(store, assessment, provenance);
-  if (!disposition) return null;
-  try {
-    return new RoutingDecision(reconstructRouting(assessment, disposition, provenance, patientId, turnId));
-  } catch (error) {
-    if (error instanceof ZodError) {
-      logger.warn({ assessmentId: assessment.id }, 'skipping malformed routing ClinicalImpression');
-      return null;
-    }
-    throw error;
-  }
-}
-
-async function findDisposition(store, assessment, provenance) {
-  const assessmentRef = `ClinicalImpression/${fhirId(assessment.id)}`;
-  const dispositionRef = (provenance.target || []).find((target) => target.reference !== assessmentRef);
-  if (!dispositionRef) return null;
-  const resource = await store.getByReference(dispositionRef.reference);
-  return resource && identifierValue(resource, ROUTING_DISPOSITION_SLUG) ? resource : null;
-}
-
-function reconstructRouting(assessment, disposition, provenance, patientId, turnId) {
-  const ext = extMap(assessment);
-  const agent = (provenance.agent || [])[0] || {};
-  return {
-    schemaVersion: '1',
-    decisionId: ext[ROUTING_EXT.DECISION_ID],
-    patientId,
-    turnId,
-    committedAt: ext[ROUTING_EXT.COMMITTED_AT],
-    assessment: reconstructAssessment(assessment, patientId, turnId),
-    disposition: reconstructDisposition(disposition, assessment, patientId),
-    provenance: {
-      agentDevice: refToId(agent.who && agent.who.reference),
-      onBehalfOf: refToId(agent.onBehalfOf && agent.onBehalfOf.reference),
-      recordedAt: provenance.recorded,
-    },
-  };
-}
-
-function reconstructAssessment(resource, patientId, turnId) {
-  return {
-    assessmentId: identifierValue(resource, ROUTING_ASSESSMENT_SLUG),
-    patientId,
+  const assessments = await store.find({
+    patient,
+    resourceType: 'ClinicalImpression',
     turnId,
-    performedAt: resource.effectiveDateTime,
-    previousId: resource.previous ? refToId(resource.previous.reference) : null,
-    summary: resource.summary || '',
-    notes: (resource.note || []).map((note) => note.text),
-    findings: (resource.finding || []).map(reconstructFinding),
-  };
-}
-
-function reconstructFinding(finding) {
-  const ext = extMap(finding);
-  return {
-    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] || '',
-  };
-}
-
-function reconstructDisposition(resource, assessment, patientId) {
-  return {
-    dispositionId: identifierValue(resource, ROUTING_DISPOSITION_SLUG),
-    patientId,
-    kind: DISPOSITION_KIND_BY_RESOURCE[resource.resourceType],
-    primaryAction: dispositionAction(resource),
-    primaryReason: dispositionReason(resource),
-    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,
-  };
-}
-
-function reconstructDeferredItems(assessment) {
-  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] }));
-}
-
-function reconstructSecondary(action) {
-  const description = action.description || '';
-  return {
-    action: action.title,
-    composeAs: description.startsWith('compose_as: ') ? description.slice('compose_as: '.length) : description,
-  };
-}
-
-function dispositionAction(resource) {
-  if (resource.resourceType === 'Task') return ccText(resource.code);
-  if (resource.resourceType === 'RequestOrchestration') return (resource.action || [])[0] && resource.action[0].title;
-  return ccText((resource.category || [])[0]);
+    identifierSlug: ROUTING_ASSESSMENT_SLUG,
+  });
+  const bundles = await Promise.all(assessments.map(async (assessment) => {
+    const provenance = await store.getByReference(`Provenance/${fhirId(`${assessment.id}-prov`)}`);
+    if (!provenance) return [];
+    const targets = await Promise.all((provenance.target || []).map((target) => store.getByReference(target.reference)));
+    return [assessment, provenance, ...targets.filter(Boolean)];
+  }));
+  return fromFhir(bundles.flat(), { patientId });
 }
 
-function dispositionReason(resource) {
-  if (resource.resourceType === 'Task') return resource.description;
-  if (resource.resourceType === 'CarePlan') return resource.description;
-  if (resource.resourceType === 'RequestOrchestration') return (resource.action || [])[0] && resource.action[0].description;
-  return ccText((resource.payload || [])[0] && resource.payload[0].contentCodeableConcept);
-}
-
-const ccText = (concept) => (concept && concept.text) || null;
-
 module.exports = {
   storeRoutingDecision,
-  readRoutingByTurn,
+  readRoutingDecisions,
 };

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, identifierSlug = null } = {}) {
+  async find({ patient = null, resourceType = null, symptomTerm = null, identifierSlug = null, turnId = null } = {}) {
     const query = { 'meta.deleted': false };
     if (patient) query['index.patient'] = patient;
     if (symptomTerm) query['index.symptomTerm'] = symptomTerm;
+    if (turnId) query['index.turnId'] = turnId;
     if (identifierSlug) query['resource.identifier.system'] = identifierSystem(identifierSlug);
     if (resourceType) {
       const model = await this._modelFor(resourceType);

package/package.json

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

package/lib/fhir/resources/Communication.js

@@ -1,29 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, reference, patientReference, codeableConcept, toIso } = require('../helpers/elementHelper');
-const { ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
-
-class Communication {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromRoutingDisposition({ disposition }) {
-    const payload = {
-      resourceType: 'Communication',
-      id: fhirId(disposition.dispositionId),
-      identifier: [identifier(ROUTING_DISPOSITION_SLUG, disposition.dispositionId)],
-      status: 'completed',
-      category: [codeableConcept(disposition.primaryAction)],
-      subject: patientReference(disposition.patientId),
-      sent: toIso(disposition.authoredAt),
-      payload: [{ contentCodeableConcept: codeableConcept(disposition.primaryReason) }],
-      recipient: [patientReference(disposition.patientId)],
-    };
-    if (disposition.primaryCaseId) {
-      payload.reason = [{ reference: reference('Condition', disposition.primaryCaseId) }];
-    }
-    return new Communication(payload);
-  }
-}
-
-module.exports = { Communication };

package/lib/fhir/resources/RequestOrchestration.js

@@ -1,46 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  patientReference,
-  reference,
-  codeableConcept,
-  toIso,
-} = require('../helpers/elementHelper');
-const { ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
-
-class RequestOrchestration {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromRoutingDisposition({ disposition }) {
-    const action = [{
-      title: disposition.primaryAction,
-      description: disposition.primaryReason,
-      code: [codeableConcept(disposition.primaryAction)],
-    }];
-    for (const secondary of disposition.secondaryActions) {
-      action.push({
-        title: secondary.action,
-        description: `compose_as: ${secondary.composeAs}`,
-        code: [codeableConcept(secondary.action)],
-      });
-    }
-    const payload = {
-      resourceType: 'RequestOrchestration',
-      id: fhirId(disposition.dispositionId),
-      identifier: [identifier(ROUTING_DISPOSITION_SLUG, disposition.dispositionId)],
-      status: 'active',
-      intent: 'plan',
-      subject: patientReference(disposition.patientId),
-      authoredOn: toIso(disposition.authoredAt),
-      action,
-    };
-    if (disposition.primaryCaseId) {
-      payload.reason = [{ reference: reference('Condition', disposition.primaryCaseId) }];
-    }
-    return new RequestOrchestration(payload);
-  }
-}
-
-module.exports = { RequestOrchestration };