@peopl-health/nexus 5.12.0 → 5.12.1

package/lib/clinical/AssistantProcessor.js

@@ -43,7 +43,7 @@ class AssistantProcessor {
       });
     }
 
-    if (thread.isInCohort && !runOptions.toolRuntimeContext && runOptions.runId && thread.code) {
+    if (!runOptions.toolRuntimeContext && runOptions.runId && thread.code) {
       try {
         runOptions.toolRuntimeContext = new ToolRuntimeContext({
           patientCode: thread.code,

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/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');
 
@@ -11,18 +11,27 @@ function baseResource(resourceType, id, slug, patientId) {
   };
 }
 
-function provenance({ provenanceId, targetRefs, recordedAt, activityText }) {
+function provenance({ provenanceId, targetRefs, recordedAt, activity, agentDevice = null, onBehalfOf = null }) {
   return {
     resourceType: 'Provenance',
     id: fhirId(provenanceId),
     target: targetRefs,
     recorded: toIso(recordedAt),
-    agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-    activity: codeableConcept(activityText),
+    agent: [{
+      who: reference('Device', agentDevice || getDeviceId()),
+      onBehalfOf: reference('Organization', onBehalfOf || getOrganizationId()),
+    }],
+    activity,
   };
 }
 
+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/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: {
@@ -23,6 +25,14 @@ 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.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 });
 
@@ -63,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),
   };
 };
 
@@ -89,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/clusterProjection.js

@@ -1,24 +1,123 @@
-const { ClinicalImpression } = require('../resources/ClinicalImpression');
-const { Provenance } = require('../resources/Provenance');
+const { ZodError } = require('zod');
 
-const PROJECTOR_NAME = 'cluster';
+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 { CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG } = require('../constants/projectionSlugs');
+const { CLUSTER_EXT } = require('../constants/extensionSlugs');
+const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
+const { logger } = require('../../utils/logger');
 
-function projectCluster({ cluster, history = [] }) {
-  const impression = ClinicalImpression.fromClusterImpression({ cluster });
+const LIST_SEPARATOR = '; ';
+const STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
+const ACTIVITY_CODESYSTEM = 'clinical-activity';
+const ACTIVITY_CODES = {
+  opened: 'cluster-hypothesis-opened',
+  updated: 'cluster-hypothesis-updated',
+  dissolved: 'cluster-hypothesis-dissolved',
+};
+const DEFAULT_ACTIVITY_CODE = 'cluster-hypothesis';
+
+function toFhir({ cluster, history = [] }) {
   const records = history.length
     ? [...history].sort((a, b) => Date.parse(a.recordedAt) - Date.parse(b.recordedAt))
     : [{ turnId: 'opened', action: 'opened', recordedAt: cluster.openedAt, transitionReason: null }];
-  const provenances = records.map((record) => Provenance.fromClusterImpression({
-    clusterId: cluster.clusterId,
-    turnId: record.turnId,
-    action: record.action,
+  return [clusterResource(cluster), ...records.map((record) => historyProvenance(cluster.clusterId, record))];
+}
+
+function clusterResource(cluster) {
+  const payload = {
+    ...baseResource('ClinicalImpression', cluster.clusterId, CLUSTER_IMPRESSION_SLUG, cluster.patientId),
+    status: STATUS_TO_FHIR[cluster.status],
+    problem: cluster.memberCaseIds.map((caseId) => reference('Condition', caseId)),
+    extension: clusterExtensions(cluster),
+  };
+  if (cluster.label) payload.identifier.push(identifier(CLUSTER_LABEL_SLUG, cluster.label));
+  if (cluster.relationshipModel) payload.summary = cluster.relationshipModel;
+  if (cluster.openingReasoning) payload.description = cluster.openingReasoning;
+  if (cluster.dissolvedAt) payload.effectivePeriod = { start: toIso(cluster.openedAt), end: toIso(cluster.dissolvedAt) };
+  else payload.effectiveDateTime = toIso(cluster.openedAt);
+  if (cluster.dissolveCategory) payload.statusReason = codeableConcept(cluster.dissolveCategory);
+  return payload;
+}
+
+function clusterExtensions(cluster) {
+  const out = [
+    extension(CLUSTER_EXT.HYPOTHESIS_TYPE, { valueString: cluster.hypothesisType }),
+    extension(CLUSTER_EXT.CONFIDENCE, { valueString: cluster.confidence }),
+    extension(CLUSTER_EXT.CLINICAL_SIGNIFICANCE, { valueString: cluster.clinicalSignificance }),
+  ];
+  if (cluster.strengthensIf.length) {
+    out.push(extension(CLUSTER_EXT.STRENGTHENS_IF, { valueString: cluster.strengthensIf.join(LIST_SEPARATOR) }));
+  }
+  if (cluster.weakensIf.length) {
+    out.push(extension(CLUSTER_EXT.WEAKENS_IF, { valueString: cluster.weakensIf.join(LIST_SEPARATOR) }));
+  }
+  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 }));
+  return out;
+}
+
+function historyProvenance(clusterId, record) {
+  const code = ACTIVITY_CODES[record.action] || DEFAULT_ACTIVITY_CODE;
+  const payload = provenance({
+    provenanceId: `${clusterId}-prov-${record.turnId}-${record.action}`,
+    targetRefs: [reference('ClinicalImpression', clusterId)],
     recordedAt: record.recordedAt,
-    transitionReason: record.transitionReason,
-  }));
-  return [impression, ...provenances];
+    activity: codeableConcept(code, { code, system: codeSystemUrl(ACTIVITY_CODESYSTEM) }),
+  });
+  if (record.transitionReason) {
+    payload.extension = [extension('transition-reason', { valueString: record.transitionReason })];
+  }
+  return payload;
+}
+
+function fromFhir(resources, { patientId }) {
+  const out = [];
+  for (const resource of resources) {
+    if (resource.resourceType !== 'ClinicalImpression') continue;
+    if (!identifierValue(resource, CLUSTER_IMPRESSION_SLUG)) continue;
+    try {
+      out.push(new ClusterImpression(reconstruct(resource, patientId)));
+    } catch (error) {
+      if (error instanceof ZodError) {
+        logger.warn({ clusterId: resource.id }, 'skipping malformed cluster ClinicalImpression');
+        continue;
+      }
+      throw error;
+    }
+  }
+  return out;
+}
+
+function reconstruct(resource, patientId) {
+  const ext = extMap(resource);
+  const splitList = (value) => (value ? value.split(LIST_SEPARATOR) : []);
+  return {
+    schemaVersion: '1',
+    clusterId: identifierValue(resource, CLUSTER_IMPRESSION_SLUG),
+    patientId,
+    label: identifierValue(resource, CLUSTER_LABEL_SLUG) || '',
+    hypothesisType: ext[CLUSTER_EXT.HYPOTHESIS_TYPE],
+    status: ext[CLUSTER_EXT.STATUS],
+    confidence: ext[CLUSTER_EXT.CONFIDENCE],
+    clinicalSignificance: ext[CLUSTER_EXT.CLINICAL_SIGNIFICANCE],
+    memberCaseIds: (resource.problem || []).map((problemRef) => refToId(problemRef.reference)).filter(Boolean),
+    consultationId: ext[CLUSTER_EXT.CONSULTATION_ID] || null,
+    relationshipModel: resource.summary || '',
+    strengthensIf: splitList(ext[CLUSTER_EXT.STRENGTHENS_IF]),
+    weakensIf: splitList(ext[CLUSTER_EXT.WEAKENS_IF]),
+    openingReasoning: resource.description || '',
+    openedAt: resource.effectiveDateTime || resource.effectivePeriod?.start,
+    dissolvedAt: resource.effectivePeriod?.end || null,
+    dissolveReason: ext[CLUSTER_EXT.DISSOLVE_REASON] || null,
+    dissolveCategory: resource.statusReason?.text || null,
+  };
 }
 
 module.exports = {
-  projectCluster,
-  PROJECTOR_NAME,
+  toFhir,
+  fromFhir,
 };

