vintasend 0.4.0 → 0.4.7

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

@@ -0,0 +1,100 @@
+// 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 { Patient } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { usePatient } from './usePatient';
+
+vi.mock('react-router', async () => {
+  const actual = await vi.importActual('react-router');
+  return {
+    ...actual,
+    useParams: vi.fn(),
+  };
+});
+
+import { useParams } from 'react-router';
+
+describe('usePatient', () => {
+  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 patient ID is not found in params', () => {
+    vi.mocked(useParams).mockReturnValue({});
+
+    expect(() => {
+      renderHook(() => usePatient(), { wrapper });
+    }).toThrow('Patient ID not found');
+  });
+
+  test('returns undefined when patient ID is missing but ignoreMissingPatientId is true', () => {
+    vi.mocked(useParams).mockReturnValue({});
+
+    const { result } = renderHook(() => usePatient({ ignoreMissingPatientId: true }), { wrapper });
+
+    expect(result.current).toBeUndefined();
+  });
+
+  test('loads patient resource by ID from URL params', async () => {
+    const mockPatient: Patient = {
+      resourceType: 'Patient',
+      id: 'patient-123',
+      name: [{ given: ['John'], family: 'Doe' }],
+    };
+
+    await medplum.createResource(mockPatient);
+    vi.mocked(useParams).mockReturnValue({ patientId: 'patient-123' });
+
+    const { result } = renderHook(() => usePatient(), { wrapper });
+
+    await waitFor(() => {
+      expect(result.current).toBeDefined();
+      expect(result.current?.id).toBe('patient-123');
+      expect(result.current?.name?.[0]?.given?.[0]).toBe('John');
+      expect(result.current?.name?.[0]?.family).toBe('Doe');
+    });
+  });
+
+  test('calls setOutcome callback when patient is not found', async () => {
+    const setOutcome = vi.fn();
+    vi.mocked(useParams).mockReturnValue({ patientId: 'patient-nonexistent' });
+
+    const { result } = renderHook(() => usePatient({ setOutcome }), { wrapper });
+
+    await waitFor(() => {
+      expect(setOutcome).toHaveBeenCalled();
+    });
+
+    expect(result.current).toBeUndefined();
+  });
+
+  test('handles patient reference correctly', async () => {
+    const mockPatient: Patient = {
+      resourceType: 'Patient',
+      id: 'patient-456',
+      name: [{ given: ['Jane'], family: 'Smith' }],
+    };
+
+    await medplum.createResource(mockPatient);
+    vi.mocked(useParams).mockReturnValue({ patientId: 'patient-456' });
+
+    const { result } = renderHook(() => usePatient(), { wrapper });
+
+    await waitFor(() => {
+      expect(result.current?.id).toBe('patient-456');
+      expect(result.current?.name?.[0]?.given?.[0]).toBe('Jane');
+    });
+  });
+});

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

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { OperationOutcome, Patient } from '@medplum/fhirtypes';
+import { useResource } from '@medplum/react';
+import { useParams } from 'react-router';
+
+type Options = {
+  ignoreMissingPatientId?: boolean;
+  setOutcome?: (outcome: OperationOutcome) => void;
+};
+
+export function usePatient(options?: Options): Patient | undefined {
+  const { patientId } = useParams();
+  if (!patientId && !options?.ignoreMissingPatientId) {
+    throw new Error('Patient ID not found');
+  }
+  return useResource<Patient>({ reference: `Patient/${patientId}` }, options?.setOutcome);
+}

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

