@remit/web-client 0.0.67 → 0.0.69

package/src/hooks/useSearchFilterSeed.render.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Opening the filter-from-search editor: the seed count comes from the converted
+ * literal predicate in one request, under the account the filter targets. No
+ * capability probe — the deployment's semantic reach is read from the search's
+ * own results on the surface, so a seed success is never blocked by a probe.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import { createElement } from "react";
+import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import {
+	type HttpCall,
+	type HttpMock,
+	httpError,
+	mockFetch,
+} from "../test-support/http";
+import { useSearchFilterSeed } from "./useSearchFilterSeed";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+});
+
+const PREDICATE: OrganizeMatchPredicate = {
+	matchOperator: "And",
+	literalClauses: [{ field: "HasWords", value: "receipts" }],
+};
+
+function Probe() {
+	const seed = useSearchFilterSeed("acc-1", PREDICATE);
+	return createElement(
+		"div",
+		null,
+		JSON.stringify({
+			seedCount: seed.seedCount ?? null,
+			isPending: seed.isPending,
+			isError: seed.isError,
+		}),
+	);
+}
+
+const mount = (responder: (call: HttpCall) => unknown): DomHarness => {
+	http = mockFetch(responder);
+	harness = createDomHarness();
+	harness.renderApp(createElement(Probe));
+	return harness;
+};
+
+const state = (dom: DomHarness) => JSON.parse(dom.text());
+
+describe("useSearchFilterSeed", () => {
+	it("seeds the count from the literal predicate in a single preview", async () => {
+		const dom = mount((call) =>
+			call.path.endsWith("/organize/preview")
+				? { matchedCount: 12, messageIds: [] }
+				: {},
+		);
+		await dom.flush();
+		await dom.flush();
+		assert.equal(state(dom).seedCount, 12);
+		// One preview, carrying the literal clauses and no anchor.
+		const previews = http?.to("/organize/preview") ?? [];
+		assert.equal(previews.length, 1);
+		assert.equal(previews[0].body?.anchorMessageId, undefined);
+		assert.deepEqual(previews[0].body?.literalClauses, [
+			{ field: "HasWords", value: "receipts" },
+		]);
+	});
+
+	it("surfaces the seed error so the caller can offer a retry", async () => {
+		const dom = mount(() => httpError(500));
+		await dom.flush();
+		await dom.flush();
+		assert.equal(state(dom).isError, true);
+	});
+});

package/src/hooks/useSearchFilterSeed.ts

@@ -0,0 +1,61 @@
+import { organizeOperationsPreviewOrganizeMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useMutation } from "@tanstack/react-query";
+import { useCallback, useEffect } from "react";
+import { buildOrganizeInput } from "@/lib/organize/organize-model";
+import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
+
+interface SearchFilterSeed {
+	/** The live count for the converted literal predicate, seeding the editor. */
+	seedCount?: number;
+	isPending: boolean;
+	isError: boolean;
+	error: unknown;
+	retry: () => void;
+}
+
+/**
+ * Open the filter-from-search editor: seed the live count from the converted
+ * literal predicate. One `POST /organize/preview` under the account the filter
+ * targets — the count on screen is the set a literal-only filter applies to.
+ *
+ * The deployment's semantic reach is not probed here; it is read from the
+ * search's own "Related" results on the surface that opens the editor (RFC 038
+ * D5), a direct signal that needs no request and cannot hit the wrong account.
+ */
+export const useSearchFilterSeed = (
+	accountId: string | undefined,
+	literalPredicate: OrganizeMatchPredicate,
+): SearchFilterSeed => {
+	const seed = useMutation(organizeOperationsPreviewOrganizeMutation());
+	const { mutate, reset } = seed;
+
+	const run = useCallback(() => {
+		if (!accountId) return;
+		reset();
+		mutate({
+			path: { accountId },
+			body: buildOrganizeInput({
+				matchOperator: literalPredicate.matchOperator,
+				literalClauses: literalPredicate.literalClauses,
+			}),
+		});
+	}, [
+		accountId,
+		literalPredicate.matchOperator,
+		literalPredicate.literalClauses,
+		mutate,
+		reset,
+	]);
+
+	useEffect(() => {
+		run();
+	}, [run]);
+
+	return {
+		seedCount: seed.data?.matchedCount,
+		isPending: seed.isPending || seed.data === undefined,
+		isError: seed.isError,
+		error: seed.error,
+		retry: run,
+	};
+};

