vintasend 0.4.0 → 0.4.7

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

@@ -0,0 +1,131 @@
+// 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 type { Practitioner } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { MedplumProvider } from '@medplum/react';
+import { 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 { ResourceEditPage } from './ResourceEditPage';
+
+describe('ResourceEditPage', () => {
+  let medplum: MockClient;
+  let navigateSpy: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    navigateSpy = vi.fn();
+    vi.spyOn(reactRouter, 'useNavigate').mockReturnValue(navigateSpy as any);
+  });
+
+  const setup = (url: string): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter initialEntries={[url]}>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <Notifications />
+            <Routes>
+              <Route path="/:resourceType/:id/edit" element={<ResourceEditPage />} />
+            </Routes>
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  test('Renders edit page', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ family: 'Test' }],
+    });
+
+    setup(`/Practitioner/${practitioner.id}/edit`);
+
+    await waitFor(() => {
+      const submitButton = screen.getByRole('button', { name: /update|save|submit/i });
+      expect(submitButton).toBeInTheDocument();
+    });
+  });
+
+  test('Loads resource data', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ family: 'Test', given: ['John'] }],
+    });
+
+    const readResourceSpy = vi.spyOn(medplum, 'readResource');
+    setup(`/Practitioner/${practitioner.id}/edit`);
+
+    await waitFor(() => {
+      expect(readResourceSpy).toHaveBeenCalledWith('Practitioner', practitioner.id);
+    });
+  });
+
+  test('Submit updates resource', async () => {
+    const user = userEvent.setup();
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ family: 'Test' }],
+    });
+
+    setup(`/Practitioner/${practitioner.id}/edit`);
+
+    await waitFor(() => {
+      const submitButton = screen.getByRole('button', { name: /update|save|submit/i });
+      expect(submitButton).toBeInTheDocument();
+    });
+
+    const updateButton = screen.getByRole('button', { name: /update|save|submit/i });
+    vi.spyOn(medplum, 'updateResource').mockResolvedValue(practitioner as any);
+
+    await user.click(updateButton);
+
+    await waitFor(() => {
+      expect(medplum.updateResource).toHaveBeenCalled();
+      expect(screen.getByText('Success')).toBeInTheDocument();
+      expect(navigateSpy).toHaveBeenCalledWith('..');
+    });
+  });
+
+  test('Handles update error', async () => {
+    const user = userEvent.setup();
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ family: 'Test' }],
+    });
+
+    setup(`/Practitioner/${practitioner.id}/edit`);
+
+    await waitFor(() => {
+      const submitButton = screen.getByRole('button', { name: /update|save|submit/i });
+      expect(submitButton).toBeInTheDocument();
+    });
+
+    const updateButton = screen.getByRole('button', { name: /update|save|submit/i });
+    const error = new Error('Failed to update resource');
+    vi.spyOn(medplum, 'updateResource').mockRejectedValue(error);
+
+    await user.click(updateButton);
+
+    await waitFor(() => {
+      expect(medplum.updateResource).toHaveBeenCalled();
+      expect(screen.getByText(/failed to update resource/i)).toBeInTheDocument();
+    });
+  });
+
+  test('Handles load error', async () => {
+    vi.spyOn(medplum, 'readResource').mockRejectedValue(new Error('Resource not found'));
+
+    setup('/Practitioner/non-existent/edit');
+
+    await waitFor(() => {
+      expect(medplum.readResource).toHaveBeenCalled();
+      expect(screen.getByText(/resource not found/i)).toBeInTheDocument();
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { showNotification } from '@mantine/notifications';
+import { deepClone, normalizeErrorString, normalizeOperationOutcome } from '@medplum/core';
+import type { OperationOutcome, Resource, ResourceType } from '@medplum/fhirtypes';
+import { useMedplum } from '@medplum/react';
+import { useCallback, useEffect, useState } from 'react';
+import type { JSX } from 'react';
+import { useNavigate, useParams } from 'react-router';
+import { ResourceFormWithRequiredProfile } from '../../components/ResourceFormWithRequiredProfile';
+import { RESOURCE_PROFILE_URLS } from './utils';
+
+export function ResourceEditPage(): JSX.Element | null {
+  const medplum = useMedplum();
+  const { resourceType, id } = useParams() as { resourceType: ResourceType | undefined; id: string | undefined };
+  const [value, setValue] = useState<Resource | undefined>();
+  const navigate = useNavigate();
+  const [outcome, setOutcome] = useState<OperationOutcome | undefined>();
+  const profileUrl = resourceType && RESOURCE_PROFILE_URLS[resourceType];
+
+  useEffect(() => {
+    if (resourceType && id) {
+      medplum
+        .readResource(resourceType, id)
+        .then((resource) => setValue(deepClone(resource)))
+        .catch((err) => {
+          setOutcome(normalizeOperationOutcome(err));
+          showNotification({ color: 'red', message: normalizeErrorString(err), autoClose: false });
+        });
+    }
+  }, [medplum, resourceType, id]);
+
+  const handleSubmit = useCallback(
+    (newResource: Resource): void => {
+      setOutcome(undefined);
+      medplum
+        .updateResource(newResource)
+        .then(() => {
+          navigate('..')?.catch(console.error);
+          showNotification({ color: 'green', message: 'Success' });
+        })
+        .catch((err) => {
+          setOutcome(normalizeOperationOutcome(err));
+          showNotification({ color: 'red', message: normalizeErrorString(err), autoClose: false });
+        });
+    },
+    [medplum, navigate]
+  );
+
+  const handleDelete = useCallback(() => navigate('..')?.catch(console.error), [navigate]);
+
+  if (!value) {
+    return null;
+  }
+
+  return (
+    <ResourceFormWithRequiredProfile
+      defaultValue={value}
+      onSubmit={handleSubmit}
+      onDelete={handleDelete}
+      outcome={outcome}
+      profileUrl={profileUrl}
+    />
+  );
+}

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

@@ -0,0 +1,108 @@
+// 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 type { Practitioner } from '@medplum/fhirtypes';
+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 { ResourceHistoryPage } from './ResourceHistoryPage';
+
+describe('ResourceHistoryPage', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+  });
+
+  const setup = (url: string): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter initialEntries={[url]}>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <Notifications />
+            <Routes>
+              <Route path="/:resourceType/:id/history" element={<ResourceHistoryPage />} />
+            </Routes>
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  test('Renders history page', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ family: 'Test' }],
+    });
+
+    vi.spyOn(medplum, 'readHistory').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'history',
+      entry: [],
+    } as any);
+
+    setup(`/Practitioner/${practitioner.id}/history`);
+
+    await waitFor(() => {
+      expect(medplum.readHistory).toHaveBeenCalledWith('Practitioner', practitioner.id);
+    });
+  });
+
+  test('Calls readHistory with correct parameters', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ family: 'Test' }],
+    });
+
+    vi.spyOn(medplum, 'readHistory').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'history',
+      entry: [],
+    } as any);
+
+    setup(`/Practitioner/${practitioner.id}/history`);
+
+    await waitFor(() => {
+      expect(medplum.readHistory).toHaveBeenCalledWith('Practitioner', practitioner.id);
+    });
+  });
+
+  test('Returns null when resourceType is missing', async () => {
+    setup('/123/history');
+    await waitFor(() => {
+      expect(screen.queryByText('History')).not.toBeInTheDocument();
+    });
+  });
+
+  test('Returns null when id is missing', async () => {
+    setup('/Practitioner/history');
+
+    await waitFor(() => {
+      expect(screen.queryByText('History')).not.toBeInTheDocument();
+    });
+  });
+
+  test('Renders with different resource types', async () => {
+    const task = await medplum.createResource({
+      resourceType: 'Task',
+      status: 'in-progress',
+      intent: 'order',
+    });
+
+    vi.spyOn(medplum, 'readHistory').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'history',
+      entry: [],
+    } as any);
+
+    setup(`/Task/${task.id}/history`);
+
+    await waitFor(() => {
+      expect(medplum.readHistory).toHaveBeenCalledWith('Task', task.id);
+    });
+  });
+});

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

