Skip to content

Email for professionals and teams

improve jmap

Hieu Nguyen (Jack)20a941bba6ca
diff --git a/drizzle/migrations/0042_add_jmap_mailbox_revisions.sql b/drizzle/migrations/0042_add_jmap_mailbox_revisions.sql
new file mode 100644
index 0000000..abe039b
--- /dev/null
+++ b/drizzle/migrations/0042_add_jmap_mailbox_revisions.sql
@@ -0,0 +1,77 @@
+CREATE TABLE `jmap_mailbox_revisions` (
+ `mailbox_id` text PRIMARY KEY NOT NULL,
+ `revision` integer NOT NULL DEFAULT 0
+);
+
+CREATE INDEX `mailboxes_user_idx` ON `mailboxes` (`user_id`);
+
+CREATE TRIGGER `jmap_messages_ai` AFTER INSERT ON `messages`
+WHEN NEW.mailbox_id IS NOT NULL BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_messages_au` AFTER UPDATE ON `messages`
+WHEN NEW.mailbox_id IS NOT NULL BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_messages_au_old` AFTER UPDATE OF mailbox_id ON `messages`
+WHEN OLD.mailbox_id IS NOT NULL AND OLD.mailbox_id IS NOT NEW.mailbox_id BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (OLD.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_messages_ad` AFTER DELETE ON `messages`
+WHEN OLD.mailbox_id IS NOT NULL BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (OLD.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_folders_ai` AFTER INSERT ON `folders` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_folders_au` AFTER UPDATE ON `folders` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_folders_au_old` AFTER UPDATE OF mailbox_id ON `folders`
+WHEN OLD.mailbox_id IS NOT NEW.mailbox_id BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (OLD.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_folders_ad` AFTER DELETE ON `folders` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (OLD.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_mailboxes_au` AFTER UPDATE ON `mailboxes` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_mailbox_aliases_ai` AFTER INSERT ON `mailbox_aliases` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_mailbox_aliases_au` AFTER UPDATE ON `mailbox_aliases` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (NEW.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_mailbox_aliases_au_old` AFTER UPDATE OF mailbox_id ON `mailbox_aliases`
+WHEN OLD.mailbox_id IS NOT NEW.mailbox_id BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (OLD.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
+
+CREATE TRIGGER `jmap_mailbox_aliases_ad` AFTER DELETE ON `mailbox_aliases` BEGIN
+ INSERT INTO jmap_mailbox_revisions (mailbox_id, revision) VALUES (OLD.mailbox_id, 1)
+ ON CONFLICT(mailbox_id) DO UPDATE SET revision = revision + 1;
+END;
diff --git a/server/runtime/env.ts b/server/runtime/env.ts
index 0bc0a9a..8f0bae6 100644
--- a/server/runtime/env.ts
+++ b/server/runtime/env.ts
@@ -68,6 +68,7 @@ export function createNodeRuntime(): NodeRuntime {
APP_URL: optional("APP_URL")?.replace(/\/$/, ""),
INBOUND_WEBHOOK_SECRET: optional("INBOUND_WEBHOOK_SECRET"),
} as unknown as CloudflareEnv;
+ realtime.bindEnv(env);
return {
env,
diff --git a/server/runtime/realtime.ts b/server/runtime/realtime.ts
index 9242b06..f2e8715 100644
--- a/server/runtime/realtime.ts
+++ b/server/runtime/realtime.ts
@@ -1,4 +1,6 @@
import type { WebSocket } from "ws";
+import { getUserMailRevision } from "@/lib/realtime/revision";
+import type { RevisionPing, RevisionNotification } from "@/lib/realtime/types";
/**
* Per-user WebSocket fan-out, standing in for the RealtimeHub Durable
@@ -8,13 +10,30 @@ import type { WebSocket } from "ws";
*/
export class RealtimeHubRegistry {
private readonly sockets = new Map<string, Set<WebSocket>>();
+ private env: CloudflareEnv | null = null;
+
+ bindEnv(env: CloudflareEnv) {
+ this.env = env;
+ }
attach(userId: string, socket: WebSocket) {
const set = this.sockets.get(userId) ?? new Set();
set.add(socket);
this.sockets.set(userId, set);
socket.on("message", (data) => {
- if (data.toString() === "ping") socket.send("pong");
+ const message = data.toString();
+ if (message === "ping") {
+ socket.send("pong");
+ return;
+ }
+ void (async () => {
+ let ping: RevisionPing;
+ try { ping = JSON.parse(message) as RevisionPing; } catch { return; }
+ if (ping.type !== "ping" || !this.env) return;
+ const revision = await getUserMailRevision(this.env, userId);
+ const notification: RevisionNotification = { type: "revision", revision, changed: ping.revision !== null && ping.revision !== revision };
+ socket.send(JSON.stringify(notification));
+ })().catch(() => socket.close(1011, "Revision lookup failed"));
});
socket.on("close", () => {
set.delete(socket);
diff --git a/src/components/dashboard-nav.tsx b/src/components/dashboard-nav.tsx
index c1bdc7b..7fdb01c 100644
--- a/src/components/dashboard-nav.tsx
+++ b/src/components/dashboard-nav.tsx
@@ -182,7 +182,7 @@ export function DashboardNav({ className }: { className?: string }) {
{minimal && <hr className="mx-3 my-2 border-neutral-200/70" />}
{!minimal && (
<div className="mt-2 flex h-8 items-center justify-between px-3">
- <span className="text-xs font-medium uppercase tracking-wide text-neutral-400">
+ <span className="font-medium tracking-wide text-neutral-900 text-sm">
Folders
</span>
{selectedMailbox && (
diff --git a/src/components/messages/use-message-thread.ts b/src/components/messages/use-message-thread.ts
index e14bb85..bdf5e29 100644
--- a/src/components/messages/use-message-thread.ts
+++ b/src/components/messages/use-message-thread.ts
@@ -11,6 +11,7 @@ export function useMessageThread(messageId: string, threadId: string | null | un
useEffect(() => {
if (!threadId) return;
let cancelled = false;
+ let refreshTimer: number | null = null;
async function load() {
setLoading(true);
try {
@@ -24,10 +25,19 @@ export function useMessageThread(messageId: string, threadId: string | null | un
}
}
void load();
- window.addEventListener("mailflare:messages-changed", load);
+ function scheduleLoad() {
+ if (document.visibilityState !== "visible") return;
+ if (refreshTimer) window.clearTimeout(refreshTimer);
+ refreshTimer = window.setTimeout(() => {
+ refreshTimer = null;
+ void load();
+ }, 150);
+ }
+ window.addEventListener("mailflare:messages-changed", scheduleLoad);
return () => {
cancelled = true;
- window.removeEventListener("mailflare:messages-changed", load);
+ window.removeEventListener("mailflare:messages-changed", scheduleLoad);
+ if (refreshTimer) window.clearTimeout(refreshTimer);
};
}, [messageId, threadId]);
diff --git a/src/db/schema/index.ts b/src/db/schema/index.ts
index 84fdb19..4543cb0 100644
--- a/src/db/schema/index.ts
+++ b/src/db/schema/index.ts
@@ -77,7 +77,7 @@ export const mailboxes = sqliteTable(
.notNull()
.$defaultFn(() => new Date()),
},
- (t) => [uniqueIndex("mailboxes_address_idx").on(t.domainId, t.localPart)],
+ (t) => [uniqueIndex("mailboxes_address_idx").on(t.domainId, t.localPart), index("mailboxes_user_idx").on(t.userId)],
);
export const mailboxAliases = sqliteTable(
@@ -190,6 +190,11 @@ export const folders = sqliteTable(
],
);
+export const jmapMailboxRevisions = sqliteTable("jmap_mailbox_revisions", {
+ mailboxId: text("mailbox_id").primaryKey(),
+ revision: integer("revision").notNull().default(0),
+});
+
export const apiKeys = sqliteTable("api_keys", {
id: text("id").primaryKey(),
kind: text("kind", { enum: ["legacy", "mcp"] }).notNull().default("legacy"),
diff --git a/src/hooks/message-realtime-types.d.ts b/src/hooks/message-realtime-types.d.ts
index 69a73fa..942e0da 100644
--- a/src/hooks/message-realtime-types.d.ts
+++ b/src/hooks/message-realtime-types.d.ts
@@ -11,3 +11,9 @@ export interface MessageRealtimeState {
dismissNotification: () => void;
notification: NewMessageEvent | null;
}
+
+export type RealtimeChannelMessage =
+ | { type: "status"; connected: boolean }
+ | { type: "status_request" }
+ | { type: "notification"; payload: string }
+ | { type: "refresh" };
diff --git a/src/hooks/use-message-counts.ts b/src/hooks/use-message-counts.ts
index a84268e..ef28244 100644
--- a/src/hooks/use-message-counts.ts
+++ b/src/hooks/use-message-counts.ts
@@ -2,6 +2,8 @@ import { useEffect, useState } from "react";
import type { MessageCounts, MessageCountsDelta } from "./types";
import { clearMessageCountsCache, fetchMessageCounts } from "./utils";
+const REFRESH_DEBOUNCE_MS = 150;
+
const emptyCounts: MessageCounts = {
folders: {
inbox: { total: 0, unread: 0 },
@@ -28,21 +30,29 @@ export function useMessageCounts(mailboxId?: string | null, enabled = true) {
}
let cancelled = false;
+ let refreshTimer: number | null = null;
+ let requestNumber = 0;
async function loadCounts(force = false) {
+ const currentRequest = ++requestNumber;
setIsLoading(true);
try {
const nextCounts = await fetchMessageCounts(mailboxId, force);
- if (!cancelled) setCounts(nextCounts ?? emptyCounts);
+ if (!cancelled && currentRequest === requestNumber) setCounts(nextCounts ?? emptyCounts);
} finally {
- if (!cancelled) setIsLoading(false);
+ if (!cancelled && currentRequest === requestNumber) setIsLoading(false);
}
}
void loadCounts();
function onMessagesChanged() {
clearMessageCountsCache();
- void loadCounts(true);
+ if (document.visibilityState !== "visible") return;
+ if (refreshTimer) window.clearTimeout(refreshTimer);
+ refreshTimer = window.setTimeout(() => {
+ refreshTimer = null;
+ void loadCounts(true);
+ }, REFRESH_DEBOUNCE_MS);
}
function onMessageCountsDelta(event: Event) {
const detail = (event as CustomEvent<MessageCountsDelta>).detail;
@@ -61,14 +71,13 @@ export function useMessageCounts(mailboxId?: string | null, enabled = true) {
window.addEventListener("mailflare:messages-changed", onMessagesChanged);
window.addEventListener("mailflare:message-counts-changed", onMessagesChanged);
window.addEventListener("mailflare:message-counts-delta", onMessageCountsDelta);
- const refreshInterval = window.setInterval(() => void loadCounts(true), 15_000);
return () => {
cancelled = true;
window.removeEventListener("mailflare:messages-changed", onMessagesChanged);
window.removeEventListener("mailflare:message-counts-changed", onMessagesChanged);
window.removeEventListener("mailflare:message-counts-delta", onMessageCountsDelta);
- window.clearInterval(refreshInterval);
+ if (refreshTimer) window.clearTimeout(refreshTimer);
};
}, [enabled, mailboxId]);
diff --git a/src/hooks/use-message-polling.ts b/src/hooks/use-message-polling.ts
index 8edccd5..893fbab 100644
--- a/src/hooks/use-message-polling.ts
+++ b/src/hooks/use-message-polling.ts
@@ -6,6 +6,7 @@ import {
import type {
MessageRealtimeState,
NewMessageEvent,
+ RealtimeChannelMessage,
} from "./message-realtime-types";
import {
getRealtimeWebSocketUrl,
@@ -22,36 +23,83 @@ export function useMessagePolling(): MessageRealtimeState {
useEffect(() => {
let socket: WebSocket | null = null;
+ let channel: BroadcastChannel | null = null;
+ let lockAbort: AbortController | null = null;
+ let releaseLeader: (() => void) | null = null;
let reconnectTimer: number | null = null;
let heartbeatTimer: number | null = null;
let fallbackTimer: number | null = null;
let reconnectAttempt = 0;
+ let revision: string | null = null;
+ let connected = false;
+ let leader = false;
+ let sessionToken = getClientSessionToken();
let stopped = false;
function dispatchMessagesChanged() {
- window.dispatchEvent(new Event("mailflare:messages-changed"));
+ window.dispatchEvent(new CustomEvent("mailflare:messages-changed", { detail: { realtime: true } }));
}
function clearConnectionTimers() {
if (reconnectTimer) window.clearTimeout(reconnectTimer);
if (heartbeatTimer) window.clearInterval(heartbeatTimer);
- if (fallbackTimer) window.clearInterval(fallbackTimer);
reconnectTimer = null;
heartbeatTimer = null;
- fallbackTimer = null;
}
function startFallbackRefresh() {
if (fallbackTimer) return;
- fallbackTimer = window.setInterval(
- dispatchMessagesChanged,
- REALTIME_FALLBACK_INTERVAL_MS,
- );
+ fallbackTimer = window.setInterval(() => {
+ if (!connected && document.visibilityState === "visible") dispatchMessagesChanged();
+ }, REALTIME_FALLBACK_INTERVAL_MS);
+ }
+
+ function setConnected(value: boolean) {
+ connected = value;
+ if (value) {
+ if (fallbackTimer) window.clearInterval(fallbackTimer);
+ fallbackTimer = null;
+ } else {
+ startFallbackRefresh();
+ }
+ if (leader) channel?.postMessage({ type: "status", connected: value } satisfies RealtimeChannelMessage);
+ }
+
+ function handleNotification(payload: string, fromSocket: boolean) {
+ try {
+ const parsed = JSON.parse(payload) as { type?: string; revision?: string; changed?: boolean; draftId?: string; mailboxId?: string };
+ if (parsed.type === "revision" && typeof parsed.revision === "string") {
+ revision = parsed.revision;
+ if (parsed.changed) {
+ dispatchMessagesChanged();
+ if (fromSocket) channel?.postMessage({ type: "refresh" } satisfies RealtimeChannelMessage);
+ }
+ return;
+ }
+ if (parsed.type === "agent_draft" && parsed.draftId && parsed.mailboxId) {
+ window.dispatchEvent(new CustomEvent("mailflare:agent-draft", { detail: parsed }));
+ dispatchMessagesChanged();
+ if (fromSocket) channel?.postMessage({ type: "notification", payload } satisfies RealtimeChannelMessage);
+ return;
+ }
+ } catch { return; }
+ const event = parseNewMessageEvent(payload);
+ if (!event) return;
+ dispatchMessagesChanged();
+ setNotification(event);
+ if (fromSocket) {
+ showBrowserNewMessageNotification(event);
+ channel?.postMessage({ type: "notification", payload } satisfies RealtimeChannelMessage);
+ }
+ }
+
+ function sendHeartbeat() {
+ if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify({ type: "ping", revision }));
}
function scheduleReconnect() {
- if (stopped || !getClientSessionToken()) return;
- startFallbackRefresh();
+ setConnected(false);
+ if (stopped || !leader || !getClientSessionToken()) return;
const delay = getReconnectDelay(reconnectAttempt);
reconnectAttempt += 1;
reconnectTimer = window.setTimeout(connect, delay);
@@ -59,54 +107,119 @@ export function useMessagePolling(): MessageRealtimeState {
function connect() {
clearConnectionTimers();
- if (stopped || !getClientSessionToken()) return;
+ if (stopped || !leader || !getClientSessionToken()) return;
socket = new WebSocket(getRealtimeWebSocketUrl());
socket.onopen = () => {
reconnectAttempt = 0;
- heartbeatTimer = window.setInterval(() => {
- if (socket?.readyState === WebSocket.OPEN) socket.send("ping");
- }, REALTIME_HEARTBEAT_INTERVAL_MS);
+ revision = null;
+ setConnected(true);
+ dispatchMessagesChanged();
+ sendHeartbeat();
+ heartbeatTimer = window.setInterval(sendHeartbeat, REALTIME_HEARTBEAT_INTERVAL_MS);
};
socket.onmessage = (message) => {
if (message.data === "pong" || typeof message.data !== "string") return;
- try {
- const payload = JSON.parse(message.data) as { type?: string; draftId?: string; mailboxId?: string };
- if (payload.type === "agent_draft" && payload.draftId && payload.mailboxId) {
- window.dispatchEvent(new CustomEvent("mailflare:agent-draft", { detail: payload }));
- dispatchMessagesChanged();
- return;
- }
- } catch { /* Ignore malformed notification. */ }
- const event = parseNewMessageEvent(message.data);
- if (!event) return;
- dispatchMessagesChanged();
- setNotification(event);
- showBrowserNewMessageNotification(event);
+ handleNotification(message.data, true);
};
socket.onerror = () => socket?.close();
- socket.onclose = scheduleReconnect;
+ socket.onclose = () => {
+ clearConnectionTimers();
+ scheduleReconnect();
+ };
+ }
+
+ function requestLeadership() {
+ if (stopped || !getClientSessionToken()) return;
+ if (!channel || !navigator.locks) {
+ leader = true;
+ connect();
+ return;
+ }
+ lockAbort = new AbortController();
+ void navigator.locks.request("mailflare:realtime", { signal: lockAbort.signal }, async () => {
+ if (stopped || !getClientSessionToken()) return;
+ await new Promise<void>((resolve) => {
+ releaseLeader = resolve;
+ leader = true;
+ connect();
+ });
+ leader = false;
+ releaseLeader = null;
+ }).catch(() => {});
}
function restartForSessionChange() {
+ sessionToken = getClientSessionToken();
if (socket) {
socket.onclose = null;
socket.close(1000, "Session changed");
socket = null;
}
clearConnectionTimers();
+ setConnected(false);
+ lockAbort?.abort();
+ releaseLeader?.();
+ leader = false;
reconnectAttempt = 0;
+ revision = null;
setNotification(null);
- if (getClientSessionToken()) connect();
+ requestLeadership();
+ }
+
+ function onChannelMessage(event: MessageEvent<RealtimeChannelMessage>) {
+ const message = event.data;
+ if (message?.type === "status_request" && leader) {
+ channel?.postMessage({ type: "status", connected } satisfies RealtimeChannelMessage);
+ } else if (message?.type === "status" && !leader) {
+ setConnected(message.connected);
+ if (message.connected) dispatchMessagesChanged();
+ } else if (message?.type === "notification" && !leader) {
+ handleNotification(message.payload, false);
+ } else if (message?.type === "refresh") {
+ dispatchMessagesChanged();
+ }
+ }
+
+ function onLocalMessagesChanged(event: Event) {
+ if ((event as CustomEvent<{ realtime?: boolean }>).detail?.realtime) return;
+ channel?.postMessage({ type: "refresh" } satisfies RealtimeChannelMessage);
+ }
+
+ function onVisibilityChange() {
+ if (document.visibilityState === "visible") dispatchMessagesChanged();
}
+ function onStorageChange() {
+ if (sessionToken !== getClientSessionToken()) restartForSessionChange();
+ }
+
+ if (typeof BroadcastChannel !== "undefined") {
+ channel = new BroadcastChannel("mailflare:realtime");
+ channel.onmessage = onChannelMessage;
+ channel.postMessage({ type: "status_request" } satisfies RealtimeChannelMessage);
+ }
window.addEventListener(AUTH_SESSION_CHANGED_EVENT, restartForSessionChange);
- connect();
+ window.addEventListener("storage", onStorageChange);
+ window.addEventListener("mailflare:messages-changed", onLocalMessagesChanged);
+ document.addEventListener("visibilitychange", onVisibilityChange);
+ window.addEventListener("focus", onVisibilityChange);
+ startFallbackRefresh();
+ requestLeadership();
return () => {
stopped = true;
window.removeEventListener(AUTH_SESSION_CHANGED_EVENT, restartForSessionChange);
+ window.removeEventListener("storage", onStorageChange);
+ window.removeEventListener("mailflare:messages-changed", onLocalMessagesChanged);
+ document.removeEventListener("visibilitychange", onVisibilityChange);
+ window.removeEventListener("focus", onVisibilityChange);
+ if (leader) channel?.postMessage({ type: "status", connected: false } satisfies RealtimeChannelMessage);
+ lockAbort?.abort();
+ releaseLeader?.();
clearConnectionTimers();
+ if (fallbackTimer) window.clearInterval(fallbackTimer);
+ channel?.close();
if (socket) {
socket.onclose = null;
socket.close(1000, "Client closed");
diff --git a/src/hooks/use-messages.ts b/src/hooks/use-messages.ts
index 4e2fffa..f25abf7 100644
--- a/src/hooks/use-messages.ts
+++ b/src/hooks/use-messages.ts
@@ -5,9 +5,10 @@ import {
clearMessageListCache,
fetchMessageList,
getMessageQueryParams,
- MESSAGE_POLL_INTERVAL_MS,
} from "./utils";
+const REFRESH_DEBOUNCE_MS = 150;
+
export function useMessages(
folder: MessageFolder,
mailboxId?: string | null,
@@ -26,19 +27,22 @@ export function useMessages(
useEffect(() => {
if (!enabled) return;
let cancelled = false;
+ let refreshTimer: number | null = null;
+ let requestNumber = 0;
async function loadMessages(force = false, showLoading = false) {
+ const currentRequest = ++requestNumber;
if (showLoading) setIsLoading(true);
try {
const params = getMessageQueryParams(folder, mailboxId, filters, folderId);
const data = await fetchMessageList(params, force);
- if (!cancelled) {
+ if (!cancelled && currentRequest === requestNumber) {
setMessages(data.messages ?? []);
setTotal(data.total ?? 0);
setLimit(data.limit ?? filters?.limit ?? 25);
setOffset(data.offset ?? filters?.offset ?? 0);
}
} finally {
- if (!cancelled) setIsLoading(false);
+ if (!cancelled && currentRequest === requestNumber) setIsLoading(false);
}
}
@@ -46,15 +50,19 @@ export function useMessages(
function onMessagesChanged() {
clearMessageListCache();
clearMessageCountsCache();
- void loadMessages(true);
+ if (document.visibilityState !== "visible") return;
+ if (refreshTimer) window.clearTimeout(refreshTimer);
+ refreshTimer = window.setTimeout(() => {
+ refreshTimer = null;
+ void loadMessages(true);
+ }, REFRESH_DEBOUNCE_MS);
}
window.addEventListener("mailflare:messages-changed", onMessagesChanged);
- const refreshInterval = window.setInterval(() => void loadMessages(true), MESSAGE_POLL_INTERVAL_MS);
return () => {
cancelled = true;
window.removeEventListener("mailflare:messages-changed", onMessagesChanged);
- window.clearInterval(refreshInterval);
+ if (refreshTimer) window.clearTimeout(refreshTimer);
};
}, [enabled, filters?.group, filters?.limit, filters?.offset, filters?.query, filters?.read, filters?.title, folder, folderId, mailboxId]);
diff --git a/src/hooks/utils.ts b/src/hooks/utils.ts
index f54e82e..87ae0e6 100644
--- a/src/hooks/utils.ts
+++ b/src/hooks/utils.ts
@@ -3,8 +3,6 @@ import { parseSearchQuery } from "@/lib/search/query-utils";
import type { MessageFilterOptions, MessageFolder } from "./types";
import type { MessageCounts, MessageListResponse } from "./types";
-export const MESSAGE_POLL_INTERVAL_MS = 15_000;
-
/**
* The search string goes to the server whole; operators are parsed there
* against the full-text index. Only the read state is lifted out here so the
@@ -78,7 +76,9 @@ export function clearMessageCountsCache() {
}
export function clearMessageListCache() {
+ messageCacheGeneration += 1;
messageListCache.clear();
+ messageListRequests.clear();
}
export function clearMessageClientState() {
diff --git a/src/lib/jmap/handler.ts b/src/lib/jmap/handler.ts
index c651f10..d2e8d37 100644
--- a/src/lib/jmap/handler.ts
+++ b/src/lib/jmap/handler.ts
@@ -106,30 +106,34 @@ function eventSource(ctx: JmapContext, url: URL): Response {
const closeAfter = url.searchParams.get("closeafter") === "state";
const encoder = new TextEncoder();
let last = "";
- let timer: ReturnType<typeof setInterval> | null = null;
+ let timer: ReturnType<typeof setTimeout> | null = null;
+ let stopped = false;
const stream = new ReadableStream<Uint8Array>({
async start(controller) {
const emit = async () => {
- const [mailbox, email] = await Promise.all([getMailboxState(ctx), getEmailState(ctx)]);
+ const email = await getEmailState(ctx);
+ const mailbox = await getMailboxState(ctx, email);
+ if (stopped) return;
const state = `${mailbox}|${email}`;
if (state === last) {
controller.enqueue(encoder.encode(`event: ping\ndata: {"interval": ${ping}}\n\n`));
- return;
- }
- last = state;
- const changed = { [ctx.accountId]: { Mailbox: mailbox, Email: email, Thread: email } };
- controller.enqueue(encoder.encode(`event: state\ndata: ${JSON.stringify({ "@type": "StateChange", changed })}\n\n`));
- if (closeAfter) {
- controller.close();
- if (timer) clearInterval(timer);
+ } else {
+ last = state;
+ const changed = { [ctx.accountId]: { Mailbox: mailbox, Email: email, Thread: email } };
+ controller.enqueue(encoder.encode(`event: state\ndata: ${JSON.stringify({ "@type": "StateChange", changed })}\n\n`));
+ if (closeAfter) {
+ stopped = true;
+ controller.close();
+ }
}
+ if (!stopped) timer = setTimeout(() => void emit().catch(() => { stopped = true; }), ping * 1000);
};
await emit();
- if (!closeAfter) timer = setInterval(() => void emit().catch(() => timer && clearInterval(timer)), ping * 1000);
},
cancel() {
- if (timer) clearInterval(timer);
+ stopped = true;
+ if (timer) clearTimeout(timer);
},
});
return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-store", Connection: "keep-alive", ...corsHeaders() } });
diff --git a/src/lib/jmap/processor.ts b/src/lib/jmap/processor.ts
index 42bd848..5fb9ccf 100644
--- a/src/lib/jmap/processor.ts
+++ b/src/lib/jmap/processor.ts
@@ -3,7 +3,7 @@ import { JmapError } from "./errors";
import { mailboxChanges, mailboxGet, mailboxQuery, mailboxSet } from "./mailboxes";
import { emailChanges, emailGet, emailImport, emailQuery, emailQueryChanges, emailSet, emailUnsupported, searchSnippetGet, threadChanges, threadGet } from "./emails";
import { emailSubmissionChanges, emailSubmissionGet, emailSubmissionQuery, emailSubmissionSet, identityChanges, identityGet, identitySet } from "./identities";
-import { getEmailState, getMailboxState } from "./state";
+import { getEmailState } from "./state";
import type { JmapContext, JmapInvocation, JmapMethodHandler, JmapRequest, JmapResponse } from "./types";
const METHODS: Record<string, JmapMethodHandler> = {
@@ -123,7 +123,7 @@ export async function processRequest(ctx: JmapContext, request: JmapRequest): Pr
}
export async function sessionState(ctx: JmapContext): Promise<string> {
- return `${await getMailboxState(ctx)}:${(await getEmailState(ctx)).split(".")[0]}`;
+ return getEmailState(ctx);
}
export function validateRequest(body: unknown): JmapRequest {
diff --git a/src/lib/jmap/revision.ts b/src/lib/jmap/revision.ts
new file mode 100644
index 0000000..c5990d8
--- /dev/null
+++ b/src/lib/jmap/revision.ts
@@ -0,0 +1,20 @@
+import { inArray } from "drizzle-orm";
+import { jmapMailboxRevisions } from "@/db/schema";
+import { listJmapMailboxes } from "./access";
+import type { JmapContext } from "./types";
+
+/** A cheap change signal for the stream; every message and folder write bumps a mailbox revision. */
+export async function getJmapRevision(ctx: JmapContext): Promise<string> {
+ const mailboxes = await listJmapMailboxes(ctx);
+ const ids = mailboxes.map((mailbox) => mailbox.id);
+ if (ids.length === 0) return "[]";
+ const revisions = new Map<string, number>();
+ for (let offset = 0; offset < ids.length; offset += 100) {
+ const rows = await ctx.db
+ .select({ mailboxId: jmapMailboxRevisions.mailboxId, revision: jmapMailboxRevisions.revision })
+ .from(jmapMailboxRevisions)
+ .where(inArray(jmapMailboxRevisions.mailboxId, ids.slice(offset, offset + 100)));
+ for (const row of rows) revisions.set(row.mailboxId, row.revision);
+ }
+ return JSON.stringify(mailboxes.map((mailbox) => [mailbox.id, mailbox.permission, mailbox.localPart, mailbox.hostname, mailbox.displayName, revisions.get(mailbox.id) ?? 0]).sort((a, b) => String(a[0]).localeCompare(String(b[0]))));
+}
diff --git a/src/lib/jmap/state.ts b/src/lib/jmap/state.ts
index 573c370..ab34f2f 100644
--- a/src/lib/jmap/state.ts
+++ b/src/lib/jmap/state.ts
@@ -1,38 +1,11 @@
-import { count, inArray, max, sql, sum } from "drizzle-orm";
-import { folders, messages } from "@/db/schema";
import type { JmapContext } from "./types";
-import { listAccessibleMailboxIdSet } from "./access";
+import { getJmapRevision } from "./revision";
-/**
- * Opaque state strings. Messages have no updated_at, so the Email state is a
- * digest of what a client would notice changing: row count, newest row, and
- * the flag and status tallies. Changes cannot be replayed from it, so
- * /changes answers cannotCalculateChanges and clients re-query.
- */
+/** Opaque revision tokens change on every message or folder write. */
export async function getEmailState(ctx: JmapContext): Promise<string> {
- const ids = Array.from(await listAccessibleMailboxIdSet(ctx));
- if (ids.length === 0) return "0";
- const [row] = await ctx.db
- .select({
- total: count(),
- newest: max(sql<number>`${messages}.rowid`),
- read: sum(sql`case when ${messages.read} then 1 else 0 end`),
- starred: sum(sql`case when ${messages.starred} then 1 else 0 end`),
- status: sum(sql`length(${messages.status})`),
- folder: sum(sql`case when ${messages.folderId} is null then 0 else 1 end`),
- })
- .from(messages)
- .where(inArray(messages.mailboxId, ids));
- return [row?.total ?? 0, row?.newest ?? 0, row?.read ?? 0, row?.starred ?? 0, row?.status ?? 0, row?.folder ?? 0].join(".");
+ return getJmapRevision(ctx);
}
-export async function getMailboxState(ctx: JmapContext): Promise<string> {
- const ids = Array.from(await listAccessibleMailboxIdSet(ctx));
- if (ids.length === 0) return "0";
- const [row] = await ctx.db
- .select({ total: count(), newest: max(sql<number>`${folders}.rowid`), names: sum(sql`length(${folders.name})`) })
- .from(folders)
- .where(inArray(folders.mailboxId, ids));
- // Counts live on Mailbox objects, so the mailbox state moves with the email state too.
- return `${ids.length}.${row?.total ?? 0}.${row?.newest ?? 0}.${row?.names ?? 0}.${await getEmailState(ctx)}`;
+export async function getMailboxState(ctx: JmapContext, emailState?: string): Promise<string> {
+ return emailState ?? getJmapRevision(ctx);
}
diff --git a/src/lib/realtime/hub.ts b/src/lib/realtime/hub.ts
index b85aa2e..4da6220 100644
--- a/src/lib/realtime/hub.ts
+++ b/src/lib/realtime/hub.ts
@@ -1,5 +1,6 @@
import { DurableObject } from "cloudflare:workers";
-import type { NewMessageNotification, AgentDraftNotification } from "./types";
+import { getUserMailRevision } from "./revision";
+import type { NewMessageNotification, AgentDraftNotification, RevisionPing, RevisionNotification } from "./types";
export class RealtimeHub extends DurableObject<CloudflareEnv> {
async fetch(request: Request): Promise<Response> {
@@ -13,7 +14,10 @@ export class RealtimeHub extends DurableObject<CloudflareEnv> {
const pair = new WebSocketPair();
const client = pair[0];
const server = pair[1];
+ const userId = request.headers.get("X-Mailflare-Realtime-User");
+ if (!userId) return new Response("Unauthorized", { status: 401 });
this.ctx.acceptWebSocket(server);
+ server.serializeAttachment({ userId });
return new Response(null, { status: 101, webSocket: client });
}
@@ -36,7 +40,27 @@ export class RealtimeHub extends DurableObject<CloudflareEnv> {
return new Response("Not found", { status: 404 });
}
- webSocketMessage(socket: WebSocket, message: string | ArrayBuffer): void {
- if (message === "ping") socket.send("pong");
+ async webSocketMessage(socket: WebSocket, message: string | ArrayBuffer): Promise<void> {
+ if (message === "ping") {
+ socket.send("pong");
+ return;
+ }
+ if (typeof message !== "string") return;
+ let ping: RevisionPing;
+ try {
+ ping = JSON.parse(message) as RevisionPing;
+ } catch {
+ return;
+ }
+ if (ping.type !== "ping") return;
+ const userId = socket.deserializeAttachment() as { userId?: string } | null;
+ if (!userId?.userId) return;
+ try {
+ const revision = await getUserMailRevision(this.env, userId.userId);
+ const notification: RevisionNotification = { type: "revision", revision, changed: ping.revision !== null && ping.revision !== revision };
+ socket.send(JSON.stringify(notification));
+ } catch {
+ socket.close(1011, "Revision lookup failed");
+ }
}
}
diff --git a/src/lib/realtime/revision.ts b/src/lib/realtime/revision.ts
new file mode 100644
index 0000000..1688199
--- /dev/null
+++ b/src/lib/realtime/revision.ts
@@ -0,0 +1,19 @@
+import type { MailboxRevisionRow } from "./types";
+
+/** Covers every mailbox visible to a user, including shared mailboxes. */
+export async function getUserMailRevision(env: CloudflareEnv, userId: string): Promise<string> {
+ const result = await env.DB.prepare(`
+ SELECT m.id AS mailbox_id, COALESCE(r.revision, 0) AS revision, 'owner' AS permission
+ FROM mailboxes m
+ LEFT JOIN jmap_mailbox_revisions r ON r.mailbox_id = m.id
+ WHERE m.user_id = ? AND m.disabled = 0
+ UNION
+ SELECT m.id AS mailbox_id, COALESCE(r.revision, 0) AS revision, a.permission AS permission
+ FROM mailbox_access a
+ JOIN mailboxes m ON m.id = a.mailbox_id
+ LEFT JOIN jmap_mailbox_revisions r ON r.mailbox_id = m.id
+ WHERE a.user_id = ? AND m.type = 'shared' AND m.disabled = 0
+ ORDER BY mailbox_id, permission
+ `).bind(userId, userId).all<MailboxRevisionRow>();
+ return JSON.stringify(result.results.map((row) => [row.mailbox_id, row.revision, row.permission]));
+}
diff --git a/src/lib/realtime/types.d.ts b/src/lib/realtime/types.d.ts
index 82125ce..1745ddf 100644
--- a/src/lib/realtime/types.d.ts
+++ b/src/lib/realtime/types.d.ts
@@ -13,6 +13,23 @@ export interface AgentDraftNotification {
type: "agent_draft";
}
+export interface MailboxRevisionRow {
+ mailbox_id: string;
+ revision: number;
+ permission: string;
+}
+
+export interface RevisionPing {
+ type: "ping";
+ revision: string | null;
+}
+
+export interface RevisionNotification {
+ type: "revision";
+ revision: string;
+ changed: boolean;
+}
+
export interface RealtimeNotificationRequest {
userIds: string[];
payload: NewMessageNotification | AgentDraftNotification;
diff --git a/worker.ts b/worker.ts
index 5ee38f3..4867c77 100644
--- a/worker.ts
+++ b/worker.ts
@@ -34,7 +34,9 @@ export default {
}
const hub = env.REALTIME.getByName(user.id);
- return hub.fetch(new Request("https://mailflare-realtime/connect", request));
+ const hubRequest = new Request("https://mailflare-realtime/connect", request);
+ hubRequest.headers.set("X-Mailflare-Realtime-User", user.id);
+ return hub.fetch(hubRequest);
}
return nextHandler.fetch(request, env, ctx);