vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/hooks/useDebouncedUpdateResource.test.tsx

@@ -0,0 +1,166 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { renderHook, waitFor } from '@testing-library/react';
+import type { Patient } from '@medplum/fhirtypes';
+import { HomerSimpson, MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { useDebouncedUpdateResource, DEFAULT_SAVE_TIMEOUT_MS } from './useDebouncedUpdateResource';
+
+describe('useDebouncedUpdateResource', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+  });
+
+  test('debounces resource updates with default timeout', async () => {
+    const { result } = renderHook(() => useDebouncedUpdateResource(medplum));
+
+    const mockPatient = { ...HomerSimpson } as Patient & { id: string };
+    const updatedPatient1 = { ...HomerSimpson, name: [{ given: ['Jane'], family: 'Simpson' }] } as Patient & {
+      id: string;
+    };
+    const updatedPatient2 = { ...HomerSimpson, name: [{ given: ['Bob'], family: 'Smith' }] } as Patient & {
+      id: string;
+    };
+
+    const updateSpy = vi.spyOn(medplum, 'updateResource').mockResolvedValue(updatedPatient2);
+
+    // Call the debounced function multiple times rapidly
+    const debouncedUpdate = result.current;
+    debouncedUpdate(mockPatient).catch(() => {});
+    debouncedUpdate(updatedPatient1).catch(() => {
+      // Ignore promise rejections
+    });
+    debouncedUpdate(updatedPatient2).catch(() => {
+      // Ignore promise rejections
+    });
+
+    // Should not have been called immediately
+    expect(updateSpy).not.toHaveBeenCalled();
+
+    // Wait for debounce timeout
+    await waitFor(
+      () => {
+        // Should have been called only once (last call)
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).toHaveBeenCalledWith(updatedPatient2);
+      },
+      { timeout: DEFAULT_SAVE_TIMEOUT_MS + 1000 }
+    );
+  });
+
+  test('debounces resource updates with custom timeout', async () => {
+    const customTimeout = 100;
+    const { result } = renderHook(() => useDebouncedUpdateResource(medplum, customTimeout));
+
+    const mockPatient = { ...HomerSimpson } as Patient & { id: string };
+
+    const updateSpy = vi.spyOn(medplum, 'updateResource').mockResolvedValue(mockPatient);
+
+    const debouncedUpdate = result.current;
+    debouncedUpdate(mockPatient).catch(() => {
+      // Ignore promise rejections
+    });
+
+    expect(updateSpy).not.toHaveBeenCalled();
+
+    await waitFor(
+      () => {
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).toHaveBeenCalledWith(mockPatient);
+      },
+      { timeout: customTimeout + 100 }
+    );
+  });
+
+  test('returns the resource payload immediately', async () => {
+    const { result } = renderHook(() => useDebouncedUpdateResource(medplum));
+
+    const mockPatient = { ...HomerSimpson } as Patient & { id: string };
+
+    const debouncedUpdate = result.current;
+    const returnedValue = await debouncedUpdate(mockPatient);
+
+    expect(returnedValue).toEqual(mockPatient);
+  });
+
+  test('cancels previous pending updates when new update is called', async () => {
+    const { result } = renderHook(() => useDebouncedUpdateResource(medplum));
+
+    const mockPatient1 = { ...HomerSimpson, name: [{ given: ['First'], family: 'Simpson' }] } as Patient & {
+      id: string;
+    };
+    const mockPatient2 = { ...HomerSimpson, name: [{ given: ['Second'], family: 'Simpson' }] } as Patient & {
+      id: string;
+    };
+
+    const updateSpy = vi.spyOn(medplum, 'updateResource').mockResolvedValue(mockPatient2);
+
+    const debouncedUpdate = result.current;
+    debouncedUpdate(mockPatient1).catch(() => {
+      // Ignore promise rejections
+    });
+
+    await new Promise<void>((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, DEFAULT_SAVE_TIMEOUT_MS - 100);
+    });
+
+    debouncedUpdate(mockPatient2).catch(() => {
+      // Ignore promise rejections
+    });
+
+    await waitFor(
+      () => {
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).toHaveBeenCalledWith(mockPatient2);
+      },
+      { timeout: DEFAULT_SAVE_TIMEOUT_MS + 500 }
+    );
+  });
+
+  test('handles update errors gracefully', async () => {
+    const { result } = renderHook(() => useDebouncedUpdateResource(medplum));
+
+    const mockPatient = { ...HomerSimpson } as Patient & { id: string };
+
+    const error = new Error('Update failed');
+    const updateSpy = vi.spyOn(medplum, 'updateResource').mockRejectedValue(error);
+
+    let caughtError: Error | undefined;
+    const rejectionHandler = (reason: unknown): void => {
+      caughtError = reason as Error;
+    };
+    process.on('unhandledRejection', rejectionHandler);
+
+    try {
+      const debouncedUpdate = result.current;
+      const returnedValue = await debouncedUpdate(mockPatient);
+      expect(returnedValue).toEqual(mockPatient);
+
+      // Wait for debounce timeout - error happens inside debounced callback
+      await waitFor(
+        () => {
+          expect(updateSpy).toHaveBeenCalled();
+        },
+        { timeout: DEFAULT_SAVE_TIMEOUT_MS + 500 }
+      );
+
+      await new Promise<void>((resolve) => {
+        setTimeout(() => {
+          resolve();
+        }, 100);
+      });
+
+      // Verify updateResource was called with the correct patient
+      expect(updateSpy).toHaveBeenCalledWith(mockPatient);
+
+      // Verify the error was caught (it happens in the debounced callback)
+      expect(caughtError).toBe(error);
+    } finally {
+      process.removeListener('unhandledRejection', rejectionHandler);
+    }
+  });
+});

