@peopl-health/nexus 5.9.0-dev.921 → 6.0.0-dev.611

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 };

package/lib/fhir/resources/RiskAssessment.js

@@ -1,99 +0,0 @@
-const { getDeviceId } = require('../config/fhirConfig');
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  patientReference,
-  reference,
-  codeableConcept,
-  extension,
-  toIso,
-} = require('../helpers/elementHelper');
-const { PATIENT_RISK_SLUG } = require('../constants/projectionSlugs');
-
-const RISK_SEVERITY_CODESYSTEM = 'risk-severity';
-const PREDICTION_KIND_AE = 'ae';
-const PREDICTION_KIND_DISEASE = 'disease';
-const PREDICTION_KIND_COMORBIDITY = 'comorbidity';
-
-function aePrediction(ae) {
-  const prediction = {
-    outcome: codeableConcept(ae.aeName),
-    qualitativeRisk: codeableConcept(ae.severityIfConfirmed, {
-      code: ae.severityIfConfirmed,
-      system: codeSystemUrl(RISK_SEVERITY_CODESYSTEM),
-    }),
-    extension: [extension('risk-prediction-kind', { valueString: PREDICTION_KIND_AE })],
-  };
-  if (ae.why) prediction.rationale = ae.why;
-  for (const symptom of ae.minimumSymptomSet) {
-    prediction.extension.push(extension('risk-minimum-symptom-set', { valueString: symptom }));
-  }
-  return prediction;
-}
-
-function diseasePrediction(risk) {
-  const prediction = {
-    outcome: codeableConcept(risk.bodySite),
-    extension: [extension('risk-prediction-kind', { valueString: PREDICTION_KIND_DISEASE })],
-  };
-  for (const complication of risk.complications) {
-    prediction.extension.push(extension('risk-disease-complication', { valueString: complication }));
-  }
-  for (const symptom of risk.warningSymptoms) {
-    prediction.extension.push(extension('risk-disease-warning-symptom', { valueString: symptom }));
-  }
-  for (const comorbidity of risk.amplifierComorbidities) {
-    prediction.extension.push(extension('risk-disease-amplifier', { valueString: comorbidity }));
-  }
-  return prediction;
-}
-
-function comorbidityPrediction(amplifier) {
-  const prediction = {
-    outcome: codeableConcept(amplifier.comorbidity),
-    rationale: amplifier.interaction,
-    extension: [extension('risk-prediction-kind', { valueString: PREDICTION_KIND_COMORBIDITY })],
-  };
-  if (amplifier.clinicalNote) {
-    prediction.extension.push(extension('risk-comorbidity-clinical-note', { valueString: amplifier.clinicalNote }));
-  }
-  return prediction;
-}
-
-class RiskAssessment {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromPatientRisk({ assessment }) {
-    const payload = {
-      resourceType: 'RiskAssessment',
-      id: fhirId(assessment.assessmentId),
-      identifier: [identifier(PATIENT_RISK_SLUG, assessment.assessmentId)],
-      status: assessment.status,
-      subject: patientReference(assessment.patientId),
-      performer: reference('Device', getDeviceId()),
-      occurrenceDateTime: toIso(assessment.assessedAt),
-    };
-    const prediction = [
-      ...assessment.predictedAes.map(aePrediction),
-      ...assessment.diseaseRisks.map(diseasePrediction),
-      ...assessment.comorbidityAmplifiers.map(comorbidityPrediction),
-    ];
-    if (prediction.length) payload.prediction = prediction;
-    const extensions = [];
-    if (assessment.sourceRegimen) extensions.push(extension('assessed-source-regimen', { valueString: assessment.sourceRegimen }));
-    if (assessment.sourceDiagnosis) extensions.push(extension('assessed-source-diagnosis', { valueString: assessment.sourceDiagnosis }));
-    if (assessment.sourcePhase) extensions.push(extension('assessed-source-phase', { valueString: assessment.sourcePhase }));
-    if (assessment.assessedByModel) extensions.push(extension('assessed-by-model', { valueString: assessment.assessedByModel }));
-    if (extensions.length) payload.extension = extensions;
-    return new RiskAssessment(payload);
-  }
-}
-
-module.exports = {
-  RiskAssessment,
-  PREDICTION_KIND_AE,
-  PREDICTION_KIND_DISEASE,
-  PREDICTION_KIND_COMORBIDITY,
-};

