@peopl-health/nexus 5.13.0-dev.1152 → 5.13.0-dev.1155

package/lib/fhir/helpers/resourceHelper.js

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

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

@@ -34,7 +34,7 @@ function toFhir(intervention) {
     provenanceId: `${intervention.interventionId}-prov`,
     targetRefs: [{ reference: `${primary.resourceType}/${fhirId(intervention.interventionId)}` }],
     recordedAt: intervention.deliveredAt,
-    activityText: ACTIVITY_TEXT,
+    activity: codeableConcept(ACTIVITY_TEXT),
   })];
 }
 

package/lib/fhir/projections/registerProjectors.js

@@ -5,7 +5,6 @@ const { projectReminder, PROJECTOR_NAME: REMINDER_PROJECTOR_NAME } = require('./
 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 { projectCluster, PROJECTOR_NAME: CLUSTER_PROJECTOR_NAME } = require('./clusterProjection');
 const { projectPalliativeAssessment, PROJECTOR_NAME: PALLIATIVE_PROJECTOR_NAME } = require('./palliativeProjection');
 const { projectPalliativeCarePlan, PROJECTOR_NAME: PALLIATIVE_CAREPLAN_PROJECTOR_NAME } = require('./palliativeCarePlanProjection');
 
@@ -16,7 +15,6 @@ const PROJECTORS = [
   { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },
   { name: SAFETY_GATE_PROJECTOR_NAME, project: projectSafetyGate },
   { name: RECOMMENDATION_PLAN_PROJECTOR_NAME, project: projectRecommendationPlan },
-  { name: CLUSTER_PROJECTOR_NAME, project: projectCluster },
   { name: PALLIATIVE_PROJECTOR_NAME, project: projectPalliativeAssessment },
   { name: PALLIATIVE_CAREPLAN_PROJECTOR_NAME, project: projectPalliativeCarePlan },
 ];

package/lib/fhir/projections/routingProjection.js

@@ -128,7 +128,7 @@ function toFhir(routingDecision) {
         reference(dispositionResource.resourceType, disposition.dispositionId),
       ],
       recordedAt: prov.recordedAt,
-      activityText: ACTIVITY_TEXT,
+      activity: codeableConcept(ACTIVITY_TEXT),
       agentDevice: prov.agentDevice,
       onBehalfOf: prov.onBehalfOf,
     }),

package/lib/fhir/projections/symptomCaseProjection.js

