vintasend 0.4.0 → 0.4.7

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

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CPT, getReferenceString } from '@medplum/core';
+import type { MedplumClient } from '@medplum/core';
+import type { ChargeItem, Claim, ClaimItem, Coverage, Encounter, Reference } from '@medplum/fhirtypes';
+import { calculateTotalPrice } from './chargeitems';
+import { createSelfPayCoverage } from './coverage';
+
+export async function createClaimFromEncounter(
+  medplum: MedplumClient,
+  patientId: string,
+  encounterId: string,
+  practitionerId: string,
+  chargeItems: ChargeItem[]
+): Promise<Claim | undefined> {
+  const coverageResults = await medplum.searchResources('Coverage', `patient=Patient/${patientId}&status=active`);
+  let coverage: Coverage = coverageResults[0];
+  if (!coverage) {
+    coverage = await createSelfPayCoverage(medplum, patientId);
+  }
+
+  const claim: Claim = {
+    resourceType: 'Claim',
+    status: 'draft',
+    type: { coding: [{ code: 'professional' }] },
+    use: 'claim',
+    created: new Date().toISOString(),
+    patient: { reference: `Patient/${patientId}` },
+    provider: { reference: `Practitioner/${practitionerId}`, type: 'Practitioner' },
+    priority: { coding: [{ code: 'normal' }] },
+    insurance: [
+      {
+        sequence: 1,
+        focal: true,
+        coverage: { reference: getReferenceString(coverage) },
+      },
+    ],
+    item: getCptChargeItems(chargeItems, { reference: `Encounter/${encounterId}` }),
+    total: { value: calculateTotalPrice(chargeItems) },
+  };
+  return medplum.createResource(claim);
+}
+
+export function getCptChargeItems(chargeItems: ChargeItem[], encounter: Reference<Encounter>): ClaimItem[] {
+  const cptChargeItems = chargeItems.filter((item) => item.code?.coding?.some((coding) => coding.system === CPT));
+  return cptChargeItems.map((chargeItem: ChargeItem, index: number) => {
+    const modifiers = chargeItem.extension
+      ?.filter((ext) => ext.url === 'http://hl7.org/fhir/StructureDefinition/chargeitem-modifier')
+      .map((ext) => {
+        return ext.valueCodeableConcept;
+      })
+      .filter((modifier) => modifier !== undefined);
+
+    return {
+      sequence: index + 1,
+      encounter: [encounter],
+      productOrService: {
+        coding: chargeItem.code.coding?.filter((coding) => coding.system === CPT),
+        text: chargeItem.code.text,
+      },
+      net: chargeItem.priceOverride,
+      ...(modifiers && modifiers.length > 0 ? { modifier: modifiers } : {}),
+    };
+  });
+}

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

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { parseSearchRequest } from '@medplum/core';
+import type { SearchRequest } from '@medplum/core';
+
+export interface NormalizeCommunicationSearchOptions {
+  search?: string;
+  defaultSort?: string;
+  defaultStatus?: string;
+  defaultCount?: string;
+  defaultTotal?: string;
+}
+
+export interface NormalizeCommunicationSearchResult {
+  normalizedSearch: string;
+  parsedSearch: SearchRequest;
+}
+
+export function normalizeCommunicationSearch({
+  search = '',
+  defaultSort = '-_lastUpdated',
+  defaultStatus = 'in-progress',
+  defaultCount = '20',
+  defaultTotal = 'accurate',
+}: NormalizeCommunicationSearchOptions): NormalizeCommunicationSearchResult {
+  const params = new URLSearchParams(search || `_sort=${defaultSort}`);
+  const entries = Array.from(params.entries());
+
+  const addIfMissing = (key: string, value: string | undefined): void => {
+    if (value && !params.has(key)) {
+      entries.push([key, value]);
+    }
+  };
+
+  addIfMissing('_sort', defaultSort);
+  addIfMissing('status', defaultStatus);
+  addIfMissing('_count', defaultCount);
+  addIfMissing('_total', defaultTotal);
+
+  const normalizedSearch = new URLSearchParams(entries).toString();
+
+  return {
+    normalizedSearch,
+    parsedSearch: parseSearchRequest(`Communication?${normalizedSearch}`),
+  };
+}

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

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Coverage } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { createSelfPayCoverage } from './coverage';
+
+describe('createSelfPayCoverage', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+  });
+
+  test('creates a self-pay coverage for patient', async () => {
+    const createdCoverage: Coverage = {
+      resourceType: 'Coverage',
+      id: 'coverage-123',
+      status: 'active',
+      beneficiary: { reference: 'Patient/patient-123' },
+      payor: [{ reference: 'Patient/patient-123' }],
+      type: {
+        coding: [{ code: 'SELFPAY', display: 'Self Pay' }],
+      },
+      period: {
+        start: new Date().toISOString(),
+      },
+    };
+    const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue(createdCoverage as any);
+
+    const result = await createSelfPayCoverage(medplum as any, 'patient-123');
+
+    expect(createSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        subscriber: { reference: 'Patient/patient-123' },
+        beneficiary: { reference: 'Patient/patient-123' },
+        payor: [{ reference: 'Patient/patient-123' }],
+        type: expect.objectContaining({
+          coding: [expect.objectContaining({ code: 'SELFPAY', display: 'Self Pay' })],
+        }),
+        period: expect.objectContaining({
+          start: expect.any(String),
+        }),
+      })
+    );
+    expect(result).toBe(createdCoverage);
+  });
+});

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

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { MedplumClient } from '@medplum/core';
+import type { Coverage } from '@medplum/fhirtypes';
+
+/**
+ * Creates a self-pay coverage for a patient
+ * @param medplum - Medplum client instance
+ * @param patientId - ID of the patient
+ * @returns Promise with the created Coverage resource
+ */
+export async function createSelfPayCoverage(medplum: MedplumClient, patientId: string): Promise<Coverage> {
+  return medplum.createResource({
+    resourceType: 'Coverage',
+    status: 'active',
+    type: {
+      coding: [
+        {
+          system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode',
+          code: 'SELFPAY',
+          display: 'Self Pay',
+        },
+      ],
+      text: 'Self Pay',
+    },
+    subscriber: { reference: `Patient/${patientId}` },
+    beneficiary: { reference: `Patient/${patientId}` },
+    payor: [{ reference: `Patient/${patientId}` }],
+    period: {
+      start: new Date().toISOString(),
+    },
+  });
+}

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

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { DocumentReference, ServiceRequest } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { fetchLabOrderRequisitionDocuments, getHealthGorillaRequisitionId } from './documentReference';
+
+describe('documentReference utils', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+  });
+
+  describe('getHealthGorillaRequisitionId', () => {
+    test('returns id from requisition', () => {
+      const request: ServiceRequest = {
+        resourceType: 'ServiceRequest',
+        requisition: {
+          system: 'https://www.healthgorilla.com',
+          value: 'req-1',
+        },
+        status: 'active',
+        intent: 'order',
+        subject: { reference: 'Patient/patient-1' },
+      };
+
+      expect(getHealthGorillaRequisitionId(request)).toBe('req-1');
+    });
+
+    test('returns id from identifier array', () => {
+      const request: ServiceRequest = {
+        resourceType: 'ServiceRequest',
+        identifier: [
+          { system: 'https://www.healthgorilla.com', value: 'req-2' },
+          { system: 'http://example.com', value: 'other' },
+        ],
+        status: 'active',
+        intent: 'order',
+        subject: { reference: 'Patient/patient-1' },
+      };
+
+      expect(getHealthGorillaRequisitionId(request)).toBe('req-2');
+    });
+
+    test('returns undefined when not present', () => {
+      const request: ServiceRequest = {
+        resourceType: 'ServiceRequest',
+        status: 'active',
+        intent: 'order',
+        subject: { reference: 'Patient/patient-1' },
+      };
+      expect(getHealthGorillaRequisitionId(request)).toBeUndefined();
+    });
+  });
+
+  describe('fetchLabOrderRequisitionDocuments', () => {
+    test('returns empty array when requisition id missing', async () => {
+      const request: ServiceRequest = {
+        resourceType: 'ServiceRequest',
+        status: 'active',
+        intent: 'order',
+        subject: { reference: 'Patient/patient-1' },
+      };
+      const searchSpy = vi.spyOn(medplum, 'searchResources');
+
+      const result = await fetchLabOrderRequisitionDocuments(medplum as any, request);
+
+      expect(result).toEqual([]);
+      expect(searchSpy).not.toHaveBeenCalled();
+    });
+
+    test('fetches requisition documents', async () => {
+      const request: ServiceRequest = {
+        resourceType: 'ServiceRequest',
+        requisition: { system: 'https://www.healthgorilla.com', value: 'req-42' },
+        status: 'active',
+        intent: 'order',
+        subject: { reference: 'Patient/patient-1' },
+      };
+      const documents: DocumentReference[] = [
+        { resourceType: 'DocumentReference', id: 'doc-1', status: 'current', content: [] },
+      ];
+      const searchSpy = vi.spyOn(medplum, 'searchResources').mockResolvedValue(documents as any);
+
+      const result = await fetchLabOrderRequisitionDocuments(medplum as any, request);
+
+      expect(searchSpy).toHaveBeenCalledWith(
+        'DocumentReference',
+        expect.objectContaining({
+          toString: expect.any(Function),
+        }),
+        { cache: 'no-cache' }
+      );
+      const searchParams = (searchSpy.mock.calls[0][1] as URLSearchParams).toString();
+      expect(searchParams).toContain('category=LabOrderRequisition');
+      expect(searchParams).toContain('identifier=https%3A%2F%2Fwww.healthgorilla.com%7Creq-42');
+      expect(searchParams).toContain('_sort=-_lastUpdated');
+      expect(result).toEqual(documents);
+    });
+  });
+});

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

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { DocumentReference, ServiceRequest } from '@medplum/fhirtypes';
+import type { MedplumClient } from '@medplum/core';
+
+const HEALTH_GORILLA_REQUEST_SYSTEM = 'https://www.healthgorilla.com';
+
+/**
+ * Fetches DocumentReference resources with LabOrderRequisition category that match a ServiceRequest's Health Gorilla Requisition ID
+ * @param medplum - The Medplum client
+ * @param serviceRequest - The ServiceRequest to fetch the DocumentReference for
+ * @returns The DocumentReference resources
+ */
+export async function fetchLabOrderRequisitionDocuments(
+  medplum: MedplumClient,
+  serviceRequest: ServiceRequest
+): Promise<DocumentReference[]> {
+  const healthGorillaRequisitionId = getHealthGorillaRequisitionId(serviceRequest);
+
+  if (!healthGorillaRequisitionId) {
+    return [];
+  }
+
+  const searchParams = new URLSearchParams({
+    category: 'LabOrderRequisition',
+    identifier: `${HEALTH_GORILLA_REQUEST_SYSTEM}|${healthGorillaRequisitionId}`,
+    _sort: '-_lastUpdated',
+  });
+
+  const results = await medplum.searchResources('DocumentReference', searchParams, { cache: 'no-cache' });
+  return results;
+}
+
+/**
+ * Extracts the Health Gorilla Requisition ID from a ServiceRequest
+ * Looks for the requisition identifier with system "https://www.healthgorilla.com"
+ * @param serviceRequest - The ServiceRequest to extract the Health Gorilla Requisition ID from
+ * @returns The Health Gorilla Requisition ID
+ */
+export function getHealthGorillaRequisitionId(serviceRequest: ServiceRequest): string | undefined {
+  // Check if ServiceRequest has a requisition identifier
+  if (serviceRequest.requisition?.system === HEALTH_GORILLA_REQUEST_SYSTEM) {
+    return serviceRequest.requisition.value;
+  }
+
+  // Also check the identifier array for Health Gorilla identifiers
+  if (serviceRequest.identifier) {
+    const healthGorillaIdentifier = serviceRequest.identifier.find((id) => id.system === HEALTH_GORILLA_REQUEST_SYSTEM);
+    if (healthGorillaIdentifier?.value) {
+      return healthGorillaIdentifier.value;
+    }
+  }
+
+  return undefined;
+}

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

