Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(frontend): coordinate HTTP token refresh with a shared worker (#21622)
p0ny844a319bf090
diff --git a/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts b/frontend/src/api/middlewares/authInterceptorMiddleware.test.tsindex 9d8e5769de..01591801dc 100644--- a/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts+++ b/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts@@ -109,6 +109,129 @@ describe("authInterceptor", () => {expect(mocks.authStore.unauthenticatedOccurred).toBe(false);});+ test("recovers worker startup before marking the session expired", async () => {+ const { refreshTokensInWorker } = await import(+ "../refreshTokenSharedWorker"+ );+ const refreshRequests = vi.fn();+ let attempts = 0;+ class StartupWorker extends EventTarget {+ port = Object.assign(new EventTarget(), {+ start: vi.fn(),+ close: vi.fn(),+ postMessage: () => {+ refreshRequests();+ queueMicrotask(() =>+ this.port.dispatchEvent(new MessageEvent("message", { data: {} }))+ );+ },+ });+ constructor() {+ super();+ const fail = ++attempts === 1;+ queueMicrotask(() => {+ if (fail) this.dispatchEvent(new Event("error"));+ else {+ this.port.dispatchEvent(+ new MessageEvent("message", { data: { ready: true } })+ );+ }+ });+ }+ }+ vi.stubGlobal("SharedWorker", StartupWorker);+ mocks.refreshTokens.mockImplementation(refreshTokensInWorker);+ const next = vi+ .fn()+ .mockRejectedValueOnce(+ new ConnectError("access token not found", Code.Unauthenticated)+ )+ .mockResolvedValueOnce({ ok: true });+ try {+ await expect(authInterceptor(next)(createRequest())).resolves.toEqual({+ ok: true,+ });+ expect(attempts).toBe(2);+ expect(refreshRequests).toHaveBeenCalledTimes(1);+ expect(next).toHaveBeenCalledTimes(2);+ expect(mocks.authStore.unauthenticatedOccurred).toBe(false);+ expect(mocks.pushNotification).not.toHaveBeenCalled();+ } finally {+ vi.unstubAllGlobals();+ }+ });++ test.each([false, true])(+ "startup exhaustion preserves the session and later recovers (silent=%s)",+ async (silent) => {+ vi.resetModules();+ const { refreshTokensInWorker } = await import(+ "../refreshTokenSharedWorker"+ );+ const { authInterceptor: interceptor } = await import(+ "./authInterceptorMiddleware"+ );+ let attempts = 0;+ let available = false;+ const refreshRequests = vi.fn();+ class StartupWorker extends EventTarget {+ port = Object.assign(new EventTarget(), {+ start: vi.fn(),+ close: vi.fn(),+ postMessage: () => {+ refreshRequests();+ queueMicrotask(() =>+ this.port.dispatchEvent(new MessageEvent("message", { data: {} }))+ );+ },+ });+ constructor() {+ super();+ attempts++;+ queueMicrotask(() => {+ if (!available) this.dispatchEvent(new Event("error"));+ else+ this.port.dispatchEvent(+ new MessageEvent("message", { data: { ready: true } })+ );+ });+ }+ }+ vi.stubGlobal("SharedWorker", StartupWorker);+ mocks.refreshTokens.mockImplementation(refreshTokensInWorker);+ const next = vi+ .fn()+ .mockRejectedValue(+ new ConnectError("access token expired", Code.Unauthenticated)+ );+ try {+ for (let outage = 0; outage < 2; outage++) {+ await expect(+ interceptor(next)(createRequest({ silent }))+ ).rejects.toMatchObject({ code: Code.Unavailable });+ expect(mocks.authStore.unauthenticatedOccurred).toBe(false);+ expect(mocks.pushNotification).not.toHaveBeenCalled();+ expect(refreshRequests).not.toHaveBeenCalled();+ }+ expect(attempts).toBe(6);+ available = true;+ next+ .mockRejectedValueOnce(+ new ConnectError("access token expired", Code.Unauthenticated)+ )+ .mockResolvedValueOnce({ ok: true });+ await expect(+ interceptor(next)(createRequest({ silent }))+ ).resolves.toEqual({ ok: true });+ expect(refreshRequests).toHaveBeenCalledTimes(1);+ expect(mocks.authStore.unauthenticatedOccurred).toBe(false);+ expect(mocks.pushNotification).not.toHaveBeenCalled();+ } finally {+ vi.unstubAllGlobals();+ }+ }+ );+test("keeps silent unauthenticated refresh failures notification-free", async () => {const next = vi.fn()diff --git a/frontend/src/api/middlewares/authInterceptorMiddleware.ts b/frontend/src/api/middlewares/authInterceptorMiddleware.tsindex c31c35b7b7..49ead9934d 100644--- a/frontend/src/api/middlewares/authInterceptorMiddleware.ts+++ b/frontend/src/api/middlewares/authInterceptorMiddleware.ts@@ -14,6 +14,7 @@ import { PermissionDeniedDetailSchema } from "@/types/proto-es/v1/common_pb";import { appStoreUtilBridge } from "@/utils/app-store-bridge";import { ignoredCodesContextKey, silentContextKey } from "../context-key";import { refreshTokens } from "../refreshToken";+import { WorkerStartupError } from "../refreshTokenSharedWorker";const extractPermissionDeniedDetail = (error: unknown) => {if (error instanceof ConnectError) {@@ -92,6 +93,12 @@ export const authInterceptor: Interceptor = (next) => async (req) => {try {await refreshTokens();} catch (e) {+ if (e instanceof WorkerStartupError) {+ throw new ConnectError(+ "Session refresh temporarily unavailable",+ Code.Unavailable+ );+ }console.error(e);handleUnauthenticatedFailure({silent,diff --git a/frontend/src/api/refreshToken.test.ts b/frontend/src/api/refreshToken.test.tsnew file mode 100644index 0000000000..b7bed5bb06--- /dev/null+++ b/frontend/src/api/refreshToken.test.ts@@ -0,0 +1,46 @@+import { afterEach, beforeEach, expect, test, vi } from "vitest";++const mocks = vi.hoisted(() => ({ refresh: vi.fn(), workerRefresh: vi.fn() }));+vi.mock("@/api", () => ({+ authServiceClientConnect: { refresh: mocks.refresh },+}));+vi.mock("./refreshTokenSharedWorker", () => ({+ refreshTokensInWorker: mocks.workerRefresh,+}));++import { refreshTokens } from "./refreshToken";++beforeEach(() => {+ mocks.refresh.mockReset().mockResolvedValue({});+ mocks.workerRefresh.mockReset().mockResolvedValue(undefined);+});+afterEach(() => vi.unstubAllGlobals());++test("uses Web Locks when available without starting a SharedWorker", async () => {+ const request = vi.fn(+ (+ _name: string,+ _options: LockOptions,+ callback: (lock: Lock) => Promise<boolean>+ ) => callback({ name: "bb_token_refresh", mode: "exclusive" })+ );+ vi.stubGlobal("navigator", { locks: { request } });+ await refreshTokens();+ expect(request).toHaveBeenCalledTimes(1);+ expect(mocks.refresh).toHaveBeenCalledTimes(1);+ expect(mocks.workerRefresh).not.toHaveBeenCalled();+});++test("shares the SharedWorker fallback between callers without Web Locks", async () => {+ vi.stubGlobal("navigator", {});+ await Promise.all([refreshTokens(), refreshTokens()]);+ expect(mocks.workerRefresh).toHaveBeenCalledTimes(1);+ expect(mocks.refresh).not.toHaveBeenCalled();+});++test("propagates fallback errors without an uncoordinated retry", async () => {+ vi.stubGlobal("navigator", {});+ mocks.workerRefresh.mockRejectedValue(new Error("worker failed"));+ await expect(refreshTokens()).rejects.toThrow("worker failed");+ expect(mocks.refresh).not.toHaveBeenCalled();+});diff --git a/frontend/src/api/refreshToken.ts b/frontend/src/api/refreshToken.tsindex e15131dca5..33b6818d07 100644--- a/frontend/src/api/refreshToken.ts+++ b/frontend/src/api/refreshToken.ts@@ -1,4 +1,5 @@import { authServiceClientConnect } from "@/api";+import { refreshTokensInWorker } from "./refreshTokenSharedWorker";const LOCK_NAME = "bb_token_refresh";const CHANNEL_NAME = "bb_token_refresh";@@ -8,7 +9,7 @@ let localPromise: Promise<void> | null = null;/*** Refresh the access token using the refresh token cookie.- * Uses Web Lock API for cross-tab coordination.+ * Uses Web Locks for cross-tab coordination, or a SharedWorker on HTTP.* Only one tab performs the refresh; others wait for completion.*/export async function refreshTokens(): Promise<void> {@@ -39,6 +40,10 @@ async function doRefresh(): Promise<void> {}async function tryAcquireAndRefresh(): Promise<boolean> {+ if (!navigator.locks) {+ await refreshTokensInWorker();+ return true;+ }return navigator.locks.request(LOCK_NAME,{ ifAvailable: true },diff --git a/frontend/src/api/refreshToken.worker.test.ts b/frontend/src/api/refreshToken.worker.test.tsnew file mode 100644index 0000000000..13ae2474a0--- /dev/null+++ b/frontend/src/api/refreshToken.worker.test.ts@@ -0,0 +1,87 @@+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";++const mocks = vi.hoisted(() => ({ refresh: vi.fn() }));+vi.mock("@connectrpc/connect", () => ({ createClient: () => mocks }));+vi.mock("@connectrpc/connect-web", () => ({ createConnectTransport: vi.fn() }));++function connect() {+ const port = {+ onmessage: undefined as undefined | (() => Promise<void>),+ postMessage: vi.fn(),+ };+ (globalThis as unknown as { onconnect: (event: unknown) => void }).onconnect({+ ports: [port],+ });+ return port;+}++beforeEach(async () => {+ vi.resetModules();+ mocks.refresh.mockReset();+ await import("./refreshToken.worker");+});++afterEach(() => vi.useRealTimers());++describe("shared refresh worker", () => {+ test("lets a slow rotation finish without a client deadline", async () => {+ vi.useFakeTimers();+ const response = Promise.withResolvers<void>();+ mocks.refresh.mockReturnValue(response.promise);+ const a = connect();+ const first = a.onmessage!();+ expect(mocks.refresh).toHaveBeenCalledExactlyOnceWith({});+ await vi.advanceTimersByTimeAsync(40000);+ const b = connect();+ const second = b.onmessage!();+ expect(mocks.refresh).toHaveBeenCalledTimes(1);+ expect(a.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });+ expect(b.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });+ response.resolve();+ await Promise.all([first, second]);+ expect(a.postMessage).toHaveBeenLastCalledWith({});+ expect(b.postMessage).toHaveBeenLastCalledWith({});+ });++ test("two tabs share one request and a later refresh can rotate again", async () => {+ const response = Promise.withResolvers<void>();+ mocks.refresh+ .mockReturnValueOnce(response.promise)+ .mockResolvedValue(undefined);+ const a = connect();+ const b = connect();+ const first = a.onmessage!();+ const second = b.onmessage!();+ expect(mocks.refresh).toHaveBeenCalledTimes(1);+ expect(a.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });+ expect(b.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });+ response.resolve();+ await Promise.all([first, second]);+ expect(a.postMessage).toHaveBeenCalledWith({});+ expect(b.postMessage).toHaveBeenCalledWith({});+ await b.onmessage!();+ expect(mocks.refresh).toHaveBeenCalledTimes(2);+ });++ test("all waiting tabs receive a failed refresh and later calls can recover", async () => {+ const response = Promise.withResolvers<void>();+ mocks.refresh+ .mockReturnValueOnce(response.promise)+ .mockResolvedValue(undefined);+ const a = connect();+ const b = connect();+ const first = a.onmessage!();+ const second = b.onmessage!();+ response.reject(new Error("invalid refresh token"));+ await Promise.all([first, second]);+ expect(mocks.refresh).toHaveBeenCalledTimes(1);+ expect(a.postMessage).toHaveBeenCalledWith({+ error: "invalid refresh token",+ });+ expect(b.postMessage).toHaveBeenCalledWith({+ error: "invalid refresh token",+ });+ await a.onmessage!();+ expect(a.postMessage).toHaveBeenLastCalledWith({});+ });+});diff --git a/frontend/src/api/refreshToken.worker.ts b/frontend/src/api/refreshToken.worker.tsnew file mode 100644index 0000000000..052caab80b--- /dev/null+++ b/frontend/src/api/refreshToken.worker.ts@@ -0,0 +1,42 @@+import { createClient } from "@connectrpc/connect";+import { createConnectTransport } from "@connectrpc/connect-web";+import { AuthService } from "@/types/proto-es/v1/auth_service_pb";++const client = createClient(+ AuthService,+ createConnectTransport({+ baseUrl: import.meta.env.BB_GRPC_LOCAL || globalThis.location.origin,+ fetch: (input, init) => fetch(input, { ...init, credentials: "include" }),+ })+);++let pending: Promise<void> | undefined;++const scope = globalThis as unknown as {+ onconnect: (event: MessageEvent) => void;+};++scope.onconnect = (event) => {+ const port = event.ports[0];+ port.onmessage = async () => {+ // The worker owns the network request, so closing the initiating tab+ // does not hand an in-flight refresh to another tab.+ pending ??= client+ .refresh({})+ .then(() => {})+ .finally(() => {+ pending = undefined;+ });+ let result: { error?: string } = {};+ try {+ await pending;+ } catch (error) {+ result = {+ error:+ error instanceof Error ? error.message : "Session refresh failed",+ };+ }+ port.postMessage(result);+ };+ port.postMessage({ ready: true });+};diff --git a/frontend/src/api/refreshTokenSharedWorker.test.ts b/frontend/src/api/refreshTokenSharedWorker.test.tsnew file mode 100644index 0000000000..73763808d0--- /dev/null+++ b/frontend/src/api/refreshTokenSharedWorker.test.ts@@ -0,0 +1,162 @@+import { afterEach, beforeEach, expect, test, vi } from "vitest";++class TestWorker extends EventTarget {+ port = Object.assign(new EventTarget(), {+ start: vi.fn(),+ close: vi.fn(),+ postMessage: vi.fn(),+ });+}+let worker: TestWorker;+let construct: ReturnType<typeof vi.fn>;+let refreshTokensInWorker: typeof import("./refreshTokenSharedWorker").refreshTokensInWorker;++beforeEach(async () => {+ vi.resetModules();+ worker = new TestWorker();+ construct = vi.fn(function () {+ return worker;+ });+ vi.stubGlobal("SharedWorker", construct);+ ({ refreshTokensInWorker } = await import("./refreshTokenSharedWorker"));+});+afterEach(() => {+ vi.unstubAllGlobals();+ vi.useRealTimers();+});++function respond(data: { ready?: boolean; error?: string } = {}) {+ worker.port.dispatchEvent(new MessageEvent("message", { data }));+}++test("shares one request within a tab without Web Locks and reuses the worker", async () => {+ vi.stubGlobal("navigator", {});+ const a = refreshTokensInWorker();+ const b = refreshTokensInWorker();+ expect(a).toBe(b);+ expect(worker.port.postMessage).not.toHaveBeenCalled();+ respond({ ready: true });+ expect(worker.port.postMessage).toHaveBeenCalledTimes(1);+ respond();+ await Promise.all([a, b]);+ const c = refreshTokensInWorker();+ respond();+ await c;+ expect(construct).toHaveBeenCalledTimes(1);+ expect(worker.port.postMessage).toHaveBeenCalledTimes(2);+});++test("propagates authentication errors and can refresh after signing in again", async () => {+ const first = expect(refreshTokensInWorker()).rejects.toThrow(+ "invalid refresh token"+ );+ respond({ ready: true });+ respond({ error: "invalid refresh token" });+ await first;+ const next = refreshTokensInWorker();+ respond();+ await next;+});++test("worker failure after readiness prevents independent retries", async () => {+ const first = expect(refreshTokensInWorker()).rejects.toThrow(+ "worker failed"+ );+ respond({ ready: true });+ worker.dispatchEvent(new Event("error"));+ await first;+ await expect(refreshTokensInWorker()).rejects.toThrow("worker failed");+ expect(construct).toHaveBeenCalledTimes(1);+ expect(worker.port.postMessage).toHaveBeenCalledTimes(1);+});++test("slow startup leaves a full watchdog interval for refresh", async () => {+ vi.useFakeTimers();+ const first = refreshTokensInWorker();+ const rejected = vi.fn();+ void first.catch(rejected);+ await vi.advanceTimersByTimeAsync(34000);+ expect(worker.port.postMessage).not.toHaveBeenCalled();+ respond({ ready: true });+ await vi.advanceTimersByTimeAsync(34000);+ expect(rejected).not.toHaveBeenCalled();+ expect(worker.port.postMessage).toHaveBeenCalledExactlyOnceWith("refresh");+ respond();+ await first;+ const later = refreshTokensInWorker();+ respond();+ await later;+ expect(construct).toHaveBeenCalledTimes(1);+});++test("a silent worker times out without starting another refresh", async () => {+ vi.useFakeTimers();+ const first = expect(refreshTokensInWorker()).rejects.toThrow(+ "worker failed"+ );+ respond({ ready: true });+ await vi.advanceTimersByTimeAsync(35000);+ await first;+ respond();+ await expect(refreshTokensInWorker()).rejects.toThrow("worker failed");+ expect(worker.port.postMessage).toHaveBeenCalledTimes(1);+});++test("does not fall back to an uncoordinated refresh when SharedWorker is unavailable", async () => {+ vi.stubGlobal("SharedWorker", undefined);+ await expect(refreshTokensInWorker()).rejects.toThrow();+});++for (const failure of ["error", "timeout"] as const) {+ test(`startup ${failure} retries within the same shared refresh promise`, async () => {+ vi.useFakeTimers();+ const first = refreshTokensInWorker();+ const rejected = vi.fn();+ void first.catch(rejected);+ expect(refreshTokensInWorker()).toBe(first);+ const failedWorker = worker;+ if (failure === "error") {+ worker.dispatchEvent(new Event("error"));+ } else {+ await vi.advanceTimersByTimeAsync(35000);+ }+ expect(failedWorker.port.postMessage).not.toHaveBeenCalled();+ expect(failedWorker.port.close).toHaveBeenCalledTimes(1);+ worker = new TestWorker();+ await vi.advanceTimersByTimeAsync(250);+ expect(rejected).not.toHaveBeenCalled();+ expect(refreshTokensInWorker()).toBe(first);+ expect(construct).toHaveBeenCalledTimes(2);+ expect(worker.port.postMessage).not.toHaveBeenCalled();+ respond({ ready: true });+ expect(worker.port.postMessage).toHaveBeenCalledExactlyOnceWith("refresh");+ failedWorker.dispatchEvent(new Event("error"));+ respond();+ await first;+ expect(rejected).not.toHaveBeenCalled();+ const later = refreshTokensInWorker();+ respond();+ await later;+ expect(worker.port.postMessage).toHaveBeenCalledTimes(2);+ });+}++test("persistent startup failures reject after three attempts without refreshing", async () => {+ vi.useFakeTimers();+ const result = expect(refreshTokensInWorker()).rejects.toThrow(+ "worker failed"+ );+ const failedWorkers = [];+ for (let attempt = 1; attempt <= 3; attempt++) {+ failedWorkers.push(worker);+ worker.dispatchEvent(new Event("error"));+ worker = new TestWorker();+ await vi.advanceTimersByTimeAsync(250 * attempt);+ }+ await result;+ expect(construct).toHaveBeenCalledTimes(3);+ for (const failedWorker of failedWorkers) {+ expect(failedWorker.port.close).toHaveBeenCalledTimes(1);+ expect(failedWorker.port.postMessage).not.toHaveBeenCalled();+ }+});diff --git a/frontend/src/api/refreshTokenSharedWorker.ts b/frontend/src/api/refreshTokenSharedWorker.tsnew file mode 100644index 0000000000..7779e0e105--- /dev/null+++ b/frontend/src/api/refreshTokenSharedWorker.ts@@ -0,0 +1,116 @@+let worker: SharedWorker | undefined;+let workerError: Error | undefined;+let workerReady = false;+let localPromise: Promise<void> | null = null;++const WAIT_TIMEOUT_MS = 35000;+const STARTUP_ATTEMPTS = 3;+const STARTUP_RETRY_DELAY_MS = 250;++/** Startup failed before this caller dispatched a refresh request. */+export class WorkerStartupError extends Error {}++/** Refresh shared session cookies through the same worker in every tab. */+export function refreshTokensInWorker(): Promise<void> {+ if (localPromise) {+ return localPromise;+ }+ localPromise = refreshWithStartupRetry().finally(() => {+ localPromise = null;+ });+ return localPromise;+}++async function refreshWithStartupRetry(): Promise<void> {+ for (let attempt = 1; ; attempt++) {+ try {+ await refreshInWorker();+ return;+ } catch (error) {+ if (+ !(error instanceof WorkerStartupError) ||+ attempt >= STARTUP_ATTEMPTS+ ) {+ throw error;+ }+ // Keep transient startup failures inside the shared promise: callers+ // interpret a rejected refresh as an expired session.+ await new Promise((resolve) =>+ setTimeout(resolve, STARTUP_RETRY_DELAY_MS * attempt)+ );+ }+ }+}++async function refreshInWorker(): Promise<void> {+ if (workerError) throw workerError;+ if (!worker) {+ worker = new SharedWorker(+ new URL("./refreshToken.worker.ts", import.meta.url),+ {+ type: "module",+ name: "bb_token_refresh",+ }+ );+ const startingWorker = worker;+ worker.addEventListener("error", () => {+ if (worker === startingWorker && workerReady) {+ workerError = new Error("Session refresh worker failed");+ }+ });+ worker.port.start();+ }+ const currentWorker = worker;+ return new Promise<void>((resolve, reject) => {+ const cleanup = () => {+ clearTimeout(timeout);+ currentWorker.port.removeEventListener("message", onMessage);+ currentWorker.port.removeEventListener("messageerror", onFailure);+ currentWorker.removeEventListener("error", onFailure);+ };+ const onFailure = () => {+ cleanup();+ const error = new Error("Session refresh worker failed");+ if (workerReady) {+ workerError ??= error;+ } else {+ // No refresh was dispatched before readiness, so retrying startup is safe.+ currentWorker.port.close();+ worker = undefined;+ reject(new WorkerStartupError(error.message));+ return;+ }+ reject(workerError ?? error);+ };+ const sendRefresh = () => {+ clearTimeout(timeout);+ timeout = setTimeout(onFailure, WAIT_TIMEOUT_MS);+ try {+ currentWorker.port.postMessage("refresh");+ } catch {+ onFailure();+ }+ };+ const onMessage = (+ event: MessageEvent<{ ready?: boolean; error?: string }>+ ) => {+ if (event.data.ready) {+ if (!workerReady) {+ workerReady = true;+ sendRefresh();+ }+ return;+ }+ cleanup();+ if (event.data.error) reject(new Error(event.data.error));+ else resolve();+ };+ // After readiness, a timed-out worker may still be rotating cookies.+ // Retrying could reuse the consumed token.+ let timeout = setTimeout(onFailure, WAIT_TIMEOUT_MS);+ currentWorker.port.addEventListener("message", onMessage);+ currentWorker.port.addEventListener("messageerror", onFailure);+ currentWorker.addEventListener("error", onFailure);+ if (workerReady) sendRefresh();+ });+}diff --git a/frontend/vite.config.test.ts b/frontend/vite.config.test.tsnew file mode 100644index 0000000000..af1e06f449--- /dev/null+++ b/frontend/vite.config.test.ts@@ -0,0 +1,55 @@+// @vitest-environment node+import { fileURLToPath } from "node:url";+import { build } from "vite";+import { expect, test } from "vitest";+import config from "./vite.config";++test("refresh worker keeps its URL across builds with different worker contents", async () => {+ const bundles = [];+ for (const version of ["old", "new"]) {+ const result = await build({+ configFile: false,+ logLevel: "silent",+ resolve: config.resolve,+ worker: {+ ...config.worker,+ plugins: () => [+ {+ name: "worker-version-fixture",+ transform(code, id) {+ if (id.endsWith("/refreshToken.worker.ts")) {+ return `${code}\nconsole.info(${JSON.stringify(version)});`;+ }+ },+ },+ ],+ },+ build: {+ write: false,+ rollupOptions: {+ input: fileURLToPath(+ new URL("./src/api/refreshTokenSharedWorker.ts", import.meta.url)+ ),+ preserveEntrySignatures: "strict",+ },+ },+ });+ if (Array.isArray(result) || !("output" in result)) {+ throw new Error("Expected one production bundle");+ }+ bundles.push(result.output);+ }++ const workers = bundles.map((bundle) => {+ const worker = bundle.find(+ (output) => output.fileName === "refreshToken.worker.js"+ );+ expect(worker).toBeDefined();+ return worker;+ });+ expect(workers[0]).not.toEqual(workers[1]);+ const entries = bundles.map((bundle) =>+ bundle.find((output) => output.type === "chunk" && output.isEntry)+ );+ expect(entries[0]).toEqual(entries[1]);+});diff --git a/frontend/vite.config.ts b/frontend/vite.config.tsindex 8c9d0c68b0..1b471ec38a 100644--- a/frontend/vite.config.ts+++ b/frontend/vite.config.ts@@ -164,5 +164,15 @@ export default defineConfig({},worker: {format: "es",+ rollupOptions: {+ output: {+ // Old and new app tabs must connect to the same refresh coordinator.+ // Keep its URL stable and outside the immutable /assets/ cache.+ entryFileNames: (chunk) =>+ chunk.name === "refreshToken.worker"+ ? "refreshToken.worker.js"+ : "assets/[name]-[hash].js",+ },+ },},});