@remit/web-client 0.0.278 → 0.0.280

package/src/hooks/useOrganizeWiden.test.ts

@@ -2,9 +2,10 @@
  * The widen step's two-phase preview. On a semantic-capable deployment it runs
  * the anchor preview once and stops. On a deployment that reports
  * `semanticUnavailable` (no vector pipeline — semantic-capability.ts) it
- * re-previews with sender-derived literal clauses — one `From` clause per
- * distinct sender, combined with `Or`, no anchor — and reports the literal match
- * count, so every commit scope acts on the sender-matched set.
+ * re-previews with what the whole selection agrees on (#458) — one `From` or
+ * `FromDomain` clause when senders agree, the shared subject when they don't,
+ * combined with `Or`, no anchor — and reports the literal match count, so
+ * every commit scope acts on the same set the fallback derived.
  */
 
 import assert from "node:assert/strict";
@@ -29,12 +30,16 @@ type Responder = Parameters<typeof mockFetch>[0];
 
 const PREVIEW_PATH = "/organize/preview";
 
-const mount = (senders: string[], responder: Responder) => {
+const mount = (
+	senders: string[],
+	responder: Responder,
+	subjects: string[] = [],
+) => {
 	http = mockFetch(responder);
 	harness = createDomHarness();
 	const holder: { current: Widen | undefined } = { current: undefined };
 	function Probe() {
-		const widen = useOrganizeWiden("acc-1", "msg-1", senders);
+		const widen = useOrganizeWiden("acc-1", "msg-1", senders, subjects);
 		holder.current = widen;
 		const { preview } = widen;
 		useEffect(() => {
@@ -130,6 +135,39 @@ describe("useOrganizeWiden — no vector pipeline, senders present", () => {
 	});
 });
 
+describe("useOrganizeWiden — no vector pipeline, mixed senders sharing a subject", () => {
+	it("re-previews with the shared subject rather than one From clause per sender (#458)", async () => {
+		const holder = mount(
+			["billing@acme.test", "accounts@globex.test"],
+			(call) =>
+				call.body?.anchorMessageId
+					? { matchedCount: 0, messageIds: [], semanticUnavailable: true }
+					: {
+							matchedCount: 64,
+							messageIds: ["m"],
+							semanticUnavailable: false,
+						},
+			["Invoice 1841", "Invoice 1902"],
+		);
+		await settle(2);
+
+		const calls = http?.to(PREVIEW_PATH) ?? [];
+		assert.equal(calls.length, 2);
+		const second = calls[1];
+		assert.equal(second.body?.anchorMessageId, undefined);
+		assert.equal(second.body?.matchOperator, "Or");
+		assert.deepEqual(second.body?.literalClauses, [
+			{ field: "Subject", value: "Invoice" },
+		]);
+
+		const widen = holder.current;
+		assert.deepEqual(widen?.matchPredicate, {
+			matchOperator: "Or",
+			literalClauses: [{ field: "Subject", value: "Invoice" }],
+		});
+	});
+});
+
 describe("useOrganizeWiden — no vector pipeline, no senders", () => {
 	it("does not re-preview and stays capability-absent with the anchor predicate", async () => {
 		const holder = mount([], () => ({
@@ -148,4 +186,32 @@ describe("useOrganizeWiden — no vector pipeline, no senders", () => {
 		assert.deepEqual(widen?.senders, []);
 		assert.equal(widen?.matchPredicate.anchorMessageId, "msg-1");
 	});
+
+	it("still re-previews on a shared subject alone (#458)", async () => {
+		const holder = mount(
+			[],
+			(call) =>
+				call.body?.anchorMessageId
+					? { matchedCount: 0, messageIds: [], semanticUnavailable: true }
+					: {
+							matchedCount: 12,
+							messageIds: ["m"],
+							semanticUnavailable: false,
+						},
+			["Invoice 1841", "Invoice 1902"],
+		);
+		await settle(2);
+
+		const calls = http?.to(PREVIEW_PATH) ?? [];
+		assert.equal(calls.length, 2);
+		const second = calls[1];
+		assert.equal(second.body?.anchorMessageId, undefined);
+		assert.deepEqual(second.body?.literalClauses, [
+			{ field: "Subject", value: "Invoice" },
+		]);
+
+		const widen = holder.current;
+		assert.equal(widen?.semanticUnavailable, true);
+		assert.equal(widen?.senderFallback, true);
+	});
 });

package/src/hooks/useOrganizeWiden.ts

@@ -1,5 +1,5 @@
 import { organizeOperationsPreviewOrganizeMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { deriveSenderClauses, distinctSenders } from "@remit/ui";
+import { derivePropertyClauses, distinctSenders } from "@remit/ui";
 import { useMutation } from "@tanstack/react-query";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildOrganizeInput } from "@/lib/organize/organize-model";
@@ -9,16 +9,17 @@ import {
 } from "@/lib/organize/sender-fallback";
 
 /**
- * "Select similar messages" (the widen step) with a sender-derived fallback for
- * deployments without the vector pipeline.
+ * "Select similar messages" (the widen step) with a selection-agreement
+ * fallback for deployments without the vector pipeline.
  *
  * The first preview runs the semantic anchor (POST /organize/preview). When the
  * server reports `semanticUnavailable` — no vector pipeline on this deployment
  * (semantic-capability.ts) — the widen re-previews with the literal vocabulary
- * that matches vector-free: one `From` clause per distinct sender in the
- * selection, combined with `Or`, no anchor. The counts shown, the one-time
- * back-apply, and any standing filter then all carry that same literal
- * predicate, so the previewed set equals the set every commit scope acts on.
+ * that matches vector-free: what the whole selection agrees on (#458) — one
+ * sender/domain clause, or the subject the selection shares when senders don't
+ * — combined with `Or`, no anchor. The counts shown, the one-time back-apply,
+ * and any standing filter then all carry that same literal predicate, so the
+ * previewed set equals the set every commit scope acts on.
  *
  * A semantic-capable deployment never fires the second preview and keeps exactly
  * the anchor behaviour.
@@ -27,12 +28,17 @@ export const useOrganizeWiden = (
 	accountId: string | undefined,
 	anchorMessageId: string | undefined,
 	senders: readonly string[],
+	subjects: readonly string[],
 ) => {
 	const mutation = useMutation(organizeOperationsPreviewOrganizeMutation());
 	const { mutate, reset: mutationReset } = mutation;
 	const [fellBack, setFellBack] = useState(false);
 
 	const distinct = useMemo(() => distinctSenders(senders), [senders]);
+	const agreementClauses = useMemo(
+		() => derivePropertyClauses(distinct, subjects),
+		[distinct, subjects],
+	);
 
 	const preview = useCallback(() => {
 		if (!accountId || !anchorMessageId) return;
@@ -53,21 +59,24 @@ export const useOrganizeWiden = (
 	}, [mutationReset]);
 
 	const data = mutation.data;
-	// The first preview came back capability-absent and there are senders to
-	// match on: re-preview with the literal clauses before showing any count, so
-	// the count the user sees is the sender-match count, never a flash of the
-	// empty semantic result.
+	// The first preview came back capability-absent and the selection agrees on
+	// something to match on — a sender, a domain, or just a shared subject, not
+	// senders alone (#458): re-preview with the literal clauses before showing
+	// any count, so the count the user sees is the agreement's match count,
+	// never a flash of the empty semantic result.
 	const willFallBack =
-		data?.semanticUnavailable === true && !fellBack && distinct.length > 0;
+		data?.semanticUnavailable === true &&
+		!fellBack &&
+		agreementClauses.length > 0;
 
 	useEffect(() => {
 		if (!willFallBack || !accountId) return;
 		setFellBack(true);
 		mutate({
 			path: { accountId },
-			body: buildOrganizeInput(buildSenderFallbackDraft(distinct)),
+			body: buildOrganizeInput(buildSenderFallbackDraft(distinct, subjects)),
 		});
-	}, [willFallBack, accountId, distinct, mutate]);
+	}, [willFallBack, accountId, distinct, subjects, mutate]);
 
 	// The literal re-preview has no anchor, so its response reports
 	// `semanticUnavailable: false`; `fellBack` is what remembers the capability
@@ -76,7 +85,7 @@ export const useOrganizeWiden = (
 	const isPending = mutation.isPending || willFallBack;
 
 	const matchPredicate: OrganizeMatchPredicate = fellBack
-		? { matchOperator: "Or", literalClauses: deriveSenderClauses(distinct) }
+		? { matchOperator: "Or", literalClauses: agreementClauses }
 		: {
 				...(anchorMessageId ? { anchorMessageId } : {}),
 				matchOperator: "And",

package/src/hooks/useStarredThreads.ts

@@ -14,20 +14,28 @@
  * below the newest page rendered an empty list however much of it the
  * collection held (#308); the server answers the predicate over the whole
  * collection instead, and a page comes back full of matches.
+ *
+ * Free text is one of those parameters, so a search is this same paginated
+ * query rather than a second, single-page one beside it. The separate one had
+ * no error state of its own — an expired session read as "nothing matched" —
+ * no continuation, so "Load more" was a dead button under a query, and its own
+ * loading state, so a cached listing flashed the empty state while it was in
+ * flight.
  */
 import { unifiedThreadOperationsListAllThreadsQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import { unifiedThreadOperationsListAllThreads } from "@remit/api-http-client/sdk.gen.ts";
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
 import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
 import { useMemo } from "react";
-import type { InboxFilterParams } from "@/lib/inbox-filters";
+import type { ThreadSearchTokenParams } from "@/lib/thread-search-tokens";
 
 /** The criteria the Flagged view narrows its listing by, all server-applied. */
-export interface StarredCriteria extends InboxFilterParams {
-	/** Free text, matched against subject and From over the whole collection. */
+export interface StarredCriteria extends ThreadSearchTokenParams {
+	/**
+	 * Free text, matched against subject, From and the body preview over the
+	 * whole collection.
+	 */
 	query?: string;
-	/** Page size, set only by the single-page text search. */
-	limit?: number;
 }
 
 // `starred` and `order` are the view itself, not a criterion, so they are set
@@ -101,37 +109,6 @@ export function useStarredThreads(
 	};
 }
 
-/**
- * The server's own text match over the whole starred collection, as one page.
- *
- * The free-text filter has two halves that no single request covers: the server
- * matches subject and From over every starred message, and the client can also
- * match a snippet, but only on rows it has already loaded. The server's set is
- * the filter — it is the half that sees the mail below the newest page — and
- * the snippet pass complements it (#308). Same shape as the daily brief's
- * unscoped search, which merges the same two halves.
- */
-export function useStarredTextSearch(
-	criteria: StarredCriteria,
-	limit: number,
-): RemitImapThreadMessageResponse[] {
-	const text = criteria.query ?? "";
-	const query = { ...starredQuery(criteria), limit };
-	const { data } = useQuery({
-		queryKey: unifiedThreadOperationsListAllThreadsQueryKey({ query }),
-		queryFn: async () => {
-			const { data: page } = await unifiedThreadOperationsListAllThreads({
-				query,
-				throwOnError: true,
-			});
-			return page;
-		},
-		enabled: text.length > 0,
-		staleTime: 30_000,
-	});
-	return useMemo(() => data?.items ?? [], [data]);
-}
-
 /**
  * How many of the matching starred messages are unread, counted by the server.
  *

package/src/lib/brief-criteria.test.ts

@@ -21,8 +21,13 @@ const tokensOf = (query: string): SearchToken[] =>
 		mailboxesByName: new Map([["sent", "mb2"]]),
 	}).tokens;
 
-const criteriaOf = (query: string, attributes: string[] = []) =>
-	briefCriteria("all", new Set(attributes), tokensOf(query)).criteria;
+const criteriaOf = (
+	query: string,
+	attributes: string[] = [],
+	accountId?: string,
+) =>
+	briefCriteria("all", new Set(attributes), tokensOf(query), accountId)
+		.criteria;
 
 const residualTypes = (query: string, attributes: string[] = []) =>
 	briefCriteria("all", new Set(attributes), tokensOf(query)).residual.map(
@@ -30,13 +35,16 @@ const residualTypes = (query: string, attributes: string[] = []) =>
 	);
 
 describe("briefCriteria", () => {
-	test("an unnarrowed brief asks for nothing in particular", () => {
-		assert.deepEqual(criteriaOf(""), {});
+	// The brief renders no muted sender's mail, so every request it makes says
+	// so — the alternative is a header counting mail the list drops (#1137).
+	test("an unnarrowed brief still refuses muted senders", () => {
+		assert.deepEqual(criteriaOf(""), { muted: false });
 		assert.deepEqual(residualTypes(""), []);
 	});
 
 	test("the chips travel as parameters", () => {
 		assert.deepEqual(criteriaOf("", ["unread", "attachment"]), {
+			muted: false,
 			unread: true,
 			attachments: true,
 		});
@@ -44,6 +52,7 @@ describe("briefCriteria", () => {
 
 	test("a typed token asks for exactly what its chip asks for", () => {
 		assert.deepEqual(criteriaOf("is:unread has:attachment"), {
+			muted: false,
 			unread: true,
 			attachments: true,
 		});
@@ -51,20 +60,36 @@ describe("briefCriteria", () => {
 	});
 
 	test("is:read narrows the request rather than the rows", () => {
-		assert.deepEqual(criteriaOf("is:read"), { unread: false });
+		assert.deepEqual(criteriaOf("is:read"), { muted: false, unread: false });
 		assert.deepEqual(residualTypes("is:read"), []);
 	});
 
 	test("is:starred travels too", () => {
-		assert.deepEqual(criteriaOf("is:starred"), { starred: true });
+		assert.deepEqual(criteriaOf("is:starred"), { muted: false, starred: true });
 		assert.deepEqual(residualTypes("is:starred"), []);
 	});
 
+	// #1136: the pill used to narrow the rows after they arrived, so a count
+	// taken over every account was not the size of the list showing one.
+	test("the account pill travels as a parameter", () => {
+		assert.deepEqual(criteriaOf("", [], "acc_1"), {
+			muted: false,
+			accountId: "acc_1",
+		});
+	});
+
+	test("the cross-account brief names no account", () => {
+		assert.equal(Object.hasOwn(criteriaOf(""), "accountId"), false);
+	});
+
 	// The section supplies its own category, so the shared criteria must not
 	// carry one — two categories on one request is a request for neither.
 	test("the category never travels in the shared criteria", () => {
-		assert.deepEqual(criteriaOf("category:personal"), {});
-		assert.deepEqual(criteriaOf("", ["unread"]), { unread: true });
+		assert.deepEqual(criteriaOf("category:personal"), { muted: false });
+		assert.deepEqual(criteriaOf("", ["unread"]), {
+			muted: false,
+			unread: true,
+		});
 		assert.equal(
 			Object.hasOwn(
 				briefCriteria("personal", new Set(), []).criteria,
@@ -74,13 +99,32 @@ describe("briefCriteria", () => {
 		);
 	});
 
-	// `listAllThreads` has one text parameter matching subject and From at once,
-	// so neither token can be asked for on its own and both stay residue.
-	test("from: and subject: have no parameter here and come back as residue", () => {
-		assert.deepEqual(criteriaOf("from:alice"), {});
-		assert.deepEqual(residualTypes("from:alice"), ["from"]);
-		assert.deepEqual(residualTypes("subject:invoice"), ["subject"]);
-		assert.deepEqual(BRIEF_TOKEN_PARAMS.includes("from"), false);
+	// #1128: the free-text parameter matches subject and From at once, so
+	// neither token could be asked for on its own and both were applied over the
+	// rows a section had fetched. Each has its own parameter now.
+	test("from: and subject: travel as parameters", () => {
+		assert.deepEqual(criteriaOf("from:alice"), {
+			muted: false,
+			from: "alice",
+		});
+		assert.deepEqual(residualTypes("from:alice"), []);
+		assert.deepEqual(criteriaOf("subject:invoice"), {
+			muted: false,
+			subject: "invoice",
+		});
+		assert.deepEqual(residualTypes("subject:invoice"), []);
+		assert.equal(BRIEF_TOKEN_PARAMS.includes("from"), true);
+		assert.equal(BRIEF_TOKEN_PARAMS.includes("subject"), true);
+	});
+
+	// One parameter per field, so a second value cannot be expressed; it drops
+	// to the residue rather than being silently lost.
+	test("a second from: stays residue", () => {
+		assert.deepEqual(criteriaOf("from:alice from:bob"), {
+			muted: false,
+			from: "alice",
+		});
+		assert.deepEqual(residualTypes("from:alice from:bob"), ["from"]);
 	});
 
 	test("dates, the mailbox and the account stay residue", () => {
@@ -92,7 +136,10 @@ describe("briefCriteria", () => {
 	});
 
 	test("a chip beats the token that contradicts it", () => {
-		assert.deepEqual(criteriaOf("is:read", ["unread"]), { unread: true });
+		assert.deepEqual(criteriaOf("is:read", ["unread"]), {
+			muted: false,
+			unread: true,
+		});
 		assert.deepEqual(residualTypes("is:read", ["unread"]), ["isRead"]);
 	});
 });
@@ -102,7 +149,6 @@ describe("briefCountsMatchRows", () => {
 		briefCountsMatchRows({
 			residual: [],
 			attributes: new Set<string>(),
-			accountScoped: false,
 			...over,
 		});
 
@@ -112,11 +158,7 @@ describe("briefCountsMatchRows", () => {
 	});
 
 	test("a residual token makes the count wider than the list", () => {
-		assert.equal(reach({ residual: tokensOf("from:alice") }), false);
-	});
-
-	test("the account pills scope the rows and nothing else", () => {
-		assert.equal(reach({ accountScoped: true }), false);
+		assert.equal(reach({ residual: tokensOf("before:2024-01-01") }), false);
 	});
 
 	test("a chip with no parameter makes the count wider than the list", () => {

package/src/lib/brief-criteria.ts

@@ -4,13 +4,15 @@
  * The brief's category scope is not a criterion here: every section is its own
  * category-scoped request, so the category travels per section rather than in
  * the shared criteria. What is shared is the attribute chips and the tokens
- * typed in the field — `is:unread`, `has:attachment`, `is:starred` — all of them
- * columns on the ThreadMessage row, so all of them travel as query parameters
- * over the whole scope instead of as a pass over the rows already fetched
- * (#312).
+ * typed in the field — `from:`, `subject:`, `is:unread`, `has:attachment`,
+ * `is:starred` — all of them fields on the ThreadMessage row, so all of them
+ * travel as query parameters over the whole scope instead of as a pass over the
+ * rows already fetched (#312, #1128).
  *
- * `from:` and `subject:` stay residue: `listAllThreads` has one text parameter
- * that matches both at once, so neither can be asked for on its own.
+ * The account pill and mute travel with them. Both used to narrow the rows after
+ * they arrived, which is what took the number off every section header: a count
+ * over every account, muted senders included, is not the size of a list showing
+ * one account without them (#1136, #1137).
  *
  * Two chips have no parameter anywhere — "From contacts" reads `senderTrust`,
  * which is off-row (design D7), and "Today" is a date, which no listing
@@ -24,11 +26,14 @@ import { inboxFilterParams } from "./inbox-filters.js";
 import type { SearchToken } from "./search-tokens.js";
 import {
 	type ThreadSearchTokenParamName,
+	type ThreadSearchTokenParams,
 	threadSearchTokens,
 } from "./thread-search-tokens.js";
 
 /** The token parameters `listAllThreads` carries. */
 export const BRIEF_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
+	"from",
+	"subject",
 	"category",
 	"unread",
 	"starred",
@@ -53,7 +58,12 @@ export const briefClientOnlyFilters = (
 	new Set(BRIEF_CLIENT_ONLY_FILTERS.filter((id) => attributes.has(id)));
 
 /** Everything a section request narrows by except its own category. */
-export type BriefSectionParams = Omit<InboxFilterParams, "category">;
+export type BriefSectionParams = Omit<ThreadSearchTokenParams, "category"> & {
+	/** The account the pills narrow to, or absent for the whole config. */
+	accountId?: string;
+	/** Always `false` here: the brief renders no muted sender's mail. */
+	muted?: boolean;
+};
 
 export interface BriefCriteria {
 	/** What every section request carries, chips and carried tokens together. */
@@ -66,19 +76,29 @@ export const briefCriteria = (
 	category: string,
 	attributes: ReadonlySet<string>,
 	tokens: readonly SearchToken[],
+	accountId?: string,
 ): BriefCriteria => {
-	const chipParams = inboxFilterParams({ category, attributes });
+	const chipParams: InboxFilterParams = inboxFilterParams({
+		category,
+		attributes,
+	});
 	const { params, residual } = threadSearchTokens(
 		tokens,
 		chipParams,
 		BRIEF_TOKEN_PARAMS,
 	);
 	const request = { ...params, ...chipParams };
-	const criteria: BriefSectionParams = {};
+	// Mute is not a control the reader sets: the brief is the view that hides
+	// muted senders, so every request it makes says so and every count it shows
+	// is a count of what it renders.
+	const criteria: BriefSectionParams = { muted: false };
+	if (request.from !== undefined) criteria.from = request.from;
+	if (request.subject !== undefined) criteria.subject = request.subject;
 	if (request.unread !== undefined) criteria.unread = request.unread;
 	if (request.starred !== undefined) criteria.starred = request.starred;
 	if (request.attachments !== undefined)
 		criteria.attachments = request.attachments;
+	if (accountId !== undefined) criteria.accountId = accountId;
 	return { criteria, residual };
 };
 
@@ -87,24 +107,23 @@ export interface BriefCountReach {
 	residual: readonly SearchToken[];
 	/** Attribute chips currently on. */
 	attributes: ReadonlySet<string>;
-	/** True while the reader has narrowed the brief to one account. */
-	accountScoped: boolean;
 }
 
 /**
  * Whether a section's server count is a count of what the section shows.
  *
  * The count answers the request. Anything narrowing the rows after they arrive —
- * a residual token, a chip with no parameter, the account pills, which no
- * listing endpoint scopes by — makes the count the size of a wider set than the
- * list. A wider number rendered as the section's size is a worse reading than no
- * number, so the caller asks for none.
+ * a residual token, or a chip with no parameter — makes the count the size of a
+ * wider set than the list. A wider number rendered as the section's size is a
+ * worse reading than no number, so the caller asks for none.
+ *
+ * The account pills are not among them any more, and neither is mute: both are
+ * parameters the request carries, so the count narrows exactly as the list does
+ * (#1136, #1137).
  */
 export const briefCountsMatchRows = ({
 	residual,
 	attributes,
-	accountScoped,
 }: BriefCountReach): boolean =>
 	residual.length === 0 &&
-	!accountScoped &&
 	!BRIEF_CLIENT_ONLY_FILTERS.some((id) => attributes.has(id));