package/dist/examples/vintasend-medplum-example/src/hooks/useDebouncedUpdateResource.ts

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { useDebouncedCallback } from '@mantine/hooks';
+import type { MedplumClient } from '@medplum/core';
+import type { Resource } from '@medplum/fhirtypes';
+
+export const DEFAULT_SAVE_TIMEOUT_MS = 500;
+
+/**
+ * Hook that provides a debounced version of medplum's updateResource
+ *
+ * @param medplum - The MedplumClient instance
+ * @param timeoutMs - Optional timeout in milliseconds
+ * @returns A debounced function that updates any Medplum resource
+ */
+export function useDebouncedUpdateResource<T extends Resource>(
+  medplum: MedplumClient,
+  timeoutMs: number = DEFAULT_SAVE_TIMEOUT_MS
+): (resourcePayload: T) => Promise<T> {
+  const debouncedCallback = useDebouncedCallback(async (resourcePayload: T): Promise<T> => {
+    return (await medplum.updateResource(resourcePayload)) as T;
+  }, timeoutMs);
+
+  return async (resourcePayload: T): Promise<T> => {
+    debouncedCallback(resourcePayload);
+    return resourcePayload;
+  };
+}

package/dist/examples/vintasend-medplum-example/src/hooks/useEncounter.test.tsx

@@ -0,0 +1,94 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { renderHook, waitFor } from '@testing-library/react';
+import { MedplumProvider } from '@medplum/react';
+import type { JSX } from 'react';
+import type { Encounter } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { useEncounter } from './useEncounter';
+
+vi.mock('react-router', async () => {
+  const actual = await vi.importActual('react-router');
+  return {
+    ...actual,
+    useParams: vi.fn(),
+  };
+});
+
+import { useParams } from 'react-router';
+
+describe('useEncounter', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    vi.mocked(useParams).mockReturnValue({});
+  });
+
+  const wrapper = ({ children }: { children: React.ReactNode }): JSX.Element => (
+    <MedplumProvider medplum={medplum}>{children}</MedplumProvider>
+  );
+
+  test('returns undefined when encounter ID is not found in params', () => {
+    vi.mocked(useParams).mockReturnValue({});
+
+    const { result } = renderHook(() => useEncounter(), { wrapper });
+
+    expect(result.current).toBeUndefined();
+  });
+
+  test('loads encounter resource by ID from URL params', async () => {
+    const mockEncounter: Encounter = {
+      resourceType: 'Encounter',
+      id: 'encounter-123',
+      status: 'in-progress',
+      class: { code: 'AMB', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+      subject: { reference: 'Patient/patient-123' },
+    };
+
+    await medplum.createResource(mockEncounter);
+    vi.mocked(useParams).mockReturnValue({ encounterId: 'encounter-123' });
+
+    const { result } = renderHook(() => useEncounter(), { wrapper });
+
+    await waitFor(() => {
+      expect(result.current).toBeDefined();
+      expect(result.current?.id).toBe('encounter-123');
+      expect(result.current?.status).toBe('in-progress');
+      expect(result.current?.class?.code).toBe('AMB');
+    });
+  });
+
+  test('handles different encounter IDs correctly', async () => {
+    const mockEncounter: Encounter = {
+      resourceType: 'Encounter',
+      id: 'encounter-456',
+      status: 'finished',
+      class: { code: 'IMP', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+      subject: { reference: 'Patient/patient-456' },
+    };
+
+    await medplum.createResource(mockEncounter);
+    vi.mocked(useParams).mockReturnValue({ encounterId: 'encounter-456' });
+
+    const { result } = renderHook(() => useEncounter(), { wrapper });
+
+    await waitFor(() => {
+      expect(result.current?.id).toBe('encounter-456');
+      expect(result.current?.status).toBe('finished');
+      expect(result.current?.class?.code).toBe('IMP');
+    });
+  });
+
+  test('returns undefined when encounter does not exist', async () => {
+    vi.mocked(useParams).mockReturnValue({ encounterId: 'encounter-nonexistent' });
+
+    const { result } = renderHook(() => useEncounter(), { wrapper });
+
+    await waitFor(() => {
+      expect(result.current).toBeUndefined();
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/src/hooks/useEncounter.ts

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Encounter } from '@medplum/fhirtypes';
+import { useResource } from '@medplum/react';
+import { useParams } from 'react-router';
+
+export function useEncounter(): Encounter | undefined {
+  const { encounterId } = useParams();
+
+  return useResource<Encounter>({ reference: `Encounter/${encounterId}` });
+}