@@ -0,0 +1,379 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { MedplumProvider } from '@medplum/react';
+import type { JSX } from 'react';
+import type { Communication } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { useThreadInbox } from './useThreadInbox';
+import type { WithId } from '@medplum/core';
+
+const mockCommunication1: Communication = {
+  resourceType: 'Communication',
+  id: 'comm-1',
+  status: 'completed',
+  sent: '2024-01-01T10:00:00Z',
+  payload: [{ contentString: 'First message' }],
+};
+
+const mockCommunication2: Communication = {
+  resourceType: 'Communication',
+  id: 'comm-2',
+  status: 'completed',
+  sent: '2024-01-01T11:00:00Z',
+  payload: [{ contentString: 'Second message' }],
+  partOf: [{ reference: 'Communication/comm-1' }],
+};
+
+describe('useThreadInbox', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+  });
+
+  const wrapper = ({ children }: { children: React.ReactNode }): JSX.Element => (
+    <MedplumProvider medplum={medplum}>{children}</MedplumProvider>
+  );
+
+  test('returns initial loading state', () => {
+    const { result } = renderHook(() => useThreadInbox({ query: '', threadId: undefined }), { wrapper });
+
+    expect(result.current.loading).toBe(true);
+    expect(result.current.threadMessages).toEqual([]);
+    expect(result.current.selectedThread).toBeUndefined();
+    expect(result.current.error).toBeNull();
+    expect(result.current.total).toBeUndefined();
+  });
+
+  test('fetches thread messages and returns only one message per topic', async () => {
+    const mockCommunication4: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-4',
+      status: 'completed',
+      sent: '2024-01-01T13:00:00Z',
+      payload: [{ contentString: 'Fourth message' }],
+      partOf: [{ reference: 'Communication/comm-1' }],
+    };
+
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockCommunication1 as WithId<Communication> }],
+    });
+
+    const graphqlSpy = vi.spyOn(medplum, 'graphql').mockResolvedValue({
+      data: {
+        thread_comm1: [mockCommunication4],
+      },
+    } as any);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: undefined }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(graphqlSpy).toHaveBeenCalled();
+
+    await waitFor(() => {
+      expect(result.current.threadMessages).toHaveLength(1);
+      expect(result.current.threadMessages[0][0].id).toBe('comm-1');
+      expect(result.current.threadMessages[0][1]?.id).toBe('comm-4');
+    });
+  });
+
+  test('skips topics without messages', async () => {
+    const parentWithoutMessages: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-no-replies',
+      status: 'completed',
+      sent: '2024-01-01T10:00:00Z',
+      payload: [{ contentString: 'Parent with no replies' }],
+    };
+
+    const parentWithMessages: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-with-replies',
+      status: 'completed',
+      sent: '2024-01-01T11:00:00Z',
+      payload: [{ contentString: 'Parent with replies' }],
+    };
+
+    const replyMessage: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-reply',
+      status: 'completed',
+      sent: '2024-01-01T12:00:00Z',
+      payload: [{ contentString: 'Reply message' }],
+      partOf: [{ reference: 'Communication/comm-with-replies' }],
+    };
+
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 2,
+      entry: [
+        { resource: parentWithoutMessages as WithId<Communication> },
+        { resource: parentWithMessages as WithId<Communication> },
+      ],
+    });
+
+    vi.spyOn(medplum, 'graphql').mockResolvedValue({
+      data: {
+        thread_commnoreplies: [],
+        thread_commwithreplies: [replyMessage],
+      },
+    } as any);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: undefined }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    await waitFor(() => {
+      expect(result.current.threadMessages).toHaveLength(1);
+      expect(result.current.threadMessages[0][0].id).toBe('comm-with-replies');
+      expect(result.current.threadMessages[0][1]?.id).toBe('comm-reply');
+      expect(result.current.threadMessages.find((t) => t[0].id === 'comm-no-replies')).toBeUndefined();
+    });
+  });
+
+  test('selects thread by threadId', async () => {
+    await medplum.createResource(mockCommunication1);
+    await medplum.createResource(mockCommunication2);
+
+    vi.spyOn(medplum, 'graphql').mockResolvedValue({
+      data: {
+        thread_comm1: [mockCommunication2],
+      },
+    } as any);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: 'comm-1' }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    await waitFor(() => {
+      expect(result.current.selectedThread?.id).toBe('comm-1');
+    });
+  });
+
+  test('reads thread from API when threadId not found in messages', async () => {
+    // Don't create the resource, so it won't be found in search
+    // This simulates a thread that exists but isn't in the current search results
+
+    const readSpy = vi.spyOn(medplum, 'readResource').mockResolvedValue(mockCommunication1 as WithId<Communication>);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: 'comm-1' }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    await waitFor(() => {
+      expect(readSpy).toHaveBeenCalledWith('Communication', 'comm-1');
+      expect(result.current.selectedThread?.id).toBe('comm-1');
+    });
+  });
+
+  test('reads parent thread when reading child communication with partOf field', async () => {
+    const parentCommunication: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-0',
+      status: 'completed',
+      sent: '2024-01-01T09:00:00Z',
+      payload: [{ contentString: 'Parent message' }],
+    };
+
+    const communicationWithPartOf: Communication = {
+      ...mockCommunication1,
+      partOf: [{ reference: 'Communication/comm-0' }],
+    };
+
+    vi.spyOn(medplum, 'readResource').mockResolvedValue(communicationWithPartOf as WithId<Communication>);
+
+    const readReferenceSpy = vi.spyOn(medplum, 'readReference').mockResolvedValue(parentCommunication as any);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: 'comm-1' }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    await waitFor(() => {
+      expect(readReferenceSpy).toHaveBeenCalledWith({ reference: 'Communication/comm-0' });
+      expect(result.current.selectedThread?.id).toBe('comm-0');
+    });
+  });
+
+  test('handles thread status update', async () => {
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockCommunication1 as WithId<Communication> }],
+    });
+
+    vi.spyOn(medplum, 'graphql').mockResolvedValue({
+      data: {
+        thread_comm1: [mockCommunication2],
+      },
+    } as any);
+
+    const updatedCommunication: Communication = {
+      ...mockCommunication1,
+      status: 'in-progress',
+    };
+
+    const updateSpy = vi
+      .spyOn(medplum, 'updateResource')
+      .mockResolvedValue(updatedCommunication as WithId<Communication>);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: 'comm-1' }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.selectedThread?.id).toBe('comm-1');
+    });
+
+    await act(async () => result.current.handleThreadStatusChange('in-progress'));
+
+    await waitFor(() => {
+      expect(updateSpy).toHaveBeenCalled();
+      expect(result.current.selectedThread?.status).toBe('in-progress');
+      expect(result.current.threadMessages[0][0].status).toBe('in-progress');
+    });
+  });
+
+  test('does not update status when no thread is selected', async () => {
+    const updateSpy = vi.spyOn(medplum, 'updateResource');
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: undefined }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    await result.current.handleThreadStatusChange('in-progress');
+
+    expect(updateSpy).not.toHaveBeenCalled();
+  });
+
+  test('handles update errors gracefully', async () => {
+    await medplum.createResource(mockCommunication1);
+    await medplum.createResource(mockCommunication2);
+
+    vi.spyOn(medplum, 'graphql').mockResolvedValue({
+      data: {
+        thread_comm1: [mockCommunication2],
+      },
+    } as any);
+
+    const error = new Error('Update failed');
+    vi.spyOn(medplum, 'updateResource').mockRejectedValue(error);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: 'comm-1' }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.selectedThread?.id).toBe('comm-1');
+    });
+
+    await act(async () => result.current.handleThreadStatusChange('in-progress'));
+
+    await waitFor(() => {
+      expect(result.current.error).toBe(error);
+    });
+  });
+
+  test('adds new thread message', async () => {
+    const newMessage: Communication = {
+      resourceType: 'Communication',
+      id: 'comm-new',
+      status: 'completed',
+      sent: '2024-01-01T13:00:00Z',
+      payload: [{ contentString: 'New message' }],
+    };
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: undefined }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    await act(async () => {
+      result.current.addThreadMessage(newMessage);
+    });
+
+    await waitFor(() => {
+      expect(result.current.threadMessages).toHaveLength(1);
+      expect(result.current.threadMessages[0][0].id).toBe('comm-new');
+      expect(result.current.threadMessages[0][1]).toBeUndefined();
+    });
+  });
+
+  test('handles search errors gracefully', async () => {
+    const error = new Error('Search failed');
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(medplum, 'search').mockRejectedValue(error);
+
+    const { result } = renderHook(() => useThreadInbox({ query: 'status=completed', threadId: undefined }), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+      expect(result.current.error).toBe(error);
+    });
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  test('clears selected thread when threadId becomes undefined', async () => {
+    await medplum.createResource(mockCommunication1);
+    await medplum.createResource(mockCommunication2);
+
+    vi.spyOn(medplum, 'graphql').mockResolvedValue({
+      data: {
+        thread_comm1: [mockCommunication2],
+      },
+    } as any);
+
+    const { result, rerender } = renderHook(({ threadId }) => useThreadInbox({ query: 'status=completed', threadId }), {
+      wrapper,
+      initialProps: { threadId: 'comm-1' as string | undefined },
+    });
+
+    await waitFor(() => {
+      expect(result.current.selectedThread?.id).toBe('comm-1');
+    });
+
+    rerender({ threadId: undefined });
+
+    await waitFor(() => {
+      expect(result.current.selectedThread).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,194 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { useState, useEffect, useCallback } from 'react';
+import type { Communication } from '@medplum/fhirtypes';
+import { useMedplum } from '@medplum/react';
+import { getReferenceString } from '@medplum/core';
+
+export interface UseThreadInboxOptions {
+  query: string;
+  threadId: string | undefined;
+}
+
+export interface UseThreadInboxReturn {
+  loading: boolean;
+  error: Error | null;
+  // Tuple: [Parent Thread, Last Message in Thread (optional)]
+  threadMessages: [Communication, Communication | undefined][];
+  selectedThread: Communication | undefined;
+  total: number | undefined;
+  addThreadMessage: (message: Communication) => void;
+  handleThreadStatusChange: (newStatus: Communication['status']) => Promise<void>;
+  refreshThreadMessages: () => Promise<void>;
+}
+
+/*
+useThreadInbox is a hook that fetches all communications and returns the thread messages and selected thread.
+All comunications returned do not have a partOf field.
+It also provides a function to update the status of the selected thread.
+
+@param query - The query to fetch all communications.
+@param threadId - The id of the thread to select.
+@returns The thread messages and selected thread.
+@returns A function to update the status of the selected thread.
+*/
+export function useThreadInbox({ query, threadId }: UseThreadInboxOptions): UseThreadInboxReturn {
+  const medplum = useMedplum();
+  const [loading, setLoading] = useState(true);
+  const [threadMessages, setThreadMessages] = useState<[Communication, Communication | undefined][]>([]);
+  const [selectedThread, setSelectedThread] = useState<Communication | undefined>(undefined);
+  const [error, setError] = useState<Error | null>(null);
+  const [total, setTotal] = useState<number | undefined>(undefined);
+
+  const fetchAllCommunications = useCallback(async (): Promise<void> => {
+    const searchParams = new URLSearchParams(query);
+    searchParams.append('identifier:not', 'ai-message-topic');
+    searchParams.append('part-of:missing', 'true');
+    searchParams.append('_has:Communication:part-of:_id:not', 'null');
+
+    const bundle = await medplum.search('Communication', searchParams.toString(), { cache: 'no-cache' });
+    const parents =
+      bundle.entry
+        ?.map((entry) => entry.resource as Communication)
+        .filter((r): r is Communication => r !== undefined) || [];
+
+    if (bundle.total !== undefined) {
+      setTotal(bundle.total);
+    }
+
+    if (parents.length === 0) {
+      setThreadMessages([]);
+      return;
+    }
+
+    const queryParts = parents.map((parent) => {
+      const safeId = parent.id?.replace(/-/g, '') || '';
+      const alias = `thread_${safeId}`;
+      const ref = getReferenceString(parent);
+
+      return `
+          ${alias}: CommunicationList(
+            part_of: "${ref}"
+            _sort: "-sent"
+            _count: 1
+          ) {
+            id
+            meta {
+              lastUpdated
+            }
+            partOf {
+              reference
+            }
+            sender {
+              display
+              reference
+            }
+            payload {
+              contentString
+            }
+            sent
+            status
+          }
+        `;
+    });
+
+    const fullQuery = `
+        query {
+          ${queryParts.join('\n')}
+        }
+      `;
+
+    const response = await medplum.graphql(fullQuery);
+
+    const threadsWithReplies = parents
+      .map((parent) => {
+        const safeId = parent.id?.replace(/-/g, '') || '';
+        const alias = `thread_${safeId}`;
+        const childList = response.data[alias] as Communication[] | undefined;
+        const lastMessage = childList && childList.length > 0 ? childList[0] : undefined;
+        return [parent, lastMessage];
+      })
+      .filter((thread): thread is [Communication, Communication] => thread[1] !== undefined);
+
+    setThreadMessages(threadsWithReplies);
+  }, [medplum, query]);
+
+  useEffect(() => {
+    setLoading(true);
+    fetchAllCommunications()
+      .catch((err: Error) => {
+        setError(err);
+      })
+      .finally(() => {
+        setLoading(false);
+      });
+  }, [fetchAllCommunications]);
+
+  useEffect(() => {
+    const fetchThread = async (): Promise<void> => {
+      if (threadId) {
+        const thread = threadMessages.find((t) => t[0].id === threadId);
+        if (thread) {
+          setSelectedThread(thread[0]);
+        } else {
+          try {
+            const communication: Communication = await medplum.readResource('Communication', threadId);
+
+            if (communication.partOf === undefined) {
+              setSelectedThread(communication);
+            } else {
+              const parentRef = communication.partOf[0].reference;
+              if (parentRef) {
+                const parent = await medplum.readReference({ reference: parentRef } as any);
+                setSelectedThread(parent as Communication);
+              }
+            }
+          } catch (err) {
+            setError(err as Error);
+          }
+        }
+      } else {
+        setSelectedThread(undefined);
+      }
+    };
+
+    fetchThread().catch((err) => {
+      setError(err as Error);
+    });
+  }, [threadId, threadMessages, medplum]);
+
+  const handleThreadStatusChange = async (newStatus: Communication['status']): Promise<void> => {
+    if (!selectedThread) {
+      return;
+    }
+    try {
+      const updatedThread = await medplum.updateResource({
+        ...selectedThread,
+        status: newStatus,
+      });
+
+      setSelectedThread(updatedThread);
+      setThreadMessages((prev) =>
+        prev.map(([parent, lastMsg]) => (parent.id === updatedThread.id ? [updatedThread, lastMsg] : [parent, lastMsg]))
+      );
+    } catch (err) {
+      setError(err as Error);
+    }
+  };
+
+  const addThreadMessage = async (message: Communication): Promise<void> => {
+    await fetchAllCommunications();
+    setThreadMessages((prev) => [[message, undefined], ...prev]);
+  };
+
+  return {
+    loading,
+    error,
+    threadMessages,
+    selectedThread,
+    total,
+    addThreadMessage,
+    handleThreadStatusChange,
+    refreshThreadMessages: fetchAllCommunications,
+  };
+}

package/dist/examples/vintasend-medplum-example/src/index.css

@@ -0,0 +1,8 @@
+.rbc-calendar {
+  font-family:
+    -apple-system, 'system-ui', 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji';
+}
+
+.rbc-btn-group button {
+  font-size: 14px;
+}