feat: V3 Search

features/conversations/utils/__tests__/search.test.ts

@@ -0,0 +1,161 @@
+import { dmMatchesSearchQuery, groupMatchesSearchQuery } from "../search";
+import { getInboxProfileSocialsQueryData } from "@/queries/useInboxProfileSocialsQuery";
+import type {
+  DmWithCodecsType,
+  GroupWithCodecsType,
+} from "@/utils/xmtpRN/client";
+
+// Mock getInboxProfileSocialsQueryData
+jest.mock("@/queries/useInboxProfileSocialsQuery", () => ({
+  getInboxProfileSocialsQueryData: jest.fn(),
+}));
+
+// Mock getPreferredInboxName
+jest.mock("@/utils/profile", () => ({
+  getPreferredInboxName: jest.fn((profiles) => profiles?.userNames?.[0] || ""),
+}));
+
+const mockGetInboxProfileSocialsQueryData =
+  getInboxProfileSocialsQueryData as jest.Mock;
+
+describe("Search Query Matchers", () => {
+  const account = "testAccount";
+  const searchQuery = "test";
+  const mockInboxId = "mockInboxId";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("dmMatchesSearchQuery", () => {
+    it("returns true if inboxId matches the search query", async () => {
+      const mockDm = {
+        peerInboxId: jest.fn().mockResolvedValue(mockInboxId),
+        members: jest.fn().mockResolvedValue([]),
+      } as unknown as DmWithCodecsType;
+
+      mockGetInboxProfileSocialsQueryData.mockReturnValue([
+        { userNames: ["testUser"] },
+      ]);
+
+      const result = await dmMatchesSearchQuery({
+        account,
+        searchQuery,
+        dm: mockDm,
+      });
+      expect(result).toBe(true);
+    });
+
+    it("returns true if a member's address matches the search query", async () => {
+      const mockDm = {
+        peerInboxId: jest.fn().mockResolvedValue("nonMatchingId"),
+        members: jest.fn().mockResolvedValue([{ addresses: ["testAddress"] }]),
+      } as unknown as DmWithCodecsType;
+
+      mockGetInboxProfileSocialsQueryData.mockReturnValue(null);
+
+      const result = await dmMatchesSearchQuery({
+        account,
+        searchQuery,
+        dm: mockDm,
+      });
+      expect(result).toBe(true);
+    });
+
+    it("returns false if neither inboxId nor members match the search query", async () => {
+      const mockDm = {
+        peerInboxId: jest.fn().mockResolvedValue("nonMatchingId"),
+        members: jest
+          .fn()
+          .mockResolvedValue([{ addresses: ["nonMatchingAddress"] }]),
+      } as unknown as DmWithCodecsType;
+
+      mockGetInboxProfileSocialsQueryData.mockReturnValue(null);
+
+      const result = await dmMatchesSearchQuery({
+        account,
+        searchQuery,
+        dm: mockDm,
+      });
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("groupMatchesSearchQuery", () => {
+    it("returns true if group name matches the search query", async () => {
+      const mockGroup = {
+        name: "testGroupName",
+        members: jest.fn().mockResolvedValue([]),
+      } as unknown as GroupWithCodecsType;
+
+      const result = await groupMatchesSearchQuery({
+        account,
+        searchQuery,
+        group: mockGroup,
+      });
+      expect(result).toBe(true);
+    });
+
+    it("returns true if a member's inboxId matches the search query", async () => {
+      const mockGroup = {
+        name: "nonMatchingName",
+        members: jest
+          .fn()
+          .mockResolvedValue([
+            { inboxId: mockInboxId, addresses: ["nonMatchingAddress"] },
+          ]),
+      } as unknown as GroupWithCodecsType;
+
+      mockGetInboxProfileSocialsQueryData.mockReturnValue([
+        { userNames: ["testUser"] },
+      ]);
+
+      const result = await groupMatchesSearchQuery({
+        account,
+        searchQuery: "mockInbox",
+        group: mockGroup,
+      });
+      expect(result).toBe(true);
+    });
+
+    it("returns true if a member's address matches the search query", async () => {
+      const mockGroup = {
+        name: "nonMatchingName",
+        members: jest
+          .fn()
+          .mockResolvedValue([
+            { inboxId: "nonMatchingId", addresses: ["testAddress"] },
+          ]),
+      } as unknown as GroupWithCodecsType;
+
+      mockGetInboxProfileSocialsQueryData.mockReturnValue(null);
+
+      const result = await groupMatchesSearchQuery({
+        account,
+        searchQuery,
+        group: mockGroup,
+      });
+      expect(result).toBe(true);
+    });
+
+    it("returns false if neither group name, inboxId, nor members match the search query", async () => {
+      const mockGroup = {
+        name: "nonMatchingName",
+        members: jest
+          .fn()
+          .mockResolvedValue([
+            { inboxId: "nonMatchingId", addresses: ["nonMatchingAddress"] },
+          ]),
+      } as unknown as GroupWithCodecsType;
+
+      mockGetInboxProfileSocialsQueryData.mockReturnValue(null);
+
+      const result = await groupMatchesSearchQuery({
+        account,
+        searchQuery,
+        group: mockGroup,
+      });
+      expect(result).toBe(false);
+    });
+  });
+});

features/conversations/utils/search.ts

@@ -0,0 +1,113 @@
+import { getInboxProfileSocialsQueryData } from "@/queries/useInboxProfileSocialsQuery";
+import { getPreferredInboxName } from "@/utils/profile";
+import type {
+  DmWithCodecsType,
+  GroupWithCodecsType,
+} from "@/utils/xmtpRN/client";
+import type { InboxId } from "@xmtp/react-native-sdk";
+
+type DmSearchParams = {
+  account: string;
+  searchQuery: string;
+  dm: DmWithCodecsType;
+};
+
+export const dmMatchesSearchQuery = async ({
+  account,
+  searchQuery,
+  dm,
+}: DmSearchParams): Promise<boolean> => {
+  const inboxId = await dm.peerInboxId();
+  if (await inboxIdMatchesSearchQuery({ account, searchQuery, inboxId })) {
+    return true;
+  }
+  const members = await dm.members();
+  for (const member of members) {
+    if (
+      addressMatchesSearchQuery({
+        searchQuery,
+        address: member.addresses[0],
+      })
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
+type GroupSearchParams = {
+  account: string;
+  searchQuery: string;
+  group: GroupWithCodecsType;
+};
+
+export const groupMatchesSearchQuery = async ({
+  account,
+  searchQuery,
+  group,
+}: GroupSearchParams): Promise<boolean> => {
+  if (group.name.toLowerCase().includes(searchQuery.toLowerCase())) {
+    return true;
+  }
+  const members = await group.members();
+  for (const member of members) {
+    if (
+      await inboxIdMatchesSearchQuery({
+        account,
+        searchQuery,
+        inboxId: member.inboxId,
+      })
+    ) {
+      return true;
+    }
+    if (
+      addressMatchesSearchQuery({
+        searchQuery,
+        address: member.addresses[0],
+      })
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
+type InboxIdSearchParams = {
+  account: string;
+  searchQuery: string;
+  inboxId: InboxId;
+};
+
+const inboxIdMatchesSearchQuery = async ({
+  account,
+  searchQuery,
+  inboxId,
+}: InboxIdSearchParams): Promise<boolean> => {
+  if (inboxId.toLowerCase().includes(searchQuery.toLowerCase())) {
+    return true;
+  }
+  const profiles = getInboxProfileSocialsQueryData(account, inboxId);
+  if (!profiles) {
+    return false;
+  }
+  const name = getPreferredInboxName(profiles);
+  if (name.toLowerCase().includes(searchQuery.toLowerCase())) {
+    return true;
+  }
+  return false;
+};
+
+type AddressSearchParams = {
+  searchQuery: string;
+  address: string;
+};
+
+const addressMatchesSearchQuery = ({
+  searchQuery,
+  address,
+}: AddressSearchParams): boolean => {
+  if (!address) {
+    return false;
+  }
+  return address.toLowerCase().includes(searchQuery.toLowerCase());
+};

queries/__snapshots__/QueryKeys.test.ts.snap

@@ -16,6 +16,7 @@ exports[`QueryKeys should match the snapshot 1`] = `
   "GROUP_MEMBERS": "groupMembersv2",
   "GROUP_NAME": "groupName",
   "GROUP_PERMISSIONS": "groupPermissions",
+  "GROUP_PERMISSION_POLICY": "groupPermissionPolicy",
   "GROUP_PHOTO": "groupPhoto",
   "PENDING_JOIN_REQUESTS": "pendingJoinRequests",
   "PINNED_FRAME": "pinnedFrame",

queries/useInboxProfileSocialsQuery.ts

@@ -33,7 +33,7 @@ const fetchInboxProfileSocials = async (inboxIds: InboxId) => {
   return data;
 };
 
-const inboxProfileSocialesQueryConfig = (
+const inboxProfileSocialsQueryConfig = (
   account: string,
   inboxId: InboxId | undefined
 ) => ({
@@ -54,7 +54,7 @@ export const useInboxProfileSocialsQuery = (
   account: string,
   inboxId: InboxId | undefined
 ) => {
-  return useQuery(inboxProfileSocialesQueryConfig(account, inboxId));
+  return useQuery(inboxProfileSocialsQueryConfig(account, inboxId));
 };
 
 export const useInboxProfileSocialsQueries = (
@@ -63,7 +63,7 @@ export const useInboxProfileSocialsQueries = (
 ) => {
   return useQueries({
     queries: inboxIds.map((inboxId) =>
-      inboxProfileSocialesQueryConfig(account, inboxId)
+      inboxProfileSocialsQueryConfig(account, inboxId)
     ),
   });
 };
@@ -73,7 +73,7 @@ export const fetchInboxProfileSocialsQuery = (
   inboxId: InboxId
 ) => {
   return queryClient.fetchQuery(
-    inboxProfileSocialesQueryConfig(account, inboxId)
+    inboxProfileSocialsQueryConfig(account, inboxId)
   );
 };
 
@@ -84,10 +84,21 @@ export const setInboxProfileSocialsQueryData = (
   updatedAt?: number
 ) => {
   return queryClient.setQueryData(
-    profileSocialsQueryKey(account, inboxId),
+    inboxProfileSocialsQueryConfig(account, inboxId).queryKey,
     data,
     {
       updatedAt,
     }
   );
 };
+
+export const getInboxProfileSocialsQueryData = (
+  account: string,
+  inboxId: InboxId
+): ProfileSocials[] | null => {
+  return (
+    queryClient.getQueryData(
+      inboxProfileSocialsQueryConfig(account, inboxId).queryKey
+    ) ?? null
+  );
+};

screens/ConversationList.tsx

@@ -42,6 +42,11 @@ import { useConversationListRequestCount } from "../features/conversation-list/u
 import { useConversationListItems } from "../features/conversation-list/useConversationListItems";
 import { ConversationWithCodecsType } from "@utils/xmtpRN/client";
 import { ConversationContextMenu } from "@/components/ConversationContextMenu";
+import { ConversationVersion } from "@xmtp/react-native-sdk";
+import {
+  dmMatchesSearchQuery,
+  groupMatchesSearchQuery,
+} from "@/features/conversations/utils/search";
 
 type Props = {
   searchBarRef:
@@ -109,9 +114,39 @@ function ConversationList({ navigation, route, searchBarRef }: Props) {
   }, [initialLoadDoneOnce, currentAccount]);
 
   useEffect(() => {
-    // TODO:
-    setFlatListItems({ items: items ?? [], searchQuery });
-  }, [searchQuery, profiles, items]);
+    const getFilteredItems = async () => {
+      const filteredItems: FlatListItemType[] = [];
+      for (const item of items ?? []) {
+        if (item.version === ConversationVersion.GROUP) {
+          const groupMatches = await groupMatchesSearchQuery({
+            account: currentAccount!,
+            searchQuery,
+            group: item,
+          });
+          if (groupMatches) {
+            filteredItems.push(item);
+          }
+        } else if (item.version === ConversationVersion.DM) {
+          const dmMatches = await dmMatchesSearchQuery({
+            account: currentAccount!,
+            searchQuery,
+            dm: item,
+          });
+          if (dmMatches) {
+            filteredItems.push(item);
+          }
+        }
+      }
+      return filteredItems ?? [];
+    };
+    if (searchQuery.trim().length > 0) {
+      getFilteredItems().then((filteredItems) => {
+        setFlatListItems({ items: filteredItems, searchQuery });
+      });
+    } else {
+      setFlatListItems({ items: items ?? [], searchQuery });
+    }
+  }, [searchQuery, profiles, items, currentAccount]);
 
   // Search bar hook
   useHeaderSearchBar({