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

package/lib/fhir/projections/routingProjection.js

@@ -1,48 +0,0 @@
-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 ACTIVITY_TEXT = 'routing-decision';
-
-const DISPOSITION_BY_KIND = {
-  communication: Communication,
-  communication_request: CommunicationRequest,
-  task: Task,
-  orchestration: RequestOrchestration,
-  care_plan: CarePlan,
-};
-
-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];
-}
-
-module.exports = {
-  projectRoutingDecision,
-  PROJECTOR_NAME,
-};

package/lib/fhir/projections/symptomCaseProjection.js

@@ -1,65 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { ClinicalImpression } = require('../resources/ClinicalImpression');
-const { Condition } = require('../resources/Condition');
-const { Observation } = require('../resources/Observation');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'symptomCase';
-const ACTIVITY_TEXT = 'symptom-management';
-const PLACEHOLDER_DECISION_POSTURE = 'pending_initial_assessment';
-
-function assessmentResources(assessment, dropPreviousTo) {
-  const grade = assessment.grade;
-  const hasGradeSignal = grade.bestEstimate !== null
-    || grade.possibleRange !== null
-    || Boolean(grade.confidence)
-    || Boolean(grade.reasoning)
-    || Boolean(assessment.gradeThresholdClause);
-  const out = [ClinicalImpression.fromSymptomAssessment({ assessment, dropPreviousTo, hasGradeSignal })];
-  if (hasGradeSignal) out.push(Observation.fromSymptomGrade({ assessment }));
-  return out;
-}
-
-function projectSymptomCase(managedSymptom) {
-  const { condition, latestAssessment, priorAssessments } = managedSymptom;
-  const allAssessments = [latestAssessment, ...priorAssessments];
-  const placeholderIds = new Set(
-    allAssessments.filter((a) => a.decisionPosture === PLACEHOLDER_DECISION_POSTURE).map((a) => a.assessmentId),
-  );
-
-  const fhirCondition = Condition.fromSymptomCase({
-    condition,
-    verification: latestAssessment.gradeVerification,
-    headAssessmentId: latestAssessment.assessmentId,
-  });
-
-  const out = [fhirCondition, ...assessmentResources(latestAssessment, placeholderIds)];
-  const provenanceTargets = [
-    { reference: `Condition/${fhirId(condition.conditionId)}` },
-    { reference: `ClinicalImpression/${fhirId(latestAssessment.assessmentId)}` },
-  ];
-  out.push(Provenance.fromSymptomCase({
-    provenanceId: `${condition.conditionId}-prov`,
-    targetRefs: provenanceTargets,
-    recordedAt: latestAssessment.performedAt,
-    activityText: ACTIVITY_TEXT,
-  }));
-
-  for (const prior of priorAssessments) {
-    if (placeholderIds.has(prior.assessmentId)) continue;
-    out.push(...assessmentResources(prior, placeholderIds));
-    out.push(Provenance.fromSymptomCase({
-      provenanceId: `${prior.assessmentId}-prov`,
-      targetRefs: [{ reference: `ClinicalImpression/${fhirId(prior.assessmentId)}` }],
-      recordedAt: prior.performedAt,
-      activityText: ACTIVITY_TEXT,
-    }));
-  }
-
-  return out;
-}
-
-module.exports = {
-  projectSymptomCase,
-  PROJECTOR_NAME,
-};

package/lib/fhir/resources/CarePlan.js

