@remit/web-client 0.0.324 → 0.0.326

package/src/hooks/useStaleAccountSync.ts

@@ -1,325 +0,0 @@
-import { mailboxOperationsListMailboxesQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { syncOperationsTriggerSync } from "@remit/api-http-client/sdk.gen.ts";
-import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
-import { type QueryClient, useQueryClient } from "@tanstack/react-query";
-import pMap from "p-map";
-import { useEffect, useRef } from "react";
-import { shouldEscalate } from "@/lib/error-classifier";
-import { reportFatalError } from "@/lib/fatal-error";
-import {
-	HOT_POLL_INTERVAL_MS,
-	isHotSyncWindowActive,
-	subscribeHotSyncWindow,
-} from "@/lib/hot-sync-window";
-import { getRuntimeConfig } from "@/runtime-config";
-
-/**
- * Mailboxes are considered stale 15 minutes after the last successful sync.
- * Exposed for unit tests and possible future tuning.
- */
-export const STALENESS_THRESHOLD_MS = 15 * 60 * 1000;
-
-const DEFAULT_POLL_INTERVAL_SECONDS = 30;
-
-const parsePositiveIntSeconds = (
-	raw: string | undefined,
-	fallback: number,
-): number => {
-	if (!raw) return fallback;
-	const parsed = Number.parseInt(raw, 10);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-};
-
-/**
- * Floor for the poll interval.
- *
- * This poll uses POST /sync, the same endpoint as a person pressing refresh,
- * and that endpoint's triggers skip the server's per-mailbox freshness gate
- * (`MAILBOX_FRESHNESS_MS`, 60s). A timer is not a person: every tick is a full
- * folder-by-folder re-enumeration for every open account, so the interval is
- * what bounds that work. Thirty seconds is the answer to how stale an open
- * tab's mail may be, and buys it at twice the fan-out the gate's own window
- * would allow. `mailboxPollIntervalSeconds` can lengthen the interval, never
- * shorten it past this.
- */
-export const MIN_POLL_INTERVAL_MS = 30 * 1000;
-
-/**
- * Resolve the configured poll interval, never returning less than
- * {@link MIN_POLL_INTERVAL_MS}.
- */
-export const resolvePollIntervalMs = (
-	configuredSeconds: string | undefined,
-): number =>
-	Math.max(
-		parsePositiveIntSeconds(configuredSeconds, DEFAULT_POLL_INTERVAL_SECONDS) *
-			1000,
-		MIN_POLL_INTERVAL_MS,
-	);
-
-/**
- * Client-side online-poll interval (#1251): while an account's mail is open,
- * the tab re-triggers the same sync the pull-to-refresh path uses on this
- * cadence — the replacement for the server's removed "online tier".
- */
-export const POLL_INTERVAL_MS = resolvePollIntervalMs(
-	getRuntimeConfig().mailboxPollIntervalSeconds,
-);
-
-/**
- * The interval this tab is currently due on: the hot one while a refresh press
- * is still recent, the configured ambient one otherwise. A deployment that has
- * lengthened `mailboxPollIntervalSeconds` still gets the hot cadence for the
- * few minutes after a press, which is what makes a press mean "and keep
- * looking".
- */
-export const currentPollIntervalMs = (
-	now: number = Date.now(),
-	ambientMs: number = POLL_INTERVAL_MS,
-): number =>
-	isHotSyncWindowActive(now)
-		? Math.min(HOT_POLL_INTERVAL_MS, ambientMs)
-		: ambientMs;
-
-/**
- * Bounded concurrency for the per-poll fan-out across open accounts —
- * mirrors `SCHEDULER_ENQUEUE_CONCURRENCY` in
- * remit-imap-worker/src/scheduler/config.ts (never an unbounded
- * `Promise.all`, see doc/rules/coding-standards.md). A browser tab realistically
- * has a handful of accounts open at once, so this is a ceiling, not a tuned
- * throughput target.
- */
-export const POLL_CONCURRENCY = 5;
-
-/**
- * Module-level guard: which accounts have already had a background sync
- * fired in this browser tab's session. Survives layout re-mounts (route
- * changes) so re-mounting MailLayout does not spam SQS.
- */
-const triggeredAccountIds = new Set<string>();
-
-interface AccountLike {
-	accountId: string;
-	lastSyncAt?: number;
-}
-
-/**
- * Pure selector: given a list of accounts and the current time, return
- * the accountIds whose mailbox-list is stale and should be refreshed.
- * `null`/`undefined` `lastSyncAt` is treated as stale unconditionally.
- */
-export const selectStaleAccountIds = (
-	accounts: AccountLike[],
-	now: number,
-	thresholdMs: number = STALENESS_THRESHOLD_MS,
-): string[] =>
-	accounts
-		.filter((account) => {
-			const last = account.lastSyncAt;
-			if (last === undefined || last === null) return true;
-			return now - last > thresholdMs;
-		})
-		.map((account) => account.accountId);
-
-/**
- * Pure predicate: has at least one full poll interval elapsed since the last
- * poll? Shared by the recurring timer and the visibility-regain catch-up
- * check so both use the exact same due-ness rule.
- */
-export const hasPollIntervalElapsed = (
-	now: number,
-	lastPollAt: number,
-	intervalMs: number = POLL_INTERVAL_MS,
-): boolean => now - lastPollAt >= intervalMs;
-
-/**
- * Pure selector: drop any accountId already mid-flight so a poll tick never
- * stacks a second request onto one still in progress.
- */
-export const selectPollableAccountIds = (
-	accountIds: string[],
-	inFlight: ReadonlySet<string>,
-): string[] => accountIds.filter((id) => !inFlight.has(id));
-
-/**
- * Test-only helpers. Not exported from the public hook surface; consumers
- * should never reach into the module-level Set directly.
- */
-export const __resetStaleAccountSyncGuard = (): void => {
-	triggeredAccountIds.clear();
-};
-export const __peekStaleAccountSyncGuard = (): ReadonlySet<string> =>
-	triggeredAccountIds;
-
-/**
- * Handle a failed background mailbox-sync trigger. This is a best-effort, direct
- * SDK probe (not a React Query call), so we apply the same fail-fast decision by
- * hand with the `softError` meta the call site owns: its non-5xx failures (the
- * account's own 4xx, a statusless connectivity blip) stay soft — we drop the
- * per-account guard so a later remount can retry, then log and move on. But a
- * 5xx is OUR API broken, and per the contract (#1059) that always escalates to
- * the full-screen overlay — even from a background trigger.
- *
- * Nobody is waiting on this one. It fires on mount, so escalating its 401 would
- * put the full-screen page up on load for anyone whose session had lapsed,
- * ahead of the sign-in the shell is already about to ask for.
- */
-export const handleBackgroundSyncFailure = (
-	accountId: string,
-	error: unknown,
-): void => {
-	triggeredAccountIds.delete(accountId);
-	if (shouldEscalate(error, { softError: true }, "nobody")) {
-		reportFatalError(error);
-		return;
-	}
-	console.warn("[remit] background mailbox sync failed", {
-		accountId,
-		error,
-	});
-};
-
-/**
- * Trigger the same sync the pull-to-refresh path uses and invalidate the
- * mailbox-list query on success. `throwOnError: true` so a server failure
- * rejects instead of silently resolving with `{ error }` (the default),
- * which would let a 500 look like a successful sync and invalidate queries
- * anyway.
- */
-const runBackgroundSync = (
-	accountId: string,
-	queryClient: QueryClient,
-): Promise<void> =>
-	syncOperationsTriggerSync({ path: { accountId }, throwOnError: true }).then(
-		() => {
-			queryClient.invalidateQueries({
-				queryKey: mailboxOperationsListMailboxesQueryKey({
-					path: { accountId },
-				}),
-			});
-		},
-	);
-
-/**
- * Auto-trigger a background mailbox-list sync for every stale account the
- * first time MailLayout mounts in a session, then keep it fresh with a
- * recurring online poll for as long as the mail app stays open (#1251) —
- * the client-side replacement for the server's removed "online" sync tier.
- * The poll runs on the ambient interval, or the hot one for the few minutes
- * after somebody presses refresh, and only while the tab is visible.
- * Fire-and-forget: does not block render, and silently logs failures (this
- * is a best-effort background refresh — the user-visible UI for triggering
- * is the "Refresh mailboxes" button in Settings).
- */
-export const useStaleAccountSync = (
-	accounts: RemitImapAccountResponse[],
-): void => {
-	const queryClient = useQueryClient();
-	// Hold the latest accounts in a ref so both effects can read them without
-	// re-running on every render; they re-run only when the joined accountId
-	// list actually changes (account added / removed).
-	const accountsRef = useRef(accounts);
-	accountsRef.current = accounts;
-	const stableKey = accounts.map((a) => a.accountId).join(",");
-
-	// biome-ignore lint/correctness/useExhaustiveDependencies: stableKey is a serialized account list used to trigger re-sync on account changes; adding it would cause issues without also referencing accountsRef
-	useEffect(() => {
-		const now = Date.now();
-		const stale = selectStaleAccountIds(accountsRef.current, now);
-		const fresh = stale.filter((id) => !triggeredAccountIds.has(id));
-		if (fresh.length === 0) return;
-
-		for (const accountId of fresh) {
-			triggeredAccountIds.add(accountId);
-			runBackgroundSync(accountId, queryClient).catch((err: unknown) => {
-				handleBackgroundSyncFailure(accountId, err);
-			});
-		}
-	}, [stableKey, queryClient]);
-
-	// biome-ignore lint/correctness/useExhaustiveDependencies: stableKey re-runs the poll loop when the account list changes; accountsRef supplies the live list each tick
-	useEffect(() => {
-		let lastPollAt = Date.now();
-		let timeoutId: ReturnType<typeof setTimeout> | undefined;
-		const inFlight = new Set<string>();
-
-		const poll = () => {
-			lastPollAt = Date.now();
-			const ids = selectPollableAccountIds(
-				accountsRef.current.map((a) => a.accountId),
-				inFlight,
-			);
-			// Mark every selected id in flight before dispatch (not as pMap
-			// starts each one) so a concurrency-queued id still counts as
-			// "already polling" for the next tick's `selectPollableAccountIds`
-			// check — no stacked requests even while waiting for a free slot.
-			for (const accountId of ids) inFlight.add(accountId);
-			void pMap(
-				ids,
-				(accountId) =>
-					runBackgroundSync(accountId, queryClient)
-						.catch((err: unknown) => {
-							handleBackgroundSyncFailure(accountId, err);
-						})
-						.finally(() => {
-							inFlight.delete(accountId);
-						}),
-				{ concurrency: POLL_CONCURRENCY },
-			);
-		};
-
-		const tick = () => {
-			if (document.visibilityState === "visible") {
-				poll();
-				timeoutId = setTimeout(tick, currentPollIntervalMs());
-				return;
-			}
-			// Hidden: don't reschedule. `handleVisibilityChange` resumes the loop
-			// (with an immediate catch-up poll if one is due) once the tab is
-			// visible again. A hot window running out while the tab is away costs
-			// nothing — there is nobody watching a list to keep current.
-		};
-
-		// A tick that fired while the tab was hidden left no timer behind, so
-		// coming back is the only thing that can re-arm the loop — it does so
-		// unconditionally. Due-ness decides whether this tab polls *now*, never
-		// whether a next tick exists: a tab that went to sleep on the hot cadence
-		// and came back after the window lapsed is not due against a longer
-		// ambient interval, and used to stop polling for good (#1031).
-		const handleVisibilityChange = () => {
-			if (document.visibilityState !== "visible") return;
-			if (timeoutId !== undefined) clearTimeout(timeoutId);
-			const now = Date.now();
-			const intervalMs = currentPollIntervalMs(now);
-			if (hasPollIntervalElapsed(now, lastPollAt, intervalMs)) {
-				poll();
-				timeoutId = setTimeout(tick, intervalMs);
-				return;
-			}
-			timeoutId = setTimeout(tick, lastPollAt + intervalMs - now);
-		};
-
-		// A press opens the hot window, but this loop may already be asleep on a
-		// long ambient interval — reschedule onto the hot one rather than sit
-		// out the rest of that wait. The press has just triggered its own sync,
-		// so this only moves the *next* tick: never a poll on the press itself,
-		// and never a tighter loop than the interval (POST /sync is deliberately
-		// never coalesced, #37).
-		const handleHotWindow = () => {
-			if (document.visibilityState !== "visible") return;
-			if (timeoutId !== undefined) clearTimeout(timeoutId);
-			lastPollAt = Date.now();
-			timeoutId = setTimeout(tick, currentPollIntervalMs());
-		};
-
-		timeoutId = setTimeout(tick, currentPollIntervalMs());
-		document.addEventListener("visibilitychange", handleVisibilityChange);
-		const unsubscribeHotWindow = subscribeHotSyncWindow(handleHotWindow);
-
-		return () => {
-			if (timeoutId !== undefined) clearTimeout(timeoutId);
-			document.removeEventListener("visibilitychange", handleVisibilityChange);
-			unsubscribeHotWindow();
-		};
-	}, [stableKey, queryClient]);
-};

package/src/hooks/useStarredThreads.test.ts

@@ -1,209 +0,0 @@
-/**
- * useStarredThreads — regression cover for issue #70.
- *
- * The Starred pane rendered its rows from `GET /threads?starred=true` but
- * resolved the open thread from the unfiltered (INBOX-scoped) listing. Rows for
- * starred mail filed outside INBOX therefore had nothing to resolve to and
- * opened no reading pane.
- *
- * Strategy follows useRescueCandidates.test.ts: pre-seed a QueryClient under the
- * key the hook generates and render it synchronously, so the queryFn never
- * fires. The last two cases are the ones that fail if the wrong listing comes
- * back — the unfiltered key is seeded alongside and must not be read.
- */
-
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { unifiedThreadOperationsListAllThreadsQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createElement } from "react";
-import { renderToString } from "react-dom/server";
-import {
-	starredThreadsQueryKey,
-	useStarredThreads,
-	useStarredUnreadCount,
-} from "./useStarredThreads.js";
-
-interface Page {
-	items: RemitImapThreadMessageResponse[];
-	continuationToken?: string;
-}
-
-function makeThread(
-	messageId: string,
-	overrides: Partial<RemitImapThreadMessageResponse> = {},
-): RemitImapThreadMessageResponse {
-	return {
-		messageId,
-		threadMessageId: `tm-${messageId}`,
-		threadId: `t-${messageId}`,
-		accountConfigId: "acc",
-		mailboxId: "mb-inbox",
-		sentDate: 1_000_000,
-		isRead: false,
-		hasAttachment: false,
-		hasStars: true,
-		isDeleted: false,
-		createdAt: 1_000_000,
-		updatedAt: 1_000_000,
-		fromName: "Anna de Vries",
-		fromEmail: "anna@example.nl",
-		subject: `subject ${messageId}`,
-		snippet: "…",
-		senderTrust: "vip",
-		...overrides,
-	} as RemitImapThreadMessageResponse;
-}
-
-/**
- * Renders the hook against a cache holding `starredPages` under the starred key
- * and `unfilteredItems` under the unfiltered one, so a hook reading the wrong
- * listing returns the wrong threads instead of returning nothing.
- */
-function renderHook(
-	starredPages: Page[],
-	unfilteredItems: RemitImapThreadMessageResponse[] = [],
-): RemitImapThreadMessageResponse[] {
-	const client = new QueryClient({
-		defaultOptions: { queries: { retry: false } },
-	});
-	client.setQueryData(starredThreadsQueryKey(), {
-		pages: starredPages,
-		pageParams: starredPages.map((_, index) =>
-			index === 0 ? undefined : `page-${index}`,
-		),
-	});
-	client.setQueryData(unifiedThreadOperationsListAllThreadsQueryKey(), {
-		items: unfilteredItems,
-	});
-
-	let captured: RemitImapThreadMessageResponse[] = [];
-
-	function Capture() {
-		captured = useStarredThreads().threads;
-		return null;
-	}
-
-	renderToString(
-		createElement(
-			QueryClientProvider,
-			{ client },
-			createElement(Capture),
-		) as never,
-	);
-
-	return captured;
-}
-
-describe("useStarredThreads", () => {
-	test("returns no threads when the listing is empty", () => {
-		assert.deepEqual(renderHook([{ items: [] }]), []);
-	});
-
-	test("flattens every loaded page, in page order", () => {
-		const threads = renderHook([
-			{ items: [makeThread("m1"), makeThread("m2")], continuationToken: "p2" },
-			{ items: [makeThread("m3")] },
-		]);
-		assert.deepEqual(
-			threads.map((thread) => thread.messageId),
-			["m1", "m2", "m3"],
-		);
-	});
-
-	test("returns a starred thread that lives outside INBOX", () => {
-		// The case issue #70 could not open: starred, filed in Sent, and absent
-		// from the unfiltered listing the pane used to resolve against.
-		const sent = makeThread("m-sent", { mailboxId: "mb-sent" });
-		const threads = renderHook([{ items: [sent] }], [makeThread("m-inbox")]);
-		assert.deepEqual(
-			threads.map((thread) => thread.messageId),
-			["m-sent"],
-		);
-		assert.equal(
-			threads.find((thread) => thread.messageId === "m-sent")?.mailboxId,
-			"mb-sent",
-		);
-	});
-
-	test("does not read the unfiltered INBOX listing", () => {
-		const threads = renderHook([{ items: [] }], [makeThread("m-inbox")]);
-		assert.deepEqual(threads, []);
-	});
-});
-
-// #308: the chips were a pass over the pages loaded so far, and the header
-// count was their length. Both are the server's answer now.
-describe("starred criteria", () => {
-	test("carries the chips as query parameters", () => {
-		const [params] = starredThreadsQueryKey({
-			category: ["social"],
-			unread: true,
-			attachments: true,
-		}) as [
-			{
-				query?: {
-					starred?: boolean;
-					category?: string[];
-					unread?: boolean;
-					attachments?: boolean;
-				};
-			},
-		];
-		assert.equal(params.query?.starred, true);
-		assert.deepEqual(params.query?.category, ["social"]);
-		assert.equal(params.query?.unread, true);
-		assert.equal(params.query?.attachments, true);
-	});
-
-	test("an unfiltered listing asks for exactly what it asked for before", () => {
-		assert.deepEqual(starredThreadsQueryKey({}), starredThreadsQueryKey());
-	});
-});
-
-describe("useStarredUnreadCount", () => {
-	function renderCount(seed?: { count?: number }): number | undefined {
-		const client = new QueryClient({
-			defaultOptions: { queries: { retry: false } },
-		});
-		if (seed) {
-			client.setQueryData(
-				unifiedThreadOperationsListAllThreadsQueryKey({
-					query: {
-						starred: true,
-						order: "desc",
-						unread: true,
-						count: true,
-						results: false,
-					},
-				}),
-				seed,
-			);
-		}
-
-		let captured: number | undefined;
-		function Capture() {
-			captured = useStarredUnreadCount();
-			return null;
-		}
-		renderToString(
-			createElement(
-				QueryClientProvider,
-				{ client },
-				createElement(Capture),
-			) as never,
-		);
-		return captured;
-	}
-
-	test("reports the server's count", () => {
-		assert.equal(renderCount({ count: 137 }), 137);
-	});
-
-	// A count the server has not answered is no number at all. A page length
-	// dressed as a total is what this replaces.
-	test("reports nothing when the server has not answered", () => {
-		assert.equal(renderCount(), undefined);
-	});
-});

package/src/hooks/useStarredThreads.ts

@@ -1,146 +0,0 @@
-/**
- * The starred listing — `GET /threads?starred=true`, served by the `byStarred`
- * index — as one hook, so the Starred pane's list and its selection resolve
- * from the same query.
- *
- * The two are the same cache entry, not two requests: they share a query key,
- * so `threads` here is exactly the set of rows the list rendered. Resolving a
- * selection from any other listing reintroduces issue #70 — the INBOX-scoped
- * unified listing cannot see a starred thread filed elsewhere, so its row is
- * clickable but resolves to nothing and no reading pane opens.
- *
- * The filters travel as query parameters rather than as a pass over the pages
- * loaded so far. A starred collection is paged, so a category whose mail sits
- * below the newest page rendered an empty list however much of it the
- * collection held (#308); the server answers the predicate over the whole
- * collection instead, and a page comes back full of matches.
- *
- * Free text is one of those parameters, so a search is this same paginated
- * query rather than a second, single-page one beside it. The separate one had
- * no error state of its own — an expired session read as "nothing matched" —
- * no continuation, so "Load more" was a dead button under a query, and its own
- * loading state, so a cached listing flashed the empty state while it was in
- * flight.
- */
-import { unifiedThreadOperationsListAllThreadsQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { unifiedThreadOperationsListAllThreads } from "@remit/api-http-client/sdk.gen.ts";
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
-import { useMemo } from "react";
-import type { ThreadSearchTokenParams } from "@/lib/thread-search-tokens";
-
-/** The criteria the Flagged view narrows its listing by, all server-applied. */
-export interface StarredCriteria extends ThreadSearchTokenParams {
-	/**
-	 * Free text, matched against subject, From and the body preview over the
-	 * whole collection.
-	 */
-	query?: string;
-}
-
-// `starred` and `order` are the view itself, not a criterion, so they are set
-// last: no chip can widen the listing past starred mail or reorder it.
-const starredQuery = (criteria: StarredCriteria) => ({
-	...criteria,
-	starred: true as const,
-	order: "desc" as const,
-});
-
-export const starredThreadsQueryKey = (criteria: StarredCriteria = {}) =>
-	unifiedThreadOperationsListAllThreadsQueryKey({
-		query: starredQuery(criteria),
-	});
-
-interface StarredThreads {
-	/** Every matching starred thread across the pages loaded so far, newest first. */
-	threads: RemitImapThreadMessageResponse[];
-	isLoading: boolean;
-	isError: boolean;
-	error: unknown;
-	refetch: () => void;
-	fetchNextPage: () => void;
-	hasNextPage: boolean;
-	isFetchingNextPage: boolean;
-}
-
-export function useStarredThreads(
-	criteria: StarredCriteria = {},
-): StarredThreads {
-	const {
-		data,
-		isLoading,
-		isError,
-		error,
-		refetch,
-		fetchNextPage,
-		hasNextPage,
-		isFetchingNextPage,
-	} = useInfiniteQuery({
-		queryKey: starredThreadsQueryKey(criteria),
-		queryFn: async ({ pageParam }) => {
-			const { data: page } = await unifiedThreadOperationsListAllThreads({
-				query: {
-					...starredQuery(criteria),
-					continuationToken: pageParam,
-				},
-				throwOnError: true,
-			});
-			return page;
-		},
-		initialPageParam: undefined as string | undefined,
-		getNextPageParam: (lastPage) => lastPage.continuationToken,
-		staleTime: 60_000,
-	});
-
-	const threads = useMemo(
-		() => (data?.pages ?? []).flatMap((page) => page.items ?? []),
-		[data],
-	);
-
-	return {
-		threads,
-		isLoading,
-		isError,
-		error,
-		refetch,
-		fetchNextPage,
-		hasNextPage,
-		isFetchingNextPage,
-	};
-}
-
-/**
- * How many of the matching starred messages are unread, counted by the server.
- *
- * Its own request, so no cursor enters the key and pressing "load more" cannot
- * move the number — the count is over the whole collection under the active
- * criteria, which is what the header claims it is. A page-length count grows
- * with every press and reads as a total, which is the defect this replaces
- * (#308). `results: false` reads the count alone: no rows are fetched or
- * enriched to answer it.
- *
- * Undefined until the server answers, and undefined when it cannot. The header
- * shows no number rather than a made-up one.
- */
-export function useStarredUnreadCount(
-	criteria: StarredCriteria = {},
-): number | undefined {
-	const query = {
-		...starredQuery(criteria),
-		unread: true,
-		count: true,
-		results: false,
-	};
-	const { data } = useQuery({
-		queryKey: unifiedThreadOperationsListAllThreadsQueryKey({ query }),
-		queryFn: async () => {
-			const { data: page } = await unifiedThreadOperationsListAllThreads({
-				query,
-				throwOnError: true,
-			});
-			return page;
-		},
-		staleTime: 60_000,
-	});
-	return data?.count;
-}