vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/main.tsx

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider, createTheme } from '@mantine/core';
+import '@mantine/core/styles.css';
+import { Notifications } from '@mantine/notifications';
+import '@mantine/notifications/styles.css';
+import '@mantine/spotlight/styles.css';
+import { MedplumClient } from '@medplum/core';
+import { MedplumProvider } from '@medplum/react';
+import '@medplum/react/styles.css';
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { RouterProvider, createBrowserRouter } from 'react-router';
+import { App } from './App';
+
+const medplum = new MedplumClient({
+  onUnauthenticated: () => (window.location.href = '/'),
+  // baseUrl: 'http://localhost:8103/', // Uncomment this to run against the server on your localhost
+  cacheTime: 60000,
+  autoBatchTime: 100,
+});
+
+const theme = createTheme({
+  headings: {
+    sizes: {
+      h1: {
+        fontSize: '1.125rem',
+        fontWeight: '500',
+        lineHeight: '2.0',
+      },
+    },
+  },
+  fontSizes: {
+    xs: '0.6875rem',
+    sm: '0.875rem',
+    md: '0.875rem',
+    lg: '1.0rem',
+    xl: '1.125rem',
+  },
+});
+
+const router = createBrowserRouter([{ path: '*', element: <App /> }]);
+
+const navigate = (path: string): Promise<void> => router.navigate(path);
+
+const container = document.getElementById('root') as HTMLDivElement;
+const root = createRoot(container);
+root.render(
+  <StrictMode>
+    <MedplumProvider medplum={medplum} navigate={navigate}>
+      <MantineProvider theme={theme}>
+        <Notifications position="bottom-right" />
+        <RouterProvider router={router} />
+      </MantineProvider>
+    </MedplumProvider>
+  </StrictMode>
+);

package/dist/examples/vintasend-medplum-example/src/pages/SearchPage.module.css

@@ -0,0 +1,6 @@
+.paper {
+  @mixin smaller-than $mantine-breakpoint-sm {
+    margin: 2px;
+    padding: 4px;
+  }
+}

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