@@ -1,93 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  patientReference,
-  reference,
-  codeableConcept,
-  extension,
-  toIso,
-} = require('../helpers/elementHelper');
-const { CONTINGENCY_PLAN_SLUG, ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
-
-const CONTINGENCY_STATUS_TO_FHIR = {
-  armed: 'active',
-  fired_reminder: 'active',
-  fired_team: 'active',
-  auto_resolved: 'completed',
-  cancelled: 'revoked',
-};
-
-class CarePlan {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromContingency({ carePlan }) {
-    const payload = {
-      resourceType: 'CarePlan',
-      id: fhirId(carePlan.planId),
-      identifier: [identifier(CONTINGENCY_PLAN_SLUG, carePlan.planId)],
-      status: CONTINGENCY_STATUS_TO_FHIR[carePlan.status],
-      intent: 'plan',
-      subject: patientReference(carePlan.patientId),
-      created: toIso(carePlan.createdAt),
-      period: contingencyPeriod(carePlan),
-    };
-    if (carePlan.concern) payload.description = carePlan.concern;
-    if (carePlan.relatedCaseId) {
-      payload.addresses = [{ reference: reference('Condition', carePlan.relatedCaseId) }];
-    }
-    if (carePlan.relatedClusterId) {
-      payload.supportingInfo = [reference('ClinicalImpression', carePlan.relatedClusterId)];
-    }
-    const ext = contingencyExtensions(carePlan);
-    if (ext.length) payload.extension = ext;
-    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);
-  }
-}
-
-function contingencyPeriod(carePlan) {
-  const period = { start: toIso(carePlan.createdAt) };
-  if (carePlan.resolvedAt) period.end = toIso(carePlan.resolvedAt);
-  return period;
-}
-
-function contingencyExtensions(carePlan) {
-  const out = [extension('contingency-status', { valueString: carePlan.status })];
-  if (carePlan.awaitingCharacterization) {
-    out.push(extension('contingency-awaiting-characterization', { valueString: carePlan.awaitingCharacterization }));
-  }
-  if (carePlan.whyThisMatters) {
-    out.push(extension('contingency-why-this-matters', { valueString: carePlan.whyThisMatters }));
-  }
-  if (carePlan.creationReasoning) {
-    out.push(extension('contingency-creation-reasoning', { valueString: carePlan.creationReasoning }));
-  }
-  if (carePlan.resolvedReason) {
-    out.push(extension('contingency-resolved-reason', { valueString: carePlan.resolvedReason }));
-  }
-  return out;
-}
-
-module.exports = {
-  CarePlan,
-  CONTINGENCY_STATUS_TO_FHIR,
-};

package/lib/fhir/resources/ClinicalImpression.js

