vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/utils/encounter.ts

@@ -0,0 +1,261 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getReferenceString, createReference, formatHumanName, getExtension, HTTP_HL7_ORG } from '@medplum/core';
+import type { MedplumClient } from '@medplum/core';
+import type {
+  Appointment,
+  ChargeItem,
+  ClinicalImpression,
+  Coding,
+  Encounter,
+  HumanName,
+  Patient,
+  PlanDefinition,
+  Practitioner,
+  ServiceRequest,
+  Task,
+} from '@medplum/fhirtypes';
+
+export async function createEncounter(
+  medplum: MedplumClient,
+  start: Date,
+  end: Date,
+  classification: Coding,
+  patient: Patient,
+  planDefinition: PlanDefinition
+): Promise<Encounter> {
+  const appointment = await medplum.createResource({
+    resourceType: 'Appointment',
+    status: 'booked',
+    start: start.toISOString(),
+    end: end.toISOString(),
+    participant: [
+      {
+        actor: {
+          reference: getReferenceString(patient),
+          display: formatHumanName(patient.name?.[0] as HumanName),
+        },
+        status: 'accepted',
+      },
+      {
+        actor: {
+          reference: getReferenceString(medplum.getProfile() as Practitioner),
+          display: formatHumanName(medplum.getProfile()?.name as HumanName),
+        },
+        status: 'accepted',
+      },
+    ],
+  });
+
+  const encounter: Encounter = await medplum.createResource({
+    resourceType: 'Encounter',
+    status: 'planned',
+    statusHistory: [],
+    classHistory: [],
+    class: classification,
+    subject: createReference(patient),
+    appointment: [createReference(appointment)],
+    participant: [
+      {
+        individual: {
+          reference: getReferenceString(medplum.getProfile() as Practitioner),
+        },
+      },
+    ],
+  });
+
+  const clinicalImpressionData: ClinicalImpression = {
+    resourceType: 'ClinicalImpression',
+    status: 'in-progress',
+    description: 'Initial clinical impression',
+    subject: createReference(patient),
+    encounter: createReference(encounter),
+    date: new Date().toISOString(),
+  };
+
+  await medplum.createResource(clinicalImpressionData);
+
+  await medplum.post(medplum.fhirUrl('PlanDefinition', planDefinition.id as string, '$apply'), {
+    resourceType: 'Parameters',
+    parameter: [
+      { name: 'subject', valueString: getReferenceString(patient) },
+      { name: 'encounter', valueString: getReferenceString(encounter) },
+      { name: 'practitioner', valueString: getReferenceString(medplum.getProfile() as Practitioner) },
+    ],
+  });
+
+  await createChargeItemFromPlanDefinition(medplum, encounter, patient, planDefinition);
+  await handleChargeItemsFromTasks(medplum, encounter, patient);
+
+  return encounter;
+}
+
+async function createChargeItemFromPlanDefinition(
+  medplum: MedplumClient,
+  encounter: Encounter,
+  patient: Patient,
+  planDefinition: PlanDefinition
+): Promise<void> {
+  const serviceBillingCodeExtension = getExtension(
+    planDefinition,
+    `${HTTP_HL7_ORG}/fhir/uv/order-catalog/StructureDefinition/ServiceBillingCode`
+  );
+
+  const chargeDefinitionExtension = getExtension(
+    planDefinition,
+    'http://medplum.com/fhir/StructureDefinition/applicable-charge-definition'
+  );
+
+  if (!serviceBillingCodeExtension?.valueCodeableConcept || !chargeDefinitionExtension?.valueCanonical) {
+    console.log('PlanDefinition missing required extensions for charge item creation');
+    return;
+  }
+
+  const cptCoding = serviceBillingCodeExtension.valueCodeableConcept.coding?.find(
+    (coding) => coding.system === 'http://www.ama-assn.org/go/cpt'
+  );
+
+  if (!cptCoding) {
+    return;
+  }
+
+  const chargeItem: ChargeItem = {
+    resourceType: 'ChargeItem',
+    status: 'planned',
+    subject: createReference(patient),
+    context: createReference(encounter),
+    occurrenceDateTime: new Date().toISOString(),
+    code: serviceBillingCodeExtension.valueCodeableConcept,
+    extension: [serviceBillingCodeExtension],
+    quantity: {
+      value: 1,
+    },
+    definitionCanonical: [chargeDefinitionExtension.valueCanonical],
+  };
+
+  await medplum.createResource(chargeItem);
+}
+
+async function handleChargeItemsFromTasks(
+  medplum: MedplumClient,
+  encounter: Encounter,
+  patient: Patient
+): Promise<void> {
+  const tasks = await medplum.search('Task', {
+    encounter: getReferenceString(encounter),
+  });
+
+  if (!tasks.entry?.length) {
+    return;
+  }
+
+  await Promise.all(
+    tasks.entry.map(async (entry) => {
+      const task = entry.resource as Task;
+      const serviceRequestRef = task.focus?.reference;
+
+      if (!serviceRequestRef?.startsWith('ServiceRequest/')) {
+        return;
+      }
+
+      try {
+        const serviceRequest: ServiceRequest = await medplum.readReference({
+          reference: serviceRequestRef,
+        });
+        await createChargeItemFromServiceRequest(medplum, patient, serviceRequest);
+      } catch (err) {
+        console.error(`Error processing ServiceRequest ${serviceRequestRef}:`, err);
+      }
+    })
+  );
+}
+
+async function createChargeItemFromServiceRequest(
+  medplum: MedplumClient,
+  patient: Patient,
+  serviceRequest: ServiceRequest
+): Promise<void> {
+  const chargeDefinitionExtension = getExtension(
+    serviceRequest,
+    'http://medplum.com/fhir/StructureDefinition/applicable-charge-definition'
+  );
+
+  if (
+    !chargeDefinitionExtension?.valueCanonical ||
+    !serviceRequest.code?.coding?.find((c) => c.system === 'http://www.ama-assn.org/go/cpt')
+  ) {
+    return;
+  }
+
+  const canonicalUrl = chargeDefinitionExtension?.valueCanonical;
+  const definitionCanonical = canonicalUrl ? [canonicalUrl] : [];
+
+  const chargeItem: ChargeItem = {
+    resourceType: 'ChargeItem',
+    status: 'planned',
+    supportingInformation: [
+      {
+        reference: `ServiceRequest/${serviceRequest.id}`,
+      },
+    ],
+    subject: createReference(patient),
+    context: serviceRequest.encounter,
+    occurrenceDateTime: serviceRequest.occurrenceDateTime || new Date().toISOString(),
+    code: serviceRequest.code || { coding: [] },
+    quantity: {
+      value: 1,
+    },
+    definitionCanonical: definitionCanonical,
+  };
+
+  await medplum.createResource(chargeItem);
+}
+
+export async function updateEncounterStatus(
+  medplum: MedplumClient,
+  encounter: Encounter,
+  appointment: Appointment | undefined,
+  newStatus: Encounter['status']
+): Promise<Encounter> {
+  const updatedEncounter: Encounter = {
+    ...encounter,
+    status: newStatus,
+    ...(newStatus === 'in-progress' &&
+      !encounter.period?.start && {
+        period: {
+          ...encounter.period,
+          start: new Date().toISOString(),
+        },
+      }),
+    ...(newStatus === 'finished' &&
+      !encounter.period?.end && {
+        period: {
+          ...encounter.period,
+          end: new Date().toISOString(),
+        },
+      }),
+  };
+
+  if (appointment) {
+    const updatedAppointment: Appointment = appointment;
+    switch (newStatus) {
+      case 'cancelled':
+        updatedAppointment.status = 'cancelled';
+        break;
+      case 'finished':
+        updatedAppointment.status = 'fulfilled';
+        break;
+      case 'in-progress':
+        updatedAppointment.status = 'checked-in';
+        break;
+      case 'arrived':
+        updatedAppointment.status = 'arrived';
+        break;
+      default:
+        break;
+    }
+    await medplum.updateResource(updatedAppointment);
+  }
+
+  return medplum.updateResource(updatedEncounter);
+}

