Skip to content

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.ts
index 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.ts
index 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.tsx
index 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.mjs
new file mode 100644
index 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.mjs
new file mode 100644
index 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; }
+});