@@ -0,0 +1,295 @@
+// 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 { MockClient } from '@medplum/mock';
+import type { Communication, Patient, Task, UserConfiguration } from '@medplum/fhirtypes';
+import { MedplumProvider } from '@medplum/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { MemoryRouter, Routes, Route } from 'react-router';
+import { describe, expect, test, vi, beforeEach, afterEach } from 'vitest';
+import { SearchPage } from './SearchPage';
+import type { WithId } from '@medplum/core';
+
+describe('SearchPage', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    localStorage.clear();
+  });
+
+  async function setup(url: string, client = medplum, userConfig?: UserConfiguration): Promise<void> {
+    if (userConfig) {
+      vi.spyOn(client, 'getUserConfiguration').mockReturnValue(userConfig as unknown as WithId<UserConfiguration>);
+    }
+    await act(async () => {
+      render(
+        <MedplumProvider medplum={client}>
+          <MemoryRouter initialEntries={[url]} initialIndex={0}>
+            <MantineProvider>
+              <Notifications />
+              <Routes>
+                <Route path="/:resourceType" element={<SearchPage />} />
+                <Route path="/:resourceType/new" element={<div>New Resource</div>} />
+                <Route path="/Patient/:patientId/:resourceType/:id" element={<div>Patient Resource</div>} />
+                <Route path="/:resourceType/:id" element={<div>Resource Detail</div>} />
+              </Routes>
+            </MantineProvider>
+          </MemoryRouter>
+        </MedplumProvider>
+      );
+    });
+  }
+
+  test('Renders SearchControl for Task resource type', async () => {
+    await setup('/Task');
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Renders SearchControl for Patient resource type', async () => {
+    await setup('/Patient');
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Renders with search query parameters', async () => {
+    await setup('/Task?_fields=id,_lastUpdated,code,description');
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Uses default resource type from localStorage', async () => {
+    localStorage.setItem('defaultResourceType', 'Practitioner');
+    await setup('/Practitioner');
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Uses default resource type from UserConfiguration', async () => {
+    const userConfig: UserConfiguration = {
+      resourceType: 'UserConfiguration',
+      option: [{ id: 'defaultResourceType', valueString: 'ServiceRequest' }],
+    };
+    await setup('/ServiceRequest', medplum, userConfig);
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Saves and retrieves last search from localStorage', async () => {
+    await setup('/Task?_fields=id,code&name:contains=test');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+
+    // Verify default resource type was saved
+    expect(localStorage.getItem('defaultResourceType')).toBe('Task');
+
+    // Verify search was saved
+    const savedSearch = localStorage.getItem('Task-defaultSearch');
+    expect(savedSearch).toBeTruthy();
+    const parsed = JSON.parse(savedSearch as string);
+    expect(parsed.resourceType).toBe('Task');
+  });
+
+  test('Retrieves filters from last search', async () => {
+    // Set up a previous search in localStorage
+    const previousSearch = {
+      resourceType: 'Task',
+      filters: [{ code: 'status', operator: 'eq', value: 'in-progress' }],
+    };
+    localStorage.setItem('Task-defaultSearch', JSON.stringify(previousSearch));
+
+    await setup('/Task');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('Retrieves sort rules from last search', async () => {
+    // Set up a previous search in localStorage
+    const previousSearch = {
+      resourceType: 'Task',
+      sortRules: [{ code: 'priority', descending: false }],
+    };
+    localStorage.setItem('Task-defaultSearch', JSON.stringify(previousSearch));
+
+    await setup('/Task');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('Defaults to _lastUpdated descending sort when no last search', async () => {
+    await setup('/Observation');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('Handles search with offset and count', async () => {
+    await setup('/Task?_offset=10&_count=50');
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Navigates to resource with patient reference on click', async () => {
+    // Create a task with a patient reference
+    const patient: Patient = {
+      resourceType: 'Patient',
+      id: 'patient-123',
+      name: [{ family: 'Test', given: ['Patient'] }],
+    };
+    await medplum.createResource(patient);
+
+    const task: Task = {
+      resourceType: 'Task',
+      id: 'task-456',
+      status: 'in-progress',
+      intent: 'order',
+      for: { reference: 'Patient/patient-123', display: 'Test Patient' },
+    };
+    await medplum.createResource(task);
+
+    await setup('/Task');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('Navigates to resource without patient reference on click', async () => {
+    const task: Task = {
+      resourceType: 'Task',
+      id: 'task-789',
+      status: 'draft',
+      intent: 'order',
+    };
+    await medplum.createResource(task);
+
+    await setup('/Task');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('Handles resource with subject reference to Patient', async () => {
+    const task: Task = {
+      resourceType: 'Task',
+      id: 'task-subject',
+      status: 'in-progress',
+      intent: 'order',
+    };
+    await medplum.createResource(task);
+
+    await setup('/Task');
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('Handles Communication with sender reference to Patient', async () => {
+    const communication: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-123',
+      status: 'completed',
+      sender: { reference: 'Patient/patient-456' },
+    };
+    await medplum.createResource(communication);
+
+    await setup('/Communication');
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+  });
+
+  test('New button navigates to new resource page', async () => {
+    await setup('/Task');
+    expect(await screen.findByText('New...')).toBeInTheDocument();
+
+    await act(async () => {
+      fireEvent.click(screen.getByText('New...'));
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('New Resource')).toBeInTheDocument();
+    });
+  });
+
+  test('Handles resource click navigation', async () => {
+    window.open = vi.fn();
+
+    await setup('/Task');
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+
+    // Verify SearchControl is rendered and functional
+    const searchControl = screen.getByTestId('search-control');
+    expect(searchControl).toBeInTheDocument();
+  });
+
+  test('SearchControl supports checkbox selection', async () => {
+    await setup('/Task');
+    const searchControl = await screen.findByTestId('search-control');
+    expect(searchControl).toBeInTheDocument();
+  });
+
+  test('Handles onChange for search definition updates', async () => {
+    await setup('/Task');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+
+    // Test pagination which triggers onChange
+    const nextPageButton = screen.queryByLabelText('Next page');
+    if (nextPageButton) {
+      await act(async () => {
+        fireEvent.click(nextPageButton);
+      });
+    }
+  });
+
+  test('Renders with default fields when not specified', async () => {
+    await setup('/Practitioner');
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+
+  test('Shows loading when search is not ready', async () => {
+    // Create a mock that simulates loading state
+    const loadingClient = new MockClient();
+    vi.spyOn(loadingClient, 'isLoading').mockReturnValue(true);
+
+    await setup('/Task', loadingClient);
+
+    // The component should show loading or SearchControl once ready
+    await waitFor(
+      () => {
+        const searchControl = screen.queryByTestId('search-control');
+        const loader = document.querySelector('.mantine-Loader-root');
+        expect(searchControl || loader).toBeTruthy();
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('Handles auxClick to open resource in new tab', async () => {
+    window.open = vi.fn();
+
+    await setup('/Task');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('search-control')).toBeInTheDocument();
+    });
+
+    // The onAuxClick handler should be available on resource rows
+    const searchControl = screen.getByTestId('search-control');
+    expect(searchControl).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,124 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Paper } from '@mantine/core';
+import { DEFAULT_SEARCH_COUNT, formatSearchQuery, isReference, parseSearchRequest } from '@medplum/core';
+import type { Filter, SearchRequest, SortRule } from '@medplum/core';
+import type { Patient, Reference, Resource, UserConfiguration } from '@medplum/fhirtypes';
+import { Loading, SearchControl, useMedplum } from '@medplum/react';
+import { useEffect, useState } from 'react';
+import type { JSX } from 'react';
+import { useLocation, useNavigate } from 'react-router';
+import { useResourceType } from './resource/useResourceType';
+import classes from './SearchPage.module.css';
+
+export function SearchPage(): JSX.Element {
+  const medplum = useMedplum();
+  const navigate = useNavigate();
+  const location = useLocation();
+  const [search, setSearch] = useState<SearchRequest>();
+
+  useEffect(() => {
+    const parsedSearch = parseSearchRequest(location.pathname + location.search);
+
+    const populatedSearch = addSearchValues(parsedSearch, medplum.getUserConfiguration());
+
+    if (
+      location.pathname === `/${populatedSearch.resourceType}` &&
+      location.search === formatSearchQuery(populatedSearch)
+    ) {
+      saveLastSearch(populatedSearch);
+      setSearch(populatedSearch);
+    } else {
+      navigate(`/${populatedSearch.resourceType}${formatSearchQuery(populatedSearch)}`)?.catch(console.error);
+    }
+  }, [medplum, navigate, location]);
+
+  useResourceType(search?.resourceType, { onInvalidResourceType: () => navigate('..')?.catch(console.error) });
+
+  if (!search?.resourceType || !search.fields || search.fields.length === 0) {
+    return <Loading />;
+  }
+
+  return (
+    <Paper shadow="xs" m="xs" p="xs" className={classes.paper}>
+      <SearchControl
+        checkboxesEnabled={true}
+        search={search}
+        onClick={(e) => navigate(getResourceUrl(e.resource))?.catch(console.error)}
+        onAuxClick={(e) => window.open(getResourceUrl(e.resource), '_blank')}
+        onNew={() => {
+          navigate(`/${search.resourceType}/new`)?.catch(console.error);
+        }}
+        onChange={(e) => {
+          navigate(`/${search.resourceType}${formatSearchQuery(e.definition)}`)?.catch(console.error);
+        }}
+      />
+    </Paper>
+  );
+}
+
+function addSearchValues(search: SearchRequest, config: UserConfiguration | undefined): SearchRequest {
+  const resourceType = search.resourceType || getDefaultResourceType(config);
+  const fields = search.fields ?? ['_id', '_lastUpdated'];
+  const filters = search.filters ?? (!search.resourceType ? getDefaultFilters(resourceType) : undefined);
+  const sortRules = search.sortRules ?? getDefaultSortRules(resourceType);
+  const offset = search.offset ?? 0;
+  const count = search.count ?? DEFAULT_SEARCH_COUNT;
+
+  return {
+    ...search,
+    resourceType,
+    fields,
+    filters,
+    sortRules,
+    offset,
+    count,
+  };
+}
+
+function getDefaultResourceType(config: UserConfiguration | undefined): string {
+  return (
+    localStorage.getItem('defaultResourceType') ??
+    config?.option?.find((o) => o.id === 'defaultResourceType')?.valueString ??
+    'Task'
+  );
+}
+
+function getDefaultFilters(resourceType: string): Filter[] | undefined {
+  return getLastSearch(resourceType)?.filters;
+}
+
+function getDefaultSortRules(resourceType: string): SortRule[] {
+  const lastSearch = getLastSearch(resourceType);
+  if (lastSearch?.sortRules) {
+    return lastSearch.sortRules;
+  }
+  return [{ code: '_lastUpdated', descending: true }];
+}
+
+function getLastSearch(resourceType: string): SearchRequest | undefined {
+  const value = localStorage.getItem(resourceType + '-defaultSearch');
+  return value ? (JSON.parse(value) as SearchRequest) : undefined;
+}
+
+function saveLastSearch(search: SearchRequest): void {
+  localStorage.setItem('defaultResourceType', search.resourceType);
+  localStorage.setItem(search.resourceType + '-defaultSearch', JSON.stringify(search));
+}
+
+function getResourceUrl<T extends Resource>(resource: T): string {
+  const patientFields = ['patient', 'subject', 'sender'] as (keyof T)[];
+  for (const key of patientFields) {
+    if (key in resource) {
+      const value = resource[key];
+      if (isPatientReference(value)) {
+        return `/${value.reference}/${resource.resourceType}/${resource.id}`;
+      }
+    }
+  }
+  return `/${resource.resourceType}/${resource.id}`;
+}
+
+function isPatientReference(input: unknown): input is Reference<Patient> & { reference: string } {
+  return isReference(input) && input.reference.startsWith('Patient/');
+}

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

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { MedplumClient } from '@medplum/core';
+import { DrAliceSmith, MockClient } from '@medplum/mock';
+import { MedplumProvider } from '@medplum/react';
+import crypto from 'crypto';
+import { MemoryRouter } from 'react-router';
+import { TextEncoder } from 'util';
+import { describe, expect, test, beforeAll, vi } from 'vitest';
+import { App } from '../App';
+import { act, fireEvent, render, screen } from '../test-utils/render';
+
+describe('SignInPage', () => {
+  function setup(url = '/signin', medplumClient?: MedplumClient): MedplumClient {
+    const client = medplumClient ?? new MockClient({ profile: null, clientId: 'my-client-id' });
+    render(
+      <MemoryRouter initialEntries={[url]} initialIndex={0}>
+        <MedplumProvider medplum={client}>
+          <App />
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+    return client;
+  }
+
+  beforeAll(() => {
+    Object.defineProperty(global, 'TextEncoder', {
+      value: TextEncoder,
+    });
+
+    Object.defineProperty(global.self, 'crypto', {
+      value: crypto.webcrypto,
+    });
+  });
+
+  function expectSigninPageRendered(): void {
+    expect(screen.getByText('Sign in to Provider')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Continue' })).toBeInTheDocument();
+  }
+
+  test('Renders', async () => {
+    setup();
+
+    expectSigninPageRendered();
+  });
+
+  test('Success', async () => {
+    const client = setup();
+
+    vi.spyOn(client, 'processCode').mockImplementation(async () => {
+      (client as MockClient).setProfile(DrAliceSmith);
+      return DrAliceSmith;
+    });
+
+    await act(async () => {
+      fireEvent.change(screen.getByLabelText('Email *'), { target: { value: 'admin@example.com' } });
+    });
+
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: 'Continue' }));
+    });
+
+    // Wait for password field to appear
+    await screen.findByLabelText('Password *');
+
+    await act(async () => {
+      fireEvent.change(screen.getByLabelText('Password *'), { target: { value: 'password' } });
+    });
+
+    const submitButton = screen.getByRole('button', { name: /Continue|Sign In/i });
+    await act(async () => {
+      fireEvent.click(submitButton);
+    });
+
+    expect(await screen.findByTestId('search-control')).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Title } from '@mantine/core';
+import { Logo, SignInForm } from '@medplum/react';
+import type { JSX } from 'react';
+import { useNavigate } from 'react-router';
+
+export function SignInPage(): JSX.Element {
+  const navigate = useNavigate();
+  return (
+    <SignInForm
+      // Configure according to your settings
+      googleClientId="921088377005-3j1sa10vr6hj86jgmdfh2l53v3mp7lfi.apps.googleusercontent.com"
+      onSuccess={() => navigate('/')?.catch(console.error)}
+    >
+      <Logo size={32} />
+      <Title order={3} py="lg">
+        Sign in to Provider
+      </Title>
+    </SignInForm>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/pages/encounter/EncounterChartPage.test.tsx

@@ -0,0 +1,87 @@
+// 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 { MockClient } from '@medplum/mock';
+import { MedplumProvider } from '@medplum/react';
+import { render, screen, waitFor } from '@testing-library/react';
+import { MemoryRouter, Routes, Route } from 'react-router';
+import { describe, expect, test, vi, beforeEach } from 'vitest';
+import { EncounterChartPage } from './EncounterChartPage';
+import * as notificationsModule from '../../utils/notifications';
+
+describe('EncounterChartPage', () => {
+  let medplum: MockClient;
+  let showErrorNotificationSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    showErrorNotificationSpy = vi.spyOn(notificationsModule, 'showErrorNotification');
+  });
+
+  function setup(initialPath: string, routePattern: string = '/Encounter/:encounterId/*'): ReturnType<typeof render> {
+    return render(
+      <MemoryRouter initialEntries={[initialPath]}>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <Notifications />
+            <Routes>
+              <Route path={routePattern} element={<EncounterChartPage />}>
+                <Route path="*" element={<div data-testid="outlet">Outlet Content</div>} />
+              </Route>
+            </Routes>
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  }
+
+  test('Renders EncounterChart when encounterId is present', async () => {
+    setup('/Encounter/encounter-123');
+
+    await waitFor(() => {
+      const loader = document.querySelector('.mantine-Loader-root');
+      expect(loader).toBeInTheDocument();
+    });
+  });
+
+  test('Renders Outlet when encounterId is present', async () => {
+    setup('/Encounter/encounter-123');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('outlet')).toBeInTheDocument();
+    });
+
+    expect(screen.getByText('Outlet Content')).toBeInTheDocument();
+  });
+
+  test('Shows error notification and returns null when encounterId is missing', () => {
+    setup('/Encounter', '/Encounter/:encounterId?/*');
+
+    expect(showErrorNotificationSpy).toHaveBeenCalledWith('Encounter ID not found');
+    const loader = document.querySelector('.mantine-Loader-root');
+    expect(loader).not.toBeInTheDocument();
+    expect(screen.queryByTestId('outlet')).not.toBeInTheDocument();
+  });
+
+  test('Creates correct encounter reference from encounterId', async () => {
+    setup('/Encounter/encounter-456');
+
+    await waitFor(() => {
+      const loader = document.querySelector('.mantine-Loader-root');
+      expect(loader).toBeInTheDocument();
+    });
+  });
+
+  test('Handles nested routes correctly', async () => {
+    setup('/Encounter/encounter-123/nested/path');
+
+    await waitFor(() => {
+      const loader = document.querySelector('.mantine-Loader-root');
+      expect(loader).toBeInTheDocument();
+    });
+
+    expect(screen.getByTestId('outlet')).toBeInTheDocument();
+  });
+});