@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { ResourceType } from '@medplum/fhirtypes';
+import { ResourceHistoryTable } from '@medplum/react';
+import type { JSX } from 'react';
+import { useParams } from 'react-router';
+
+export function ResourceHistoryPage(): JSX.Element | null {
+  const { resourceType, id } = useParams() as { resourceType: ResourceType | undefined; id: string | undefined };
+
+  if (!resourceType || !id) {
+    return null;
+  }
+
+  return <ResourceHistoryTable key={`${resourceType}/${id}`} resourceType={resourceType} id={id} />;
+}

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

@@ -0,0 +1,7 @@
+.tab {
+  color: var(--tabs-color);
+
+  &[data-active] {
+    color: var(--mantine-color-white);
+  }
+}

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

@@ -0,0 +1,37 @@
+// 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 { ErrorBoundary, Loading, MedplumProvider } from '@medplum/react';
+import { Suspense } from 'react';
+import { MemoryRouter } from 'react-router';
+import { App } from '../../App';
+import { act, render, screen } from '../../test-utils/render';
+
+describe('ResourcePage', () => {
+  async function setup(url: string, medplum = new MockClient()): Promise<void> {
+    await act(async () => {
+      render(
+        <MedplumProvider medplum={medplum}>
+          <MemoryRouter initialEntries={[url]} initialIndex={0}>
+            <MantineProvider>
+              <Notifications />
+              <ErrorBoundary>
+                <Suspense fallback={<Loading />}>
+                  <App />
+                </Suspense>
+              </ErrorBoundary>
+            </MantineProvider>
+          </MemoryRouter>
+        </MedplumProvider>
+      );
+    });
+  }
+
+  test('Details tab renders', async () => {
+    await setup('/Practitioner/123');
+    expect((await screen.findAllByText('Name'))[0]).toBeInTheDocument();
+    expect(screen.getByText('Gender')).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Stack } from '@mantine/core';
+import { getReferenceString } from '@medplum/core';
+import type { Resource, ResourceType } from '@medplum/fhirtypes';
+import { Document, LinkTabs, useMedplum } from '@medplum/react';
+import type { JSX } from 'react';
+import { useEffect, useState } from 'react';
+import { Outlet, useNavigate, useParams } from 'react-router';
+import classes from './ResourcePage.module.css';
+import { useResourceType } from './useResourceType';
+
+const tabs = ['Details', 'Edit', 'History'];
+
+export function ResourcePage(): JSX.Element | null {
+  const navigate = useNavigate();
+  const medplum = useMedplum();
+  const { resourceType, id } = useParams();
+  const [resource, setResource] = useState<Resource | undefined>(undefined);
+
+  useResourceType(resourceType, { onInvalidResourceType: () => navigate('..')?.catch(console.error) });
+
+  useEffect(() => {
+    if (resourceType && id) {
+      medplum
+        .readResource(resourceType as ResourceType, id)
+        .then(setResource)
+        .catch(console.error);
+    }
+  }, [medplum, resourceType, id, navigate]);
+
+  if (!resource) {
+    return null;
+  }
+
+  return (
+    <Document key={getReferenceString(resource)}>
+      <Stack>
+        <LinkTabs variant="pills" baseUrl={`/${resourceType}/${id}`} tabs={tabs} classNames={classes} />
+        <Outlet />
+      </Stack>
+    </Document>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/pages/resource/useResourceType.ts

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { tryGetDataType } from '@medplum/core';
+import type { ResourceType } from '@medplum/fhirtypes';
+import { useMedplum } from '@medplum/react';
+import { useEffect, useRef, useState } from 'react';
+
+type UseResourceTypeOptions = {
+  onInvalidResourceType?: (resourceType: string) => void;
+};
+
+export function useResourceType(
+  resourceType: string | undefined,
+  options?: UseResourceTypeOptions
+): ResourceType | undefined {
+  const medplum = useMedplum();
+
+  const lastInput = useRef<string | undefined>(resourceType);
+  const [validatedResourceType, setValidatedResourceType] = useState<ResourceType | undefined>();
+
+  useEffect(() => {
+    if (resourceType !== lastInput.current) {
+      lastInput.current = resourceType;
+      setValidatedResourceType(undefined);
+      if (resourceType) {
+        medplum
+          .requestSchema(resourceType)
+          .then(() => {
+            if (!tryGetDataType(resourceType)) {
+              setValidatedResourceType(undefined);
+              if (options?.onInvalidResourceType) {
+                options.onInvalidResourceType(resourceType);
+              }
+            } else {
+              setValidatedResourceType(resourceType as ResourceType);
+            }
+          })
+          .catch(console.error);
+      }
+    }
+  }, [medplum, options, resourceType]);
+
+  return validatedResourceType;
+}

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

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { ResourceType } from '@medplum/fhirtypes';
+
+export const RESOURCE_PROFILE_URLS: Partial<Record<ResourceType, string>> = {
+  Patient: 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient',
+  ServiceRequest: 'http://medplum.com/StructureDefinition/medplum-provider-lab-procedure-servicerequest',
+  Device: 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-implantable-device',
+};