@@ -1,118 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { SYMPTOM_ASSESSMENT_SLUG, CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, ROUTING_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
-
-const CLUSTER_STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
-const CLUSTER_LIST_SEPARATOR = '; ';
-
-class ClinicalImpression {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromClusterImpression({ cluster }) {
-    const epistemicExts = [
-      extension('clusterHypothesisType', { valueString: cluster.hypothesisType }),
-      extension('clusterHypothesisConfidence', { valueString: cluster.confidence }),
-      extension('clusterClinicalSignificance', { valueString: cluster.clinicalSignificance }),
-    ];
-    if (cluster.strengthensIf.length) {
-      epistemicExts.push(extension('clusterStrengthensIf', { valueString: cluster.strengthensIf.join(CLUSTER_LIST_SEPARATOR) }));
-    }
-    if (cluster.weakensIf.length) {
-      epistemicExts.push(extension('clusterWeakensIf', { valueString: cluster.weakensIf.join(CLUSTER_LIST_SEPARATOR) }));
-    }
-    const lifecycleExts = [extension('cluster-status', { valueString: cluster.status })];
-    if (cluster.consultationId) lifecycleExts.push(extension('cluster-consultation-id', { valueString: cluster.consultationId }));
-    if (cluster.dissolveReason) lifecycleExts.push(extension('cluster-dissolve-reason', { valueString: cluster.dissolveReason }));
-
-    const identifiers = [identifier(CLUSTER_IMPRESSION_SLUG, cluster.clusterId)];
-    if (cluster.label) identifiers.push(identifier(CLUSTER_LABEL_SLUG, cluster.label));
-
-    const payload = {
-      resourceType: 'ClinicalImpression',
-      id: fhirId(cluster.clusterId),
-      identifier: identifiers,
-      status: CLUSTER_STATUS_TO_FHIR[cluster.status],
-      subject: patientReference(cluster.patientId),
-      problem: cluster.memberCaseIds.map((caseId) => reference('Condition', caseId)),
-      extension: [...epistemicExts, ...lifecycleExts],
-    };
-    if (cluster.relationshipModel) payload.summary = cluster.relationshipModel;
-    if (cluster.openingReasoning) payload.description = cluster.openingReasoning;
-    if (cluster.dissolvedAt) {
-      // toIso normalizes to Z; a non-Z openedAt/dissolvedAt does not byte-for-byte round-trip (known loss).
-      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 new ClinicalImpression(payload);
-  }
-
-  static fromSymptomAssessment({ assessment, dropPreviousTo = null, hasGradeSignal = false }) {
-    const extensions = [];
-    if (assessment.trajectory) extensions.push(extension('trajectory', { valueString: assessment.trajectory }));
-    if (assessment.decisionPosture) extensions.push(extension('decision-posture', { valueString: assessment.decisionPosture }));
-    if (assessment.postureReason) extensions.push(extension('posture-reason', { valueString: assessment.postureReason }));
-    if (assessment.reasoning) extensions.push(extension('assessment-reasoning', { valueString: assessment.reasoning }));
-    const payload = {
-      resourceType: 'ClinicalImpression',
-      id: fhirId(assessment.assessmentId),
-      identifier: [identifier(SYMPTOM_ASSESSMENT_SLUG, assessment.assessmentId)],
-      status: 'completed',
-      subject: patientReference(assessment.patientId),
-      effectiveDateTime: toIso(assessment.performedAt),
-      problem: [reference('Condition', assessment.conditionId)],
-      extension: extensions,
-    };
-    if (hasGradeSignal) {
-      payload.finding = [{ item: { reference: reference('Observation', `${assessment.assessmentId}-grade`) } }];
-    }
-    if (assessment.problemRepresentation) payload.summary = assessment.problemRepresentation;
-    if (assessment.previousId && !(dropPreviousTo && dropPreviousTo.has(assessment.previousId))) {
-      payload.previous = reference('ClinicalImpression', assessment.previousId);
-    }
-    return new ClinicalImpression(payload);
-  }
-
-  static fromRoutingAssessment({ assessment, decisionId, committedAt, deferredItems = [], primaryCaseId = null }) {
-    const extensions = [
-      extension('routing-turn-id', { valueString: assessment.turnId }),
-      extension('routing-decision-id', { valueString: decisionId }),
-      extension('routing-committed-at', { valueDateTime: toIso(committedAt) }),
-    ];
-    if (primaryCaseId) extensions.push(extension('routing-primary-case-id', { valueString: primaryCaseId }));
-    for (const deferred of deferredItems) {
-      extensions.push(extension('routing-deferred-item', { valueString: deferred.item }));
-      extensions.push(extension('routing-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) => ({
-        item: reference('Condition', finding.caseId),
-        extension: [
-          extension('routing-finding-case-id', { valueString: finding.caseId }),
-          extension('routing-finding-reasoning', { valueString: finding.clinicalReasoning }),
-          extension('routing-finding-action', { valueString: finding.decisionAction }),
-        ],
-      })),
-      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);
-  }
-}
-
-module.exports = {
-  ClinicalImpression,
-  CLUSTER_STATUS_TO_FHIR,
-  CLUSTER_LIST_SEPARATOR,
-};

package/lib/fhir/resources/Communication.js

@@ -1,65 +0,0 @@
-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');
-
-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',
-      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/CommunicationRequest.js

@@ -1,182 +0,0 @@
-const { getOrganizationId } = require('../config/fhirConfig');
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  reference,
-  patientReference,
-  recipientReference,
-  codeableConcept,
-  extension,
-  notes,
-  toIso,
-} = require('../helpers/elementHelper');
-const {
-  ESCALATION_SLUG,
-  ESCALATION_KIND_SLUG,
-  REMINDER_SLUG,
-  REMINDER_KIND_SLUG,
-  COMMUNICATION_CHANNEL_SLUG,
-  CONTINGENCY_STEP_SLUG,
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
-  ROUTING_DISPOSITION_SLUG,
-} = require('../constants/projectionSlugs');
-const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
-const { CONTINGENCY_STATUS_TO_FHIR } = require('./CarePlan');
-
-const CONTINGENCY_PRIORITY_CROSSWALK = {
-  critical: 'stat',
-  high: 'urgent',
-  medium: 'routine',
-  low: 'routine',
-  routine: 'routine',
-  urgent: 'urgent',
-  asap: 'asap',
-  stat: 'stat',
-};
-const { interventionExtensions } = require('./interventionExtensions');
-
-const NOTIFY_STATUS_TO_CR_STATUS = {
-  queued: 'active',
-  sent: 'active',
-  acknowledged: 'completed',
-  failed: 'revoked',
-};
-
-const REMINDER_STATUS_TO_CR_STATUS = {
-  scheduled: 'active',
-  cancelled: 'revoked',
-  expired: 'revoked',
-};
-
-class CommunicationRequest {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromNotifyEscalation({ notify }) {
-    const payload = {
-      resourceType: 'CommunicationRequest',
-      id: fhirId(notify.eventId),
-      identifier: [identifier(ESCALATION_SLUG, notify.eventId)],
-      status: NOTIFY_STATUS_TO_CR_STATUS[notify.status],
-      intent: 'plan',
-      priority: SEVERITY_TO_PRIORITY[notify.severity] || 'routine',
-      category: [codeableConcept(notify.kind, { code: notify.kind, system: codeSystemUrl(ESCALATION_KIND_SLUG) })],
-      subject: patientReference(notify.patientId),
-      authoredOn: toIso(notify.createdAt),
-    };
-    if (notify.reason) payload.reason = [{ concept: codeableConcept(notify.reason) }];
-    if (typeof notify.recipient === 'string' && /^[A-Za-z]+\/[A-Za-z0-9._-]+$/.test(notify.recipient)) {
-      payload.recipient = [{ reference: notify.recipient }];
-    }
-    if (notify.requiresAck) {
-      payload.extension = [extension('requires-ack', { valueBoolean: true })];
-    }
-    if (notify.fireAt) payload.occurrenceDateTime = toIso(notify.fireAt);
-    if (notify.followupPurpose) {
-      (payload.extension || (payload.extension = [])).push(
-        extension('followup-purpose', { valueString: notify.followupPurpose }),
-      );
-    }
-    return new CommunicationRequest(payload);
-  }
-
-  static fromReminder({ reminder }) {
-    const payload = {
-      resourceType: 'CommunicationRequest',
-      id: fhirId(reminder.reminderId),
-      identifier: [identifier(REMINDER_SLUG, reminder.reminderId)],
-      status: REMINDER_STATUS_TO_CR_STATUS[reminder.status],
-      intent: 'plan',
-      category: [codeableConcept(reminder.kind, { code: reminder.kind, system: codeSystemUrl(REMINDER_KIND_SLUG) })],
-      medium: [codeableConcept(reminder.channel, { code: reminder.channel, system: codeSystemUrl(COMMUNICATION_CHANNEL_SLUG) })],
-      subject: patientReference(reminder.patientId),
-      recipient: [recipientReference({
-        patientId: reminder.patientId,
-        recipientKind: reminder.recipientKind,
-        recipientRefId: reminder.recipientRefId,
-      })],
-      payload: [{ contentCodeableConcept: codeableConcept(reminder.message) }],
-      occurrenceDateTime: toIso(reminder.fireAt),
-      authoredOn: toIso(reminder.authoredAt),
-    };
-    if (reminder.cancelReason) payload.statusReason = codeableConcept(reminder.cancelReason);
-    return new CommunicationRequest(payload);
-  }
-
-  static fromContingencyStep({ step, planId, patientId, createdAt, parentStatus }) {
-    const stepId = `${planId}-${step.recipient}`;
-    const payload = {
-      resourceType: 'CommunicationRequest',
-      id: fhirId(stepId),
-      identifier: [identifier(CONTINGENCY_STEP_SLUG, stepId)],
-      status: CONTINGENCY_STATUS_TO_FHIR[parentStatus],
-      intent: 'plan',
-      category: [codeableConcept(`contingency-${step.recipient}`)],
-      subject: patientReference(patientId),
-      recipient: [step.recipient === 'patient'
-        ? patientReference(patientId)
-        : { reference: `Organization/${fhirId(getOrganizationId())}` }],
-      payload: [{ contentCodeableConcept: codeableConcept(step.message) }],
-      authoredOn: toIso(createdAt),
-      basedOn: [{ reference: `CarePlan/${fhirId(planId)}` }],
-    };
-    const priority = step.priority ? CONTINGENCY_PRIORITY_CROSSWALK[step.priority] || 'routine' : null;
-    if (priority) payload.priority = priority;
-    const ext = [];
-    if (step.priority) ext.push(extension('contingency-step-priority', { valueString: step.priority }));
-    if (step.actionRequested) ext.push(extension('contingency-action-requested', { valueString: step.actionRequested }));
-    if (step.firesAfterSilenceMinutes !== null && step.firesAfterSilenceMinutes !== undefined) {
-      ext.push(extension('fires-after-silence-minutes', { valueInteger: step.firesAfterSilenceMinutes }));
-    }
-    if (ext.length) payload.extension = ext;
-    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',
-      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/Device.js

@@ -1,24 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, codeableConcept } = require('../helpers/elementHelper');
-
-class Device {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromTriageProjection({ deviceId, compositeTableHash }) {
-    const version = [{ value: 'pro-ctcae-composite' }];
-    if (compositeTableHash) version.push({ type: { text: 'composite-table' }, value: `sha256:${compositeTableHash}` });
-    return new Device({
-      resourceType: 'Device',
-      id: fhirId(deviceId),
-      identifier: [identifier('device', deviceId)],
-      status: 'active',
-      name: [{ value: 'PRO-CTCAE composite → CTCAE grade estimator', type: 'user-friendly-name' }],
-      type: [codeableConcept('Software / clinical algorithm')],
-      version,
-    });
-  }
-}
-
-module.exports = { Device };

package/lib/fhir/resources/Patient.js

@@ -1,18 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier } = require('../helpers/elementHelper');
-
-class Patient {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromTriageProjection({ patientId }) {
-    return new Patient({
-      resourceType: 'Patient',
-      id: fhirId(String(patientId)),
-      identifier: [identifier('patient', String(patientId))],
-    });
-  }
-}
-
-module.exports = { Patient };

