refactor: remove artist scope from account emails

Author: arpitgupta1214

app/api/account-emails/route.ts

@@ -11,11 +11,8 @@ import { extractAccountIds } from "@/utils/extractAccountIds";
 import FileInfoDialogHeader from "./FileInfoDialogHeader";
 import FileInfoDialogContent from "./FileInfoDialogContent";
 import FileInfoDialogMetadata from "./FileInfoDialogMetadata";
-import { useQuery } from "@tanstack/react-query";
-import { Tables } from "@/types/database.types";
 import { useUserProvider } from "@/providers/UserProvder";
-
-type AccountEmail = Tables<"account_emails">;
+import { useAccountEmails } from "@/hooks/useAccountEmails";
 
 type FileInfoDialogProps = {
   file: FileRow | null;
@@ -38,19 +35,10 @@ export default function FileInfoDialog({ file, open, onOpenChange }: FileInfoDia
   const canEdit = file ? isTextFile(file.file_name) : false;
 
   // Fetch owner email
-  const { data: emails } = useQuery<AccountEmail[]>({
-    queryKey: ["file-owner-email", ownerAccountId, artistAccountId],
-    queryFn: async () => {
-      if (!ownerAccountId || !artistAccountId || !userData) return [];
-      const params = new URLSearchParams();
-      params.append("accountIds", ownerAccountId);
-      params.append("currentAccountId", userData.id);
-      params.append("artistAccountId", artistAccountId);
-      const response = await fetch(`/api/account-emails?${params}`);
-      if (!response.ok) return [];
-      return response.json();
-    },
-    enabled: !!ownerAccountId && !!artistAccountId && !!userData && open,
+  const { data: emails } = useAccountEmails({
+    accountIds: ownerAccountId ? [ownerAccountId] : [],
+    enabled: open,
+    queryKey: ["file-owner-email", ownerAccountId],
   });
 
   const ownerEmail = emails?.[0]?.email || undefined;
@@ -121,4 +109,3 @@ export default function FileInfoDialog({ file, open, onOpenChange }: FileInfoDia
     </Dialog>
   );
 }
-

components/Files/FileInfoDialog.tsx

@@ -1,14 +1,10 @@
-import { Tables } from "@/types/database.types";
 import { Task } from "@/lib/tasks/getTasks";
 import TaskCard from "@/components/VercelChat/tools/tasks/TaskCard";
 import TaskSkeleton from "./TaskSkeleton";
 import TaskDetailsDialog from "@/components/VercelChat/dialogs/tasks/TaskDetailsDialog";
-import { useArtistProvider } from "@/providers/ArtistProvider";
 import { useUserProvider } from "@/providers/UserProvder";
 import { useMemo } from "react";
-import { useQuery } from "@tanstack/react-query";
-
-type AccountEmail = Tables<"account_emails">;
+import { useAccountEmails } from "@/hooks/useAccountEmails";
 
 interface TasksListProps {
   tasks: Task[];
@@ -18,7 +14,6 @@ interface TasksListProps {
 
 const TasksList: React.FC<TasksListProps> = ({ tasks, isLoading, isError }) => {
   const { userData } = useUserProvider();
-  const { selectedArtist } = useArtistProvider();
 
   // Extract unique account IDs from tasks
   const accountIds = useMemo(
@@ -27,21 +22,9 @@ const TasksList: React.FC<TasksListProps> = ({ tasks, isLoading, isError }) => {
   );
 
   // Batch fetch emails for all task owners
-  const { data: accountEmails = [] } = useQuery<AccountEmail[]>({
+  const { data: accountEmails = [] } = useAccountEmails({
+    accountIds,
     queryKey: ["task-owner-emails", accountIds],
-    queryFn: async () => {
-      if (accountIds.length === 0 || !userData) return [];
-      const params = new URLSearchParams();
-      accountIds.forEach(id => params.append("accountIds", id));
-      params.append("currentAccountId", userData.id);
-      if (selectedArtist) {
-        params.append("artistAccountId", selectedArtist.account_id);
-      }
-      const response = await fetch(`/api/account-emails?${params}`);
-      if (!response.ok) throw new Error("Failed to fetch emails");
-      return response.json();
-    },
-    enabled: accountIds.length > 0 && !!userData,
   });
 
   // Create lookup map for O(1) email access

components/TasksPage/TasksList.tsx

@@ -0,0 +1,42 @@
+"use client";
+
+import { useQuery } from "@tanstack/react-query";
+import { usePrivy } from "@privy-io/react-auth";
+import { fetchAccountEmails, type AccountEmail } from "@/lib/accounts/fetchAccountEmails";
+
+interface UseAccountEmailsParams {
+  accountIds: string[];
+  enabled?: boolean;
+  queryKey?: readonly unknown[];
+}
+
+/**
+ * Fetches account email rows for one or more account IDs the authenticated user can access.
+ */
+export function useAccountEmails({
+  accountIds,
+  enabled = true,
+  queryKey = ["account-emails", accountIds],
+}: UseAccountEmailsParams) {
+  const { getAccessToken, authenticated } = usePrivy();
+
+  return useQuery<AccountEmail[]>({
+    queryKey: [...queryKey],
+    queryFn: async () => {
+      if (accountIds.length === 0) {
+        return [];
+      }
+
+      const accessToken = await getAccessToken();
+      if (!accessToken) {
+        throw new Error("Please sign in to view account emails");
+      }
+
+      return fetchAccountEmails({
+        accessToken,
+        accountIds,
+      });
+    },
+    enabled: enabled && accountIds.length > 0 && authenticated,
+  });
+}

hooks/useAccountEmails.ts

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { fetchAccountEmails } from "../fetchAccountEmails";
+
+vi.mock("@/lib/api/getClientApiBaseUrl", () => ({
+  getClientApiBaseUrl: vi.fn(() => "https://test-recoup-api.vercel.app"),
+}));
+
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe("fetchAccountEmails", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns early when no account IDs are provided", async () => {
+    const result = await fetchAccountEmails({
+      accessToken: "token",
+      accountIds: [],
+    });
+
+    expect(result).toEqual([]);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("builds repeated account_id params and sends bearer auth", async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue([
+        {
+          id: "email-1",
+          account_id: "acc-1",
+          email: "owner@example.com",
+          updated_at: "2026-04-08T00:00:00.000Z",
+        },
+      ]),
+    });
+
+    const result = await fetchAccountEmails({
+      accessToken: "token-123",
+      accountIds: ["acc-1", "acc-2"],
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://test-recoup-api.vercel.app/api/accounts/emails?account_id=acc-1&account_id=acc-2",
+      {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer token-123",
+        },
+      },
+    );
+    expect(result[0]?.email).toBe("owner@example.com");
+  });
+
+  it("throws the API error message when the request fails", async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      json: vi.fn().mockResolvedValue({ error: "Unauthorized" }),
+    });
+
+    await expect(
+      fetchAccountEmails({
+        accessToken: "token",
+        accountIds: ["acc-1"],
+      }),
+    ).rejects.toThrow("Unauthorized");
+  });
+});

lib/accounts/__tests__/fetchAccountEmails.test.ts

@@ -0,0 +1,40 @@
+import { getClientApiBaseUrl } from "@/lib/api/getClientApiBaseUrl";
+import { Tables } from "@/types/database.types";
+
+export type AccountEmail = Tables<"account_emails">;
+
+interface FetchAccountEmailsParams {
+  accessToken: string;
+  accountIds: string[];
+}
+
+/**
+ * Fetches account email rows for the provided account IDs.
+ */
+export async function fetchAccountEmails({
+  accessToken,
+  accountIds,
+}: FetchAccountEmailsParams): Promise<AccountEmail[]> {
+  if (accountIds.length === 0) {
+    return [];
+  }
+
+  const url = new URL(`${getClientApiBaseUrl()}/api/accounts/emails`);
+  accountIds.forEach(accountId => {
+    url.searchParams.append("account_id", accountId);
+  });
+
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => null);
+    throw new Error(error?.error || "Failed to fetch account emails");
+  }
+
+  return response.json();
+}