Skip to content

Email for professionals and teams

6.4 KB
Raw Blame
import { authFetch } from "@/lib/auth/client";
import { parseSearchQuery } from "@/lib/search/query-utils";
import { getUserTimeZone } from "@/lib/time/utils";
import { setCachedMessageRead } from "@/lib/messages/detail-cache";
import type { MessageFilterOptions, MessageFolder } from "./types";
import type { MessageCounts, MessageListResponse } from "./types";

/**
 * 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
 * unread toggle and `is:unread` share one `read` parameter.
 */
export function parseMessageSearchQuery(query: string): MessageFilterOptions {
	const parsed = parseSearchQuery(query);
	const filters: MessageFilterOptions = {};
	if (parsed.read) filters.read = parsed.read;
	const remaining = query.replace(/(^|\s)(is:(un)?read|:(un)?read)(?=\s|$)/gi, " ").replace(/\s+/g, " ").trim();
	if (remaining) filters.query = remaining;
	return filters;
}

export function getMessageQueryParams(
	folder: MessageFolder,
	mailboxId?: string | null,
	filters?: MessageFilterOptions,
	folderId?: string | null,
) {
	const params = new URLSearchParams();
	params.set("timeZone", getUserTimeZone());

	if (folder === "inbox") {
		params.set("direction", "inbound");
		params.set("status", "received");
	}
	if (folder === "starred") params.set("starred", "true");
	if (folder === "snoozed") params.set("snoozed", "true");

	if (folder === "sent") {
		params.set("direction", "outbound");
		params.set("status", "sent");
	}

	if (folder === "scheduled") {
		params.set("direction", "outbound");
		params.set("scheduled", "true");
	}

	if (folder === "drafts") {
		params.set("direction", "outbound");
		params.set("status", "draft");
	}

	if (folder === "archived" || folder === "trash" || folder === "spam") {
		params.set("status", folder);
	}

	if (folderId) params.set("folderId", folderId);
	if (mailboxId) params.set("mailboxId", mailboxId);
	const searchFilters = filters?.query ? parseMessageSearchQuery(filters.query) : null;
	const parsedFilters = searchFilters
		? { ...filters, ...searchFilters, read: filters?.read ?? searchFilters.read }
		: filters;
	if (parsedFilters?.query?.trim()) params.set("q", parsedFilters.query.trim());
	if (parsedFilters?.title?.trim()) params.set("title", parsedFilters.title.trim());
	if (parsedFilters?.read && parsedFilters.read !== "all") params.set("read", parsedFilters.read);
	if (filters?.limit) params.set("limit", String(filters.limit));
	if (filters?.offset) params.set("offset", String(filters.offset));
	if (filters?.group) params.set("group", filters.group);

	return params;
}

const messageCountsCache = new Map<string, MessageCounts>();
const messageCountsRequests = new Map<string, Promise<MessageCounts | undefined>>();
const messageListCache = new Map<string, MessageListResponse>();
const messageListRequests = new Map<string, Promise<MessageListResponse>>();
let messageCacheGeneration = 0;
let messageCountsGeneration = 0;

export function clearMessageCountsCache() {
	messageCountsGeneration += 1;
	messageCountsCache.clear();
	messageCountsRequests.clear();
}

export function clearMessageListCache() {
	messageCacheGeneration += 1;
	messageListCache.clear();
	messageListRequests.clear();
}

/**
 * Mirror a read/unread change into the cached lists and details, so a list
 * remounted later (or a detail reopened) never shows the old state.
 */
export function markMessagesReadInCaches(messageIds: string[], read: boolean) {
	const ids = new Set(messageIds);
	for (const [key, response] of messageListCache) {
		if (!response.messages?.some((message) => ids.has(message.id))) continue;
		messageListCache.set(key, {
			...response,
			messages: response.messages.map((message) => {
				if (!ids.has(message.id)) return message;
				const threadSize = message.threadMessageIds?.length;
				return {
					...message,
					read,
					...(threadSize !== undefined ? { threadUnread: read ? 0 : threadSize } : {}),
				};
			}),
		});
	}
	for (const id of ids) setCachedMessageRead(id, read);
}

// Caches must drop on every change, including ones made while no list is mounted
// (e.g. reading a message from the popup on a page without the inbox list).
if (typeof window !== "undefined") {
	window.addEventListener("mailflare:messages-changed", () => {
		clearMessageListCache();
		clearMessageCountsCache();
	});
}

export function clearMessageClientState() {
	messageCacheGeneration += 1;
	messageCountsGeneration += 1;
	messageCountsCache.clear();
	messageCountsRequests.clear();
	messageListCache.clear();
	messageListRequests.clear();
}

export async function fetchMessageCounts(mailboxId?: string | null, force = false): Promise<MessageCounts | undefined> {
	const key = mailboxId ?? "all";
	if (!force && messageCountsCache.has(key)) return messageCountsCache.get(key);
	if (!force && messageCountsRequests.has(key)) return messageCountsRequests.get(key);

	const requestGeneration = messageCacheGeneration;
	const countsGeneration = messageCountsGeneration;
	const request = (async () => {
		const params = new URLSearchParams();
		if (mailboxId) params.set("mailboxId", mailboxId);
		const query = params.toString();
		const res = await authFetch(`/api/messages/counts${query ? `?${query}` : ""}`);
		const data = (await res.json()) as { counts?: MessageCounts };
		const counts = data.counts;
		if (
			counts &&
			requestGeneration === messageCacheGeneration &&
			countsGeneration === messageCountsGeneration
		) {
			messageCountsCache.set(key, counts);
		}
		return counts;
	})().finally(() => {
		if (messageCountsRequests.get(key) === request) {
			messageCountsRequests.delete(key);
		}
	});

	messageCountsRequests.set(key, request);
	return request;
}

export async function fetchMessageList(params: URLSearchParams, force = false): Promise<MessageListResponse> {
	const key = params.toString();
	if (!force && messageListCache.has(key)) return messageListCache.get(key) ?? {};
	if (!force && messageListRequests.has(key)) return messageListRequests.get(key) ?? {};

	const requestGeneration = messageCacheGeneration;
	const request = authFetch(`/api/messages?${key}`)
		.then((res) => res.json())
		.then((data) => {
			const response = data as MessageListResponse;
			if (requestGeneration === messageCacheGeneration) {
				messageListCache.set(key, response);
			}
			return response;
		})
		.finally(() => {
			if (requestGeneration === messageCacheGeneration) {
				messageListRequests.delete(key);
			}
		});

	messageListRequests.set(key, request);
	return request;
}