package/lib/fhir/projections/contingencyProjection.js

@@ -60,7 +60,7 @@ function toFhir(contingency) {
     provenanceId: `${carePlan.planId}-prov`,
     targetRefs,
     recordedAt: carePlan.createdAt,
-    activityText: ACTIVITY_TEXT,
+    activity: codeableConcept(ACTIVITY_TEXT),
   }));
   return resources;
 }

package/lib/fhir/projections/interventionProjection.js

@@ -1,42 +1,244 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { Procedure } = require('../resources/Procedure');
-const { Communication } = require('../resources/Communication');
-const { Task } = require('../resources/Task');
-const { CommunicationRequest } = require('../resources/CommunicationRequest');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'intervention';
+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 { baseResource, provenance } = require('../helpers/resourceHelper');
+const { identifierValue, refToId, extValues } = 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');
+
 const ACTIVITY_TEXT = 'intervention-record';
 const PROCEDURE_KINDS = new Set(['otc', 'self_care', 'other']);
 
-function projectIntervention(intervention) {
-  const primary = primaryResource(intervention);
+const EXT = {
+  RATIONALE: 'intervention-rationale',
+  OUTCOME_NOTES: 'intervention-outcome-notes',
+  OUTCOME: 'intervention-outcome',
+  RECIPIENT_KIND: 'intervention-recipient-kind',
+  RECIPIENT_REF: 'intervention-recipient-ref',
+};
+
+const RESOURCE_TYPES = ['Procedure', 'Communication', 'Task', 'CommunicationRequest'];
 
-  return [primary, Provenance.fromSymptomCase({
+const interventionReason = (caseId) => [{ reference: reference('Condition', caseId) }];
+const withNote = (payload, intervention) => {
+  const note = notes(intervention.rationale, intervention.outcomeNotes);
+  return note ? { ...payload, note } : payload;
+};
+
+function toFhir(intervention) {
+  const primary = primaryResource(intervention);
+  return [primary, provenance({
     provenanceId: `${intervention.interventionId}-prov`,
     targetRefs: [{ reference: `${primary.resourceType}/${fhirId(intervention.interventionId)}` }],
     recordedAt: intervention.deliveredAt,
-    activityText: ACTIVITY_TEXT,
+    activity: codeableConcept(ACTIVITY_TEXT),
   })];
 }
 
 function primaryResource(intervention) {
-  if (PROCEDURE_KINDS.has(intervention.kind)) {
-    return Procedure.fromIntervention({ intervention });
+  if (PROCEDURE_KINDS.has(intervention.kind)) return procedureResource(intervention);
+  if (intervention.kind === 'education') return communicationResource(intervention);
+  if (intervention.kind === 'team_escalation') return taskResource(intervention);
+  if (intervention.kind === 'follow_up_check') return communicationRequestResource(intervention);
+  throw new Error(`unknown intervention variant: ${intervention.kind}`);
+}
+
+function procedureResource(intervention) {
+  return withNote({
+    ...baseResource('Procedure', intervention.interventionId, INTERVENTION_SLUG, intervention.patientId),
+    status: intervention.outcome === 'pending' ? 'in-progress' : 'completed',
+    code: codeableConcept(intervention.interventionLabel),
+    reason: interventionReason(intervention.caseId),
+    occurrenceDateTime: toIso(intervention.deliveredAt),
+    outcome: codeableConcept(intervention.outcome, { code: intervention.outcome, system: codeSystemUrl(INTERVENTION_OUTCOME_SLUG) }),
+    category: [codeableConcept(intervention.kind, { code: intervention.kind, system: codeSystemUrl(INTERVENTION_KIND_SLUG) })],
+    extension: interventionExtensions(intervention, { withRecipient: true }),
+  }, intervention);
+}
+
+function communicationResource(intervention) {
+  return withNote({
+    ...baseResource('Communication', intervention.interventionId, INTERVENTION_SLUG, intervention.patientId),
+    status: 'completed',
+    category: [codeableConcept(intervention.kind, { code: intervention.kind, system: codeSystemUrl(INTERVENTION_KIND_SLUG) })],
+    reason: interventionReason(intervention.caseId),
+    sent: toIso(intervention.deliveredAt),
+    payload: [{ contentCodeableConcept: codeableConcept(intervention.interventionLabel) }],
+    recipient: [recipientReference({
+      patientId: intervention.patientId,
+      recipientKind: intervention.recipientKind,
+      recipientRefId: intervention.recipientRefId,
+    })],
+    extension: interventionExtensions(intervention),
+  }, intervention);
+}
+
+function taskResource(intervention) {
+  const payload = withNote({
+    resourceType: 'Task',
+    id: fhirId(intervention.interventionId),
+    identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
+    status: intervention.outcome === 'pending' ? 'requested' : 'completed',
+    intent: 'order',
+    code: codeableConcept(intervention.interventionLabel, {
+      code: intervention.kind,
+      system: codeSystemUrl(INTERVENTION_KIND_SLUG),
+      display: intervention.interventionLabel,
+    }),
+    authoredOn: toIso(intervention.deliveredAt),
+    for: patientReference(intervention.patientId),
+    requester: reference('Device', getDeviceId()),
+    reason: interventionReason(intervention.caseId),
+    extension: interventionExtensions(intervention, { withRecipient: true }),
+  }, intervention);
+  if (intervention.outcome !== 'pending') {
+    const outcomeCc = codeableConcept(intervention.outcome, { code: intervention.outcome, system: codeSystemUrl(INTERVENTION_OUTCOME_SLUG) });
+    payload.output = [{ type: codeableConcept(INTERVENTION_OUTCOME_SLUG), valueCodeableConcept: outcomeCc }];
   }
-  if (intervention.kind === 'education') {
-    return Communication.fromIntervention({ intervention });
+  return payload;
+}
+
+function communicationRequestResource(intervention) {
+  return withNote({
+    ...baseResource('CommunicationRequest', intervention.interventionId, INTERVENTION_SLUG, intervention.patientId),
+    status: intervention.outcome === 'pending' ? 'active' : 'completed',
+    intent: 'plan',
+    category: [codeableConcept(intervention.kind, { code: intervention.kind, system: codeSystemUrl(INTERVENTION_KIND_SLUG) })],
+    reason: interventionReason(intervention.caseId),
+    payload: [{ contentCodeableConcept: codeableConcept(intervention.interventionLabel) }],
+    recipient: [recipientReference({
+      patientId: intervention.patientId,
+      recipientKind: intervention.recipientKind,
+      recipientRefId: intervention.recipientRefId,
+    })],
+    occurrenceDateTime: toIso(intervention.deliveredAt),
+    authoredOn: toIso(intervention.deliveredAt),
+    extension: interventionExtensions(intervention),
+  }, intervention);
+}
+
+function interventionExtensions(intervention, { withRecipient = false } = {}) {
+  const out = [];
+  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 }));
+  if (withRecipient && intervention.recipientKind === 'related_person' && intervention.recipientRefId) {
+    out.push(extension(EXT.RECIPIENT_KIND, { valueString: 'related_person' }));
+    out.push(extension(EXT.RECIPIENT_REF, { valueString: intervention.recipientRefId }));
   }
-  if (intervention.kind === 'team_escalation') {
-    return Task.fromIntervention({ intervention });
+  return out;
+}
+
+function fromFhir(resources, { patientId }) {
+  return resources
+    .filter((r) => RESOURCE_TYPES.includes(r.resourceType) && identifierValue(r, INTERVENTION_SLUG))
+    .map((resource) => reconstruct(resource, patientId))
+    .filter(Boolean);
+}
+
+function reconstruct(resource, patientId) {
+  const reasonRef = resource.reason && resource.reason[0] && resource.reason[0].reference;
+  const base = {
+    interventionId: identifierValue(resource, INTERVENTION_SLUG),
+    patientId,
+    caseId: refToId(reasonRef && reasonRef.reference),
+    rationale: extValues(resource, EXT.RATIONALE)[0] ?? null,
+    outcomeNotes: extValues(resource, EXT.OUTCOME_NOTES)[0] ?? null,
+    outcomeExt: extValues(resource, EXT.OUTCOME)[0] ?? null,
+    recipientKind: 'patient',
+    recipientRefId: null,
+  };
+  let reconstructed;
+  if (resource.resourceType === 'Procedure') reconstructed = reconstructProcedure(resource, base);
+  else if (resource.resourceType === 'Communication') reconstructed = reconstructCommunication(resource, base);
+  else if (resource.resourceType === 'Task') reconstructed = reconstructTask(resource, base);
+  else reconstructed = reconstructCommunicationRequest(resource, base);
+  try {
+    return new Intervention(reconstructed);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      logger.warn({ interventionId: reconstructed.interventionId }, 'skipping malformed intervention resource');
+      return null;
+    }
+    throw error;
   }
-  if (intervention.kind === 'follow_up_check') {
-    return CommunicationRequest.fromIntervention({ intervention });
+}
+
+function reconstructProcedure(resource, base) {
+  const { outcomeExt, ...dto } = base;
+  return {
+    ...dto,
+    kind: categoryCode(resource),
+    interventionLabel: (resource.code && resource.code.text) || null,
+    deliveredAt: resource.occurrenceDateTime,
+    outcome: outcomeExt ?? codeableConceptCode(resource.outcome),
+    ...recipientFromExtension(resource),
+  };
+}
+
+function reconstructCommunication(resource, base) {
+  const { outcomeExt, ...dto } = base;
+  const content = resource.payload && resource.payload[0] && resource.payload[0].contentCodeableConcept;
+  const outcome = outcomeExt ?? undefined;
+  return {
+    ...dto,
+    kind: categoryCode(resource),
+    interventionLabel: (content && content.text) || null,
+    deliveredAt: resource.sent,
+    ...(outcome ? { outcome } : {}),
+    ...recipientFromReference(resource),
+  };
+}
+
+function reconstructTask(resource, base) {
+  const { outcomeExt, ...dto } = base;
+  const output = resource.output && resource.output[0];
+  return {
+    ...dto,
+    kind: codingCode(resource.code),
+    interventionLabel: (resource.code && resource.code.text) || null,
+    deliveredAt: resource.authoredOn,
+    outcome: outcomeExt ?? (output ? codeableConceptCode(output.valueCodeableConcept) : 'pending'),
+    ...recipientFromExtension(resource),
+  };
+}
+
+function reconstructCommunicationRequest(resource, base) {
+  const { outcomeExt, ...dto } = base;
+  const content = resource.payload && resource.payload[0] && resource.payload[0].contentCodeableConcept;
+  return {
+    ...dto,
+    kind: categoryCode(resource),
+    interventionLabel: (content && content.text) || null,
+    deliveredAt: resource.occurrenceDateTime,
+    outcome: outcomeExt ?? (resource.status === 'active' ? 'pending' : 'unknown'),
+    ...recipientFromReference(resource),
+  };
+}
+
+function recipientFromExtension(resource) {
+  const kind = extValues(resource, EXT.RECIPIENT_KIND)[0];
+  const refId = extValues(resource, EXT.RECIPIENT_REF)[0];
+  if (kind === 'related_person' && refId) return { recipientKind: 'related_person', recipientRefId: refId };
+  return { recipientKind: 'patient', recipientRefId: null };
+}
+
+function recipientFromReference(resource) {
+  const recipientRef = resource.recipient && resource.recipient[0] && resource.recipient[0].reference;
+  if (recipientRef && recipientRef.startsWith('RelatedPerson/')) {
+    return { recipientKind: 'related_person', recipientRefId: refToId(recipientRef) };
   }
-  throw new Error(`unknown intervention variant: ${intervention.kind}`);
+  return { recipientKind: 'patient', recipientRefId: null };
 }
 
+const codingCode = (concept) => (concept && concept.coding && concept.coding[0] && concept.coding[0].code) || null;
+const categoryCode = (resource) => codingCode(resource.category && resource.category[0]);
+const codeableConceptCode = (concept) => codingCode(concept) || (concept && concept.text) || 'pending';
+
 module.exports = {
-  projectIntervention,
-  PROJECTOR_NAME,
+  toFhir,
+  fromFhir,
 };

package/lib/fhir/projections/registerProjectors.js

@@ -2,13 +2,9 @@ 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');
-const { projectIntervention, PROJECTOR_NAME: INTERVENTION_PROJECTOR_NAME } = require('./interventionProjection');
-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');
 
@@ -16,13 +12,9 @@ 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 },
-  { name: INTERVENTION_PROJECTOR_NAME, project: projectIntervention },
-  { 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 },
 ];