vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/pages/patient/TasksTab.test.tsx

@@ -0,0 +1,185 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { render, screen, waitFor } from '@testing-library/react';
+import { MedplumProvider } from '@medplum/react';
+import { MockClient } from '@medplum/mock';
+import { MemoryRouter, Routes, Route } from 'react-router';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { TasksTab } from './TasksTab';
+import type { Task } from '@medplum/fhirtypes';
+
+describe('TasksTab', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+  });
+
+  const setup = (initialPath = '/Patient/patient-123/Task'): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter initialEntries={[initialPath]}>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <Routes>
+              <Route path="/Patient/:patientId/Task" element={<TasksTab />} />
+              <Route path="/Patient/:patientId/Task/:taskId" element={<TasksTab />} />
+            </Routes>
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  const mockTask: Task = {
+    resourceType: 'Task',
+    id: 'task-123',
+    status: 'in-progress',
+    intent: 'order',
+    code: { text: 'Test Task' },
+    authoredOn: '2023-01-01T12:00:00Z',
+    for: { reference: 'Patient/patient-123' },
+  };
+
+  test('renders TaskBoard component', async () => {
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('My Tasks')).toBeInTheDocument();
+    });
+  });
+
+  test('filters tasks by patient ID', async () => {
+    await medplum.createResource(mockTask);
+    const searchSpy = vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockTask }],
+    } as any);
+
+    setup();
+
+    await waitFor(() => {
+      expect(searchSpy).toHaveBeenCalled();
+    });
+
+    const callArgs = searchSpy.mock.calls[0];
+    expect(callArgs[0]).toBe('Task');
+    expect(callArgs[1]).toContain('patient=Patient%2Fpatient-123');
+    expect(callArgs[1]).toContain('_sort=-_lastUpdated');
+  });
+
+  test('displays tasks for the patient', async () => {
+    await medplum.createResource(mockTask);
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockTask }],
+    } as any);
+
+    setup();
+
+    await waitFor(
+      () => {
+        expect(screen.getByText('Test Task')).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('uses patient-specific URL for task navigation', async () => {
+    await medplum.createResource(mockTask);
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockTask }],
+    } as any);
+
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Task')).toBeInTheDocument();
+    });
+
+    const links = screen.getAllByRole('link');
+    const taskLink = links.find((link) => link.getAttribute('href')?.includes('/Patient/patient-123/Task/task-123'));
+    expect(taskLink).toBeDefined();
+    // getTaskUri includes the query string, so check that href starts with the expected path
+    expect(taskLink?.getAttribute('href')).toMatch(/^\/Patient\/patient-123\/Task\/task-123/);
+  });
+
+  test('handles selected task from URL parameter', async () => {
+    await medplum.createResource(mockTask);
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockTask }],
+    } as any);
+    vi.spyOn(medplum, 'readResource').mockResolvedValue(mockTask as any);
+
+    setup(
+      '/Patient/patient-123/Task/task-123?_sort=-_lastUpdated&_count=20&_total=accurate&patient=Patient%2Fpatient-123'
+    );
+
+    await waitFor(
+      () => {
+        expect(medplum.readResource).toHaveBeenCalledWith('Task', 'task-123');
+      },
+      { timeout: 3000 }
+    );
+
+    await waitFor(
+      () => {
+        expect(screen.getByText('Properties')).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('handles different patient IDs', async () => {
+    const taskForDifferentPatient: Task = {
+      ...mockTask,
+      id: 'task-456',
+      for: { reference: 'Patient/patient-456' },
+    };
+    await medplum.createResource(taskForDifferentPatient);
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: taskForDifferentPatient }],
+    } as any);
+
+    setup('/Patient/patient-456/Task?_sort=-_lastUpdated&_count=20&_total=accurate&patient=Patient%2Fpatient-456');
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Task')).toBeInTheDocument();
+    });
+
+    const links = screen.getAllByRole('link');
+    const taskLink = links.find((link) => link.getAttribute('href')?.includes('/Patient/patient-456/Task/task-456'));
+    expect(taskLink).toBeDefined();
+    // getTaskUri includes the query string, so check that href starts with the expected path
+    expect(taskLink?.getAttribute('href')).toMatch(/^\/Patient\/patient-456\/Task\/task-456/);
+  });
+
+  test('shows empty state when no tasks found', async () => {
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 0,
+      entry: [],
+    } as any);
+
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('No tasks available.')).toBeInTheDocument();
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/src/pages/patient/TasksTab.tsx

