@remit/web-client 0.0.1

package/src/lib/brief.test.ts

@@ -0,0 +1,366 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import type { ThreadRowData } from "@remit/ui";
+import {
+	groupBriefSections,
+	matchesBriefSearch,
+	matchesSearchTokens,
+} from "./brief.js";
+import type { SearchToken } from "./search-tokens.js";
+
+function row(
+	overrides: Partial<ThreadRowData> & Pick<ThreadRowData, "id">,
+): ThreadRowData {
+	return {
+		accountId: "acc_1",
+		fromName: "Sender",
+		fromEmail: "sender@example.com",
+		subject: "Subject",
+		snippet: "Snippet",
+		timeLabel: "09:00",
+		isRead: false,
+		hasAttachment: false,
+		starred: false,
+		...overrides,
+	};
+}
+
+describe("groupBriefSections", () => {
+	test("returns empty array when no rows", () => {
+		const sections = groupBriefSections([]);
+		assert.deepStrictEqual(sections, []);
+	});
+
+	// --- One section per category ---
+
+	test("personal goes to the personal section", () => {
+		const r = row({ id: "1", category: "personal" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "personal");
+		assert.strictEqual(sections[0].label, "Personal");
+	});
+
+	test("transactional goes to the transactional section", () => {
+		const r = row({ id: "1", category: "transactional" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections[0].id, "transactional");
+		assert.strictEqual(sections[0].label, "Transactional");
+	});
+
+	test("newsletter goes to the newsletter section", () => {
+		const r = row({ id: "1", category: "newsletter" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections[0].id, "newsletter");
+		assert.strictEqual(sections[0].label, "Newsletter");
+	});
+
+	test("marketing goes to the marketing section", () => {
+		const r = row({ id: "1", category: "marketing" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections[0].id, "marketing");
+		assert.strictEqual(sections[0].label, "Marketing");
+	});
+
+	test("social goes to the social section", () => {
+		const r = row({ id: "1", category: "social" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections[0].id, "social");
+		assert.strictEqual(sections[0].label, "Social");
+	});
+
+	test("automated goes to the automated section", () => {
+		const r = row({ id: "1", category: "automated" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections[0].id, "automated");
+		assert.strictEqual(sections[0].label, "Automated");
+	});
+
+	// --- Read state is not a routing signal ---
+
+	test("read and unread rows of a category share one section", () => {
+		const rows: ThreadRowData[] = [
+			row({ id: "1", isRead: false, category: "personal" }),
+			row({ id: "2", isRead: true, category: "personal" }),
+		];
+		const sections = groupBriefSections(rows);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "personal");
+		assert.strictEqual(sections[0].threads.length, 2);
+	});
+
+	// --- Fallback to personal ---
+
+	test("missing category falls back to personal", () => {
+		const r = row({ id: "1" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "personal");
+	});
+
+	// --- Starred is a row marker, not a section (Flagged lives in the nav) ---
+
+	test("a starred newsletter stays in the newsletter section", () => {
+		const r = row({ id: "1", starred: true, category: "newsletter" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "newsletter");
+	});
+
+	test("a starred personal message stays in the personal section", () => {
+		const r = row({ id: "1", starred: true, category: "personal" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "personal");
+	});
+
+	test("starred mail never produces a flagged section", () => {
+		const rows: ThreadRowData[] = [
+			row({ id: "p", category: "personal" }),
+			row({ id: "f", starred: true, category: "automated" }),
+		];
+		const sections = groupBriefSections(rows);
+		assert.deepStrictEqual(
+			sections.map((s) => s.id),
+			["personal", "automated"],
+		);
+	});
+
+	// --- Trust no longer sections ---
+
+	test("a vip newsletter stays in the newsletter section (trust does not section)", () => {
+		const r = row({ id: "1", trust: "vip", category: "newsletter" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "newsletter");
+	});
+
+	test("a wellknown automated row stays in the automated section", () => {
+		const r = row({ id: "1", trust: "wellknown", category: "automated" });
+		const sections = groupBriefSections([r]);
+		assert.strictEqual(sections.length, 1);
+		assert.strictEqual(sections[0].id, "automated");
+	});
+
+	// --- Section order and omission ---
+
+	test("display order is: personal, transactional, newsletter, marketing, social, automated", () => {
+		const rows: ThreadRowData[] = [
+			row({ id: "auto", category: "automated" }),
+			row({ id: "social", category: "social" }),
+			row({ id: "mkt", category: "marketing" }),
+			row({ id: "news", category: "newsletter" }),
+			row({ id: "txn", category: "transactional" }),
+			row({ id: "pers", category: "personal" }),
+			row({ id: "star", starred: true, category: "automated" }),
+		];
+		const sections = groupBriefSections(rows);
+		assert.deepStrictEqual(
+			sections.map((s) => s.id),
+			[
+				"personal",
+				"transactional",
+				"newsletter",
+				"marketing",
+				"social",
+				"automated",
+			],
+		);
+	});
+
+	test("empty sections are omitted", () => {
+		const sections = groupBriefSections([row({ id: "1", category: "social" })]);
+		assert.deepStrictEqual(
+			sections.map((s) => s.id),
+			["social"],
+		);
+	});
+
+	test("each row appears in exactly one section", () => {
+		const rows: ThreadRowData[] = [
+			row({ id: "1", category: "personal" }),
+			row({ id: "2", starred: true, category: "automated" }),
+			row({ id: "3", category: "automated" }),
+			row({ id: "4", category: "transactional" }),
+			row({ id: "5", starred: true, category: "newsletter" }),
+			row({ id: "6", category: "newsletter" }),
+			row({ id: "7", category: "marketing" }),
+		];
+		const sections = groupBriefSections(rows);
+		const allIds = sections.flatMap((s) => s.threads.map((t) => t.id));
+		assert.strictEqual(allIds.length, rows.length);
+		const uniqueIds = new Set(allIds);
+		assert.strictEqual(uniqueIds.size, rows.length);
+	});
+});
+
+describe("matchesBriefSearch", () => {
+	const r = row({
+		id: "1",
+		fromName: "Alice Tan",
+		fromEmail: "alice@example.com",
+		subject: "Q3 roadmap",
+		snippet: "See the attached deck",
+	});
+
+	test("matches on fromName (case-insensitive)", () => {
+		assert.strictEqual(matchesBriefSearch(r, "alice"), true);
+	});
+
+	test("matches on fromEmail", () => {
+		assert.strictEqual(matchesBriefSearch(r, "alice@example"), true);
+	});
+
+	test("matches on subject", () => {
+		assert.strictEqual(matchesBriefSearch(r, "roadmap"), true);
+	});
+
+	test("matches on snippet", () => {
+		assert.strictEqual(matchesBriefSearch(r, "deck"), true);
+	});
+
+	test("returns false when query matches nothing", () => {
+		assert.strictEqual(matchesBriefSearch(r, "zyxwvuts"), false);
+	});
+});
+
+describe("matchesSearchTokens", () => {
+	const from = (value: string): SearchToken => ({
+		type: "from",
+		raw: `from:${value}`,
+		value,
+	});
+	const hasAttachment: SearchToken = {
+		type: "hasAttachment",
+		raw: "has:attachment",
+	};
+	const isUnread: SearchToken = { type: "isUnread", raw: "is:unread" };
+	const after = (epochSeconds: number): SearchToken => ({
+		type: "after",
+		raw: "after:x",
+		value: "x",
+		epochSeconds,
+	});
+	const before = (epochSeconds: number): SearchToken => ({
+		type: "before",
+		raw: "before:x",
+		value: "x",
+		epochSeconds,
+	});
+
+	test("returns true with no tokens", () => {
+		assert.strictEqual(matchesSearchTokens(row({ id: "1" }), []), true);
+	});
+
+	test("from: matches fromEmail or fromName, case-insensitively", () => {
+		const r = row({ id: "1", fromEmail: "alice@dhl.com", fromName: "DHL" });
+		assert.strictEqual(matchesSearchTokens(r, [from("DHL")]), true);
+		assert.strictEqual(matchesSearchTokens(r, [from("alice@dhl")]), true);
+		assert.strictEqual(matchesSearchTokens(r, [from("ups")]), false);
+	});
+
+	test("has:attachment requires hasAttachment true", () => {
+		assert.strictEqual(
+			matchesSearchTokens(row({ id: "1", hasAttachment: true }), [
+				hasAttachment,
+			]),
+			true,
+		);
+		assert.strictEqual(
+			matchesSearchTokens(row({ id: "1", hasAttachment: false }), [
+				hasAttachment,
+			]),
+			false,
+		);
+	});
+
+	test("is:unread requires isRead falsy", () => {
+		assert.strictEqual(
+			matchesSearchTokens(row({ id: "1", isRead: false }), [isUnread]),
+			true,
+		);
+		assert.strictEqual(
+			matchesSearchTokens(row({ id: "1", isRead: true }), [isUnread]),
+			false,
+		);
+	});
+
+	test("after:/before: compare against sentDate (ms)", () => {
+		const jan15 = row({
+			id: "1",
+			sentDate: Date.parse("2024-01-15T00:00:00Z"),
+		});
+		assert.strictEqual(
+			matchesSearchTokens(jan15, [
+				after(Date.parse("2024-01-01T00:00:00Z") / 1000),
+			]),
+			true,
+		);
+		assert.strictEqual(
+			matchesSearchTokens(jan15, [
+				before(Date.parse("2024-01-01T00:00:00Z") / 1000),
+			]),
+			false,
+		);
+	});
+
+	test("a date token never matches a row with no sentDate", () => {
+		const r = row({ id: "1" });
+		assert.strictEqual(matchesSearchTokens(r, [after(0)]), false);
+		assert.strictEqual(matchesSearchTokens(r, [before(0)]), false);
+	});
+
+	test("in: matches on mailboxId", () => {
+		const r = row({ id: "1", mailboxId: "mb-archive" });
+		const inToken: SearchToken = {
+			type: "in",
+			raw: "in:archive",
+			value: "archive",
+			mailboxId: "mb-archive",
+		};
+		assert.strictEqual(matchesSearchTokens(r, [inToken]), true);
+		assert.strictEqual(
+			matchesSearchTokens(row({ id: "2", mailboxId: "mb-inbox" }), [inToken]),
+			false,
+		);
+	});
+
+	test("account: matches on accountId", () => {
+		const r = row({ id: "1", accountId: "acc_work" });
+		const accountToken: SearchToken = {
+			type: "account",
+			raw: "account:work",
+			value: "work",
+			accountId: "acc_work",
+		};
+		assert.strictEqual(matchesSearchTokens(r, [accountToken]), true);
+		assert.strictEqual(
+			matchesSearchTokens(row({ id: "2", accountId: "acc_personal" }), [
+				accountToken,
+			]),
+			false,
+		);
+	});
+
+	test("all tokens must match (AND)", () => {
+		const r = row({
+			id: "1",
+			fromEmail: "alice@dhl.com",
+			hasAttachment: true,
+			isRead: false,
+		});
+		assert.strictEqual(
+			matchesSearchTokens(r, [from("dhl"), hasAttachment, isUnread]),
+			true,
+		);
+		assert.strictEqual(
+			matchesSearchTokens(r, [
+				from("dhl"),
+				hasAttachment,
+				isUnread,
+				from("ups"),
+			]),
+			false,
+		);
+	});
+});

package/src/lib/brief.ts

@@ -0,0 +1,180 @@
+/**
+ * Daily brief grouping logic.
+ *
+ * Pure function: takes a flat list of thread message rows and returns one
+ * section per message category, in a fixed display order:
+ *
+ *  1. Personal
+ *  2. Transactional
+ *  3. Newsletter
+ *  4. Marketing
+ *  5. Social
+ *  6. Automated
+ *
+ * Each row lands in the section for its category; a row with no category counts
+ * as `personal` (the classifier's own fallback). Starred mail is not a section —
+ * the star is a per-row marker, so a starred message stays in its category.
+ *
+ * Sender trust (vip/wellknown) no longer sections the brief — the signal is
+ * still carried on each row (see `toThreadRowData`) for future use, but it does
+ * not decide where a row lands. Read state is likewise not a routing signal: in
+ * a high-volume mailbox read≠handled and unread≠important; unread is a
+ * user-selectable filter chip instead.
+ *
+ * Muted senders (filtered by the caller) and empty sections are excluded.
+ */
+
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { MessageCategory } from "@remit/domain-enums";
+import type {
+	SenderTrustLevel,
+	ThreadCategory,
+	ThreadRowData,
+	ThreadSection,
+} from "@remit/ui";
+import { toDisplayCategory } from "./display-category.js";
+import { formatEmailDate } from "./format.js";
+import type { SearchToken } from "./search-tokens.js";
+
+/**
+ * Map a `RemitImapThreadMessageResponse` to the `ThreadRowData` shape used by
+ * remit-ui row body components. Mirrors the logic in MessageListItem so the
+ * brief rows render identically to per-mailbox rows.
+ */
+export function toThreadRowData(
+	thread: RemitImapThreadMessageResponse,
+): ThreadRowData {
+	const suspicious = thread.authenticity?.dkimMismatch === true;
+	return {
+		id: thread.messageId,
+		accountId: thread.accountId ?? thread.accountConfigId,
+		mailboxId: thread.mailboxId,
+		fromName: thread.fromName ?? thread.fromEmail ?? "Unknown",
+		fromEmail: thread.fromEmail ?? "",
+		subject: thread.subject ?? "(No subject)",
+		snippet: thread.snippet ?? "",
+		timeLabel: formatEmailDate(thread.sentDate),
+		sentDate: thread.sentDate,
+		isRead: thread.isRead,
+		hasAttachment: thread.hasAttachment,
+		starred:
+			thread.star != null && thread.star !== "none" && thread.hasStars === true,
+		trust: thread.senderTrust as SenderTrustLevel,
+		category: toDisplayCategory(thread.category),
+		suspicious,
+	};
+}
+
+/**
+ * Category sections in fixed display order. The `id`/`label` drive the rendered
+ * section; `category` is the row category that routes into it.
+ */
+const CATEGORY_SECTIONS: ReadonlyArray<{
+	id: string;
+	label: string;
+	category: ThreadCategory;
+}> = [
+	{ id: "personal", label: "Personal", category: MessageCategory.personal },
+	{
+		id: "transactional",
+		label: "Transactional",
+		category: MessageCategory.transactional,
+	},
+	{
+		id: "newsletter",
+		label: "Newsletter",
+		category: MessageCategory.newsletter,
+	},
+	{ id: "marketing", label: "Marketing", category: MessageCategory.marketing },
+	{ id: "social", label: "Social", category: MessageCategory.social },
+	{ id: "automated", label: "Automated", category: MessageCategory.automated },
+];
+
+/**
+ * Group a flat list of thread row data into one section per message category.
+ * Rows should already be filtered for the selected account chip (if any) before
+ * calling this function.
+ *
+ * @param rows      Flat array of ThreadRowData, sorted newest-first.
+ * @returns         Array of ThreadSection in category display order — empty
+ *                  sections are omitted.
+ */
+export function groupBriefSections(rows: ThreadRowData[]): ThreadSection[] {
+	const byCategory = new Map<string, ThreadRowData[]>(
+		CATEGORY_SECTIONS.map((s) => [s.category, []]),
+	);
+
+	for (const row of rows) {
+		const category = row.category ?? MessageCategory.personal;
+		const bucket =
+			byCategory.get(category) ?? byCategory.get(MessageCategory.personal);
+		bucket?.push(row);
+	}
+
+	const sections: ThreadSection[] = [];
+	for (const section of CATEGORY_SECTIONS) {
+		const threads = byCategory.get(section.category);
+		if (threads && threads.length > 0)
+			sections.push({
+				id: section.id,
+				label: section.label,
+				threads,
+			});
+	}
+	return sections;
+}
+
+/**
+ * Returns true when `t` matches the free-text `query` (lower-cased).
+ * Checked against fromName, fromEmail, subject, and snippet.
+ */
+export function matchesBriefSearch(t: ThreadRowData, query: string): boolean {
+	return (
+		t.fromName.toLowerCase().includes(query) ||
+		t.fromEmail.toLowerCase().includes(query) ||
+		t.subject.toLowerCase().includes(query) ||
+		t.snippet.toLowerCase().includes(query)
+	);
+}
+
+/**
+ * Returns true when `t` satisfies every parsed filter token — the client-side
+ * counterpart of the params `threadOperationsSearchThreads` accepts, applied
+ * over the already-loaded brief/flagged rows (#428). A row without the data a
+ * token needs (e.g. no `sentDate` for `before:`/`after:`) never matches that
+ * token, so it drops out rather than showing under an unverifiable filter.
+ * `in:`/`account:` have no server param at all — this is the entire
+ * implementation of both, reusing the same per-account fan-out the daily
+ * brief already reads its rows from (`accountId`/`mailboxId` are already on
+ * every row).
+ */
+export function matchesSearchTokens(
+	t: ThreadRowData,
+	tokens: SearchToken[],
+): boolean {
+	return tokens.every((token) => {
+		switch (token.type) {
+			case "from": {
+				const needle = token.value.toLowerCase();
+				return (
+					t.fromEmail.toLowerCase().includes(needle) ||
+					t.fromName.toLowerCase().includes(needle)
+				);
+			}
+			case "hasAttachment":
+				return t.hasAttachment === true;
+			case "isUnread":
+				return !t.isRead;
+			case "after":
+				return t.sentDate != null && t.sentDate >= token.epochSeconds * 1000;
+			case "before":
+				return t.sentDate != null && t.sentDate < token.epochSeconds * 1000;
+			case "in":
+				return t.mailboxId === token.mailboxId;
+			case "account":
+				return t.accountId === token.accountId;
+			default:
+				return false;
+		}
+	});
+}