@peopl-health/nexus 5.13.0-dev.1142 → 5.13.0-dev.1146

package/lib/fhir/projections/interventionProjection.js

@@ -1,18 +1,36 @@
-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,
@@ -21,22 +39,206 @@ function projectIntervention(intervention) {
 }
 
 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

@@ -6,7 +6,6 @@ const { projectSymptomCase, PROJECTOR_NAME: SYMPTOM_CASE_PROJECTOR_NAME } = requ
 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');
@@ -20,7 +19,6 @@ const PROJECTORS = [
   { 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 },

package/lib/fhir/resources/Communication.js

@@ -1,48 +1,12 @@
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  reference,
-  patientReference,
-  recipientReference,
-  codeableConcept,
-  notes,
-  toIso,
-} = require('../helpers/elementHelper');
-const {
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
-  ROUTING_DISPOSITION_SLUG,
-} = require('../constants/projectionSlugs');
-const { interventionExtensions } = require('./interventionExtensions');
+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 fromIntervention({ intervention }) {
-    const payload = {
-      resourceType: 'Communication',
-      id: fhirId(intervention.interventionId),
-      identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
-      status: 'completed',
-      category: [codeableConcept(intervention.kind, { code: intervention.kind, system: codeSystemUrl(INTERVENTION_KIND_SLUG) })],
-      subject: patientReference(intervention.patientId),
-      reason: [{ reference: reference('Condition', 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),
-    };
-    const note = notes(intervention.rationale, intervention.outcomeNotes);
-    if (note) payload.note = note;
-    return new Communication(payload);
-  }
-
   static fromRoutingDisposition({ disposition }) {
     const payload = {
       resourceType: 'Communication',

package/lib/fhir/resources/CommunicationRequest.js

@@ -15,12 +15,9 @@ const {
   REMINDER_SLUG,
   REMINDER_KIND_SLUG,
   COMMUNICATION_CHANNEL_SLUG,
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
   ROUTING_DISPOSITION_SLUG,
 } = require('../constants/projectionSlugs');
 const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
-const { interventionExtensions } = require('./interventionExtensions');
 
 const NOTIFY_STATUS_TO_CR_STATUS = {
   queued: 'active',
@@ -91,31 +88,6 @@ class CommunicationRequest {
     return new CommunicationRequest(payload);
   }
 
-  static fromIntervention({ intervention }) {
-    const payload = {
-      resourceType: 'CommunicationRequest',
-      id: fhirId(intervention.interventionId),
-      identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
-      status: intervention.outcome === 'pending' ? 'active' : 'completed',
-      intent: 'plan',
-      category: [codeableConcept(intervention.kind, { code: intervention.kind, system: codeSystemUrl(INTERVENTION_KIND_SLUG) })],
-      subject: patientReference(intervention.patientId),
-      reason: [{ reference: reference('Condition', 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),
-    };
-    const note = notes(intervention.rationale, intervention.outcomeNotes);
-    if (note) payload.note = note;
-    return new CommunicationRequest(payload);
-  }
-
   static fromRoutingDisposition({ disposition }) {
     const payload = {
       resourceType: 'CommunicationRequest',

package/lib/fhir/resources/Procedure.js

@@ -1,43 +1,11 @@
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  patientReference,
-  reference,
-  codeableConcept,
-  notes,
-  toIso,
-} = require('../helpers/elementHelper');
-const {
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
-  INTERVENTION_OUTCOME_SLUG,
-} = require('../constants/projectionSlugs');
-const { interventionExtensions } = require('./interventionExtensions');
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, patientReference } = require('../helpers/elementHelper');
 
 class Procedure {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromIntervention({ intervention }) {
-    const payload = {
-      resourceType: 'Procedure',
-      id: fhirId(intervention.interventionId),
-      identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
-      status: intervention.outcome === 'pending' ? 'in-progress' : 'completed',
-      code: codeableConcept(intervention.interventionLabel),
-      subject: patientReference(intervention.patientId),
-      reason: [{ reference: reference('Condition', 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 }),
-    };
-    const note = notes(intervention.rationale, intervention.outcomeNotes);
-    if (note) payload.note = note;
-    return new Procedure(payload);
-  }
-
   static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
     const assertion = fact.assertion;
     const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length

package/lib/fhir/resources/Task.js

@@ -12,9 +12,6 @@ const {
 const {
   ESCALATION_SLUG,
   ESCALATION_KIND_SLUG,
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
-  INTERVENTION_OUTCOME_SLUG,
   ROUTING_DISPOSITION_SLUG,
   RECOMMENDATION_REC_SLUG,
   PALLIATIVE_ESCALATION_SLUG,
@@ -22,7 +19,6 @@ const {
 } = require('../constants/projectionSlugs');
 const { PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
-const { interventionExtensions } = require('./interventionExtensions');
 
 const TICKET_STATUS_TO_TASK_STATUS = {
   queued: 'requested',
@@ -60,33 +56,6 @@ class Task {
     return new Task(payload);
   }
 
-  static fromIntervention({ intervention }) {
-    const payload = {
-      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: [{ reference: reference('Condition', intervention.caseId) }],
-      extension: interventionExtensions(intervention, { withRecipient: true }),
-    };
-    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 }];
-    }
-    const note = notes(intervention.rationale, intervention.outcomeNotes);
-    if (note) payload.note = note;
-    return new Task(payload);
-  }
-
   static fromRecommendationPlan({ plan, element, taskId }) {
     const { recommendation } = element;
     const { patient } = recommendation;

package/lib/fhir/services/interventionService.js

@@ -1,148 +1,24 @@
-const { ZodError } = require('zod');
-
-const { fhirId, identifierSystem } = require('../helpers/fhirHelper');
-const { identifierValue, refToId, extValues } = require('../helpers/fhirReadHelper');
-const { INTERVENTION_SLUG } = require('../constants/projectionSlugs');
-const {
-  RATIONALE_EXT,
-  OUTCOME_NOTES_EXT,
-  OUTCOME_EXT,
-  RECIPIENT_KIND_EXT,
-  RECIPIENT_REF_EXT,
-} = require('../resources/interventionExtensions');
-const { PROJECTOR_NAME } = require('../projections/interventionProjection');
+const { fhirId } = require('../helpers/fhirHelper');
 const { getFhirStore } = require('../stores/fhirStore');
-const { Intervention } = require('../../shared/dtos/Intervention');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-const VARIANT_TYPES = new Set(['Procedure', 'Communication', 'Task', 'CommunicationRequest']);
+const { toFhir, fromFhir } = require('../projections/interventionProjection');
+const { storeResources } = require('./fhirService');
 
 async function storeIntervention({ patientId, intervention }) {
   if (intervention.patientId !== patientId) {
     throw new Error(`storeIntervention patientId mismatch: expected ${patientId}`);
   }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: intervention }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
+  const { stored } = await storeResources(toFhir(intervention));
   return { count: stored.length, ids: stored };
 }
 
 async function readInterventions({ patientId, caseId = null }) {
   const store = getFhirStore();
   const patient = `Patient/${fhirId(patientId)}`;
-  const interventionSystem = identifierSystem(INTERVENTION_SLUG);
-  const resources = (await store.find({ patient }))
-    .filter((resource) => VARIANT_TYPES.has(resource.resourceType)
-      && (resource.identifier || []).some((id) => id.system === interventionSystem));
-  const interventions = [];
-  for (const resource of resources) {
-    if (!identifierValue(resource, INTERVENTION_SLUG)) continue;
-    const reconstructed = reconstructIntervention(resource, patientId);
-    if (!reconstructed.caseId) continue;
-    if (caseId && reconstructed.caseId !== caseId) continue;
-    try {
-      interventions.push(new Intervention(reconstructed));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ interventionId: reconstructed.interventionId }, 'skipping malformed intervention resource');
-        continue;
-      }
-      throw error;
-    }
-  }
-  return interventions;
-}
-
-function reconstructIntervention(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, RATIONALE_EXT)[0] ?? null,
-    outcomeNotes: extValues(resource, OUTCOME_NOTES_EXT)[0] ?? null,
-    outcomeExt: extValues(resource, OUTCOME_EXT)[0] ?? null,
-    recipientKind: 'patient',
-    recipientRefId: null,
-  };
-  if (resource.resourceType === 'Procedure') return reconstructProcedure(resource, base);
-  if (resource.resourceType === 'Communication') return reconstructCommunication(resource, base);
-  if (resource.resourceType === 'Task') return reconstructTask(resource, base);
-  return reconstructCommunicationRequest(resource, base);
+  const resources = await store.find({ patient });
+  return fromFhir(resources, { patientId })
+    .filter((intervention) => !caseId || intervention.caseId === caseId);
 }
 
-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, RECIPIENT_KIND_EXT)[0];
-  const refId = extValues(resource, RECIPIENT_REF_EXT)[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) };
-  }
-  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 = {
   storeIntervention,
   readInterventions,

package/package.json

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

package/lib/fhir/resources/interventionExtensions.js

@@ -1,28 +0,0 @@
-const { extension } = require('../helpers/elementHelper');
-
-const RATIONALE_EXT = 'intervention-rationale';
-const OUTCOME_NOTES_EXT = 'intervention-outcome-notes';
-const OUTCOME_EXT = 'intervention-outcome';
-const RECIPIENT_KIND_EXT = 'intervention-recipient-kind';
-const RECIPIENT_REF_EXT = 'intervention-recipient-ref';
-
-function interventionExtensions(intervention, { withRecipient = false } = {}) {
-  const out = [];
-  if (intervention.rationale) out.push(extension(RATIONALE_EXT, { valueString: intervention.rationale }));
-  if (intervention.outcomeNotes) out.push(extension(OUTCOME_NOTES_EXT, { valueString: intervention.outcomeNotes }));
-  if (intervention.outcome) out.push(extension(OUTCOME_EXT, { valueString: intervention.outcome }));
-  if (withRecipient && intervention.recipientKind === 'related_person' && intervention.recipientRefId) {
-    out.push(extension(RECIPIENT_KIND_EXT, { valueString: 'related_person' }));
-    out.push(extension(RECIPIENT_REF_EXT, { valueString: intervention.recipientRefId }));
-  }
-  return out;
-}
-
-module.exports = {
-  interventionExtensions,
-  RATIONALE_EXT,
-  OUTCOME_NOTES_EXT,
-  OUTCOME_EXT,
-  RECIPIENT_KIND_EXT,
-  RECIPIENT_REF_EXT,
-};