Message deletion

README.md

@@ -21,6 +21,7 @@ The app implements a secure live chat system following Medplum's ["Organizing Co
   - Send chat messages by creating new `Communication` FHIR resources
   - Real-time message updates using Medplum WebSocket `Subscription`
   - Auto-update of message status: sent, received, read, directly on `Communication` FHIR resource
+  - Message deletion
 
 - **Media Support**
   - Image and video attachments
@@ -113,6 +114,10 @@ NOTE: Login will not work yet, because Medplum's OAuth2 is not set. See the next
     EXPO_PUBLIC_MEDPLUM_NATIVE_CLIENT_ID=your_native_client_id
     ```
 
+### Configuring Access Policies (for production)
+
+The app implements message deletion functionality, which requires proper access control in production. You need to set up [Access Policies](https://www.medplum.com/docs/access/access-policies) in Medplum to ensure patients can only read/update/delete their own messages.
+
 ### Testing
 
 Run the test suite:

__tests__/hooks/useSingleThread.tsx

@@ -774,4 +774,105 @@ describe("useSingleThread", () => {
       expect(message!.read).toBe(false);
     });
   });
+
+  test("deleteMessages deletes multiple messages and updates thread", async () => {
+    const { medplum } = await setup();
+    const deleteSpy = jest.spyOn(medplum, "deleteResource");
+    const patchSpy = jest.spyOn(medplum, "patchResource");
+
+    const { result } = renderHook(() => useSingleThread({ threadId: "test-thread" }), {
+      wrapper: createWrapper(medplum),
+    });
+
+    // Wait for loading to complete
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    // Delete both messages
+    await act(async () => {
+      await result.current.deleteMessages({
+        threadId: "test-thread",
+        messageIds: ["msg-1", "msg-2"],
+      });
+    });
+
+    // Verify messages were deleted
+    expect(deleteSpy).toHaveBeenCalledTimes(2);
+    expect(deleteSpy).toHaveBeenCalledWith("Communication", "msg-1");
+    expect(deleteSpy).toHaveBeenCalledWith("Communication", "msg-2");
+
+    // Verify thread last changed date was updated
+    expect(patchSpy).toHaveBeenCalledWith(
+      "Communication",
+      "test-thread",
+      expect.arrayContaining([
+        expect.objectContaining({
+          op: "add",
+          path: "/extension/0/valueDateTime",
+          value: expect.any(String),
+        }),
+      ]),
+    );
+  });
+
+  test("deleteMessages handles errors", async () => {
+    const { medplum } = await setup();
+    const onErrorMock = jest.fn();
+    const error = new Error("Failed to delete message");
+    jest.spyOn(medplum, "deleteResource").mockRejectedValue(error);
+
+    const { result } = renderHook(() => useSingleThread({ threadId: "test-thread" }), {
+      wrapper: createWrapper(medplum, { onError: onErrorMock }),
+    });
+
+    // Wait for loading to complete
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    // Attempt to delete messages
+    await act(async () => {
+      try {
+        await result.current.deleteMessages({
+          threadId: "test-thread",
+          messageIds: ["msg-1"],
+        });
+        fail("Expected deleteMessages to throw");
+      } catch (e) {
+        expect(e).toBe(error);
+      }
+    });
+
+    // Verify error was propagated
+    expect(onErrorMock).toHaveBeenCalledWith(error);
+  });
+
+  test("deleteMessages does nothing if no profile", async () => {
+    const { medplum } = await setup();
+    const deleteSpy = jest.spyOn(medplum, "deleteResource");
+
+    // Clear the profile
+    medplum.setProfile(undefined);
+
+    const { result } = renderHook(() => useSingleThread({ threadId: "test-thread" }), {
+      wrapper: createWrapper(medplum),
+    });
+
+    // Wait for loading to complete
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    // Attempt to delete messages
+    await act(async () => {
+      await result.current.deleteMessages({
+        threadId: "test-thread",
+        messageIds: ["msg-1"],
+      });
+    });
+
+    // Verify no deletion was attempted
+    expect(deleteSpy).not.toHaveBeenCalled();
+  });
 });

app/(app)/thread/[id].tsx

@@ -8,6 +8,7 @@ import { ChatHeader } from "@/components/ChatHeader";
 import { ChatMessageInput } from "@/components/ChatMessageInput";
 import { ChatMessageList } from "@/components/ChatMessageList";
 import { LoadingScreen } from "@/components/LoadingScreen";
+import { MessageDeleteModal } from "@/components/MessageDeleteModal";
 import { useAvatars } from "@/hooks/useAvatars";
 import { useSingleThread } from "@/hooks/useSingleThread";
 
@@ -43,15 +44,19 @@ async function getAttachment() {
 export default function ThreadPage() {
   const { id } = useLocalSearchParams<{ id: string }>();
   const { profile } = useMedplumContext();
-  const { thread, isLoadingThreads, isLoading, sendMessage, markMessageAsRead } = useSingleThread({
-    threadId: id,
-  });
+  const { thread, isLoadingThreads, isLoading, sendMessage, markMessageAsRead, deleteMessages } =
+    useSingleThread({
+      threadId: id,
+    });
   const { getAvatarURL, isLoading: isAvatarsLoading } = useAvatars([
     thread?.getAvatarRef({ profile }),
   ]);
   const [message, setMessage] = useState("");
   const [isAttaching, setIsAttaching] = useState(false);
   const [isSending, setIsSending] = useState(false);
+  const [selectedMessages, setSelectedMessages] = useState<Set<string>>(new Set());
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false);
 
   // If thread is not loading and the thread undefined, redirect to the index page
   useEffect(() => {
@@ -102,20 +107,80 @@ export default function ThreadPage() {
     }
   }, [thread, handleSendMessage]);
 
+  const handleMessageSelect = useCallback((messageId: string) => {
+    setSelectedMessages((prev) => {
+      const next = new Set(prev);
+      if (next.has(messageId)) {
+        next.delete(messageId);
+      } else {
+        next.add(messageId);
+      }
+      return next;
+    });
+  }, []);
+
+  const handleConfirmDelete = useCallback(async () => {
+    if (!thread) return;
+    setIsDeleting(true);
+    try {
+      await deleteMessages({
+        threadId: thread.id,
+        messageIds: Array.from(selectedMessages),
+      });
+      setSelectedMessages(new Set());
+    } catch (error) {
+      console.error("Error deleting messages:", error);
+      Alert.alert("Error", "Failed to delete messages. Please try again.");
+    } finally {
+      setIsDeleting(false);
+      setIsDeleteModalOpen(false);
+    }
+  }, [thread, selectedMessages, deleteMessages]);
+
+  const handleDeleteMessages = useCallback(() => {
+    if (!thread || selectedMessages.size === 0) return;
+    setIsDeleteModalOpen(true);
+  }, [thread, selectedMessages]);
+
+  const handleCancelSelection = useCallback(() => {
+    setSelectedMessages(new Set());
+  }, []);
+
   if (!thread || isAvatarsLoading) {
     return <LoadingScreen />;
   }
 
   return (
     <View className="flex-1 bg-background-50">
-      <ChatHeader currentThread={thread} getAvatarURL={getAvatarURL} />
-      <ChatMessageList messages={thread.messages} loading={isSending || isLoading} />
+      <ChatHeader
+        currentThread={thread}
+        getAvatarURL={getAvatarURL}
+        selectedCount={selectedMessages.size}
+        onDelete={handleDeleteMessages}
+        onCancelSelection={handleCancelSelection}
+        isDeleting={isDeleting}
+      />
+      <ChatMessageList
+        messages={thread.messages}
+        loading={isSending || isLoading}
+        selectedMessages={selectedMessages}
+        onMessageSelect={handleMessageSelect}
+        selectionEnabled={selectedMessages.size > 0}
+      />
       <ChatMessageInput
         message={message}
         setMessage={setMessage}
         onAttachment={handleAttachment}
         onSend={handleSendMessage}
         isSending={isSending || isAttaching}
+        disabled={selectedMessages.size > 0}
+      />
+      <MessageDeleteModal
+        isOpen={isDeleteModalOpen}
+        onClose={() => setIsDeleteModalOpen(false)}
+        onConfirm={handleConfirmDelete}
+        selectedCount={selectedMessages.size}
+        isDeleting={isDeleting}
       />
     </View>
   );