package/lib/fhir/resources/Questionnaire.js

@@ -1,23 +0,0 @@
-const { getQuestionnaireCanonicalUrl, getProctcaeVersion } = require('../config/fhirConfig');
-const { fhirId } = require('../helpers/fhirHelper');
-
-class Questionnaire {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromProctcaeCatalog({ items }) {
-    return new Questionnaire({
-      resourceType: 'Questionnaire',
-      id: fhirId(`pro-ctcae-${getProctcaeVersion()}`),
-      url: getQuestionnaireCanonicalUrl(),
-      version: getProctcaeVersion(),
-      status: 'active',
-      name: 'PROCTCAE',
-      subjectType: ['Patient'],
-      item: items,
-    });
-  }
-}
-
-module.exports = { Questionnaire };

package/lib/fhir/resources/QuestionnaireResponse.js

@@ -1,29 +0,0 @@
-const { getQuestionnaireCanonicalUrl, getProctcaeVersion } = require('../config/fhirConfig');
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference, toIso } = require('../helpers/elementHelper');
-
-class QuestionnaireResponse {
-  constructor(payload) {
-    Object.assign(this, payload);
-  }
-
-  static fromTriageProjection({ qr, items }) {
-    const tid = String(qr.triageId);
-    const identifiers = [identifier('triage', tid)];
-    if (qr.questionnaireId) identifiers.push(identifier('questionnaire-week', String(qr.questionnaireId)));
-    const payload = {
-      resourceType: 'QuestionnaireResponse',
-      id: fhirId(`triage-${tid}`),
-      identifier: identifiers,
-      questionnaire: `${getQuestionnaireCanonicalUrl()}|${getProctcaeVersion()}`,
-      status: (qr.completed ?? true) ? 'completed' : 'in-progress',
-      subject: patientReference(qr.patientId),
-      source: patientReference(qr.patientId),
-    };
-    if (qr.authored) payload.authored = toIso(qr.authored);
-    if (items.length) payload.item = items;
-    return new QuestionnaireResponse(payload);
-  }
-}
-
-module.exports = { QuestionnaireResponse };