package/dist/examples/vintasend-medplum-example/src/utils/intake-form.test.ts

@@ -0,0 +1,154 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Questionnaire, QuestionnaireResponse, QuestionnaireResponseItemAnswer } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, vi, beforeEach } from 'vitest';
+
+const mockAnswers = {
+  'first-name': { valueString: 'Jamie' },
+  'last-name': { valueString: 'Doe' },
+  dob: { valueDate: '1990-01-01' },
+  phone: { valueString: '555-5555' },
+  ssn: { valueString: '123-45-6789' },
+  street: { valueString: '1 Main St' },
+  city: { valueString: 'Springfield' },
+  state: { valueCoding: { code: 'CA' } },
+  zip: { valueString: '90210' },
+  'languages-spoken': { valueCoding: { code: 'en' } },
+  'preferred-language': { valueCoding: { code: 'en' } },
+  race: { valueCoding: { code: 'race-code', display: 'Race' } },
+  ethnicity: { valueCoding: { code: 'eth-code', display: 'Ethnicity' } },
+  'veteran-status': { valueBoolean: true },
+  'consent-for-treatment-signature': { valueBoolean: true },
+  'consent-for-treatment-date': { valueDate: '2024-01-01' },
+  'agreement-to-pay-for-treatment-help': { valueBoolean: true },
+  'agreement-to-pay-for-treatment-date': { valueDate: '2024-01-02' },
+  'notice-of-privacy-practices-signature': { valueBoolean: true },
+  'notice-of-privacy-practices-date': { valueDate: '2024-01-03' },
+  'acknowledgement-for-advance-directives-signature': { valueBoolean: true },
+  'acknowledgement-for-advance-directives-date': { valueDate: '2024-01-04' },
+  'preferred-pharmacy-reference': { valueReference: { reference: 'Organization/pharmacy-1' } },
+} satisfies Record<string, QuestionnaireResponseItemAnswer>;
+
+const mockIntakeUtils = vi.hoisted(() => ({
+  addAllergy: vi.fn(),
+  addCondition: vi.fn(),
+  addConsent: vi.fn(),
+  addCoverage: vi.fn(),
+  addExtension: vi.fn(),
+  addFamilyMemberHistory: vi.fn(),
+  addImmunization: vi.fn(),
+  addLanguage: vi.fn(),
+  addMedication: vi.fn(),
+  addPharmacy: vi.fn(),
+  consentCategoryMapping: {
+    med: { coding: [] },
+    pay: { coding: [] },
+    nopp: { coding: [] },
+    acd: { coding: [] },
+  },
+  consentPolicyRuleMapping: {
+    cric: { coding: [] },
+    hipaaSelfPay: { coding: [] },
+    hipaaNpp: { coding: [] },
+    adr: { coding: [] },
+  },
+  consentScopeMapping: {
+    treatment: { coding: [] },
+    patientPrivacy: { coding: [] },
+    adr: { coding: [] },
+  },
+  convertDateToDateTime: vi.fn((date?: string) => (date ? `${date}T00:00:00Z` : undefined)),
+  extensionURLMapping: {
+    race: 'race-url',
+    ethnicity: 'ethnicity-url',
+    veteran: 'veteran-url',
+  },
+  getGroupRepeatedAnswers: vi.fn((_, __, groupId) => {
+    if (groupId === 'coverage-information') {
+      return [
+        {
+          'insurance-provider': { valueReference: { reference: 'Organization/org-1' } },
+          'subscriber-id': { valueString: 'sub-1' },
+          'relationship-to-subscriber': { valueCoding: { code: 'self' } },
+        },
+      ];
+    }
+    if (groupId === 'allergies') {
+      return [{ 'allergy-substance': { valueCoding: { code: 'peanut' } } }];
+    }
+    return [];
+  }),
+  getHumanName: vi.fn(() => ({ given: ['Jamie'], family: 'Doe' })),
+  getPatientAddress: vi.fn(() => ({ line: ['1 Main St'] })),
+  observationCategoryMapping: {
+    socialHistory: { coding: [] },
+    sdoh: { coding: [] },
+  },
+  observationCodeMapping: {
+    sexualOrientation: { coding: [] },
+    housingStatus: { coding: [] },
+    educationLevel: { coding: [] },
+    smokingStatus: { coding: [] },
+    pregnancyStatus: { coding: [] },
+    estimatedDeliveryDate: { coding: [] },
+  },
+  PROFILE_URLS: {
+    Patient: 'patient-profile',
+    ObservationSexualOrientation: 'obs-profile',
+  },
+  upsertObservation: vi.fn(),
+}));
+
+vi.mock('./intake-utils', () => mockIntakeUtils);
+
+import { onboardPatient } from './intake-form';
+
+describe('onboardPatient', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+  });
+
+  test('creates patient and invokes onboarding helpers', async () => {
+    const createSpy = vi.spyOn(medplum, 'createResource').mockImplementation(async (resource: any) => {
+      if (resource.resourceType === 'Patient') {
+        return { ...resource, id: 'patient-1' };
+      }
+      return resource;
+    });
+
+    const questionnaire = { resourceType: 'Questionnaire' } as Questionnaire;
+    const response = buildResponseFromAnswers(mockAnswers);
+
+    const patient = await onboardPatient(medplum as any, questionnaire, response);
+
+    expect(patient.id).toBe('patient-1');
+    expect(createSpy).toHaveBeenCalledWith(expect.objectContaining({ resourceType: 'Patient' }));
+    expect(mockIntakeUtils.addExtension).toHaveBeenCalledWith(
+      expect.objectContaining({}),
+      'race-url',
+      'valueCoding',
+      mockAnswers['race'],
+      'ombCategory'
+    );
+    expect(mockIntakeUtils.addLanguage).toHaveBeenCalledTimes(2);
+    expect(mockIntakeUtils.addCoverage).toHaveBeenCalledWith(medplum, patient, expect.any(Object));
+    expect(mockIntakeUtils.addAllergy).toHaveBeenCalled();
+    expect(mockIntakeUtils.addConsent).toHaveBeenCalled();
+    expect(mockIntakeUtils.addPharmacy).toHaveBeenCalled();
+  });
+});
+
+function buildResponseFromAnswers(answers: Record<string, QuestionnaireResponseItemAnswer>): QuestionnaireResponse {
+  return {
+    resourceType: 'QuestionnaireResponse',
+    status: 'completed',
+    item: Object.entries(answers).map(([linkId, answer]) => ({
+      linkId,
+      answer: [answer],
+    })),
+  };
+}

