@remit/web-client 0.0.240 → 0.0.242

package/src/components/ui/folder-role-refusal.ts

@@ -5,11 +5,9 @@
  * appointment prompt over an unrelated conflict. A 409 without one of these
  * codes is somebody else's error and keeps today's banner.
  */
-import type {
-	ApiError,
-	RemitImapCanonicalMailboxRole,
-} from "@remit/api-http-client/types.gen.ts";
+import type { RemitImapCanonicalMailboxRole } from "@remit/api-http-client/types.gen.ts";
 import { CanonicalMailboxRole } from "@remit/domain-enums";
+import { type CodedApiErrorBody, codedApiErrorBody } from "@/lib/api";
 
 /** Why the role is unresolved, as the API's `details.reason` spells it. */
 export type FolderRoleRefusalReason = "none" | "stale" | "unconfirmed";
@@ -29,18 +27,8 @@ const REASONS: ReadonlySet<string> = new Set<FolderRoleRefusalReason>([
 
 const ROLES: ReadonlySet<string> = new Set(Object.values(CanonicalMailboxRole));
 
-/**
- * The wire body as `handleError` emits it — flat, so `code` and `details` sit
- * at the top level. Everything is re-checked at runtime: this is a network
- * boundary, and the type only says what the contract promises.
- */
-const bodyOf = (error: unknown): Partial<ApiError> | undefined =>
-	typeof error === "object" && error !== null
-		? (error as Partial<ApiError>)
-		: undefined;
-
 const stringAt = (
-	details: ApiError["details"],
+	details: CodedApiErrorBody["details"],
 	key: string,
 ): string | undefined => {
 	const value = details?.[key];
@@ -55,10 +43,10 @@ const stringAt = (
 export const isFolderRoleRefusal = (
 	error: unknown,
 ): FolderRoleRefusal | undefined => {
-	const body = bodyOf(error);
+	const body = codedApiErrorBody(error);
 	if (body?.code !== "folder_role_unresolved") return undefined;
 	const { details } = body;
-	if (typeof details !== "object" || details === null) return undefined;
+	if (!details) return undefined;
 	const reason = stringAt(details, "reason");
 	const role = stringAt(details, "role");
 	const accountId = stringAt(details, "accountId");
@@ -78,4 +66,4 @@ export const isFolderRoleRefusal = (
  * one, retrying does not.
  */
 export const isMailboxNotSettledRefusal = (error: unknown): boolean =>
-	bodyOf(error)?.code === "mailbox_not_settled";
+	codedApiErrorBody(error)?.code === "mailbox_not_settled";

package/src/components/ui/placement-refusal.test.ts

@@ -1,15 +1,23 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { wrapHttpFailure } from "@/lib/api";
 import {
 	isPlacementRefusal,
 	placementRefusalBanner,
 } from "./placement-refusal.js";
 
-const refusal = (reason: string) => ({
-	message: "Message 4f1 was not acted on: its folder and uid do not name...",
-	code: "message_placement_unsettled",
-	details: { accountId: "acc-1", messageId: "msg-1", reason },
-});
+// The reader is handed what the error interceptor produces, not the flat wire
+// body it carries at `.body` (#1004).
+const refusal = (reason: string) =>
+	wrapHttpFailure(
+		{
+			message:
+				"Message 4f1 was not acted on: its folder and uid do not name...",
+			code: "message_placement_unsettled",
+			details: { accountId: "acc-1", messageId: "msg-1", reason },
+		},
+		409,
+	);
 
 describe("isPlacementRefusal", () => {
 	it("reads the reason and the message off the coded body", () => {
@@ -23,7 +31,7 @@ describe("isPlacementRefusal", () => {
 		assert.equal(isPlacementRefusal(undefined), undefined);
 		assert.equal(isPlacementRefusal(new Error("network")), undefined);
 		assert.equal(
-			isPlacementRefusal({ ...refusal("in_flight"), code: "other" }),
+			isPlacementRefusal(wrapHttpFailure({ code: "other" }, 409)),
 			undefined,
 		);
 		assert.equal(isPlacementRefusal(refusal("something_else")), undefined);

package/src/components/ui/placement-refusal.ts

@@ -4,8 +4,8 @@
  * server's sentence names a uuid and no remedy, and a message-string match
  * would start firing on an unrelated conflict the moment the copy changes.
  */
-import type { ApiError } from "@remit/api-http-client/types.gen.ts";
 import type { PushErrorInput } from "@/components/ui/error-banners";
+import { type CodedApiErrorBody, codedApiErrorBody } from "@/lib/api";
 
 /**
  * `in_flight` clears on its own once the mail server confirms the move;
@@ -25,7 +25,7 @@ const REASONS: ReadonlySet<string> = new Set<PlacementRefusalReason>([
 ]);
 
 const stringAt = (
-	details: ApiError["details"],
+	details: CodedApiErrorBody["details"],
 	key: string,
 ): string | undefined => {
 	const value = details?.[key];
@@ -35,11 +35,10 @@ const stringAt = (
 export const isPlacementRefusal = (
 	error: unknown,
 ): PlacementRefusal | undefined => {
-	if (typeof error !== "object" || error === null) return undefined;
-	const body = error as Partial<ApiError>;
-	if (body.code !== "message_placement_unsettled") return undefined;
+	const body = codedApiErrorBody(error);
+	if (body?.code !== "message_placement_unsettled") return undefined;
 	const { details } = body;
-	if (typeof details !== "object" || details === null) return undefined;
+	if (!details) return undefined;
 	const reason = stringAt(details, "reason");
 	const messageId = stringAt(details, "messageId");
 	if (!reason || !REASONS.has(reason) || !messageId) return undefined;

package/src/hooks/refusal-escalation.render.test.ts

@@ -0,0 +1,187 @@
+/**
+ * A coded 409 must reach the surface that answers it and nothing else (#1004).
+ *
+ * Both delete paths raise through `useMutation`, and the app wires the global
+ * fail-fast sink on the `MutationCache` (`shell/index.tsx`), where a 409 with
+ * no `meta` escalates to the full-screen fatal overlay. The prompt then opens
+ * underneath a red page nobody can see past — the refusal is handled and still
+ * never reaches the user. Every other test mounts on the harness's plain
+ * `QueryClient`, which has no such sink, so none of them can see this.
+ *
+ * Mounted here on the client the app actually builds, with the error
+ * interceptor registered.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import {
+	MutationCache,
+	QueryCache,
+	QueryClient,
+	QueryClientProvider,
+} from "@tanstack/react-query";
+import { act, createElement } from "react";
+import { RoleAppointmentPromptProvider } from "@/components/mail/RoleAppointmentPromptProvider";
+import { ErrorBannerProvider } from "@/components/ui/ErrorBannerProvider";
+import { __resetFatalError, getCurrentFatalError } from "@/lib/fatal-error";
+import {
+	handleMutationCacheError,
+	handleQueryCacheError,
+} from "@/lib/query-error-handler";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import { type HttpMock, mockFetch } from "../test-support/http";
+import { useDeleteMessages } from "./useDeleteMessages";
+import { type EmptyTrashState, useEmptyTrash } from "./useEmptyTrash";
+import "@/lib/client";
+
+const ACCOUNT = "acc-1";
+const INBOX = "mbx-inbox";
+const TRASH = "mbx-trash";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+let deleteMessages: ((messageIds: string[]) => void) | undefined;
+let trash: EmptyTrashState | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+	deleteMessages = undefined;
+	trash = undefined;
+	__resetFatalError();
+});
+
+const CONFIG = {
+	accounts: [
+		{
+			accountId: ACCOUNT,
+			email: "you@example.com",
+			folderAppointments: [
+				{ role: "Trash", mailboxId: TRASH, source: "Proposed" },
+			],
+		},
+	],
+};
+
+/** Fresh every call — a `Response` body can only be read once. */
+const refusal = (): Response =>
+	new Response(
+		JSON.stringify({
+			status: 409,
+			message: "Nobody has confirmed which folder is this account's Trash",
+			code: "folder_role_unresolved",
+			details: { reason: "unconfirmed", role: "Trash", accountId: ACCOUNT },
+		}),
+		{ status: 409, headers: { "content-type": "application/json" } },
+	);
+
+const broken = (): Response =>
+	new Response(JSON.stringify({ message: "boom" }), {
+		status: 500,
+		headers: { "content-type": "application/json" },
+	});
+
+const Probe = () => {
+	deleteMessages = useDeleteMessages({
+		mailboxId: INBOX,
+		accountId: ACCOUNT,
+	}).deleteMessages;
+	trash = useEmptyTrash({ accountId: ACCOUNT, mailboxId: TRASH });
+	return null;
+};
+
+/** The client `shell/index.tsx` builds: the real global escalation sink. */
+const appQueryClient = (): QueryClient =>
+	new QueryClient({
+		queryCache: new QueryCache({ onError: handleQueryCacheError }),
+		mutationCache: new MutationCache({ onError: handleMutationCacheError }),
+		defaultOptions: {
+			queries: { retry: false },
+			mutations: { retry: false },
+		},
+	});
+
+const settle = async (): Promise<void> => {
+	if (!harness) throw new Error("nothing mounted");
+	for (let round = 0; round < 40; round += 1) {
+		await harness.flush();
+		await harness.wait(0);
+	}
+};
+
+const mount = async (respond: (path: string) => unknown): Promise<void> => {
+	http = mockFetch((call) => respond(call.path));
+	harness = createDomHarness({ queryClient: appQueryClient() });
+	await harness.renderAsync(
+		createElement(
+			QueryClientProvider,
+			{ client: harness.queryClient as never },
+			createElement(
+				ErrorBannerProvider,
+				null,
+				createElement(
+					RoleAppointmentPromptProvider,
+					null,
+					createElement(Probe),
+				),
+			),
+		),
+	);
+	await settle();
+};
+
+const responder =
+	(endpoint: string, answer: () => Response) =>
+	(path: string): unknown => {
+		if (path.endsWith("/config")) return CONFIG;
+		if (path.endsWith(endpoint)) return answer();
+		return {};
+	};
+
+describe("a delete refused for its folder role", () => {
+	it("opens the appointment prompt without taking the screen", async () => {
+		await mount(responder("/messages/delete", refusal));
+
+		await act(async () => {
+			deleteMessages?.(["msg-1"]);
+		});
+		await settle();
+
+		assert.match(harness?.text() ?? "", /Confirm this account's Trash folder/);
+		assert.equal(
+			getCurrentFatalError(),
+			null,
+			"a refusal the prompt answers is not a fatal error",
+		);
+	});
+
+	it("still escalates a 500 on the same delete", async () => {
+		await mount(responder("/messages/delete", broken));
+
+		await act(async () => {
+			deleteMessages?.(["msg-1"]);
+		});
+		await settle();
+
+		assert.ok(
+			getCurrentFatalError(),
+			"the 409 opt-out must not cover anything else",
+		);
+	});
+});
+
+describe("an empty Trash refused for its folder role", () => {
+	it("states the refusal in the pane without taking the screen", async () => {
+		await mount(responder("/trash/empty", refusal));
+
+		await act(async () => {
+			trash?.emptyTrash();
+		});
+		await settle();
+
+		assert.equal(trash?.refusal?.reason, "unconfirmed");
+		assert.equal(getCurrentFatalError(), null);
+	});
+});

package/src/hooks/stale-account-sync-visibility.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Coming back to a tab always leaves the poll loop with a next tick (#1031).
+ *
+ * A tick that fires while the tab is hidden deliberately does not reschedule —
+ * `visibilitychange` is the only thing that resumes the loop. While that resume
+ * was itself conditional on a poll being due, the resume could be skipped for
+ * good: press refresh (which opens the hot 30s window), hide the tab shortly
+ * after a hot tick, let the window lapse while away, and the return is measured
+ * against the ambient interval the tab never slept through. Nothing re-armed,
+ * and the tab stopped polling until the account list changed or the layout
+ * remounted.
+ *
+ * At the default the ambient and hot intervals are equal and the loop is safe
+ * either way, so these drive a deployment that lengthened
+ * `mailboxPollIntervalSeconds` — the only shape where the bug is reachable.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, mock, test } from "node:test";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { act, createElement } from "react";
+import {
+	__resetHotSyncWindow,
+	HOT_POLL_INTERVAL_MS,
+	HOT_WINDOW_MS,
+	startHotSyncWindow,
+} from "@/lib/hot-sync-window";
+import { createDomHarness, type DomHarness } from "@/test-support/dom";
+import { makeAccount } from "@/test-support/fixtures";
+import { type HttpMock, mockFetch } from "@/test-support/http";
+
+const ACCOUNT_ID = "acc-1";
+const AMBIENT_SECONDS = 600;
+const AMBIENT_MS = AMBIENT_SECONDS * 1000;
+const T0 = 1_700_000_000_000;
+
+// The hook resolves the ambient interval once, at module load, so the config has
+// to be in place before it is imported.
+globalThis.__REMIT_CONFIG__ = {
+	mailboxPollIntervalSeconds: String(AMBIENT_SECONDS),
+};
+const { __resetStaleAccountSyncGuard, POLL_INTERVAL_MS, useStaleAccountSync } =
+	await import("./useStaleAccountSync.js");
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+
+function PollLoop() {
+	useStaleAccountSync([makeAccount({ accountId: ACCOUNT_ID, lastSyncAt: T0 })]);
+	return null;
+}
+
+/**
+ * jsdom reports "prerender" unless it is pretending to be visual, and the
+ * shared environment deliberately does not — so a spec about a tab being looked
+ * at has to say so.
+ */
+const setVisibility = (state: "hidden" | "visible"): void => {
+	Object.defineProperty(document, "visibilityState", {
+		configurable: true,
+		get: () => state,
+	});
+};
+
+/** Enough microtask turns for a dispatched poll to reach the fetch seam. */
+const settle = async (dom: DomHarness): Promise<void> => {
+	for (let round = 0; round < 3; round += 1) await dom.flush();
+};
+
+const mount = async (): Promise<DomHarness> => {
+	http = mockFetch(() => ({ status: "queued" }));
+	const dom = createDomHarness();
+	harness = dom;
+	dom.render(
+		createElement(
+			QueryClientProvider,
+			{ client: dom.queryClient },
+			createElement(PollLoop),
+		),
+	);
+	await settle(dom);
+	return dom;
+};
+
+const advance = async (dom: DomHarness, ms: number): Promise<void> => {
+	await act(async () => {
+		mock.timers.tick(ms);
+	});
+	await settle(dom);
+};
+
+const goVisible = async (dom: DomHarness): Promise<void> => {
+	setVisibility("visible");
+	dom.dispatch(dom.document, new Event("visibilitychange"));
+	await settle(dom);
+};
+
+const goHidden = async (dom: DomHarness): Promise<void> => {
+	setVisibility("hidden");
+	dom.dispatch(dom.document, new Event("visibilitychange"));
+	await settle(dom);
+};
+
+/** Every background sync this tab has fired since it mounted. */
+const polls = (): number => http?.to(`/${ACCOUNT_ID}/sync`).length ?? 0;
+
+describe("the poll loop across hide and show, on a long ambient interval", () => {
+	beforeEach(() => {
+		mock.timers.enable({ apis: ["setTimeout", "Date"], now: T0 });
+	});
+
+	afterEach(() => {
+		mock.timers.reset();
+		harness?.close();
+		harness = undefined;
+		http?.restore();
+		http = undefined;
+		__resetHotSyncWindow();
+		__resetStaleAccountSyncGuard();
+		Reflect.deleteProperty(document, "visibilityState");
+	});
+
+	test("the deployment under test really is on a lengthened interval", () => {
+		assert.equal(POLL_INTERVAL_MS, AMBIENT_MS);
+	});
+
+	test("keeps polling after a refresh press, a hidden hot window and a return", async () => {
+		setVisibility("visible");
+		const dom = await mount();
+
+		// The press: the hot window opens and the loop drops onto its cadence.
+		startHotSyncWindow();
+		await advance(dom, HOT_POLL_INTERVAL_MS);
+		assert.equal(polls(), 1, "the hot cadence polled once");
+
+		// Away before the next hot tick, and back only after the window lapsed.
+		await goHidden(dom);
+		await advance(dom, HOT_WINDOW_MS);
+		assert.equal(polls(), 1, "a hidden tab polled");
+
+		await goVisible(dom);
+		assert.equal(
+			polls(),
+			1,
+			"the return polled a tab that is not due on the ambient interval",
+		);
+
+		await advance(dom, AMBIENT_MS);
+		assert.equal(polls(), 2, "the tab came back with no tick scheduled");
+	});
+
+	test("polls on return once the ambient interval has passed", async () => {
+		setVisibility("visible");
+		const dom = await mount();
+
+		await goHidden(dom);
+		await advance(dom, AMBIENT_MS);
+		assert.equal(polls(), 0, "a hidden tab polled");
+
+		await goVisible(dom);
+		assert.equal(polls(), 1, "a tab due a poll did not catch up on return");
+
+		await advance(dom, AMBIENT_MS);
+		assert.equal(polls(), 2, "the catch-up left no next tick behind it");
+	});
+});

package/src/hooks/use-system-update.test.ts

@@ -558,6 +558,110 @@ describe("useSystemUpdate — actions", () => {
 		}
 	});
 
+	test("checking from the success row reaches the pane, not a dead button (#1015)", async () => {
+		// An undismissed run outcome wins over any check in flight, so a press
+		// made while the success banner holds the pane would leave the screen
+		// exactly as it was. The row's control retires the outcome first.
+		const succeeded = {
+			currentVersion: "0.9.4",
+			check: { status: "ok", updateAvailable: false },
+			run: run({ outcome: "succeeded" }),
+		};
+		const { dom } = mountApi(() => succeeded, createElement(SelfUpdatePanel));
+		await settle(dom);
+		assert.match(dom.html(), /Updated to Remit 0\.9\.4/);
+
+		dom.click(dom.byText("button", "Check for updates"));
+		await waitFor(
+			dom,
+			() => /Looking for a newer version/.test(dom.html()),
+			"the pressed check to reach the pane",
+		);
+		assert.doesNotMatch(dom.html(), /Updated to Remit/);
+	});
+
+	test("a check pressed from the success row fails in the open, not behind the banner (#1015)", async () => {
+		const succeeded = {
+			currentVersion: "0.9.4",
+			check: { status: "ok", updateAvailable: false },
+			run: run({ outcome: "succeeded" }),
+		};
+		const { dom } = mountApi(() => succeeded, createElement(SelfUpdatePanel));
+		await settle(dom);
+
+		const control = dom.byText("button", "Check for updates");
+		const realNow = Date.now;
+		try {
+			await act(async () => {
+				// Dispatched inside this `act` rather than through `dom.click`, so
+				// the press is stamped off the real clock and the wait it arms is
+				// measured against one already past the budget.
+				control.dispatchEvent(
+					new MouseEvent("click", { bubbles: true, cancelable: true }),
+				);
+				Date.now = () => realNow() + CHECK_ANSWER_BUDGET_MS + 1_000;
+				await dom.flush();
+			});
+			await dom.wait(5);
+			await dom.flush();
+
+			assert.match(dom.html(), /The updater did not answer/);
+			assert.doesNotMatch(dom.html(), /Updated to Remit/);
+		} finally {
+			Date.now = realNow;
+		}
+	});
+
+	test("dismissing an outcome does not uncover the check verdict it hid", async () => {
+		// The failure belongs to a press made before the run, on a pane the user
+		// has not been able to see since. Serving it as the current verdict claims
+		// a check failed that may well have succeeded.
+		let response: unknown = available;
+		const { dom, api } = mountApi(
+			() => response,
+			createElement(SelfUpdatePanel),
+		);
+		await settle(dom);
+
+		const realNow = Date.now;
+		try {
+			await act(async () => {
+				api().onCheck();
+				Date.now = () => realNow() + CHECK_ANSWER_BUDGET_MS + 1_000;
+				await dom.flush();
+			});
+			await dom.wait(5);
+			await dom.flush();
+			assert.match(dom.html(), /The updater did not answer/);
+		} finally {
+			Date.now = realNow;
+		}
+
+		response = {
+			currentVersion: "0.9.4",
+			check: { status: "ok", updateAvailable: false },
+			run: run({ outcome: "succeeded" }),
+		};
+		await retryConnection(dom, api);
+		await waitFor(
+			dom,
+			() => /Updated to Remit 0\.9\.4/.test(dom.html()),
+			"the finished run to reach the pane",
+		);
+
+		await act(async () => {
+			api().onDismissResult();
+			await dom.flush();
+		});
+		await waitFor(
+			dom,
+			() => !/Updated to Remit/.test(dom.html()),
+			"the outcome to be retired",
+		);
+		assert.doesNotMatch(dom.html(), /The updater did not answer/);
+		assert.match(dom.html(), /0\.9\.4 is the latest version/);
+	});
+
 	test("a refused refresh is shown, never swallowed back into the old verdict (#599)", async () => {
 		let refused = false;
 		const { dom, api } = mountApi(

package/src/hooks/use-system-update.ts

@@ -249,6 +249,12 @@ export function useSystemUpdate(): SelfUpdateApi {
 		if (shownRunIdRef.current !== null)
 			setDismissedRunId(shownRunIdRef.current);
 		setHeld(null);
+		// Retiring the outcome uncovers the check verdict beneath it. A failure
+		// recorded while the outcome held the pane describes a press the user can
+		// no longer see, and an update run of its own supersedes anything an
+		// earlier check concluded — either way it must not resurface here.
+		setCheckPress(null);
+		setCheckFailure(null);
 	}, []);
 
 	return {

package/src/hooks/useDeleteMessages.ts

@@ -16,6 +16,7 @@ import {
 } from "@/components/ui/placement-refusal";
 import { resolveMailboxesForMessages } from "@/hooks/useMarkAsRead";
 import { runChunkedMutation } from "@/lib/bulk-actions";
+import { softErrorStatuses } from "@/lib/error-classifier";
 import {
 	cancelThreadListQueries,
 	invalidateThreadListQueries,
@@ -92,6 +93,10 @@ export const useDeleteMessages = ({
 
 	const { mutateAsync, isPending } = useMutation({
 		...messageBulkOperationsDeleteMessagesMutation(),
+		// A coded 409 is answered here — the prompt, or a banner — so it must not
+		// also take the whole screen. Only 409: a 401, 403 or 5xx on a delete is
+		// still the fatal page's (#1059).
+		meta: softErrorStatuses(409),
 		onMutate: async (variables): Promise<ThreadMutationContext> => {
 			const messageIds = new Set(variables.body.messageIds ?? []);
 

package/src/hooks/useEmptyTrash.ts

@@ -22,6 +22,7 @@ import {
 	type FolderRoleRefusal,
 	isFolderRoleRefusal,
 } from "@/components/ui/folder-role-refusal";
+import { softErrorStatuses } from "@/lib/error-classifier";
 import {
 	invalidateThreadListQueries,
 	threadListCacheKeys,
@@ -109,6 +110,9 @@ export const useEmptyTrash = ({
 
 	const { mutateAsync, isPending } = useMutation({
 		...trashOperationsEmptyTrashMutation(),
+		// The refusal is rendered in the pane, so it must not also take the whole
+		// screen. Only 409 — every other status is still the fatal page's (#1059).
+		meta: softErrorStatuses(409),
 		onMutate: (): EmptyTrashContext => {
 			inFlight.current = scope;
 			return { scope, listMailboxId: listMailboxIdNow() };

package/src/hooks/useMessageBodyContent.ts

@@ -351,6 +351,12 @@ export const useMessageBodyContent = ({
 
 	const isLoading = query.isLoading && !!picked;
 
+	// `picked` is null for two different reasons, and a caller that treats them
+	// alike is wrong about one of them: the message has not arrived yet, or it
+	// arrived carrying nothing renderable. Only the second is a fact about the
+	// message, and only it may be stated to the reader (#1030).
+	const hasNoRenderablePart = bodyParts !== undefined && picked === null;
+
 	useEffect(() => {
 		if (isLoading) {
 			loadStartRef.current = performance.now();
@@ -374,6 +380,7 @@ export const useMessageBodyContent = ({
 		picked,
 		data,
 		isLoading,
+		hasNoRenderablePart,
 		isError: query.isError,
 		error: query.error,
 		refetch: query.refetch,