refactor(web): drop test-only surface from the reconnect toast

- move the once-per-load latch into user-metadata.util (its only consumer)
  as a plain two-line guard, deleting showGoogleReconnectToastOnLoad, its
  boolean return, and the resetGoogleReconnectToastOnLoadForTests export
- give GoogleReconnectToast a syncPendingLocalEvents parameter default so
  the test injects a plain mock instead of a flag-gated process-wide
  mock.module of google.auth.util
- pass showGoogleReconnectToast to the factory bare instead of wrapping it
  in a void lambda

No useEffect/useRef/useState in the diff.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tyler-dane

packages/web/src/auth/compass/user/util/user-metadata.util.ts

@@ -1,9 +1,10 @@
 import { Status } from "@core/errors/status.codes";
 import { UserApi } from "@web/api/user.api";
 import { userMetadataActions } from "@web/auth/state/user-metadata.store";
-import { showGoogleReconnectToastOnLoad } from "@web/common/utils/toast/google-reconnect.toast";
+import { showGoogleReconnectToast } from "@web/common/utils/toast/google-reconnect.toast";
 
 let refreshUserMetadataRequest: Promise<void> | null = null;
+let hasShownReconnectToastThisLoad = false;
 
 export const refreshUserMetadata = async (options?: {
   force?: boolean;
@@ -26,10 +27,15 @@ export const refreshUserMetadata = async (options?: {
       userMetadataActions.set(metadata);
 
       // Catches returning users whose Google grant died while they were away:
-      // they get the actionable reconnect toast on load instead of having to
-      // discover the palette's "Reconnect Google Calendar" action.
-      if (metadata.google?.connectionState === "RECONNECT_REQUIRED") {
-        showGoogleReconnectToastOnLoad();
+      // they get the actionable reconnect toast instead of having to discover
+      // the palette's "Reconnect Google Calendar" action. At most once per
+      // page load, so a dismissal isn't nagged by later refreshes.
+      if (
+        metadata.google?.connectionState === "RECONNECT_REQUIRED" &&
+        !hasShownReconnectToastThisLoad
+      ) {
+        hasShownReconnectToastThisLoad = true;
+        showGoogleReconnectToast();
       }
     })
     .catch((error) => {

packages/web/src/auth/google/util/google.auth.util.ts

@@ -55,7 +55,7 @@ const googleAuthUtil = createGoogleAuthUtil({
         );
       },
     }),
-  showReconnectToast: () => void showGoogleReconnectToast(),
+  showReconnectToast: showGoogleReconnectToast,
   syncLocalEventsToCloud: () => syncLocalEventsToCloud(),
   toastError: toast.error,
 });

packages/web/src/common/utils/toast/google-reconnect.toast.test.tsx

@@ -1,6 +1,6 @@
 import { render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { afterAll, beforeEach, describe, expect, it, mock } from "bun:test";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 
 // mock.module is process-wide and leaks across test files (deleted-toast's
 // react-toastify mock would otherwise leak in here with no error/dismiss), so
@@ -27,44 +27,31 @@ mock.module(
   }),
 );
 