@@ -41,7 +41,7 @@ function toFhir(managedSymptom) {
 }
 
 function caseProvenance(anchorId, recordedAt, targetRefs) {
-  return provenance({ provenanceId: `${anchorId}-prov`, targetRefs, recordedAt, activityText: ACTIVITY_TEXT });
+  return provenance({ provenanceId: `${anchorId}-prov`, targetRefs, recordedAt, activity: codeableConcept(ACTIVITY_TEXT) });
 }
 
 function assessmentResources(assessment, placeholderIds) {

package/lib/fhir/resources/ClinicalImpression.js

@@ -1,56 +1,13 @@
 const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
-const { CLUSTER_EXT, PALLIATIVE_EXT } = require('../constants/extensionSlugs');
-
-const CLUSTER_STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
-const CLUSTER_LIST_SEPARATOR = '; ';
+const { identifier, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
+const { RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
+const { PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 
 class ClinicalImpression {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromClusterImpression({ cluster }) {
-    const epistemicExts = [
-      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) {
-      epistemicExts.push(extension(CLUSTER_EXT.STRENGTHENS_IF, { valueString: cluster.strengthensIf.join(CLUSTER_LIST_SEPARATOR) }));
-    }
-    if (cluster.weakensIf.length) {
-      epistemicExts.push(extension(CLUSTER_EXT.WEAKENS_IF, { valueString: cluster.weakensIf.join(CLUSTER_LIST_SEPARATOR) }));
-    }
-    const lifecycleExts = [extension(CLUSTER_EXT.STATUS, { valueString: cluster.status })];
-    if (cluster.consultationId) lifecycleExts.push(extension(CLUSTER_EXT.CONSULTATION_ID, { valueString: cluster.consultationId }));
-    if (cluster.dissolveReason) lifecycleExts.push(extension(CLUSTER_EXT.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 fromRecommendationPlan({ plan }) {
     const finding = [...plan.elements]
       .sort((a, b) => a.rank - b.rank)
@@ -117,6 +74,4 @@ function palliativeFinding(finding) {
 
 module.exports = {
   ClinicalImpression,
-  CLUSTER_STATUS_TO_FHIR,
-  CLUSTER_LIST_SEPARATOR,
 };

package/lib/fhir/resources/Provenance.js

@@ -1,33 +1,12 @@
 const { getDeviceId, getOrganizationId } = require('../config/fhirConfig');
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
+const { fhirId } = require('../helpers/fhirHelper');
 const { extension, reference, codeableConcept, toIso } = require('../helpers/elementHelper');
 
-const CLUSTER_ACTIVITY_CODESYSTEM = 'clinical-activity';
-const CLUSTER_ACTIVITY_CODES = {
-  opened: 'cluster-hypothesis-opened',
-  updated: 'cluster-hypothesis-updated',
-  dissolved: 'cluster-hypothesis-dissolved',
-};
-
 class Provenance {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromClusterImpression({ clusterId, turnId, action, recordedAt, transitionReason }) {
-    const activityCode = CLUSTER_ACTIVITY_CODES[action] || 'cluster-hypothesis';
-    const payload = {
-      resourceType: 'Provenance',
-      id: fhirId(`${clusterId}-prov-${turnId}-${action}`),
-      target: [{ reference: `ClinicalImpression/${fhirId(clusterId)}` }],
-      recorded: toIso(recordedAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityCode, { code: activityCode, system: codeSystemUrl(CLUSTER_ACTIVITY_CODESYSTEM) }),
-    };
-    if (transitionReason) payload.extension = [extension('transition-reason', { valueString: transitionReason })];
-    return new Provenance(payload);
-  }
-
   static fromMentionProjection({ target, provenance, activityText }) {
     const payload = {
       resourceType: 'Provenance',

package/lib/fhir/services/clusterService.js

@@ -1,75 +1,27 @@
-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 { CLUSTER_EXT } = require('../constants/extensionSlugs');
-const { PROJECTOR_NAME } = require('../projections/clusterProjection');
+const { fhirId } = require('../helpers/fhirHelper');
+const { CLUSTER_IMPRESSION_SLUG } = require('../constants/projectionSlugs');
 const { getFhirStore } = require('../stores/fhirStore');
-const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
+const { toFhir, fromFhir } = require('../projections/clusterProjection');
+const { 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);
+  const { stored } = await storeResources(toFhir({ cluster, history }));
   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[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: ext[CLUSTER_EXT.STRENGTHENS_IF] ? ext[CLUSTER_EXT.STRENGTHENS_IF].split(CLUSTER_LIST_SEPARATOR) : [],
-    weakensIf: ext[CLUSTER_EXT.WEAKENS_IF] ? ext[CLUSTER_EXT.WEAKENS_IF].split(CLUSTER_LIST_SEPARATOR) : [],
-    openingReasoning: resource.description || '',
-    openedAt: resource.effectiveDateTime || period.start,
-    dissolvedAt: period.end || null,
-    dissolveReason: ext[CLUSTER_EXT.DISSOLVE_REASON] || null,
-    dissolveCategory: (resource.statusReason && resource.statusReason.text) || null,
-  };
+  const resources = await store.find({
+    patient,
+    resourceType: 'ClinicalImpression',
+    identifierSlug: CLUSTER_IMPRESSION_SLUG,
+  });
+  return fromFhir(resources, { patientId })
+    .filter((cluster) => (!label || cluster.label === label) && (!status || cluster.status === status));
 }
 
 module.exports = {

package/package.json

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