package/dist/examples/vintasend-medplum-example/src/utils/intake-form.ts

@@ -0,0 +1,272 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { addProfileToResource, createReference, getQuestionnaireAnswers } from '@medplum/core';
+import type { MedplumClient } from '@medplum/core';
+import type { Organization, Patient, Questionnaire, QuestionnaireResponse, Reference } from '@medplum/fhirtypes';
+import {
+  addAllergy,
+  addCondition,
+  addConsent,
+  addCoverage,
+  addExtension,
+  addFamilyMemberHistory,
+  addImmunization,
+  addLanguage,
+  addMedication,
+  addPharmacy,
+  consentCategoryMapping,
+  consentPolicyRuleMapping,
+  consentScopeMapping,
+  convertDateToDateTime,
+  extensionURLMapping,
+  getGroupRepeatedAnswers,
+  getHumanName,
+  getPatientAddress,
+  observationCategoryMapping,
+  observationCodeMapping,
+  PROFILE_URLS,
+  upsertObservation,
+} from './intake-utils';
+
+export async function onboardPatient(
+  medplum: MedplumClient,
+  questionnaire: Questionnaire,
+  response: QuestionnaireResponse
+): Promise<Patient> {
+  const answers = getQuestionnaireAnswers(response);
+
+  let patient: Patient = {
+    resourceType: 'Patient',
+  };
+
+  patient = addProfileToResource(patient, PROFILE_URLS.Patient);
+
+  // Handle demographic information
+
+  const patientName = getHumanName(answers);
+  if (patientName) {
+    patient.name = [patientName];
+  }
+
+  if (answers['dob']?.valueDate) {
+    patient.birthDate = answers['dob'].valueDate;
+  }
+
+  const patientAddress = getPatientAddress(answers);
+  if (patientAddress) {
+    patient.address = [patientAddress];
+  }
+
+  if (answers['gender-identity']?.valueCoding?.code) {
+    patient.gender = answers['gender-identity'].valueCoding.code as Patient['gender'];
+  }
+
+  if (answers['phone']?.valueString) {
+    patient.telecom = [{ system: 'phone', value: answers['phone'].valueString }];
+  }
+
+  if (answers['ssn']?.valueString) {
+    patient.identifier = [
+      {
+        type: {
+          coding: [
+            {
+              system: 'http://terminology.hl7.org/CodeSystem/v2-0203',
+              code: 'SS',
+            },
+          ],
+        },
+        system: 'http://hl7.org/fhir/sid/us-ssn',
+        value: answers['ssn'].valueString,
+      },
+    ];
+  }
+
+  const emergencyContacts = getGroupRepeatedAnswers(questionnaire, response, 'emergency-contact');
+  if (emergencyContacts) {
+    patient.contact = [];
+    for (const contact of emergencyContacts) {
+      patient.contact.push({
+        relationship: [
+          {
+            coding: [
+              {
+                system: 'http://terminology.hl7.org/CodeSystem/v2-0131',
+                code: 'EP',
+                display: 'Emergency contact person',
+              },
+            ],
+          },
+        ],
+        name: getHumanName(contact, 'emergency-contact-'),
+        telecom: [{ system: 'phone', value: contact['emergency-contact-phone']?.valueString }],
+      });
+    }
+  }
+
+  addExtension(patient, extensionURLMapping.race, 'valueCoding', answers['race'], 'ombCategory');
+  addExtension(patient, extensionURLMapping.ethnicity, 'valueCoding', answers['ethnicity'], 'ombCategory');
+  addExtension(patient, extensionURLMapping.veteran, 'valueBoolean', answers['veteran-status']);
+
+  addLanguage(patient, answers['languages-spoken']?.valueCoding);
+  addLanguage(patient, answers['preferred-language']?.valueCoding, true);
+
+  // Create the patient resource
+
+  patient = await medplum.createResource(patient);
+
+  // NOTE: Updating the questionnaire response does not trigger a loop because the bot subscription
+  // is configured for "create"-only event.
+  response.subject = createReference(patient);
+  await medplum.createResource(response);
+
+  // Handle observations
+
+  await upsertObservation(
+    medplum,
+    patient,
+    observationCodeMapping.sexualOrientation,
+    observationCategoryMapping.socialHistory,
+    'valueCodeableConcept',
+    answers['sexual-orientation']?.valueCoding,
+    PROFILE_URLS.ObservationSexualOrientation
+  );
+
+  await upsertObservation(
+    medplum,
+    patient,
+    observationCodeMapping.housingStatus,
+    observationCategoryMapping.sdoh,
+    'valueCodeableConcept',
+    answers['housing-status']?.valueCoding
+  );
+
+  await upsertObservation(
+    medplum,
+    patient,
+    observationCodeMapping.educationLevel,
+    observationCategoryMapping.sdoh,
+    'valueCodeableConcept',
+    answers['education-level']?.valueCoding
+  );
+
+  await upsertObservation(
+    medplum,
+    patient,
+    observationCodeMapping.smokingStatus,
+    observationCategoryMapping.socialHistory,
+    'valueCodeableConcept',
+    answers['smoking-status']?.valueCoding,
+    PROFILE_URLS.ObservationSmokingStatus
+  );
+
+  await upsertObservation(
+    medplum,
+    patient,
+    observationCodeMapping.pregnancyStatus,
+    observationCategoryMapping.socialHistory,
+    'valueCodeableConcept',
+    answers['pregnancy-status']?.valueCoding
+  );
+
+  const estimatedDeliveryDate = convertDateToDateTime(answers['estimated-delivery-date']?.valueDate);
+  await upsertObservation(
+    medplum,
+    patient,
+    observationCodeMapping.estimatedDeliveryDate,
+    observationCategoryMapping.socialHistory,
+    'valueDateTime',
+    estimatedDeliveryDate ? { valueDateTime: estimatedDeliveryDate } : undefined
+  );
+
+  // Handle allergies
+
+  const allergies = getGroupRepeatedAnswers(questionnaire, response, 'allergies');
+  for (const allergy of allergies) {
+    await addAllergy(medplum, patient, allergy);
+  }
+
+  // Handle medications
+
+  const medications = getGroupRepeatedAnswers(questionnaire, response, 'medications');
+  for (const medication of medications) {
+    await addMedication(medplum, patient, medication);
+  }
+
+  // Handle medical history
+
+  const medicalHistory = getGroupRepeatedAnswers(questionnaire, response, 'medical-history');
+  for (const history of medicalHistory) {
+    await addCondition(medplum, patient, history);
+  }
+
+  const familyMemberHistory = getGroupRepeatedAnswers(questionnaire, response, 'family-member-history');
+  for (const history of familyMemberHistory) {
+    await addFamilyMemberHistory(medplum, patient, history);
+  }
+
+  // Handle vaccination history (immunizations)
+
+  const vaccinationHistory = getGroupRepeatedAnswers(questionnaire, response, 'vaccination-history');
+  for (const vaccine of vaccinationHistory) {
+    await addImmunization(medplum, patient, vaccine);
+  }
+
+  // Handle coverage
+
+  const insuranceProviders = getGroupRepeatedAnswers(questionnaire, response, 'coverage-information');
+  for (const provider of insuranceProviders) {
+    await addCoverage(medplum, patient, provider);
+  }
+
+  // Handle preferred pharmacy
+
+  const preferredPharmacyReference = answers['preferred-pharmacy-reference']?.valueReference;
+  if (preferredPharmacyReference) {
+    await addPharmacy(medplum, patient, preferredPharmacyReference as Reference<Organization>);
+  }
+
+  // Handle consents
+
+  await addConsent(
+    medplum,
+    patient,
+    !!answers['consent-for-treatment-signature']?.valueBoolean,
+    consentScopeMapping.treatment,
+    consentCategoryMapping.med,
+    consentPolicyRuleMapping.cric,
+    convertDateToDateTime(answers['consent-for-treatment-date']?.valueDate)
+  );
+
+  await addConsent(
+    medplum,
+    patient,
+    !!answers['agreement-to-pay-for-treatment-help']?.valueBoolean,
+    consentScopeMapping.treatment,
+    consentCategoryMapping.pay,
+    consentPolicyRuleMapping.hipaaSelfPay,
+    convertDateToDateTime(answers['agreement-to-pay-for-treatment-date']?.valueDate)
+  );
+
+  await addConsent(
+    medplum,
+    patient,
+    !!answers['notice-of-privacy-practices-signature']?.valueBoolean,
+    consentScopeMapping.patientPrivacy,
+    consentCategoryMapping.nopp,
+    consentPolicyRuleMapping.hipaaNpp,
+    convertDateToDateTime(answers['notice-of-privacy-practices-date']?.valueDate)
+  );
+
+  await addConsent(
+    medplum,
+    patient,
+    !!answers['acknowledgement-for-advance-directives-signature']?.valueBoolean,
+    consentScopeMapping.adr,
+    consentCategoryMapping.acd,
+    consentPolicyRuleMapping.adr,
+    convertDateToDateTime(answers['acknowledgement-for-advance-directives-date']?.valueDate)
+  );
+
+  return patient;
+}