package/src/lib/organize/search-to-rule.test.ts

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { parseSearchTokens, type SearchTokenContext } from "../search-tokens";
+import {
+	buildSearchRule,
+	convertSearchToRule,
+	isConvertible,
+} from "./search-to-rule";
+
+const CONTEXT: SearchTokenContext = {
+	mailboxesByName: new Map([["archive", "mbx-archive"]]),
+	accountsByName: new Map([["work", "acc-work"]]),
+};
+
+const convert = (
+	query: string,
+	options: { searchHadSemanticReach?: boolean } = {},
+) =>
+	convertSearchToRule(parseSearchTokens(query, CONTEXT), {
+		searchHadSemanticReach: options.searchHadSemanticReach ?? false,
+	});
+
+describe("convertSearchToRule — facet → clause mapping", () => {
+	it("maps literal terms to a HasWords clause", () => {
+		const conversion = convert("quarterly report");
+		assert.deepEqual(conversion.clauses, [
+			{ field: "HasWords", value: "quarterly report" },
+		]);
+		assert.equal(conversion.keptTerms, true);
+	});
+
+	it("maps a from: facet to a From clause", () => {
+		const conversion = convert("from:alerts@github.com");
+		assert.deepEqual(conversion.clauses, [
+			{ field: "From", value: "alerts@github.com" },
+		]);
+		assert.equal(conversion.keptTerms, false);
+	});
+
+	it("combines terms and a sender under an all-match operator", () => {
+		const conversion = convert("from:alerts@github.com pull request");
+		assert.equal(conversion.matchOperator, "all");
+		assert.deepEqual(conversion.clauses, [
+			{ field: "From", value: "alerts@github.com" },
+			{ field: "HasWords", value: "pull request" },
+		]);
+	});
+});
+
+describe("convertSearchToRule — facets with no clause equivalent", () => {
+	it("keeps a folder-scoped search OUT of the rule, never silently unscoping it", () => {
+		const conversion = convert("in:archive receipts");
+		assert.deepEqual(conversion.scopedOut, {
+			mailboxId: "mbx-archive",
+			label: "archive",
+		});
+		// The folder never becomes a clause.
+		assert.deepEqual(conversion.clauses, [
+			{ field: "HasWords", value: "receipts" },
+		]);
+	});
+
+	it("drops attachment, unread and date facets, naming each", () => {
+		const conversion = convert(
+			"invoice has:attachment is:unread before:2026-01-01 after:2025-01-01",
+		);
+		const labels = conversion.droppedFacets.map((facet) => facet.label);
+		assert.deepEqual(labels, [
+			"Has attachment",
+			"Unread",
+			"Before 2026-01-01",
+			"After 2025-01-01",
+		]);
+		assert.deepEqual(conversion.clauses, [
+			{ field: "HasWords", value: "invoice" },
+		]);
+	});
+
+	it("targets the account an account: facet names, without a clause for it", () => {
+		const conversion = convert("account:work standup");
+		assert.equal(conversion.targetAccountId, "acc-work");
+		assert.deepEqual(conversion.clauses, [
+			{ field: "HasWords", value: "standup" },
+		]);
+	});
+});
+
+describe("convertSearchToRule — semantic honesty (RFC 038 D5)", () => {
+	it("states the dropped reach when the search surfaced similar mail", () => {
+		// The literal filter cannot reproduce the reach the search just showed.
+		const conversion = convert("things like this", {
+			searchHadSemanticReach: true,
+		});
+		assert.equal(conversion.droppedSemantic, true);
+		// The literal words are still kept.
+		assert.deepEqual(conversion.clauses, [
+			{ field: "HasWords", value: "things like this" },
+		]);
+	});
+
+	it("says nothing when the search had no semantic reach to drop", () => {
+		const conversion = convert("things like this", {
+			searchHadSemanticReach: false,
+		});
+		assert.equal(conversion.droppedSemantic, false);
+	});
+
+	it("never reports dropped semantics for a facet-only search", () => {
+		const conversion = convert("from:a@b.com", {
+			searchHadSemanticReach: true,
+		});
+		assert.equal(conversion.keptTerms, false);
+		assert.equal(conversion.droppedSemantic, false);
+	});
+});
+
+describe("isConvertible / buildSearchRule", () => {
+	it("is not convertible when the search yields no clause", () => {
+		assert.equal(isConvertible(convert("has:attachment")), false);
+		assert.equal(isConvertible(convert("in:archive")), false);
+	});
+
+	it("is convertible once a term or sender is present", () => {
+		assert.equal(isConvertible(convert("in:archive receipts")), true);
+	});
+
+	it("builds a standing rule with stable clause ids, no widen, empty name", () => {
+		const rule = buildSearchRule(convert("from:a@b.com nightly"));
+		assert.equal(rule.scope, "standing");
+		assert.equal(rule.widen, undefined);
+		assert.equal(rule.name, "");
+		assert.deepEqual(
+			rule.clauses.map((clause) => clause.id),
+			["search-0", "search-1"],
+		);
+	});
+
+	it("honors an explicit scope and move target", () => {
+		const rule = buildSearchRule(convert("nightly"), {
+			scope: "once",
+			moveMailboxId: "mbx-archive",
+		});
+		assert.equal(rule.scope, "once");
+		assert.equal(rule.moveMailboxId, "mbx-archive");
+	});
+});

