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

package/lib/fhir/services/riskService.js

@@ -1,101 +0,0 @@
-const { ZodError } = require('zod');
-
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifierValue, extValues } = require('../helpers/fhirReadHelper');
-const { PATIENT_RISK_SLUG } = require('../constants/projectionSlugs');
-const { PROJECTOR_NAME } = require('../projections/riskProjection');
-const {
-  PREDICTION_KIND_AE,
-  PREDICTION_KIND_DISEASE,
-  PREDICTION_KIND_COMORBIDITY,
-} = require('../resources/RiskAssessment');
-const { getFhirStore } = require('../stores/fhirStore');
-const { PatientRiskAssessment } = require('../../shared/dtos/PatientRiskAssessment');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-async function storePatientRisk({ patientId, riskAssessment }) {
-  if (riskAssessment.patientId !== patientId) {
-    throw new Error(`storePatientRisk patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: riskAssessment }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function readPatientRisk({ patientId }) {
-  const store = getFhirStore();
-  const patient = `Patient/${fhirId(patientId)}`;
-  const resources = (await store.find({ patient, resourceType: 'RiskAssessment' }))
-    .filter((resource) => identifierValue(resource, PATIENT_RISK_SLUG));
-  for (const resource of resources) {
-    try {
-      return new PatientRiskAssessment(reconstructRisk(resource, patientId));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ resourceId: resource.id }, 'skipping malformed patient-risk RiskAssessment');
-        continue;
-      }
-      throw error;
-    }
-  }
-  return null;
-}
-
-function reconstructRisk(resource, patientId) {
-  const predictions = resource.prediction || [];
-  return {
-    schemaVersion: '1',
-    assessmentId: identifierValue(resource, PATIENT_RISK_SLUG),
-    patientId,
-    status: resource.status,
-    sourceRegimen: extValues(resource, 'assessed-source-regimen')[0] || null,
-    sourceDiagnosis: extValues(resource, 'assessed-source-diagnosis')[0] || null,
-    sourcePhase: extValues(resource, 'assessed-source-phase')[0] || null,
-    predictedAes: predictions.filter((prediction) => predictionKind(prediction) === PREDICTION_KIND_AE).map(reconstructAe),
-    diseaseRisks: predictions.filter((prediction) => predictionKind(prediction) === PREDICTION_KIND_DISEASE).map(reconstructDisease),
-    comorbidityAmplifiers: predictions.filter((prediction) => predictionKind(prediction) === PREDICTION_KIND_COMORBIDITY).map(reconstructComorbidity),
-    assessedAt: resource.occurrenceDateTime,
-    assessedByModel: extValues(resource, 'assessed-by-model')[0] || null,
-  };
-}
-
-function reconstructAe(prediction) {
-  return {
-    aeName: outcomeText(prediction),
-    severityIfConfirmed:
-      (prediction.qualitativeRisk
-        && prediction.qualitativeRisk.coding
-        && prediction.qualitativeRisk.coding[0]
-        && prediction.qualitativeRisk.coding[0].code) || null,
-    minimumSymptomSet: extValues(prediction, 'risk-minimum-symptom-set'),
-    why: prediction.rationale || null,
-  };
-}
-
-function reconstructDisease(prediction) {
-  return {
-    bodySite: outcomeText(prediction),
-    complications: extValues(prediction, 'risk-disease-complication'),
-    warningSymptoms: extValues(prediction, 'risk-disease-warning-symptom'),
-    amplifierComorbidities: extValues(prediction, 'risk-disease-amplifier'),
-  };
-}
-
-function reconstructComorbidity(prediction) {
-  return {
-    comorbidity: outcomeText(prediction),
-    interaction: prediction.rationale,
-    clinicalNote: extValues(prediction, 'risk-comorbidity-clinical-note')[0] || null,
-  };
-}
-
-const predictionKind = (prediction) => extValues(prediction, 'risk-prediction-kind')[0] || null;
-
-const outcomeText = (prediction) => (prediction.outcome && prediction.outcome.text) || null;
-
-module.exports = {
-  storePatientRisk,
-  readPatientRisk,
-};

package/lib/fhir/services/routingService.js

@@ -1,147 +0,0 @@
-const { ZodError } = require('zod');
-
-const { fhirId } = require('../helpers/fhirHelper');
-const { extMap, extValues, identifierValue, refToId } = require('../helpers/fhirReadHelper');
-const { ROUTING_ASSESSMENT_SLUG, ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
-const { PROJECTOR_NAME } = require('../projections/routingProjection');
-const { getFhirStore } = require('../stores/fhirStore');
-const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-const DISPOSITION_KIND_BY_RESOURCE = {
-  Communication: 'communication',
-  CommunicationRequest: 'communication_request',
-  Task: 'task',
-  RequestOrchestration: 'orchestration',
-  CarePlan: 'care_plan',
-};
-
-async function storeRoutingDecision({ patientId, routingDecision }) {
-  if (routingDecision.patientId !== patientId) {
-    throw new Error(`storeRoutingDecision patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: routingDecision }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function readRoutingByTurn({ patientId, turnId }) {
-  const store = getFhirStore();
-  const patient = `Patient/${fhirId(patientId)}`;
-  const impressions = (await store.find({ patient, resourceType: 'ClinicalImpression' }))
-    .filter((resource) => identifierValue(resource, ROUTING_ASSESSMENT_SLUG));
-  const assessment = impressions.find((impression) => extMap(impression)['routing-turn-id'] === turnId);
-  if (!assessment) return null;
-  const provenance = await store.getByReference(`Provenance/${fhirId(`${assessment.id}-prov`)}`);
-  if (!provenance) return null;
-  const disposition = await findDisposition(store, assessment, provenance);
-  if (!disposition) return null;
-  try {
-    return new RoutingDecision(reconstructRouting(assessment, disposition, provenance, patientId, turnId));
-  } catch (error) {
-    if (error instanceof ZodError) {
-      logger.warn({ assessmentId: assessment.id }, 'skipping malformed routing ClinicalImpression');
-      return null;
-    }
-    throw error;
-  }
-}
-
-async function findDisposition(store, assessment, provenance) {
-  const assessmentRef = `ClinicalImpression/${fhirId(assessment.id)}`;
-  const dispositionRef = (provenance.target || []).find((target) => target.reference !== assessmentRef);
-  if (!dispositionRef) return null;
-  const resource = await store.getByReference(dispositionRef.reference);
-  return resource && identifierValue(resource, ROUTING_DISPOSITION_SLUG) ? resource : null;
-}
-
-function reconstructRouting(assessment, disposition, provenance, patientId, turnId) {
-  const ext = extMap(assessment);
-  const agent = (provenance.agent || [])[0] || {};
-  return {
-    schemaVersion: '1',
-    decisionId: ext['routing-decision-id'],
-    patientId,
-    turnId,
-    committedAt: ext['routing-committed-at'],
-    assessment: reconstructAssessment(assessment, patientId, turnId),
-    disposition: reconstructDisposition(disposition, assessment, patientId),
-    provenance: {
-      agentDevice: refToId(agent.who && agent.who.reference),
-      onBehalfOf: refToId(agent.onBehalfOf && agent.onBehalfOf.reference),
-      recordedAt: provenance.recorded,
-    },
-  };
-}
-
-function reconstructAssessment(resource, patientId, turnId) {
-  return {
-    assessmentId: identifierValue(resource, ROUTING_ASSESSMENT_SLUG),
-    patientId,
-    turnId,
-    performedAt: resource.effectiveDateTime,
-    previousId: resource.previous ? refToId(resource.previous.reference) : null,
-    summary: resource.summary || '',
-    notes: (resource.note || []).map((note) => note.text),
-    findings: (resource.finding || []).map(reconstructFinding),
-  };
-}
-
-function reconstructFinding(finding) {
-  const ext = extMap(finding);
-  return {
-    caseId: ext['routing-finding-case-id'] || refToId(finding.item && finding.item.reference),
-    clinicalReasoning: ext['routing-finding-reasoning'] || '',
-    decisionAction: ext['routing-finding-action'] || '',
-  };
-}
-
-function reconstructDisposition(resource, assessment, patientId) {
-  return {
-    dispositionId: identifierValue(resource, ROUTING_DISPOSITION_SLUG),
-    patientId,
-    kind: DISPOSITION_KIND_BY_RESOURCE[resource.resourceType],
-    primaryAction: dispositionAction(resource),
-    primaryReason: dispositionReason(resource),
-    primaryCaseId: extMap(assessment)['routing-primary-case-id'] || null,
-    secondaryActions: (resource.action || []).slice(1).map(reconstructSecondary),
-    deferredItems: reconstructDeferredItems(assessment),
-    authoredAt: resource.sent || resource.authoredOn || resource.created,
-  };
-}
-
-function reconstructDeferredItems(assessment) {
-  const items = extValues(assessment, 'routing-deferred-item');
-  const reasons = extValues(assessment, 'routing-deferred-reason');
-  return items.map((item, i) => ({ item, deferReason: reasons[i] }));
-}
-
-function reconstructSecondary(action) {
-  const description = action.description || '';
-  return {
-    action: action.title,
-    composeAs: description.startsWith('compose_as: ') ? description.slice('compose_as: '.length) : description,
-  };
-}
-
-function dispositionAction(resource) {
-  if (resource.resourceType === 'Task') return ccText(resource.code);
-  if (resource.resourceType === 'RequestOrchestration') return (resource.action || [])[0] && resource.action[0].title;
-  return ccText((resource.category || [])[0]);
-}
-
-function dispositionReason(resource) {
-  if (resource.resourceType === 'Task') return resource.description;
-  if (resource.resourceType === 'CarePlan') return resource.description;
-  if (resource.resourceType === 'RequestOrchestration') return (resource.action || [])[0] && resource.action[0].description;
-  return ccText((resource.payload || [])[0] && resource.payload[0].contentCodeableConcept);
-}
-
-const ccText = (concept) => (concept && concept.text) || null;
-
-module.exports = {
-  storeRoutingDecision,
-  readRoutingByTurn,
-};

package/lib/fhir/services/snapshotService.js

@@ -1,28 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { getFhirStore } = require('../stores/fhirStore');
-
-async function patientSnapshot(patientId, { resourceTypes = null } = {}) {
-  if (!String(patientId ?? '').trim()) throw new Error('patientId is required');
-  if (resourceTypes != null) {
-    if (!Array.isArray(resourceTypes)) throw new Error('resourceTypes must be an array');
-    if (resourceTypes.some((t) => typeof t !== 'string' || !t.trim())) throw new Error('resourceTypes must contain only non-empty strings');
-  }
-  const requestedTypes = resourceTypes ? [...new Set(resourceTypes.map((resourceType) => resourceType.trim()))] : null;
-  const store = getFhirStore();
-  const patient = `Patient/${fhirId(patientId)}`;
-  const linkedTypes = requestedTypes ? requestedTypes.filter((resourceType) => resourceType !== 'Patient') : null;
-  const resources = linkedTypes
-    ? (await Promise.all(linkedTypes.map((resourceType) => store.find({ patient, resourceType })))).flat()
-    : await store.find({ patient });
-  if (!requestedTypes || requestedTypes.includes('Patient')) {
-    const patientResource = await store.getByReference(patient);
-    if (patientResource) resources.push(patientResource);
-  }
-  const byType = Object.create(null);
-  for (const resource of resources) {
-    (byType[resource.resourceType] = byType[resource.resourceType] || []).push(resource);
-  }
-  return byType;
-}
-
-module.exports = { patientSnapshot };

package/lib/fhir/services/symptomCaseService.js

@@ -1,139 +0,0 @@
-const { ZodError } = require('zod');
-
-const { fhirId } = require('../helpers/fhirHelper');
-const { extMap, extValues, identifierValue } = require('../helpers/fhirReadHelper');
-const { SYMPTOM_CASE_SLUG, SYMPTOM_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
-const { PROJECTOR_NAME } = require('../projections/symptomCaseProjection');
-const { getFhirStore } = require('../stores/fhirStore');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-async function storeSymptomCase({ patientId, managedSymptom }) {
-  if (managedSymptom.condition.patientId !== patientId) {
-    throw new Error(`storeSymptomCase patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: managedSymptom }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function readSymptomCases({ patientId, ctcaeTerm = null, status = null }) {
-  const store = getFhirStore();
-  const patient = `Patient/${fhirId(patientId)}`;
-  const conditions = (await store.find({ patient, resourceType: 'Condition', symptomTerm: ctcaeTerm }))
-    .filter((condition) => 'symptom-case-status' in extMap(condition) && identifierValue(condition, SYMPTOM_CASE_SLUG));
-  const cases = [];
-  for (const condition of conditions) {
-    let managed;
-    try {
-      managed = new ManagedSymptom(await reconstructSymptomCase(condition, patientId, store));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ conditionId: condition.id }, 'skipping malformed symptom-case Condition');
-        continue;
-      }
-      throw error;
-    }
-    if (status && managed.condition.clinicalStatus !== status) continue;
-    cases.push(managed);
-  }
-  return cases;
-}
-
-async function reconstructSymptomCase(condition, patientId, store) {
-  const conditionId = identifierValue(condition, SYMPTOM_CASE_SLUG);
-  const chain = await readAssessmentChain(condition, { patientId, conditionId }, store);
-  const [latestAssessment, ...priorAssessments] = chain;
-  return {
-    condition: reconstructCondition(condition, patientId, conditionId),
-    latestAssessment,
-    priorAssessments,
-  };
-}
-
-function reconstructCondition(condition, patientId, conditionId) {
-  const ext = extMap(condition);
-  const code = condition.code || {};
-  const coding = (code.coding && code.coding[0]) || {};
-  return {
-    conditionId,
-    patientId,
-    ctcaeTerm: coding.code || code.text || null,
-    clinicalStatus: ext['symptom-case-status'],
-    onsetAt: condition.onsetDateTime,
-    abatementAt: condition.abatementDateTime || ext['legacy-abatement'] || null,
-    closeReason: ext['symptom-close-reason'] || null,
-    temporality: ext['symptom-temporality'] || null,
-    evidenceEpisodeIds: extValues(condition, 'symptom-evidence-episode-ids'),
-    currentEpisodeId: ext['symptom-current-episode-id'] || null,
-    evidenceMentionIds: extValues(condition, 'symptom-evidence-mention-ids'),
-    lastTransitionReason: (condition.note && condition.note[0] && condition.note[0].text) || null,
-    recurrenceCount: ext['symptom-recurrence-count'] ?? 0,
-    reactivatedAt: ext['symptom-reactivated-at'] || null,
-  };
-}
-
-async function readAssessmentChain(condition, ids, store) {
-  const headRef = condition.stage && condition.stage[0] && condition.stage[0].assessment
-    && condition.stage[0].assessment[0] && condition.stage[0].assessment[0].reference;
-  const impressions = [];
-  const seen = new Set();
-  let ref = headRef;
-  while (ref && !seen.has(ref)) {
-    seen.add(ref);
-    const impression = await store.getByReference(ref);
-    if (!impression) break;
-    impressions.push(impression);
-    ref = impression.previous && impression.previous.reference;
-  }
-  const chain = [];
-  for (let i = 0; i < impressions.length; i++) {
-    const previousId = impressions[i + 1] ? identifierValue(impressions[i + 1], SYMPTOM_ASSESSMENT_SLUG) : null;
-    chain.push(await reconstructAssessment(impressions[i], { ...ids, previousId }, store));
-  }
-  return chain;
-}
-
-async function reconstructAssessment(impression, { patientId, conditionId, previousId }, store) {
-  const ext = extMap(impression);
-  const findingRef = impression.finding && impression.finding[0] && impression.finding[0].item
-    && impression.finding[0].item.reference && impression.finding[0].item.reference.reference;
-  const gradeObs = findingRef ? await store.getByReference(findingRef) : null;
-  const gradeExt = extMap(gradeObs || {});
-  return {
-    assessmentId: identifierValue(impression, SYMPTOM_ASSESSMENT_SLUG),
-    conditionId,
-    patientId,
-    performedAt: impression.effectiveDateTime,
-    previousId,
-    grade: reconstructGrade(gradeObs),
-    trajectory: ext.trajectory || null,
-    decisionPosture: ext['decision-posture'] || null,
-    gradeVerification: gradeExt['grade-verification'] || 'provisional',
-    reasoning: ext['assessment-reasoning'] || null,
-    postureReason: ext['posture-reason'] || null,
-    problemRepresentation: impression.summary || null,
-    gradeThresholdClause: gradeExt['grade-threshold-clause'] || null,
-  };
-}
-
-function reconstructGrade(obs) {
-  const grade = { bestEstimate: null, confidence: null, possibleRange: null, reasoning: '' };
-  if (!obs) return grade;
-  const ext = extMap(obs);
-  if (typeof obs.valueInteger === 'number') grade.bestEstimate = obs.valueInteger;
-  if (ext['grade-confidence']) grade.confidence = ext['grade-confidence'];
-  if (ext['grade-range']) {
-    const [lo, hi] = ext['grade-range'].split('-').map((n) => Number.parseInt(n, 10));
-    if (Number.isInteger(lo) && Number.isInteger(hi)) grade.possibleRange = [lo, hi];
-  }
-  if (ext['grade-reasoning']) grade.reasoning = ext['grade-reasoning'];
-  return grade;
-}
-
-module.exports = {
-  storeSymptomCase,
-  readSymptomCases,
-};

package/lib/fhir/services/terminologyService.js

@@ -1,58 +0,0 @@
-const { PROCTCAE_ITEMS_TABLE, PROCTCAE_COMPOSITE_TABLE } = require('../config/fhirTablesConfig');
-const { buildCatalog } = require('../helpers/terminologyHelper');
-
-const { Ctcae_ID } = require('../../config/airtableConfig');
-const { getRecordByFilter } = require('../../services/airtableService');
-const { logger } = require('../../utils/logger');
-
-let catalogPromise = null;
-let loadedCompositeTableHash = null;
-
-async function getCatalog() {
-  if (!catalogPromise) {
-    catalogPromise = loadCatalog().catch((error) => {
-      catalogPromise = null;
-      throw error;
-    });
-  }
-  return catalogPromise;
-}
-
-function clearCache() {
-  catalogPromise = null;
-}
-
-async function loadCatalog() {
-  const [items, composites] = await Promise.all([
-    getRecordByFilter(Ctcae_ID, PROCTCAE_ITEMS_TABLE, 'TRUE()', null),
-    getRecordByFilter(Ctcae_ID, PROCTCAE_COMPOSITE_TABLE, 'TRUE()', null),
-  ]);
-  if (!items) throw new Error('proctcae terminology tables not readable from Airtable');
-  if (!composites) logger.warn('[terminologyService] composite table not readable; composite grading disabled');
-
-  const source = `Airtable ${Ctcae_ID} (${PROCTCAE_ITEMS_TABLE})`;
-  const catalog = buildCatalog(items, composites || [], source);
-  if (!catalog._meta.n_symptoms) throw new Error('proctcae terminology catalog is empty');
-
-  const compositeTableHash = catalog._meta.composite_table_hash ?? null;
-  if (loadedCompositeTableHash && compositeTableHash && loadedCompositeTableHash !== compositeTableHash) {
-    logger.warn('[terminologyService] composite grading table changed — grades derived after this differ from grades before it', {
-      from: loadedCompositeTableHash,
-      to: compositeTableHash,
-    });
-  }
-  loadedCompositeTableHash = compositeTableHash;
-
-  logger.info('[terminologyService] catalog loaded', {
-    source,
-    symptoms: catalog._meta.n_symptoms,
-    items: catalog._meta.n_items,
-    mappedItems: catalog._meta.n_mapped_items,
-    composites: catalog._meta.n_composites,
-    compositeTableHash,
-  });
-
-  return catalog;
-}
-
-module.exports = { getCatalog, clearCache };

package/lib/fhir/services/triageService.js

@@ -1,57 +0,0 @@
-const { gradeComposites } = require('../helpers/compositeHelper');
-const { GradedSymptom } = require('../../shared/dtos/GradedSymptom');
-const { TriageResponse } = require('../../shared/dtos/TriageResponse');
-const {
-  projectProctcaeCanonical,
-  projectTriagePatient,
-  projectProctcaeSymptomObservation,
-  projectTriageIngestDevice,
-  projectTriageQuestionnaireResponse,
-  projectTriageSymptomCondition,
-} = require('../projections/proctcaeProjection');
-const { storeResources } = require('./fhirService');
-const { getCatalog: loadTerminology } = require('./terminologyService');
-
-const FOLLOW_UP_GRADE = 1;
-
-async function storeTriage(payload) {
-  const input = new TriageResponse(payload);
-  const catalog = await loadTerminology();
-  const graded = gradeComposites(catalog, input).map((symptom) => new GradedSymptom(symptom));
-  const resources = [
-    projectProctcaeCanonical(catalog),
-    projectTriagePatient(input.patientId),
-    projectTriageIngestDevice(catalog),
-    projectTriageQuestionnaireResponse(catalog, input),
-    ...graded.map((sym) => projectProctcaeSymptomObservation(catalog, sym)),
-  ];
-  const conditions = graded
-    .filter((sym) => sym.grade >= FOLLOW_UP_GRADE)
-    .map((sym) => projectTriageSymptomCondition(catalog, sym));
-  const { stored } = await storeResources(resources);
-  const { stored: storedConditions } = await storeResources(conditions, { merge: mergeTriageSymptomCondition });
-  return { stored: [...stored, ...storedConditions] };
-}
-
-function mergeTriageSymptomCondition(existing, next) {
-  if (!existing) return next;
-  const merged = { ...next };
-  const onset = earlierOnset(existing.onsetDateTime, next.onsetDateTime);
-  if (onset) merged.onsetDateTime = onset;
-  const seen = new Set();
-  merged.evidence = [...(existing.evidence || []), ...(next.evidence || [])].filter((entry) => {
-    const ref = entry.reference && entry.reference.reference;
-    if (!ref || seen.has(ref)) return false;
-    seen.add(ref);
-    return true;
-  });
-  return merged;
-}
-
-function earlierOnset(existing, next) {
-  if (!existing) return next;
-  if (!next) return existing;
-  return Date.parse(next) < Date.parse(existing) ? next : existing;
-}
-
-module.exports = { storeTriage };

package/lib/fhir/utils/normalizeUtils.js

@@ -1,33 +0,0 @@
-const lookupValue = (value) => {
-  const first = Array.isArray(value) ? value[0] : value;
-  return first === undefined || first === '' ? null : first;
-};
-
-const integerId = (value) => {
-  if (value == null || String(value).trim() === '') return null;
-  const id = Number(value);
-  return Number.isFinite(id) ? Math.trunc(id) : null;
-};
-
-const parseList = (value) =>
-  String(value || '')
-    .split(/[;|]/)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-
-function termKey(name) {
-  return String(name || '')
-    .trim()
-    .toLowerCase()
-    .replace(/&/g, 'and')
-    .replace(/[/-]/g, ' ')
-    .replace(/[^a-z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '');
-}
-
-module.exports = {
-  lookupValue,
-  integerId,
-  parseList,
-  termKey,
-};

package/lib/shared/dtos/GradedSymptom.js

@@ -1,23 +0,0 @@
-const { z } = require('zod');
-
-const { BaseDto } = require('./BaseDto');
-
-const dateTime = z.iso.datetime({ offset: true });
-
-const schema = z.strictObject({
-  schemaVersion: z.string().default('1'),
-  symptomId: z.string(),
-  patientId: z.string(),
-  term: z.string(),
-  grade: z.number().int().min(0).max(4),
-  effective: dateTime.nullable().default(null),
-  triageId: z.string(),
-  dimensionAnswers: z.record(z.string(), z.string()).default({}),
-  source: z.string().default('triage'),
-});
-
-class GradedSymptom extends BaseDto {}
-
-GradedSymptom.schema = schema;
-
-module.exports = { GradedSymptom };

package/lib/shared/dtos/TriageResponse.js

@@ -1,35 +0,0 @@
-const { z } = require('zod');
-
-const { BaseDto } = require('./BaseDto');
-
-const dateTime = z.iso.datetime({ offset: true });
-
-const painSchema = z.strictObject({
-  hasPain: z.string().nullable().default(null),
-  frequency: z.string().nullable().default(null),
-  intensity: z.string().nullable().default(null),
-  interference: z.string().nullable().default(null),
-  locations: z.array(z.string()).default([]),
-  mostImportant: z.string().nullable().default(null),
-  otherText: z.string().nullable().default(null),
-});
-
-const schema = z.strictObject({
-  schemaVersion: z.string().default('1'),
-  triageId: z.string(),
-  patientId: z.string(),
-  authored: dateTime.nullable().default(null),
-  completed: z.boolean().default(true),
-  answers: z.record(z.string(), z.string().nullable()).default({}),
-  questionnaireId: z.string().nullable().default(null),
-  cadence: z.string().nullable().default(null),
-  satisfactionLabel: z.string().nullable().default(null),
-  satisfactionValue: z.number().int().default(-1),
-  pain: painSchema.default(() => painSchema.parse({})),
-});
-
-class TriageResponse extends BaseDto {}
-
-TriageResponse.schema = schema;
-
-module.exports = { TriageResponse };