package/lib/fhir/resources/Task.js

@@ -1,106 +0,0 @@
-const { getDeviceId } = require('../config/fhirConfig');
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  reference,
-  patientReference,
-  codeableConcept,
-  extension,
-  notes,
-  toIso,
-} = require('../helpers/elementHelper');
-const {
-  ESCALATION_SLUG,
-  ESCALATION_KIND_SLUG,
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
-  INTERVENTION_OUTCOME_SLUG,
-  ROUTING_DISPOSITION_SLUG,
-} = require('../constants/projectionSlugs');
-const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
-const { interventionExtensions } = require('./interventionExtensions');
-
-const TICKET_STATUS_TO_TASK_STATUS = {
-  queued: 'requested',
-  sent: 'requested',
-  acknowledged: 'in-progress',
-  failed: 'failed',
-};
-
-class Task {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromTicketEscalation({ ticket, deviceId }) {
-    const payload = {
-      resourceType: 'Task',
-      id: fhirId(ticket.eventId),
-      identifier: [identifier(ESCALATION_SLUG, ticket.eventId)],
-      status: TICKET_STATUS_TO_TASK_STATUS[ticket.status],
-      intent: 'order',
-      priority: SEVERITY_TO_PRIORITY[ticket.severity] || 'routine',
-      code: codeableConcept(ticket.kind, { code: ticket.kind, system: codeSystemUrl(ESCALATION_KIND_SLUG) }),
-      for: patientReference(ticket.patientId),
-      authoredOn: toIso(ticket.createdAt),
-      requester: reference('Device', deviceId),
-    };
-    if (ticket.title) payload.description = ticket.title;
-    if (ticket.reason) payload.note = [{ text: ticket.reason }];
-    if (typeof ticket.slaMinutes === 'number' && ticket.slaMinutes > 0) {
-      const start = new Date(ticket.createdAt);
-      const end = new Date(start.getTime() + ticket.slaMinutes * 60000);
-      payload.restriction = { period: { start: toIso(start), end: toIso(end) } };
-      payload.extension = [extension('sla-budget-minutes', { valueInteger: ticket.slaMinutes })];
-    }
-    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 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/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,
-};

package/lib/fhir/services/clusterService.js

@@ -1,77 +0,0 @@
-const { ZodError } = require('zod');
-
-const { fhirId, identifierSystem } = require('../helpers/fhirHelper');
-const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
-const { CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG } = require('../constants/projectionSlugs');
-const { CLUSTER_LIST_SEPARATOR } = require('../resources/ClinicalImpression');
-const { PROJECTOR_NAME } = require('../projections/clusterProjection');
-const { getFhirStore } = require('../stores/fhirStore');
-const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-async function storeCluster({ patientId, cluster, history = [] }) {
-  if (cluster.patientId !== patientId) {
-    throw new Error(`storeCluster patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: { cluster, history } }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function readClusters({ patientId, label = null, status = null }) {
-  const store = getFhirStore();
-  const patient = `Patient/${fhirId(patientId)}`;
-  const clusterSystem = identifierSystem(CLUSTER_IMPRESSION_SLUG);
-  const impressions = (await store.find({ patient, resourceType: 'ClinicalImpression' }))
-    .filter((resource) => (resource.identifier || []).some((id) => id.system === clusterSystem))
-    .filter((resource) => identifierValue(resource, CLUSTER_IMPRESSION_SLUG));
-  const clusters = [];
-  for (const impression of impressions) {
-    let cluster;
-    try {
-      cluster = new ClusterImpression(reconstructCluster(impression, patientId));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ clusterId: impression.id }, 'skipping malformed cluster ClinicalImpression');
-        continue;
-      }
-      throw error;
-    }
-    if (label && cluster.label !== label) continue;
-    if (status && cluster.status !== status) continue;
-    clusters.push(cluster);
-  }
-  return clusters;
-}
-
-function reconstructCluster(resource, patientId) {
-  const ext = extMap(resource);
-  const period = resource.effectivePeriod || {};
-  return {
-    schemaVersion: '1',
-    clusterId: identifierValue(resource, CLUSTER_IMPRESSION_SLUG),
-    patientId,
-    label: identifierValue(resource, CLUSTER_LABEL_SLUG) || '',
-    hypothesisType: ext.clusterHypothesisType,
-    status: ext['cluster-status'],
-    confidence: ext.clusterHypothesisConfidence,
-    clinicalSignificance: ext.clusterClinicalSignificance,
-    memberCaseIds: (resource.problem || []).map((problemRef) => refToId(problemRef.reference)).filter(Boolean),
-    consultationId: ext['cluster-consultation-id'] || null,
-    relationshipModel: resource.summary || '',
-    strengthensIf: ext.clusterStrengthensIf ? ext.clusterStrengthensIf.split(CLUSTER_LIST_SEPARATOR) : [],
-    weakensIf: ext.clusterWeakensIf ? ext.clusterWeakensIf.split(CLUSTER_LIST_SEPARATOR) : [],
-    openingReasoning: resource.description || '',
-    openedAt: resource.effectiveDateTime || period.start,
-    dissolvedAt: period.end || null,
-    dissolveReason: ext['cluster-dissolve-reason'] || null,
-    dissolveCategory: (resource.statusReason && resource.statusReason.text) || null,
-  };
-}
-
-module.exports = {
-  storeCluster,
-  readClusters,
-};

package/lib/fhir/services/contingencyService.js

@@ -1,117 +0,0 @@
-const { ZodError } = require('zod');
-
-const { fhirId } = require('../helpers/fhirHelper');
-const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
-const {
-  CONTINGENCY_PLAN_SLUG,
-  CONTINGENCY_STEP_SLUG,
-} = require('../constants/projectionSlugs');
-const { CONTINGENCY_STATUS_TO_FHIR } = require('../resources/CarePlan');
-const { PROJECTOR_NAME } = require('../projections/contingencyProjection');
-const { getFhirStore } = require('../stores/fhirStore');
-const { ContingencySafetyNet } = require('../../shared/dtos/ContingencySafetyNet');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-const FHIR_TO_CONTINGENCY_STATUS = invert(CONTINGENCY_STATUS_TO_FHIR);
-
-async function storeContingency({ patientId, contingency }) {
-  if (contingency.carePlan.patientId !== patientId) {
-    throw new Error(`storeContingency patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: contingency }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function readContingencies({ patientId, caseId = null, clusterId = null }) {
-  const store = getFhirStore();
-  const patient = `Patient/${fhirId(patientId)}`;
-  const plans = (await store.find({ patient, resourceType: 'CarePlan' }))
-    .filter((plan) => identifierValue(plan, CONTINGENCY_PLAN_SLUG));
-  const requests = (await store.find({ patient, resourceType: 'CommunicationRequest' }))
-    .filter((request) => identifierValue(request, CONTINGENCY_STEP_SLUG));
-
-  const nets = [];
-  for (const plan of plans) {
-    const net = reconstructContingency(plan, requests, patientId);
-    if (caseId && net.carePlan.relatedCaseId !== caseId) continue;
-    if (clusterId && net.carePlan.relatedClusterId !== clusterId) continue;
-    try {
-      nets.push(new ContingencySafetyNet(net));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ planId: net.carePlan.planId }, 'skipping malformed contingency CarePlan');
-        continue;
-      }
-      throw error;
-    }
-  }
-  return nets;
-}
-
-function reconstructContingency(plan, requests, patientId) {
-  const planId = identifierValue(plan, CONTINGENCY_PLAN_SLUG);
-  const ext = extMap(plan);
-  const stepIds = new Set([`${planId}-care_team`, `${planId}-patient`]);
-  const planSteps = requests
-    .filter((resource) => stepIds.has(identifierValue(resource, CONTINGENCY_STEP_SLUG)))
-    .map(reconstructStep);
-  const teamEscalation = planSteps.find((step) => step.recipient === 'care_team') || null;
-  const patientReminder = planSteps.find((step) => step.recipient === 'patient') || null;
-  const address = plan.addresses && plan.addresses[0] && plan.addresses[0].reference;
-  return {
-    schemaVersion: '1',
-    carePlan: {
-      planId,
-      patientId,
-      relatedCaseId: refToId(address && address.reference),
-      relatedClusterId: refToId(plan.supportingInfo && plan.supportingInfo[0] && plan.supportingInfo[0].reference),
-      concern: plan.description || '',
-      awaitingCharacterization: ext['contingency-awaiting-characterization'] || '',
-      whyThisMatters: ext['contingency-why-this-matters'] || '',
-      creationReasoning: ext['contingency-creation-reasoning'] || '',
-      status: ext['contingency-status'] || FHIR_TO_CONTINGENCY_STATUS[plan.status] || 'armed',
-      createdAt: plan.created,
-      resolvedAt: (plan.period && plan.period.end) || null,
-      resolvedReason: ext['contingency-resolved-reason'] || null,
-    },
-    teamEscalation,
-    patientReminder,
-  };
-}
-
-function reconstructStep(resource) {
-  const ext = extMap(resource);
-  const silence = ext['fires-after-silence-minutes'];
-  const firstPayload = resource.payload && resource.payload[0];
-  return {
-    recipient: recipientOf(resource),
-    message: (firstPayload && firstPayload.contentCodeableConcept && firstPayload.contentCodeableConcept.text) || null,
-    priority: ext['contingency-step-priority'] || resource.priority || null,
-    actionRequested: ext['contingency-action-requested'] || null,
-    firesAfterSilenceMinutes: typeof silence === 'number' ? silence : null,
-  };
-}
-
-function recipientOf(resource) {
-  const category = resource.category && resource.category[0] && resource.category[0].text;
-  if (category === 'contingency-patient') return 'patient';
-  if (category === 'contingency-care_team') return 'care_team';
-  const ref = resource.recipient && resource.recipient[0] && resource.recipient[0].reference;
-  return ref && ref.startsWith('Organization/') ? 'care_team' : 'patient';
-}
-
-function invert(map) {
-  const out = {};
-  for (const [key, value] of Object.entries(map)) {
-    if (!(value in out)) out[value] = key;
-  }
-  return out;
-}
-
-module.exports = {
-  storeContingency,
-  readContingencies,
-};