package/src/lib/organize/search-to-rule.ts

@@ -0,0 +1,161 @@
+import type {
+	ClauseField,
+	FilterRule,
+	MatchOperator,
+	RuleScope,
+} from "@remit/ui";
+import {
+	type ParsedSearchQuery,
+	type SearchToken,
+	searchTokenLabel,
+} from "../search-tokens";
+
+/**
+ * Filter-from-search (RFC 038 D5). A search is literal terms and facets; a filter
+ * is clause chips. This is the conversion between them — the current search
+ * becomes a pre-filled rule the shared chip editor opens on.
+ *
+ * The mapping is honest about what a filter cannot carry. A facet with no clause
+ * equivalent is never silently folded into the rule: a folder scope is reported
+ * as dropped-and-kept-out (the filter matches everywhere, not just there), the
+ * attribute facets (attachment / unread / date) are reported as left out, and a
+ * free-text query kept as a literal `HasWords` clause is reported as having lost
+ * its semantic "similar mail" reach on a deployment that cannot embed the query
+ * (D5). Pure functions only — the capability is injected, not probed here.
+ */
+
+export interface DroppedFacet {
+	/** The facet that had no clause equivalent. */
+	type: SearchToken["type"];
+	/** What was dropped, named for the user (e.g. "Has attachment", "Before 2026-01-01"). */
+	label: string;
+}
+
+export interface ScopedOutFolder {
+	mailboxId: string;
+	/** The folder the search was limited to. */
+	label: string;
+}
+
+export interface SearchConversion {
+	/** Clauses derived from the search — `From` (a `from:` facet) and `HasWords` (the free text). */
+	clauses: { field: ClauseField; value: string }[];
+	matchOperator: MatchOperator;
+	/** A folder an `in:` facet scoped the search to — kept OUT of the rule (never silently unscoped). */
+	scopedOut?: ScopedOutFolder;
+	/** Facets with no clause equivalent, each named. */
+	droppedFacets: DroppedFacet[];
+	/** The account an `account:` facet targets — the filter is created for it. */
+	targetAccountId?: string;
+	/** The search carried free-text terms, kept as a `HasWords` clause. */
+	keptTerms: boolean;
+	/**
+	 * The filter this conversion builds is always literal-only — free text has no
+	 * anchor message for a semantic widen — so the search's semantic "similar mail"
+	 * reach is dropped whenever the search had one (RFC 038 D5). True exactly when
+	 * free text was kept AND the search surfaced semantically-similar mail; on a
+	 * deployment with no semantic reach there was nothing to drop, so no note.
+	 */
+	droppedSemantic: boolean;
+}
+
+interface ConvertOptions {
+	/**
+	 * Whether the current search surfaced semantically-similar mail (a non-empty
+	 * "Related" section). This is the reach the literal filter cannot reproduce —
+	 * the direct existing signal, read from the search's own semantic results, not
+	 * a probe of deployment capability.
+	 */
+	searchHadSemanticReach: boolean;
+}
+
+const FACET_HAS_NO_CLAUSE: ReadonlySet<SearchToken["type"]> = new Set([
+	"hasAttachment",
+	"isUnread",
+	"before",
+	"after",
+]);
+
+/**
+ * Convert the current search into a rule's clauses and a record of what could not
+ * be carried. Terms become a `HasWords` clause; a `from:` facet a `From` clause;
+ * an `in:` facet a kept-out folder scope; `account:` the target account; the
+ * attribute facets are dropped. The search's terms are ANDed with its facets, so
+ * the rule matches all of them (`all`).
+ */
+export const convertSearchToRule = (
+	parsed: ParsedSearchQuery,
+	{ searchHadSemanticReach }: ConvertOptions,
+): SearchConversion => {
+	const clauses: SearchConversion["clauses"] = [];
+	const droppedFacets: DroppedFacet[] = [];
+	let scopedOut: ScopedOutFolder | undefined;
+	let targetAccountId: string | undefined;
+
+	for (const token of parsed.tokens) {
+		if (token.type === "from") {
+			clauses.push({ field: "From", value: token.value });
+			continue;
+		}
+		if (token.type === "in") {
+			scopedOut = { mailboxId: token.mailboxId, label: token.value };
+			continue;
+		}
+		if (token.type === "account") {
+			targetAccountId = token.accountId;
+			continue;
+		}
+		if (FACET_HAS_NO_CLAUSE.has(token.type)) {
+			droppedFacets.push({ type: token.type, label: searchTokenLabel(token) });
+		}
+	}
+
+	const freeText = parsed.freeText.trim();
+	const keptTerms = freeText.length > 0;
+	if (keptTerms) clauses.push({ field: "HasWords", value: freeText });
+
+	return {
+		clauses,
+		matchOperator: "all",
+		scopedOut,
+		droppedFacets,
+		targetAccountId,
+		keptTerms,
+		droppedSemantic: keptTerms && searchHadSemanticReach,
+	};
+};
+
+/**
+ * Whether the conversion yields a rule with something to match. A search of only
+ * dropped facets or a bare folder scope converts to no clauses, so there is no
+ * filter to open — the entry point offers nothing rather than an empty editor.
+ */
+export const isConvertible = (conversion: SearchConversion): boolean =>
+	conversion.clauses.length > 0;
+
+interface BuildRuleOptions {
+	scope?: RuleScope;
+	moveMailboxId?: string;
+}
+
+/**
+ * The rule the editor opens on, from a conversion. A search-derived rule defaults
+ * to a standing filter — "make this a filter" is a request to keep applying it —
+ * and the editor lets the user drop it back to a one-time apply. It carries no
+ * widen: a free-text query has no message anchor, so the semantic chip is not
+ * offered on this surface (its loss is stated in the conversion notice instead).
+ */
+export const buildSearchRule = (
+	conversion: SearchConversion,
+	{ scope = "standing", moveMailboxId }: BuildRuleOptions = {},
+): FilterRule => ({
+	clauses: conversion.clauses.map((clause, index) => ({
+		id: `search-${index}`,
+		field: clause.field,
+		value: clause.value,
+	})),
+	matchOperator: conversion.matchOperator,
+	moveMailboxId,
+	scope,
+	name: "",
+});

package/src/lib/self-update-state.ts

@@ -112,9 +112,10 @@ export function mapUpdatePhase(phase: RemitImapSystemUpdatePhase): UpdatePhase {
 
 /**
  * The surface has no entry point for this caller: `404` (no manifest URL
- * configured), `403` (authenticated but not the instance owner), or `401` (not
- * authenticated). All three render nothing and stop the poll, so a probe cannot
- * tell an off surface from a forbidden one.
+ * configured) or `401` (not authenticated). Both render nothing and stop the
+ * poll. `403` is treated the same way as defensive cover for any authenticated
+ * edge state, though the backend no longer distinguishes callers once the
+ * surface is on.
  */
 export function isSurfaceAbsent(error: unknown): boolean {
 	const status = getErrorStatus(error);