@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Task } from '@medplum/fhirtypes';
+import React, { useEffect, useState } from 'react';
+import type { JSX } from 'react';
+import { useLocation, useNavigate, useParams } from 'react-router';
+import classes from '../tasks/TasksPage.module.css';
+import { TaskBoard } from '../../components/tasks/TaskBoard';
+import { formatSearchQuery, getReferenceString, Operator } from '@medplum/core';
+import type { SearchRequest } from '@medplum/core';
+import { Loading, useMedplumProfile } from '@medplum/react';
+import { normalizeTaskSearch } from '../../utils/task-search';
+
+export function TasksTab(): JSX.Element {
+  const { patientId, taskId } = useParams();
+  const navigate = useNavigate();
+  const location = useLocation();
+  const profile = useMedplumProfile();
+  const [parsedSearch, setParsedSearch] = useState<SearchRequest>();
+  const patientRef = `Patient/${patientId}`;
+
+  useEffect(() => {
+    const { normalizedSearch, needsNavigation } = normalizeTaskSearch(location.pathname, location.search, {
+      additionalFilters: [
+        {
+          code: 'patient',
+          operator: Operator.EQUALS,
+          value: patientRef,
+        },
+      ],
+    });
+
+    if (needsNavigation) {
+      navigate(`/Patient/${patientId}/Task${formatSearchQuery(normalizedSearch)}`)?.catch(console.error);
+    } else {
+      setParsedSearch(normalizedSearch);
+    }
+  }, [location, navigate, patientId, patientRef]);
+
+  if (!parsedSearch) {
+    return <Loading />;
+  }
+
+  const onNew = (task: Task): void => {
+    navigate(getTaskUri(task))?.catch(console.error);
+  };
+
+  const getTaskUri = (task: Task): string => {
+    return `/Patient/${patientId}/Task/${task.id}${formatSearchQuery(parsedSearch)}`;
+  };
+
+  const onDelete = (_: Task): void => {
+    navigate(`/Patient/${patientId}/Task${formatSearchQuery(parsedSearch)}`)?.catch(console.error);
+  };
+
+  const onChange = (search: SearchRequest): void => {
+    navigate(`/Patient/${patientId}/Task${formatSearchQuery(search)}`)?.catch(console.error);
+  };
+
+  const myTasksFilters = parsedSearch.filters?.filter((f) => f.code !== 'owner' && f.code !== 'patient') || [];
+  myTasksFilters.push({
+    code: 'patient',
+    operator: Operator.EQUALS,
+    value: patientRef,
+  });
+  if (profile) {
+    const profileRef = getReferenceString(profile);
+    if (profileRef) {
+      myTasksFilters.push({
+        code: 'owner',
+        operator: Operator.EQUALS,
+        value: profileRef,
+      });
+    }
+  }
+  const myTasksSearch: SearchRequest = {
+    ...parsedSearch,
+    filters: myTasksFilters,
+    offset: 0,
+  };
+
+  const allTasksFilters = parsedSearch.filters?.filter((f) => f.code !== 'owner' && f.code !== 'patient') || [];
+  allTasksFilters.push({
+    code: 'patient',
+    operator: Operator.EQUALS,
+    value: patientRef,
+  });
+  const allTasksSearch: SearchRequest = {
+    ...parsedSearch,
+    filters: allTasksFilters,
+    offset: 0,
+  };
+
+  const myTasksQuery = formatSearchQuery(myTasksSearch);
+  const allTasksQuery = formatSearchQuery(allTasksSearch);
+
+  return (
+    <div className={classes.container}>
+      <TaskBoard
+        query={formatSearchQuery(parsedSearch).substring(1)}
+        selectedTaskId={taskId}
+        onDelete={onDelete}
+        onNew={onNew}
+        onChange={onChange}
+        getTaskUri={getTaskUri}
+        myTasksUri={
+          myTasksQuery ? `/Patient/${patientId}/Task?${myTasksQuery.substring(1)}` : `/Patient/${patientId}/Task`
+        }
+        allTasksUri={
+          allTasksQuery ? `/Patient/${patientId}/Task?${allTasksQuery.substring(1)}` : `/Patient/${patientId}/Task`
+        }
+      />
+    </div>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/pages/patient/TimelineTab.tsx

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Loader } from '@mantine/core';
+import { PatientTimeline } from '@medplum/react';
+import type { JSX } from 'react';
+import { usePatient } from '../../hooks/usePatient';
+
+export function TimelineTab(): JSX.Element {
+  const patient = usePatient();
+  if (!patient) {
+    return <Loader />;
+  }
+  return <PatientTimeline patient={patient} />;
+}

package/dist/examples/vintasend-medplum-example/src/pages/resource/ResourceCreatePage.test.tsx

@@ -0,0 +1,170 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { Notifications } from '@mantine/notifications';
+import { HomerSimpson, MockClient } from '@medplum/mock';
+import { MedplumProvider } from '@medplum/react';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router';
+import * as reactRouter from 'react-router';
+import { describe, expect, test, vi, beforeEach } from 'vitest';
+import { ResourceCreatePage } from './ResourceCreatePage';
+
+describe('ResourceCreatePage', () => {
+  let medplum: MockClient;
+  let navigateSpy: ReturnType<typeof vi.fn>;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    navigateSpy = vi.fn();
+    vi.spyOn(reactRouter, 'useNavigate').mockReturnValue(navigateSpy as any);
+  });
+
+  const setup = async (url: string): Promise<void> => {
+    await act(async () => {
+      render(
+        <MemoryRouter initialEntries={[url]}>
+          <MedplumProvider medplum={medplum}>
+            <MantineProvider>
+              <Notifications />
+              <Routes>
+                <Route path="/:resourceType/new" element={<ResourceCreatePage />} />
+                <Route path="/Patient/:patientId/:resourceType/new" element={<ResourceCreatePage />} />
+              </Routes>
+            </MantineProvider>
+          </MedplumProvider>
+        </MemoryRouter>
+      );
+    });
+  };
+
+  test('Renders new Practitioner form page', async () => {
+    await setup('/Practitioner/new');
+
+    await waitFor(() => {
+      expect(screen.getByText('New Practitioner')).toBeInTheDocument();
+    });
+  });
+
+  test('Renders new Task form page', async () => {
+    await setup('/Task/new');
+
+    await waitFor(() => {
+      expect(screen.getByText('New Task')).toBeInTheDocument();
+    });
+  });
+
+  test('Form submit creates new Practitioner', async () => {
+    const user = userEvent.setup();
+    await setup('/Practitioner/new');
+
+    await waitFor(() => {
+      expect(screen.getByText('New Practitioner')).toBeInTheDocument();
+    });
+
+    // Find the submit button (ResourceForm typically has a "Create" or "OK" button)
+    const submitButton = await screen.findByRole('button', { name: /create|ok|submit/i });
+    expect(submitButton).toBeInTheDocument();
+
+    // Mock createResource to return a result
+    const createdPractitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-123',
+    };
+    vi.spyOn(medplum, 'createResource').mockResolvedValue(createdPractitioner as any);
+
+    await user.click(submitButton);
+
+    await waitFor(() => {
+      expect(medplum.createResource).toHaveBeenCalled();
+    });
+  });
+
+  test('Form submit creates new Task and navigates', async () => {
+    const user = userEvent.setup();
+    await setup('/Task/new');
+
+    await waitFor(() => {
+      expect(screen.getByText('New Task')).toBeInTheDocument();
+    });
+
+    const submitButton = await screen.findByRole('button', { name: /create|ok|submit/i });
+    expect(submitButton).toBeInTheDocument();
+
+    const createdTask = {
+      resourceType: 'Task',
+      id: 'task-123',
+    };
+    vi.spyOn(medplum, 'createResource').mockResolvedValue(createdTask as any);
+
+    await user.click(submitButton);
+
+    await waitFor(
+      () => {
+        expect(medplum.createResource).toHaveBeenCalled();
+        expect(navigateSpy).toHaveBeenCalledWith('/Task/task-123');
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('Form submit creates new Task with patient context and navigates', async () => {
+    const user = userEvent.setup();
+    await setup(`/Patient/${HomerSimpson.id}/Task/new`);
+
+    await waitFor(() => {
+      expect(screen.getByText('New Task')).toBeInTheDocument();
+    });
+
+    const submitButton = await screen.findByRole('button', { name: /create|ok|submit/i });
+    expect(submitButton).toBeInTheDocument();
+
+    const createdTask = {
+      resourceType: 'Task',
+      id: 'task-123',
+    };
+    vi.spyOn(medplum, 'createResource').mockResolvedValue(createdTask as any);
+
+    await user.click(submitButton);
+
+    await waitFor(
+      () => {
+        expect(medplum.createResource).toHaveBeenCalled();
+        // Should navigate with patient path prepended - check that navigate was called
+        expect(navigateSpy).toHaveBeenCalled();
+        // The path should include the patient ID
+        const navigateCalls = navigateSpy.mock.calls;
+        expect(navigateCalls.length).toBeGreaterThan(0);
+        const lastCall = navigateCalls[navigateCalls.length - 1][0];
+        expect(String(lastCall)).toContain(`Patient/${HomerSimpson.id}`);
+        expect(String(lastCall)).toContain('Task/task-123');
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('Handles form submission error', async () => {
+    const user = userEvent.setup();
+    await setup('/Practitioner/new');
+
+    await waitFor(() => {
+      expect(screen.getByText('New Practitioner')).toBeInTheDocument();
+    });
+
+    const submitButton = await screen.findByRole('button', { name: /create|ok|submit/i });
+    expect(submitButton).toBeInTheDocument();
+
+    const error = new Error('Failed to create resource');
+    vi.spyOn(medplum, 'createResource').mockRejectedValue(error);
+
+    await user.click(submitButton);
+
+    await waitFor(() => {
+      expect(medplum.createResource).toHaveBeenCalled();
+      // Should show error notification
+      expect(screen.getByText(/failed to create resource/i)).toBeInTheDocument();
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/src/pages/resource/ResourceCreatePage.tsx

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Stack, Text } from '@mantine/core';
+import { showNotification } from '@mantine/notifications';
+import { createReference, normalizeErrorString, normalizeOperationOutcome } from '@medplum/core';
+import type { OperationOutcome, Patient, Resource, ResourceType } from '@medplum/fhirtypes';
+import { Document, Loading, useMedplum } from '@medplum/react';
+import { useEffect, useState } from 'react';
+import type { JSX } from 'react';
+import { useNavigate, useParams } from 'react-router';
+import { ResourceFormWithRequiredProfile } from '../../components/ResourceFormWithRequiredProfile';
+import { usePatient } from '../../hooks/usePatient';
+import { prependPatientPath } from '../patient/PatientPage.utils';
+import { RESOURCE_PROFILE_URLS } from './utils';
+
+const PatientReferencesElements: Partial<Record<ResourceType, string[]>> = {
+  Task: ['for'],
+  MedicationRequest: ['subject'],
+  ServiceRequest: ['subject'],
+  Device: ['patient'],
+  DiagnosticReport: ['subject'],
+  DocumentReference: ['subject'],
+  Appointment: ['participant.actor'],
+  CarePlan: ['subject'],
+};
+
+function getDefaultValue(resourceType: ResourceType, patient: Patient | undefined): Partial<Resource> {
+  const dv = { resourceType } as Partial<Resource>;
+  const refKeys = PatientReferencesElements[resourceType];
+  if (patient && refKeys) {
+    for (const key of refKeys) {
+      const keyParts = key.split('.');
+      if (keyParts.length === 1) {
+        (dv as any)[key] = createReference(patient);
+      } else if (keyParts.length === 2) {
+        const [first, second] = keyParts;
+        (dv as any)[first] = [{ [second]: createReference(patient) }];
+      } else {
+        throw new Error('Can only process keys with one or two parts');
+      }
+    }
+  }
+
+  return dv;
+}
+
+function getResourceTypeFromPath(pathname: string): ResourceType | undefined {
+  const pathParts = pathname.split('/');
+  if (pathParts.length >= 3 && pathParts[2] === 'new') {
+    return pathParts[1] as ResourceType;
+  }
+
+  return undefined;
+}
+
+export function ResourceCreatePage(): JSX.Element {
+  const medplum = useMedplum();
+  const [outcome, setOutcome] = useState<OperationOutcome | undefined>();
+  const patient = usePatient({ ignoreMissingPatientId: true, setOutcome });
+  const navigate = useNavigate();
+  const params = useParams() as { patientId?: string; resourceType?: ResourceType };
+  const resourceType = params.resourceType || getResourceTypeFromPath(location.pathname);
+  const patientId = params.patientId;
+  const [loadingPatient, setLoadingPatient] = useState(Boolean(patientId));
+  const [defaultValue, setDefaultValue] = useState<Partial<Resource>>(() => {
+    if (!resourceType) {
+      return {};
+    }
+    return getDefaultValue(resourceType, patient);
+  });
+  const profileUrl = resourceType && RESOURCE_PROFILE_URLS[resourceType];
+
+  useEffect(() => {
+    if (patient && resourceType) {
+      setDefaultValue(getDefaultValue(resourceType, patient));
+    }
+    setLoadingPatient(false);
+  }, [patient, resourceType]);
+
+  const handleSubmit = (newResource: Resource): void => {
+    if (outcome) {
+      setOutcome(undefined);
+    }
+    medplum
+      .createResource(newResource)
+      .then((result) => navigate(prependPatientPath(patient, '/' + result.resourceType + '/' + result.id)))
+      .catch((err) => {
+        if (setOutcome) {
+          setOutcome(normalizeOperationOutcome(err));
+        }
+        showNotification({
+          color: 'red',
+          message: normalizeErrorString(err),
+          autoClose: false,
+          styles: { description: { whiteSpace: 'pre-line' } },
+        });
+      });
+  };
+
+  if (loadingPatient) {
+    return <Loading />;
+  }
+
+  return (
+    <Document shadow="xs">
+      <Stack>
+        <Text fw={500}>New&nbsp;{resourceType}</Text>
+        <ResourceFormWithRequiredProfile
+          defaultValue={defaultValue}
+          onSubmit={handleSubmit}
+          outcome={outcome}
+          profileUrl={profileUrl}
+        />
+      </Stack>
+    </Document>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/pages/resource/ResourceDetailPage.tsx

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Stack, Title } from '@mantine/core';
+import { getDisplayString } from '@medplum/core';
+import { ResourceTable, useResource } from '@medplum/react';
+import type { JSX } from 'react';
+import { useParams } from 'react-router';
+
+/**
+ * This is an example of a generic "Resource Display" page.
+ * It uses the Medplum `<ResourceTable>` component to display a resource.
+ * @returns A React component that displays a resource.
+ */
+export function ResourceDetailPage(): JSX.Element | null {
+  const { resourceType, id } = useParams();
+  const resource = useResource({ reference: resourceType + '/' + id });
+
+  if (!resource) {
+    return null;
+  }
+
+  return (
+    <Stack>
+      <Title>{getDisplayString(resource)}</Title>
+      <ResourceTable key={`${resourceType}/${id}`} value={resource} />
+    </Stack>
+  );
+}