@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { HTTP_HL7_ORG } from '@medplum/core';
+import type { Coding, Encounter, Patient, PlanDefinition, Practitioner, Appointment, Task } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { createEncounter, updateEncounterStatus } from './encounter';
+
+describe('encounter utils', () => {
+  let medplum: MockClient;
+  let practitioner: Practitioner;
+  let patient: Patient;
+  let classification: Coding;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    practitioner = {
+      resourceType: 'Practitioner',
+      id: 'prac-1',
+      name: [{ given: ['Demo'], family: 'Doctor' }],
+    };
+    patient = { resourceType: 'Patient', id: 'patient-1', name: [{ given: ['Pat'], family: 'Smith' }] };
+    classification = { system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode', code: 'AMB' };
+    vi.spyOn(medplum, 'getProfile').mockReturnValue(practitioner);
+  });
+
+  describe('createEncounter', () => {
+    test('creates encounter and related resources', async () => {
+      // Capture createResource calls and respond with deterministic IDs
+      const createResourceSpy = vi.spyOn(medplum, 'createResource').mockImplementation(async (resource: any) => {
+        if (resource.resourceType === 'Appointment') {
+          return { ...resource, id: 'appt-1' };
+        }
+        if (resource.resourceType === 'Encounter') {
+          return { ...resource, id: 'enc-1' };
+        }
+        if (resource.resourceType === 'ChargeItem') {
+          return { ...resource, id: `charge-${Math.random()}` };
+        }
+        return { ...resource };
+      });
+      const postSpy = vi.spyOn(medplum, 'post').mockResolvedValue({});
+      const searchSpy = vi.spyOn(medplum, 'search').mockResolvedValue({
+        entry: [
+          {
+            resource: {
+              resourceType: 'Task',
+              focus: { reference: 'ServiceRequest/sr-1' },
+            } as Task,
+          },
+        ],
+      } as any);
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+      const readReferenceSpy = vi.spyOn(medplum, 'readReference').mockResolvedValue({
+        resourceType: 'ServiceRequest',
+        id: 'sr-1',
+        encounter: { reference: 'Encounter/enc-1' },
+        code: { coding: [{ system: 'http://www.ama-assn.org/go/cpt', code: '1234' }] },
+        occurrenceDateTime: '2020-01-01T12:00:00Z',
+        extension: [
+          {
+            url: 'http://medplum.com/fhir/StructureDefinition/applicable-charge-definition',
+            valueCanonical: 'ChargeItemDefinition/1',
+          },
+        ],
+      } as any);
+
+      const planDefinition: PlanDefinition = {
+        resourceType: 'PlanDefinition',
+        id: 'plan-1',
+        extension: [
+          {
+            url: `${HTTP_HL7_ORG}/fhir/uv/order-catalog/StructureDefinition/ServiceBillingCode`,
+            valueCodeableConcept: {
+              coding: [{ system: 'http://www.ama-assn.org/go/cpt', code: '99202', display: 'Office visit' }],
+            },
+          },
+          {
+            url: 'http://medplum.com/fhir/StructureDefinition/applicable-charge-definition',
+            valueCanonical: 'ChargeItemDefinition/plan',
+          },
+        ],
+        status: 'active',
+      };
+
+      const encounter = await createEncounter(
+        medplum as any,
+        new Date('2020-01-01T10:00:00Z'),
+        new Date('2020-01-01T10:30:00Z'),
+        classification,
+        patient,
+        planDefinition
+      );
+
+      expect(encounter.status).toBe('planned');
+      expect(encounter.id).toBe('enc-1');
+      expect(createResourceSpy).toHaveBeenCalledWith(expect.objectContaining({ resourceType: 'Appointment' }));
+      expect(postSpy).toHaveBeenCalled();
+      expect(searchSpy).toHaveBeenCalledWith('Task', expect.objectContaining({ encounter: 'Encounter/enc-1' }));
+      expect(readReferenceSpy).toHaveBeenCalledWith({ reference: 'ServiceRequest/sr-1' });
+      // Ensure a ChargeItem was attempted from service request
+      expect(
+        createResourceSpy.mock.calls.some(([resource]) => resource.resourceType === 'ChargeItem' && resource.code)
+      ).toBe(true);
+    });
+  });
+
+  describe('updateEncounterStatus', () => {
+    test('updates encounter period and appointment status', async () => {
+      const encounter: Encounter = {
+        resourceType: 'Encounter',
+        id: 'enc-1',
+        status: 'planned',
+        class: classification,
+      };
+      const appointment: Appointment = {
+        resourceType: 'Appointment',
+        id: 'appt-1',
+        status: 'booked',
+        participant: [
+          {
+            actor: { reference: 'Practitioner/prac-1' },
+            status: 'accepted',
+          },
+        ],
+      };
+      const updateSpy = vi.spyOn(medplum, 'updateResource').mockImplementation(async (resource) => resource as any);
+
+      const updatedEncounter = await updateEncounterStatus(medplum as any, encounter, appointment, 'in-progress');
+
+      expect(updateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ resourceType: 'Appointment', status: 'checked-in' })
+      );
+      expect(updateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ resourceType: 'Encounter', status: 'in-progress' })
+      );
+      expect(updatedEncounter.period?.start).toBeDefined();
+
+      // Move to finished state
+      await updateEncounterStatus(medplum as any, updatedEncounter, appointment, 'finished');
+      expect(updateSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'fulfilled' }));
+    });
+
+    test('updates appointment status for cancellation', async () => {
+      const encounter: Encounter = {
+        resourceType: 'Encounter',
+        id: 'enc-2',
+        status: 'in-progress',
+        class: classification,
+      };
+      const appointment: Appointment = {
+        resourceType: 'Appointment',
+        id: 'appt-2',
+        status: 'booked',
+        participant: [
+          {
+            actor: { reference: 'Practitioner/prac-1' },
+            status: 'accepted',
+          },
+        ],
+      };
+      const updateSpy = vi.spyOn(medplum, 'updateResource').mockImplementation(async (resource) => resource as any);
+
+      await updateEncounterStatus(medplum as any, encounter, appointment, 'cancelled');
+
+      expect(updateSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'cancelled' }));
+    });
+  });
+});