package/lib/fhir/services/interventionService.js

@@ -1,149 +0,0 @@
-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 { 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']);
-
-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);
-  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);
-}
-
-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/lib/fhir/services/resultObservationService.js

@@ -1,52 +0,0 @@
-const { Observation } = require('../resources/Observation');
-const { Provenance } = require('../resources/Provenance');
-const { RESULT_SLUG } = require('../constants/projectionSlugs');
-const { storeResources } = require('./fhirService');
-
-function resolveEffective(raw, now) {
-  if (typeof raw === 'string' && raw.trim()) {
-    const parsed = new Date(raw);
-    if (!Number.isNaN(parsed.getTime())) return parsed.toISOString();
-  }
-  return now;
-}
-
-async function storeResultObservations({ patientId, turnId, observations, idBase, now = new Date().toISOString() }) {
-  const pid = typeof patientId === 'string' ? patientId.trim() : '';
-  const tid = typeof turnId === 'string' ? turnId.trim() : '';
-  if (!pid || !tid) throw new Error('storeResultObservations requires non-empty patientId and turnId');
-  const base = typeof idBase === 'string' && idBase.trim() ? idBase.trim() : tid;
-
-  const ids = [];
-  const resources = [];
-  (observations || []).forEach((obs, index) => {
-    if (!obs || typeof obs !== 'object') return;
-    const code = (obs.code || '').trim();
-    if (!code) return;
-    const obsId = `rrobs_${base}_${index}`;
-    ids.push(obsId);
-    resources.push(Observation.fromResultObservation({
-      patientId: pid,
-      obsId,
-      code,
-      value: obs.value,
-      unit: obs.unit,
-      category: obs.category,
-      effective: resolveEffective(obs.effective, now),
-      now,
-      slug: RESULT_SLUG,
-    }));
-  });
-  if (!ids.length) return { count: 0, ids: [] };
-
-  resources.push(Provenance.fromResultObservations({
-    targetIds: ids,
-    provenanceId: `rrprov_${base}`,
-    activityText: 'patient-reported result recording',
-    now,
-  }));
-  await storeResources(resources);
-  return { count: ids.length, ids };
-}
-
-module.exports = { storeResultObservations };