-// The real module is captured up front and a flag (flipped off in afterAll)
-// decides which implementation runs per call, keeping other test files'
-// imports of google.auth.util intact.
-const actualGoogleAuthUtil = await import(
-  "@web/auth/google/util/google.auth.util"
+const { GoogleReconnectToast, showGoogleReconnectToast } = await import(
+  "@web/common/utils/toast/google-reconnect.toast"
 );
-const mockSyncPendingLocalEvents = mock();
-let isGoogleAuthUtilMocked = true;
-
-mock.module("@web/auth/google/util/google.auth.util", () => ({
-  ...actualGoogleAuthUtil,
-  syncPendingLocalEvents: () =>
-    isGoogleAuthUtilMocked
-      ? mockSyncPendingLocalEvents()
-      : actualGoogleAuthUtil.syncPendingLocalEvents(),
-}));
 
-const {
-  GoogleReconnectToast,
-  resetGoogleReconnectToastOnLoadForTests,
-  showGoogleReconnectToast,
-  showGoogleReconnectToastOnLoad,
-} = await import("@web/common/utils/toast/google-reconnect.toast");
+const mockSyncPendingLocalEvents = mock();
 
-afterAll(() => {
-  isGoogleAuthUtilMocked = false;
-});
+const renderToast = () =>
+  render(
+    <GoogleReconnectToast
+      toastId="google-revoked-api"
+      syncPendingLocalEvents={mockSyncPendingLocalEvents}
+    />,
+  );
 
 describe("GoogleReconnectToast", () => {
   beforeEach(() => {
     mockStartGoogleAuthorization.mockClear();
     mockSyncPendingLocalEvents.mockClear();
     toast.error.mockClear();
     toast.dismiss.mockClear();
+    toast.isActive.mockReturnValue(false);
   });
 
   it("explains the disconnect without blaming the user or implying data loss", () => {
-    render(<GoogleReconnectToast toastId="google-revoked-api" />);
+    renderToast();
 
     expect(
       screen.getByText("Google Calendar disconnected"),
@@ -78,7 +65,7 @@ describe("GoogleReconnectToast", () => {
 
   it("flushes pending local events, dismisses itself, then starts the consent flow", async () => {
     mockSyncPendingLocalEvents.mockResolvedValue(true);
-    render(<GoogleReconnectToast toastId="google-revoked-api" />);
+    renderToast();
 
     await userEvent.click(
       screen.getByRole("button", { name: "Reconnect Google Calendar" }),
@@ -93,7 +80,7 @@ describe("GoogleReconnectToast", () => {
 
   it("stays open and does not start authorization when the local-event flush fails", async () => {
     mockSyncPendingLocalEvents.mockResolvedValue(false);
-    render(<GoogleReconnectToast toastId="google-revoked-api" />);
+    renderToast();
 
     await userEvent.click(
       screen.getByRole("button", { name: "Reconnect Google Calendar" }),
@@ -121,17 +108,3 @@ describe("showGoogleReconnectToast", () => {
     expect(toast.error).not.toHaveBeenCalled();
   });
 });
-
-describe("showGoogleReconnectToastOnLoad", () => {
-  beforeEach(() => {
-    resetGoogleReconnectToastOnLoadForTests();
-  });
-
-  // Asserted via the return value rather than toast.error call counts: other
-  // test files leak process-wide mocks of error-toast.util, so whether the
-  // underlying toast fires here depends on suite order.
-  it("shows the reconnect toast at most once per page load", () => {
-    expect(showGoogleReconnectToastOnLoad()).toBe(true);
-    expect(showGoogleReconnectToastOnLoad()).toBe(false);
-  });
-});

packages/web/src/common/utils/toast/google-reconnect.toast.tsx

@@ -7,29 +7,34 @@ import {
   showErrorToast,
 } from "@web/common/utils/toast/error-toast.util";
 
+// Imported dynamically to avoid a module cycle: google.auth.util shows this
+// toast, and the reconnect flow needs google.auth.util's local-event flush.
+const flushPendingLocalEvents = async (): Promise<boolean> => {
+  const { syncPendingLocalEvents } = await import(
+    "@web/auth/google/util/google.auth.util"
+  );
+  return syncPendingLocalEvents();
+};
+
 interface GoogleReconnectToastProps {
   toastId: Id;
+  syncPendingLocalEvents?: () => Promise<boolean>;
 }
 
 // Shown when Google reports invalid_grant, which covers both "access expired"
 // and "user revoked access" with no way to tell them apart, so the copy must
-// stay accurate for either cause.
+// stay accurate for either cause. Hooks are fine here: ToastContainer renders
+// inside GoogleOAuthProvider (CompassProvider).
 export const GoogleReconnectToast = ({
   toastId,
+  syncPendingLocalEvents = flushPendingLocalEvents,
 }: GoogleReconnectToastProps) => {
-  // Legal here: ToastContainer renders inside GoogleOAuthProvider
-  // (CompassProvider), so the OAuth context is available.
   const { startGoogleAuthorization } = useStartGoogleAuthorization({
     intent: "connectCalendar",
     prompt: "consent",
   });
 
   const handleReconnect = async () => {
-    // Imported dynamically to avoid a module cycle: google.auth.util shows
-    // this toast, and this handler needs google.auth.util's local-event flush.
-    const { syncPendingLocalEvents } = await import(
-      "@web/auth/google/util/google.auth.util"
-    );
     const didSyncLocalEvents = await syncPendingLocalEvents();
 
     // The flush already showed its own error toast; keep this one around so
@@ -71,21 +76,3 @@ export function showGoogleReconnectToast(): Id {
     },
   );
 }
-
-// At most once per page load, so a dismissal isn't nagged mid-session but the
-// reminder returns on the next load until the user reconnects.
-let hasShownOnLoad = false;
-
-export function showGoogleReconnectToastOnLoad(): boolean {
-  if (hasShownOnLoad) {
-    return false;
-  }
-
-  hasShownOnLoad = true;
-  showGoogleReconnectToast();
-  return true;
-}
-
-export function resetGoogleReconnectToastOnLoadForTests(): void {
-  hasShownOnLoad = false;
-}