Email for professionals and teams
perf: deduplicate requests and bound session-scoped client caches (#149)
Tarun8a7ba96191e6
diff --git a/src/app/(dashboard)/dashboard-state.ts b/src/app/(dashboard)/dashboard-state.tsindex 6012e91..7f3dd05 100644--- a/src/app/(dashboard)/dashboard-state.ts+++ b/src/app/(dashboard)/dashboard-state.ts@@ -1,7 +1,7 @@"use client";import { useEffect, useLayoutEffect, useState } from "react";-import { authFetch } from "@/lib/auth/client";+import { fetchCurrentUser } from "@/hooks/use-current-user";import { readInitialAssistantPanelState, saveAssistantPanelState } from "./dashboard-state-utils";export function useDashboardState() {@@ -19,11 +19,9 @@ export function useDashboardState() {useEffect(() => {let cancelled = false;- void authFetch("/api/auth/me", { redirectOnUnauthorized: false }).then(async (response) => {- if (!response.ok) return;- const data = await response.json() as { user?: { id?: string } };- if (cancelled || !data.user?.id) return;- const prefix = `mailflare-dashboard:${data.user.id}`;+ void fetchCurrentUser().then((user) => {+ if (cancelled || !user?.id) return;+ const prefix = `mailflare-dashboard:${user.id}`;try {const savedOpen = localStorage.getItem(`${prefix}:assistant-open`);const savedFullSize = localStorage.getItem(`${prefix}:assistant-full-size`);diff --git a/src/app/(settings)/settings/import/utils.ts b/src/app/(settings)/settings/import/utils.tsindex a848c58..a3d439b 100644--- a/src/app/(settings)/settings/import/utils.ts+++ b/src/app/(settings)/settings/import/utils.ts@@ -1,5 +1,6 @@import { defaultTranslator, type Translator } from "@/lib/i18n/utils";import { authFetch } from "@/lib/auth/client";+import { getMailboxFolders, invalidateFolderCache } from "@/lib/folders/client";import type {ImapFormState,ImportFolderSummary,@@ -85,14 +86,12 @@ export async function ensureImportDestination(});const data = (await response.json()) as ImportFolderSummary & { error?: string };if (!response.ok) throw new Error(data.error ?? `Unable to create folder ${source.folderName}`);+ invalidateFolderCache();return `folder:${data.id}`;}async function fetchMailboxFolders(mailboxId: string): Promise<ImportFolderSummary[]> {- const params = new URLSearchParams({ mailboxId });- const response = await authFetch(`/api/folders?${params.toString()}`);- const data = (await response.json()) as { folders?: ImportFolderSummary[]; error?: string };- if (!response.ok) throw new Error(data.error ?? "Unable to load folders");+ const data = await getMailboxFolders<{ folders?: ImportFolderSummary[] }>(mailboxId);return data.folders ?? [];}diff --git a/src/components/dashboard-nav.tsx b/src/components/dashboard-nav.tsxindex f443b21..d2f7844 100644--- a/src/components/dashboard-nav.tsx+++ b/src/components/dashboard-nav.tsx@@ -33,7 +33,8 @@ import {import { Input } from "@/components/ui/input";import { Label } from "@/components/ui/label";import { useMessageCounts } from "@/hooks/use-message-counts";-import { authFetch } from "@/lib/auth/client";+import { AUTH_SESSION_CHANGED_EVENT, authFetch } from "@/lib/auth/client";+import { getMailboxFolders, invalidateFolderCache } from "@/lib/folders/client";import {DEFAULT_FOLDER_COLOR,FOLDER_COLOR_OPTIONS,@@ -162,6 +163,12 @@ export function DashboardNav({ className }: { className?: string }) {setFoldersOpen(readStorage(FOLDERS_OPEN_KEY, false));}, []);+ useEffect(() => {+ const reset = () => setFolders([]);+ window.addEventListener(AUTH_SESSION_CHANGED_EVENT, reset);+ return () => window.removeEventListener(AUTH_SESSION_CHANGED_EVENT, reset);+ }, []);+function toggleMore() {writeStorage(MORE_OPEN_KEY, !moreOpen);setMoreOpen(!moreOpen);@@ -187,11 +194,7 @@ export function DashboardNav({ className }: { className?: string }) {}let cancelled = false;- const params = new URLSearchParams({ mailboxId: selectedMailbox.id });- authFetch(`/api/folders?${params.toString()}`)- .then(- (response) => response.json() as Promise<{ folders?: CustomFolder[] }>,- )+ getMailboxFolders<{ folders?: CustomFolder[] }>(selectedMailbox.id).then((data) => {if (!cancelled) setFolders(data.folders ?? []);})@@ -221,6 +224,7 @@ export function DashboardNav({ className }: { className?: string }) {});if (!response.ok) return;const folder = (await response.json()) as CustomFolder;+ invalidateFolderCache();setFolders((items) =>[...items, folder].sort((a, b) => a.name.localeCompare(b.name)),);diff --git a/src/components/mailbox-selector.tsx b/src/components/mailbox-selector.tsxindex fcea224..8e1e625 100644--- a/src/components/mailbox-selector.tsx+++ b/src/components/mailbox-selector.tsx@@ -10,7 +10,7 @@ import { useSelectedMailbox } from "@/components/mailbox-provider";import { ProgressiveAvatarImage } from "@/components/progressive-avatar-image";import { isIdentityMailbox } from "@/components/mailbox-provider-utils";import { useMessageCounts } from "@/hooks/use-message-counts";-import { authFetch } from "@/lib/auth/client";+import { clearCurrentUserCache, fetchCurrentUser } from "@/hooks/use-current-user";import { getAvatarColorStyle } from "@/lib/avatar-colors";import { logoutClientSession } from "@/lib/auth/logout";import { fetchBrowserAccounts, switchBrowserAccount, type BrowserAccount } from "@/lib/auth/accounts-client";@@ -146,18 +146,20 @@ export function MailboxSelector({ initialUser }: MailboxSelectorProps = {}) {useDismissible(open, () => setOpen(false), ref);useEffect(() => {- authFetch("/api/auth/me", { redirectOnUnauthorized: false })- .then((response) => (response.ok ? response.json() : null))- .then((data) => {- const authData = data as { user?: MailboxSelectorUser } | null;- setUser(authData?.user ?? null);- setHasAvatar(!!authData?.user?.hasAvatar);+ let active = true;+ void fetchCurrentUser()+ .then((user) => {+ if (!active) return;+ setUser(user);+ setHasAvatar(!!user?.hasAvatar);})- .catch(() => setUser(null));+ .catch(() => { if (active) setUser(null); });+ return () => { active = false; };}, []);useEffect(() => {function onAvatarChanged(event: Event) {+ clearCurrentUserCache();const detail = (event as CustomEvent<ProfileAvatarChangedDetail>).detail;setAvatarUrl(detail?.url ?? getProfileAvatarUrl());setHasAvatar(true);@@ -179,6 +181,7 @@ export function MailboxSelector({ initialUser }: MailboxSelectorProps = {}) {useEffect(() => {function onNameChanged(event: Event) {+ clearCurrentUserCache();const { name } = (event as CustomEvent<ProfileNameChangedDetail>).detail;setUser((current) => current ? { ...current, name } : current);}diff --git a/src/components/messages/use-custom-folder-config.ts b/src/components/messages/use-custom-folder-config.tsindex 99c6c3c..6baf9bc 100644--- a/src/components/messages/use-custom-folder-config.ts+++ b/src/components/messages/use-custom-folder-config.ts@@ -3,7 +3,7 @@import { Folder } from "lucide-react";import { useEffect, useMemo, useState } from "react";import { useSelectedMailbox } from "@/components/mailbox-provider";-import { authFetch } from "@/lib/auth/client";+import { getMailboxFolders } from "@/lib/folders/client";import type { CustomFolderSummary } from "./custom-folder-config-types";import type { MessageFolderConfig } from "./types";@@ -14,10 +14,7 @@ export function useCustomFolderConfig(folderId: string): MessageFolderConfig {useEffect(() => {if (!selectedMailbox?.id) return;let cancelled = false;- const search = new URLSearchParams({ mailboxId: selectedMailbox.id });-- authFetch(`/api/folders?${search.toString()}`)- .then((response) => response.json() as Promise<{ folders?: CustomFolderSummary[] }>)+ getMailboxFolders<{ folders?: CustomFolderSummary[] }>(selectedMailbox.id).then((data) => {if (cancelled) return;const folder = data.folders?.find((item) => item.id === folderId);diff --git a/src/components/messages/use-mailbox-folders.ts b/src/components/messages/use-mailbox-folders.tsindex f7e110d..d62d61d 100644--- a/src/components/messages/use-mailbox-folders.ts+++ b/src/components/messages/use-mailbox-folders.ts@@ -1,29 +1,25 @@"use client";import { useEffect, useState } from "react";-import { authFetch } from "@/lib/auth/client";+import { getMailboxFolders } from "@/lib/folders/client";+import { getClientSessionToken } from "@/lib/auth/client";import type { CustomFolder } from "@/components/dashboard-nav-types";-// Shared across toolbars so reopening a menu shows the folders immediately instead of popping in.-const cache = new Map<string, CustomFolder[]>();-export function useMailboxFolders(mailboxId: string | undefined): CustomFolder[] {- const [fetched, setFetched] = useState<{ mailboxId: string; folders: CustomFolder[] } | null>(null);+ const [fetched, setFetched] = useState<{ mailboxId: string; sessionToken: string | null; folders: CustomFolder[] } | null>(null);useEffect(() => {if (!mailboxId) return;let cancelled = false;- authFetch(`/api/folders?${new URLSearchParams({ mailboxId }).toString()}`)- .then((response) => response.json() as Promise<{ folders?: CustomFolder[] }>)+ getMailboxFolders<{ folders?: CustomFolder[] }>(mailboxId).then((data) => {const folders = data.folders ?? [];- cache.set(mailboxId, folders);- if (!cancelled) setFetched({ mailboxId, folders });+ if (!cancelled) setFetched({ mailboxId, sessionToken: getClientSessionToken(), folders });}).catch(() => undefined);return () => { cancelled = true; };}, [mailboxId]);if (!mailboxId) return [];- return fetched?.mailboxId === mailboxId ? fetched.folders : cache.get(mailboxId) ?? [];+ return fetched?.mailboxId === mailboxId && fetched.sessionToken === getClientSessionToken() ? fetched.folders : [];}diff --git a/src/components/settings/inbox-rules-utils.ts b/src/components/settings/inbox-rules-utils.tsindex d1bc8cf..08080ba 100644--- a/src/components/settings/inbox-rules-utils.ts+++ b/src/components/settings/inbox-rules-utils.ts@@ -1,5 +1,6 @@import { defaultTranslator, type Translator } from "@/lib/i18n/utils";import { authFetch } from "@/lib/auth/client";+import { getMailboxFolders } from "@/lib/folders/client";import type { InboxRule, InboxRuleInput, InboxRulesResponse, RuleFoldersResponse } from "./inbox-rules-types";export async function fetchInboxRules(mailboxId: string): Promise<InboxRulesResponse> {@@ -9,9 +10,7 @@ export async function fetchInboxRules(mailboxId: string): Promise<InboxRulesResp}export async function fetchRuleFolders(mailboxId: string): Promise<RuleFoldersResponse> {- const params = new URLSearchParams({ mailboxId });- const response = await authFetch(`/api/folders?${params.toString()}`);- return (await response.json()) as RuleFoldersResponse;+ return getMailboxFolders<RuleFoldersResponse>(mailboxId);}export async function createInboxRule(input: InboxRuleInput) {diff --git a/src/lib/folders/client.ts b/src/lib/folders/client.tsnew file mode 100644index 0000000..33aa9f3--- /dev/null+++ b/src/lib/folders/client.ts@@ -0,0 +1,96 @@+"use client";++import { AUTH_SESSION_CHANGED_EVENT, authFetch, getClientSessionToken } from "@/lib/auth/client";++const CACHE_TTL_MS = 15_000;+const MAX_CACHE_ENTRIES = 32;+const MAX_INVALIDATION_RETRIES = 8;+const cache = new Map<string, { expiresAt: number; data: FolderListResponse }>();+const requests = new Map<string, Promise<FolderListResponse>>();+let epoch = 0;+let sessionEpoch = 0;+let listenersInstalled = false;++export type FolderListResponse = { folders?: unknown[]; error?: string };++function invalidate(): void {+ ++epoch;+ cache.clear();+ requests.clear();+}++function invalidateSession(): void {+ ++sessionEpoch;+ invalidate();+}++function installInvalidationListeners(): void {+ if (listenersInstalled || typeof window === "undefined") return;+ listenersInstalled = true;+ window.addEventListener(AUTH_SESSION_CHANGED_EVENT, invalidateSession);+ window.addEventListener("mailflare:messages-changed", invalidate);+ window.addEventListener("mailflare:folders-changed", invalidate);+}++export function invalidateFolderCache(): void {+ invalidate();+}++export async function getMailboxFolders<T extends FolderListResponse = FolderListResponse>(+ mailboxId: string,+): Promise<T> {+ installInvalidationListeners();+ const sessionToken = getClientSessionToken();+ const requestSessionEpoch = sessionEpoch;+ const key = `${sessionToken ?? ""}\u0000${mailboxId}`;+ for (let retries = 0; ; retries++) {+ if (sessionEpoch !== requestSessionEpoch || sessionToken !== getClientSessionToken()) {+ throw new Error("Folder request was invalidated");+ }+ const now = Date.now();+ const cached = cache.get(key);+ if (cached && cached.expiresAt > now) {+ cache.delete(key);+ cache.set(key, cached);+ return cached.data as T;+ }+ if (cached) cache.delete(key);++ const requestEpoch = epoch;+ let request = requests.get(key);+ if (!request) {+ request = (async () => {+ const params = new URLSearchParams({ mailboxId });+ const response = await authFetch(`/api/folders?${params.toString()}`, { cache: "no-store" });+ const data = (await response.json()) as FolderListResponse;+ if (!response.ok) throw new Error(data.error ?? "Unable to load folders");+ if (requestEpoch !== epoch || sessionEpoch !== requestSessionEpoch ||+ sessionToken !== getClientSessionToken() || requests.get(key) !== request) {+ throw new Error("Folder request was invalidated");+ }+ cache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS });+ if (cache.size > MAX_CACHE_ENTRIES) cache.delete(cache.keys().next().value!);+ return data;+ })();+ requests.set(key, request);+ }+ try {+ const data = await request;+ if (sessionEpoch !== requestSessionEpoch || sessionToken !== getClientSessionToken()) {+ throw new Error("Folder request was invalidated");+ }+ if (requestEpoch !== epoch) {+ if (retries >= MAX_INVALIDATION_RETRIES) throw new Error("Folder request was invalidated");+ continue;+ }+ return data as T;+ } catch (error) {+ if (sessionEpoch !== requestSessionEpoch || sessionToken !== getClientSessionToken()) {+ throw new Error("Folder request was invalidated");+ }+ if (requestEpoch === epoch || retries >= MAX_INVALIDATION_RETRIES) throw error;+ } finally {+ if (requests.get(key) === request) requests.delete(key);+ }+ }+}diff --git a/src/lib/messages/detail-cache.ts b/src/lib/messages/detail-cache.tsindex 09a2b8c..1eb7772 100644--- a/src/lib/messages/detail-cache.ts+++ b/src/lib/messages/detail-cache.ts@@ -1,42 +1,70 @@-import { authFetch } from "@/lib/auth/client";+import { AUTH_SESSION_CHANGED_EVENT, authFetch } from "@/lib/auth/client";import type { Message } from "@/hooks/types";import type { CachedMessageDetail } from "./detail-cache-types";-const detailCache = new Map<string, CachedMessageDetail>();+const CACHE_TTL_MS = 5 * 60_000;+const CACHE_LIMIT = 50;+const detailCache = new Map<string, { data: CachedMessageDetail; expiresAt: number }>();const detailRequests = new Map<string, Promise<CachedMessageDetail>>();+let generation = 0;++function cacheDetail(messageId: string, data: CachedMessageDetail) {+ detailCache.delete(messageId);+ detailCache.set(messageId, { data, expiresAt: Date.now() + CACHE_TTL_MS });+ if (detailCache.size > CACHE_LIMIT) {+ const oldest = detailCache.keys().next().value;+ if (oldest) detailCache.delete(oldest);+ }+}export function clearMessageDetailCache() {+ generation += 1;detailCache.clear();detailRequests.clear();}export function getCachedMessageDetail(messageId: string): CachedMessageDetail | undefined {- return detailCache.get(messageId);+ const cached = detailCache.get(messageId);+ if (!cached) return undefined;+ if (cached.expiresAt <= Date.now()) {+ detailCache.delete(messageId);+ return undefined;+ }+ detailCache.delete(messageId);+ detailCache.set(messageId, cached);+ return cached.data;}export function setCachedMessageRead(messageId: string, read: boolean): void {- const cached = detailCache.get(messageId);- if (cached?.message) detailCache.set(messageId, { ...cached, message: { ...cached.message, read } });+ const cached = getCachedMessageDetail(messageId);+ if (cached?.message) cacheDetail(messageId, { ...cached, message: { ...cached.message, read } });}export function primeMessageDetail(message: Message): void {if (message.textBody === undefined && message.htmlBody === undefined) return;- detailCache.set(message.id, {+ cacheDetail(message.id, {message,body: { textBody: message.textBody ?? null, htmlBody: message.htmlBody ?? null },});}export async function fetchCachedMessageDetail(messageId: string, force = false): Promise<CachedMessageDetail> {- if (!force && detailCache.has(messageId)) return detailCache.get(messageId) ?? {};- if (!force && detailRequests.has(messageId)) return detailRequests.get(messageId) ?? {};- const request = authFetch(`/api/messages/${messageId}`)- .then((response) => response.json() as Promise<CachedMessageDetail>)- .then((data) => {- detailCache.set(messageId, data);+ const cached = getCachedMessageDetail(messageId);+ if (!force && cached) return cached;+ if (detailRequests.has(messageId)) return detailRequests.get(messageId) ?? {};+ const requestGeneration = generation;+ const request = authFetch(`/api/messages/${messageId}`, { cache: "no-store" })+ .then(async (response) => {+ const data = await response.json() as CachedMessageDetail;+ if (requestGeneration !== generation) throw new Error("Message request invalidated");+ if (response.ok && !data.error) cacheDetail(messageId, data);return data;})- .finally(() => detailRequests.delete(messageId));+ .finally(() => { if (detailRequests.get(messageId) === request) detailRequests.delete(messageId); });detailRequests.set(messageId, request);return request;}++if (typeof window !== "undefined") {+ window.addEventListener(AUTH_SESSION_CHANGED_EVENT, clearMessageDetailCache);+}diff --git a/tests/folder-client-cache.test.mjs b/tests/folder-client-cache.test.mjsnew file mode 100644index 0000000..baa30d0--- /dev/null+++ b/tests/folder-client-cache.test.mjs@@ -0,0 +1,216 @@+import assert from "node:assert/strict";+import { mkdtempSync, rmSync } from "node:fs";+import { dirname, join } from "node:path";+import { fileURLToPath, pathToFileURL } from "node:url";+import test, { after } from "node:test";+import { build } from "esbuild";+import { JSDOM } from "jsdom";++const project = join(dirname(fileURLToPath(import.meta.url)), "..");+const directory = mkdtempSync(join(project, "node_modules", "folder-client-test-"));+after(() => rmSync(directory, { recursive: true, force: true }));+await build({+ entryPoints: [join(project, "src/lib/folders/client.ts")],+ outfile: join(directory, "client.mjs"), bundle: true, platform: "node", format: "esm", logLevel: "silent",+ plugins: [{ name: "mock-auth", setup(builder) {+ builder.onResolve({ filter: /^@\/lib\/auth\/client$/ }, () => ({ path: "auth", namespace: "mock" }));+ builder.onLoad({ filter: /.*/, namespace: "mock" }, () => ({+ contents: `export const AUTH_SESSION_CHANGED_EVENT = "auth-changed"; export function getClientSessionToken(){return globalThis.sessionToken ?? null;} export function authFetch(...args){return globalThis.folderFetch(...args);}`,+ loader: "js",+ }));+ } }],+});+const clientUrl = pathToFileURL(join(directory, "client.mjs")).href;+let client;+let dom;+let now;+let originalNow;++function response(folders = []) { return { ok: true, json: async () => ({ folders }) }; }+async function setup() {+ dom = new JSDOM("<!doctype html>");+ globalThis.window = dom.window;+ globalThis.sessionToken = "account-a";+ globalThis.folderFetch = async (_url, options) => { assert.equal(options.cache, "no-store"); return response([{ id: "f1" }]); };+ originalNow = Date.now;+ now = 1_000;+ Date.now = () => now;+ client = await import(`${clientUrl}?run=${Math.random()}`);+}+function cleanup() {+ Date.now = originalNow;+ dom.window.close();+ delete globalThis.window;+ delete globalThis.sessionToken;+ delete globalThis.folderFetch;+}++test("concurrent callers share one no-store fetch and successful data hits the short cache", async () => {+ await setup();+ try {+ let calls = 0;+ globalThis.folderFetch = async () => { calls++; await Promise.resolve(); return response([{ id: "f1" }]); };+ const [a, b] = await Promise.all([client.getMailboxFolders("mb1"), client.getMailboxFolders("mb1")]);+ assert.deepEqual(a, b);+ assert.equal(calls, 1);+ await client.getMailboxFolders("mb1");+ assert.equal(calls, 1);+ } finally { cleanup(); }+});++test("cache expires after 15 seconds", async () => {+ await setup();+ try {+ let calls = 0;+ globalThis.folderFetch = async () => { calls++; return response(); };+ await client.getMailboxFolders("mb1");+ now += 15_001;+ await client.getMailboxFolders("mb1");+ assert.equal(calls, 2);+ } finally { cleanup(); }+});++test("cache evicts its oldest entry after 32 mailbox entries", async () => {+ await setup();+ try {+ let calls = 0;+ globalThis.folderFetch = async () => { calls++; return response(); };+ for (let index = 0; index < 33; index++) await client.getMailboxFolders(`mb${index}`);+ await client.getMailboxFolders("mb0");+ assert.equal(calls, 34);+ } finally { cleanup(); }+});++test("session and event invalidation reject stale responses without disturbing a newer request", async () => {+ await setup();+ try {+ let resolveOld;+ globalThis.folderFetch = () => new Promise(resolve => { resolveOld = resolve; });+ const old = client.getMailboxFolders("mb1");+ await Promise.resolve();+ globalThis.sessionToken = "account-b";+ window.dispatchEvent(new window.Event("auth-changed"));+ let resolveNew;+ globalThis.folderFetch = () => new Promise(resolve => { resolveNew = resolve; });+ const fresh = client.getMailboxFolders("mb1");+ await Promise.resolve();+ resolveOld(response([{ id: "old" }]));+ await assert.rejects(old, /invalidated/);+ resolveNew(response([{ id: "new" }]));+ assert.deepEqual((await fresh).folders, [{ id: "new" }]);+ assert.deepEqual((await client.getMailboxFolders("mb1")).folders, [{ id: "new" }]);+ } finally { cleanup(); }+});++test("messages and folders events invalidate in-flight and cached data", async () => {+ await setup();+ try {+ let calls = 0;+ globalThis.folderFetch = async () => { calls++; return response([{ id: String(calls) }]); };+ await client.getMailboxFolders("mb1");+ window.dispatchEvent(new window.Event("mailflare:messages-changed"));+ await client.getMailboxFolders("mb1");+ window.dispatchEvent(new window.Event("mailflare:folders-changed"));+ await client.getMailboxFolders("mb1");+ assert.equal(calls, 3);+ } finally { cleanup(); }+});++test("pending callers receive fresh folders after a messages event", async () => {+ await setup();+ try {+ const resolvers = [];+ globalThis.folderFetch = () => new Promise(resolve => { resolvers.push(resolve); });+ const first = client.getMailboxFolders("mb1");+ const second = client.getMailboxFolders("mb1");+ assert.equal(resolvers.length, 1);+ window.dispatchEvent(new window.Event("mailflare:messages-changed"));+ resolvers[0](response([{ id: "stale" }]));+ await new Promise(resolve => setImmediate(resolve));+ assert.equal(resolvers.length, 2);+ resolvers[1](response([{ id: "fresh" }]));+ assert.deepEqual((await first).folders, [{ id: "fresh" }]);+ assert.deepEqual((await second).folders, [{ id: "fresh" }]);+ assert.equal(resolvers.length, 2);+ } finally { cleanup(); }+});++for (const invalidation of ["mailflare:folders-changed", "explicit invalidation"]) {+ test(`pending caller retries after ${invalidation}`, async () => {+ await setup();+ try {+ const resolvers = [];+ globalThis.folderFetch = () => new Promise(resolve => { resolvers.push(resolve); });+ const pending = client.getMailboxFolders("mb1");+ if (invalidation === "explicit invalidation") client.invalidateFolderCache();+ else window.dispatchEvent(new window.Event(invalidation));+ resolvers[0](response([{ id: "stale" }]));+ await new Promise(resolve => setImmediate(resolve));+ assert.equal(resolvers.length, 2);+ resolvers[1](response([{ id: "fresh" }]));+ assert.deepEqual((await pending).folders, [{ id: "fresh" }]);+ } finally { cleanup(); }+ });+}++test("a stale caller joins the replacement request without overwriting it", async () => {+ await setup();+ try {+ const resolvers = [];+ globalThis.folderFetch = () => new Promise(resolve => { resolvers.push(resolve); });+ const staleCaller = client.getMailboxFolders("mb1");+ window.dispatchEvent(new window.Event("mailflare:messages-changed"));+ const freshCaller = client.getMailboxFolders("mb1");+ assert.equal(resolvers.length, 2);+ resolvers[0](response([{ id: "stale" }]));+ await new Promise(resolve => setImmediate(resolve));+ assert.equal(resolvers.length, 2);+ resolvers[1](response([{ id: "fresh" }]));+ assert.deepEqual((await staleCaller).folders, [{ id: "fresh" }]);+ assert.deepEqual((await freshCaller).folders, [{ id: "fresh" }]);+ assert.deepEqual((await client.getMailboxFolders("mb1")).folders, [{ id: "fresh" }]);+ } finally { cleanup(); }+});++test("session event rejects an old request even when its token has not changed yet", async () => {+ await setup();+ try {+ let resolveOld;+ globalThis.folderFetch = () => new Promise(resolve => { resolveOld = resolve; });+ const old = client.getMailboxFolders("mb1");+ window.dispatchEvent(new window.Event("auth-changed"));+ resolveOld(response([{ id: "old" }]));+ await assert.rejects(old, /invalidated/);+ } finally { cleanup(); }+});++test("continuous invalidation has a bounded retry count", async () => {+ await setup();+ try {+ let calls = 0;+ globalThis.folderFetch = async () => ({+ ok: true,+ json: async () => {+ calls++;+ window.dispatchEvent(new window.Event("mailflare:messages-changed"));+ return { folders: [{ id: String(calls) }] };+ },+ });+ await assert.rejects(client.getMailboxFolders("mb1"), /invalidated/);+ assert.equal(calls, 9);+ } finally { cleanup(); }+});++test("failed responses are not cached and explicit mutation invalidation clears cache", async () => {+ await setup();+ try {+ let calls = 0;+ globalThis.folderFetch = async () => { calls++; return calls === 1 ? { ok: false, json: async () => ({ error: "failed" }) } : response(); };+ await assert.rejects(client.getMailboxFolders("mb1"), /failed/);+ await client.getMailboxFolders("mb1");+ assert.equal(calls, 2);+ client.invalidateFolderCache();+ await client.getMailboxFolders("mb1");+ assert.equal(calls, 3);+ } finally { cleanup(); }+});diff --git a/tests/message-detail-cache.test.mjs b/tests/message-detail-cache.test.mjsnew file mode 100644index 0000000..d6dfaf8--- /dev/null+++ b/tests/message-detail-cache.test.mjs@@ -0,0 +1,83 @@+import assert from "node:assert/strict";+import { mkdtempSync, rmSync } from "node:fs";+import { dirname, join } from "node:path";+import { fileURLToPath, pathToFileURL } from "node:url";+import test, { after } from "node:test";+import { build } from "esbuild";++const project = join(dirname(fileURLToPath(import.meta.url)), "..");+const temporary = mkdtempSync(join(project, "node_modules", "detail-cache-test-"));+const target = join(temporary, "cache.mjs");+await build({+ entryPoints: [join(project, "src/lib/messages/detail-cache.ts")], outfile: target,+ bundle: true, platform: "node", format: "esm", packages: "external", logLevel: "silent",+ plugins: [{ name: "test-auth", setup(builder) {+ builder.onResolve({ filter: /^@\/lib\/auth\/client$/ }, () => ({ path: "auth", namespace: "mock" }));+ builder.onLoad({ filter: /.*/, namespace: "mock" }, () => ({+ contents: "export const AUTH_SESSION_CHANGED_EVENT='session-changed';export function authFetch(...args){return globalThis.detailFetch(...args)}", loader: "js",+ }));+ } }],+});+const cache = await import(pathToFileURL(target).href);+const data = id => ({ message: { id, read: false }, body: { textBody: id, htmlBody: null } });+const response = (value, ok = true) => ({ ok, json: async () => value });+after(() => { rmSync(temporary, { recursive: true, force: true }); delete globalThis.detailFetch; });++test("concurrent detail and forced refresh callers share one request; cached reopen needs none", async () => {+ cache.clearMessageDetailCache(); let resolve; let requests = 0;+ globalThis.detailFetch = (url, init) => {+ requests++; assert.equal(init.cache, "no-store");+ return new Promise(done => { resolve = done; });+ };+ const first = cache.fetchCachedMessageDetail("one");+ const second = cache.fetchCachedMessageDetail("one", true);+ assert.equal(requests, 1);+ resolve(response(data("one")));+ assert.deepEqual(await first, await second);+ assert.deepEqual(await cache.fetchCachedMessageDetail("one"), data("one"));+ assert.equal(requests, 1);+});++test("cache invalidation blocks old account data and preserves a newer pending request", async () => {+ cache.clearMessageDetailCache(); let resolveOld, resolveNew; let requests = 0;+ globalThis.detailFetch = () => new Promise(done => { requests++; resolveOld = done; });+ const old = cache.fetchCachedMessageDetail("one");+ const rejected = assert.rejects(old, /invalidated/);+ cache.clearMessageDetailCache();+ globalThis.detailFetch = () => new Promise(done => { requests++; resolveNew = done; });+ const fresh = cache.fetchCachedMessageDetail("one");+ resolveOld(response(data("old"))); await rejected;+ assert.equal(cache.getCachedMessageDetail("one"), undefined);+ const concurrent = cache.fetchCachedMessageDetail("one");+ assert.equal(requests, 2);+ resolveNew(response(data("new")));+ assert.deepEqual(await concurrent, await fresh);+ assert.equal(cache.getCachedMessageDetail("one").message.id, "new");+});++test("failed HTTP responses and network errors are retried rather than cached", async () => {+ cache.clearMessageDetailCache(); let requests = 0;+ globalThis.detailFetch = async () => { requests++; return response({ error: "Forbidden" }, false); };+ await cache.fetchCachedMessageDetail("one"); await cache.fetchCachedMessageDetail("one");+ assert.equal(requests, 2); assert.equal(cache.getCachedMessageDetail("one"), undefined);+ globalThis.detailFetch = async () => { throw new Error("offline"); };+ await assert.rejects(cache.fetchCachedMessageDetail("one"), /offline/);+ globalThis.detailFetch = async () => response(data("one"));+ assert.equal((await cache.fetchCachedMessageDetail("one")).message.id, "one");+});++test("details expire after five minutes; storage is bounded and read-state updates still work", async () => {+ cache.clearMessageDetailCache(); const now = Date.now; let time = 1000;+ Date.now = () => time;+ try {+ globalThis.detailFetch = async () => response(data("one"));+ await cache.fetchCachedMessageDetail("one");+ cache.setCachedMessageRead("one", true);+ assert.equal(cache.getCachedMessageDetail("one").message.read, true);+ time += 300_001;+ assert.equal(cache.getCachedMessageDetail("one"), undefined);+ for (let index = 0; index < 51; index++) cache.primeMessageDetail({ id: String(index), textBody: "body" });+ assert.equal(cache.getCachedMessageDetail("0"), undefined);+ assert.equal(cache.getCachedMessageDetail("50").body.textBody, "body");+ } finally { Date.now = now; }+});