@remit/mailbox-service 0.0.110 → 0.0.112

package/src/filter-update.test.ts

@@ -0,0 +1,313 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	FilterDisabledReason,
+	FilterScope,
+	FilterState,
+} from "@remit/domain-enums";
+import { resolveFilterUpdate } from "./filter-operations.js";
+import type { Refusable } from "./refusal.js";
+
+const NOW = Date.parse("2026-09-25T12:00:00Z");
+
+const standing = {
+	scope: FilterScope.Standing,
+	expiresAt: undefined,
+	state: FilterState.Active,
+	disabledReason: FilterDisabledReason.None,
+	actionMailboxId: "mbx-invoices",
+};
+
+const awaiting = {
+	...standing,
+	state: FilterState.Disabled,
+	disabledReason: FilterDisabledReason.AwaitingFolder,
+	actionMailboxId: "None",
+};
+
+const acceptedValue = <T>(outcome: Refusable<T>): T => {
+	if (!outcome.ok) assert.fail(`refused: ${outcome.refusal.message}`);
+	return outcome.value;
+};
+
+const refusedWith = <T>(outcome: Refusable<T>, message: RegExp): void => {
+	assert.equal(outcome.ok, false, "expected a refusal");
+	if (outcome.ok) return;
+	assert.equal(outcome.refusal.kind, "Invalid");
+	assert.match(outcome.refusal.message, message);
+};
+
+describe("resolveFilterUpdate: state (#1103)", () => {
+	it("records UserDisabled when the user turns a filter off", () => {
+		assert.deepEqual(
+			resolveFilterUpdate(standing, { state: FilterState.Disabled }, NOW),
+			{
+				ok: true,
+				value: {
+					state: FilterState.Disabled,
+					disabledReason: FilterDisabledReason.UserDisabled,
+				},
+			},
+		);
+	});
+
+	for (const reason of [
+		FilterDisabledReason.UserDisabled,
+		FilterDisabledReason.AwaitingFolder,
+		FilterDisabledReason.FolderCreateFailed,
+		FilterDisabledReason.FolderMissing,
+	]) {
+		it(`clears ${reason} when the user turns the filter back on`, () => {
+			assert.deepEqual(
+				resolveFilterUpdate(
+					{ ...standing, state: FilterState.Disabled, disabledReason: reason },
+					{ state: FilterState.Active },
+					NOW,
+				),
+				{
+					ok: true,
+					value: {
+						state: FilterState.Active,
+						disabledReason: FilterDisabledReason.None,
+					},
+				},
+			);
+		});
+	}
+
+	it("keeps a disabled filter disabled, with its reason, through an expiry edit", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(
+				{ ...standing, state: FilterState.Disabled },
+				{
+					scope: FilterScope.Temporary,
+					expiresAt: "2027-01-01T00:00:00+00:00",
+				},
+				NOW,
+			),
+		);
+		assert.equal(resolved.state, FilterState.Disabled);
+		assert.equal("disabledReason" in resolved, false);
+	});
+
+	for (const reason of [
+		FilterDisabledReason.AwaitingFolder,
+		FilterDisabledReason.FolderCreateFailed,
+	]) {
+		it(`refuses to turn on a ${reason} filter that has no folder`, () => {
+			refusedWith(
+				resolveFilterUpdate(
+					{ ...awaiting, disabledReason: reason },
+					{ state: FilterState.Active },
+					NOW,
+				),
+				/pick a folder in the rule/i,
+			);
+		});
+
+		it(`turns on a ${reason} filter once the patch names a folder`, () => {
+			const resolved = acceptedValue(
+				resolveFilterUpdate(
+					{ ...awaiting, disabledReason: reason },
+					{ state: FilterState.Active, actionMailboxId: "mbx-picked" },
+					NOW,
+				),
+			);
+			assert.equal(resolved.state, FilterState.Active);
+		});
+	}
+
+	it("keeps a folderless reason when the user turns an awaiting filter off again", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(awaiting, { state: FilterState.Disabled }, NOW),
+		);
+		assert.equal(resolved.state, FilterState.Disabled);
+		assert.equal("disabledReason" in resolved, false);
+		refusedWith(
+			resolveFilterUpdate(awaiting, { state: FilterState.Active }, NOW),
+			/pick a folder in the rule/i,
+		);
+	});
+
+	it("keeps a lapsed folderless filter off when its date moves forward", () => {
+		const lapsed = {
+			...awaiting,
+			scope: FilterScope.Temporary,
+			expiresAt: "2026-01-01T00:00:00+00:00",
+			disabledReason: FilterDisabledReason.FolderCreateFailed,
+		};
+		const resolved = acceptedValue(
+			resolveFilterUpdate(
+				lapsed,
+				{
+					scope: FilterScope.Temporary,
+					expiresAt: "2027-01-01T00:00:00+00:00",
+				},
+				NOW,
+			),
+		);
+		assert.equal(resolved.state, FilterState.Disabled);
+		assert.equal("disabledReason" in resolved, false);
+		refusedWith(
+			resolveFilterUpdate(
+				{ ...lapsed, expiresAt: "2027-01-01T00:00:00+00:00" },
+				{ state: FilterState.Active },
+				NOW,
+			),
+			/pick a folder in the rule/i,
+		);
+	});
+
+	it("marks a folderless filter UserDisabled once the user picks a folder", () => {
+		assert.deepEqual(
+			resolveFilterUpdate(awaiting, { actionMailboxId: "mbx-picked" }, NOW),
+			{
+				ok: true,
+				value: {
+					actionMailboxId: "mbx-picked",
+					disabledReason: FilterDisabledReason.UserDisabled,
+				},
+			},
+		);
+	});
+
+	it("refuses Expired as a state the user sets", () => {
+		refusedWith(
+			resolveFilterUpdate(standing, { state: FilterState.Expired }, NOW),
+			/expires through its date/,
+		);
+	});
+
+	it("refuses to turn on a temporary filter whose date has passed", () => {
+		refusedWith(
+			resolveFilterUpdate(
+				{
+					...standing,
+					scope: FilterScope.Temporary,
+					expiresAt: "2026-01-01T00:00:00+00:00",
+					state: FilterState.Disabled,
+				},
+				{ state: FilterState.Active },
+				NOW,
+			),
+			/has expired/,
+		);
+	});
+
+	it("leaves a patch that names neither state nor timing untouched", () => {
+		assert.deepEqual(resolveFilterUpdate(standing, { name: "Receipts" }, NOW), {
+			ok: true,
+			value: { name: "Receipts" },
+		});
+	});
+});
+
+describe("resolveFilterUpdate: scope and expiry (reader #266)", () => {
+	it("moves Standing to Temporary given a future expiresAt", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(standing, {
+				scope: FilterScope.Temporary,
+				expiresAt: "2099-01-01T00:00:00+00:00",
+			}),
+		);
+		assert.equal(resolved.scope, FilterScope.Temporary);
+		assert.equal(resolved.expiresAt, "2099-01-01T00:00:00+00:00");
+		assert.equal(resolved.state, FilterState.Active);
+		assert.ok(resolved.ttl && resolved.ttl > 0);
+	});
+
+	it("refuses moving to Temporary without an expiresAt", () => {
+		refusedWith(
+			resolveFilterUpdate(standing, { scope: FilterScope.Temporary }),
+			/needs expiresAt/,
+		);
+	});
+
+	it("refuses an expiresAt that isn't paired with a Temporary scope", () => {
+		refusedWith(
+			resolveFilterUpdate(standing, { expiresAt: "2099-01-01T00:00:00+00:00" }),
+			/only applies to a Temporary/,
+		);
+	});
+
+	it("clears expiresAt/ttl and reports Active when moving Temporary to Standing", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(
+				{
+					...standing,
+					scope: FilterScope.Temporary,
+					expiresAt: "2020-01-01T00:00:00+00:00",
+					state: FilterState.Expired,
+				},
+				{ scope: FilterScope.Standing },
+			),
+		);
+		assert.equal(resolved.scope, FilterScope.Standing);
+		assert.equal(resolved.expiresAt, undefined);
+		assert.equal(resolved.ttl, undefined);
+		assert.equal(resolved.state, FilterState.Active);
+	});
+
+	it("recomputes ttl for an expiresAt-only change on an already-Temporary filter", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(
+				{
+					...standing,
+					scope: FilterScope.Temporary,
+					expiresAt: "2099-01-01T00:00:00+00:00",
+				},
+				{ expiresAt: "2099-06-01T00:00:00+00:00" },
+			),
+		);
+		assert.equal(resolved.scope, FilterScope.Temporary);
+		assert.equal(resolved.expiresAt, "2099-06-01T00:00:00+00:00");
+		assert.equal(
+			resolved.ttl,
+			Math.floor(new Date("2099-06-01T00:00:00+00:00").getTime() / 1000),
+		);
+		assert.equal(resolved.state, FilterState.Active);
+	});
+
+	it("reactivates a lapsed filter extended into the future", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(
+				{
+					...standing,
+					scope: FilterScope.Temporary,
+					expiresAt: "2020-01-01T00:00:00+00:00",
+					state: FilterState.Expired,
+				},
+				{ expiresAt: "2099-01-01T00:00:00+00:00" },
+			),
+		);
+		assert.equal(resolved.state, FilterState.Active);
+	});
+
+	it("reads Expired immediately when the new expiresAt is already in the past", () => {
+		const resolved = acceptedValue(
+			resolveFilterUpdate(
+				{
+					...standing,
+					scope: FilterScope.Temporary,
+					expiresAt: "2099-01-01T00:00:00+00:00",
+				},
+				{ expiresAt: "2020-01-01T00:00:00+00:00" },
+			),
+		);
+		assert.equal(resolved.state, FilterState.Expired);
+	});
+
+	it("rejects an unparseable expiresAt", () => {
+		assert.throws(
+			() =>
+				resolveFilterUpdate(standing, {
+					scope: FilterScope.Temporary,
+					expiresAt: "not-a-date",
+				}),
+			(error: unknown) => {
+				assert.equal((error as { statusCode?: number }).statusCode, 400);
+				return true;
+			},
+		);
+	});
+});

package/src/filters/filter-config.test.ts

@@ -1,51 +1,58 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	FilterItem,
-	IFilterAnchorRepository,
-	IFilterRepository,
-	IMessageLabelRepository,
-} from "@remit/data-ports";
-import { FilterMatchOperator, FilterState } from "@remit/domain-enums";
-import { _resetEmbeddingCapabilityForTest } from "@remit/search-service/capability";
-import type { PlacementMoveService } from "../placement-move.js";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import {
+	FilterClauseField,
+	FilterMatchOperator,
+	FilterScope,
+} from "@remit/domain-enums";
+import { PlacementMoveService } from "../placement-move.js";
+import {
+	openStore,
+	type Store,
+	seedAccount,
+	seedMailbox,
+} from "../test-helpers/test-store.js";
 import { buildFilterConfig, type FilterConfigDeps } from "./filter-config.js";
-import { type FilterMessage, NO_ACTION } from "./match.js";
-import { _resetMessageEmbedderForTest } from "./message-embedder.js";
-import { FilterPipeline, type MessageEmbedder } from "./pipeline.js";
-
-const anchorOnlyFilter = (destinationMailboxId: string): FilterItem =>
-	({
-		filterId: "flt-semantic",
+import type { FilterMessage } from "./match.js";
+import { FilterPipeline } from "./pipeline.js";
+
+let store: Store;
+let filterId: string;
+let accountId: string;
+let archiveId: string;
+
+beforeEach(async () => {
+	store = await openStore();
+	const account = await seedAccount(store, { accountConfigId: "cfg-1" });
+	accountId = account.accountId;
+	const archive = await seedMailbox(store, account, "Archive");
+	archiveId = archive.mailboxId;
+	const filter = await store.filter.create({
 		accountConfigId: "cfg-1",
 		name: "receipts",
-		scope: "Standing",
-		state: FilterState.Active,
-		hasAnchor: true,
-		ruleChangedAt: 1,
+		scope: FilterScope.Standing,
 		matchOperator: FilterMatchOperator.Or,
-		literalClauses: [],
-		actionLabelId: NO_ACTION,
-		actionMailboxId: destinationMailboxId,
-		createdAt: 1,
-		updatedAt: 1,
-	}) as unknown as FilterItem;
-
-const CURRENT_MODEL = "test-model@3";
+		literalClauses: [{ field: FilterClauseField.From, value: "stripe.com" }],
+		actionMailboxId: archive.mailboxId,
+	});
+	filterId = filter.filterId;
+});
 
-const repos = (filter: FilterItem): FilterConfigDeps => ({
-	filterService: {
-		listByAccountAndState: async () => [filter],
-		refreshExpiry: async (f: FilterItem) => f,
-	} as unknown as IFilterRepository,
-	filterAnchorService: {
-		get: async () => ({
-			anchorEmbedding: [1, 0, 0],
-			anchorEmbeddingId: CURRENT_MODEL,
-		}),
-	} as unknown as IFilterAnchorRepository,
-	messageLabelService: {} as unknown as IMessageLabelRepository,
-	placementMoveService: {} as unknown as PlacementMoveService,
+afterEach(() => store.close());
+
+const repos = (): FilterConfigDeps => ({
+	filterService: store.filter,
+	messageLabelService: store.messageLabel,
+	mailboxService: store.mailbox,
+	placementMoveService: new PlacementMoveService({
+		messageService: store.message,
+		threadMessageService: store.threadMessage,
+		markerService: store.placementMove,
+		addressService: store.address,
+		mailboxSpecialUseService: store.mailboxSpecialUse,
+		mailboxService: store.mailbox,
+		sqsQueueUrl: "https://sqs.test/message-mgmt",
+	}),
 });
 
 const message: FilterMessage = {
@@ -58,172 +65,23 @@ const message: FilterMessage = {
 
 describe("buildFilterConfig", () => {
 	it("returns undefined without a placement mover — no move path, filters stay off", () => {
-		const deps = repos(anchorOnlyFilter("mbx-archive"));
+		const deps = repos();
 		deps.placementMoveService = undefined;
 
 		assert.equal(buildFilterConfig(deps), undefined);
 	});
 
-	it("wires an embedder into the config", () => {
-		const config = buildFilterConfig(repos(anchorOnlyFilter("mbx-archive")));
-
-		assert.ok(config);
-		assert.ok(config.embedder);
-	});
-
-	it("lights up a semantic anchor-only filter on the body-sync pass", async () => {
-		let embedCalls = 0;
-		const embedder: MessageEmbedder = {
-			embed: async () => {
-				embedCalls += 1;
-				return [1, 0, 0];
-			},
-			embeddingId: CURRENT_MODEL,
-		};
-		const config = buildFilterConfig(
-			repos(anchorOnlyFilter("mbx-archive")),
-			embedder,
-		);
+	it("runs a literal filter on the body-sync pass", async () => {
+		const config = buildFilterConfig(repos());
 		assert.ok(config);
 
 		const decision = await new FilterPipeline(config, {
 			info: () => {},
-		}).evaluate("cfg-1", "m-1", message);
+		}).evaluate("cfg-1", accountId, "m-1", message);
 
 		assert.deepEqual(decision.move, {
-			destinationMailboxId: "mbx-archive",
-			filterId: "flt-semantic",
-		});
-		assert.equal(embedCalls, 1);
-	});
-
-	it("does not match when the message embedding diverges from the anchor", async () => {
-		const embedder: MessageEmbedder = {
-			embed: async () => [0, 1, 0],
-			embeddingId: CURRENT_MODEL,
-		};
-		const config = buildFilterConfig(
-			repos(anchorOnlyFilter("mbx-archive")),
-			embedder,
-		);
-		assert.ok(config);
-
-		const decision = await new FilterPipeline(config, {
-			info: () => {},
-		}).evaluate("cfg-1", "m-2", message);
-
-		assert.equal(decision.move, undefined);
-	});
-});
-
-// An instance with semantic search off (issue #1068). `off` selects an embedder
-// that throws by design, and the throw lands in the pipeline's per-filter catch:
-// one error-level `filter_anchor_match_failed` for every semantic filter on
-// every message it syncs. The pipeline already has a designed skip for a
-// missing embedder, so the config passes none.
-describe("buildFilterConfig with semantic search off", () => {
-	const withProviderOff = async (body: () => Promise<void>): Promise<void> => {
-		const previous = process.env.SEARCH_EMBEDDING_PROVIDER;
-		process.env.SEARCH_EMBEDDING_PROVIDER = "off";
-		_resetMessageEmbedderForTest();
-		try {
-			await body();
-		} finally {
-			if (previous === undefined) {
-				delete process.env.SEARCH_EMBEDDING_PROVIDER;
-			} else {
-				process.env.SEARCH_EMBEDDING_PROVIDER = previous;
-			}
-			_resetMessageEmbedderForTest();
-		}
-	};
-
-	it("wires no embedder", async () => {
-		await withProviderOff(async () => {
-			const config = buildFilterConfig(repos(anchorOnlyFilter("mbx-archive")));
-
-			assert.ok(config);
-			assert.equal(config.embedder, undefined);
-		});
-	});
-
-	it("skips the semantic filter without logging an error", async () => {
-		await withProviderOff(async () => {
-			const config = buildFilterConfig(repos(anchorOnlyFilter("mbx-archive")));
-			assert.ok(config);
-
-			const errors: unknown[] = [];
-			const decision = await new FilterPipeline(config, {
-				info: () => {},
-				debug: () => {},
-				warn: () => {},
-				error: (fields) => errors.push(fields.alert),
-			}).evaluate("cfg-1", "m-off", message);
-
-			assert.deepEqual(decision.labels, []);
-			assert.equal(decision.move, undefined);
-			assert.deepEqual(errors, []);
+			destinationMailboxId: archiveId,
+			filterId,
 		});
 	});
 });
-
-// The self-host `local` profile asks for the Transformers.js embedder, but the
-// backend and imap-worker images ship without `@huggingface/transformers`
-// (npm-scripts/docker-bundle.mjs). The first embed throws ERR_MODULE_NOT_FOUND,
-// which is the same capability absence `off` states and must take the same
-// designed skip — not an error-level `filter_anchor_match_failed` per semantic
-// filter per message on a user-facing GET.
-describe("buildFilterConfig when this deployment carries no embedder", () => {
-	const moduleNotFound = (): Error =>
-		Object.assign(
-			new Error("Cannot find package '@huggingface/transformers'"),
-			{ code: "ERR_MODULE_NOT_FOUND" },
-		);
-
-	it("skips the semantic filter, logs no error, and stops wiring an embedder", async () => {
-		const previous = process.env.SEARCH_EMBEDDING_PROVIDER;
-		process.env.SEARCH_EMBEDDING_PROVIDER = "local";
-		_resetMessageEmbedderForTest();
-		_resetEmbeddingCapabilityForTest();
-
-		try {
-			const unavailable: MessageEmbedder = {
-				embed: async () => {
-					throw moduleNotFound();
-				},
-				embeddingId: CURRENT_MODEL,
-			};
-			const config = buildFilterConfig(
-				repos(anchorOnlyFilter("mbx-archive")),
-				unavailable,
-			);
-			assert.ok(config);
-
-			const errors: unknown[] = [];
-			const decision = await new FilterPipeline(config, {
-				info: () => {},
-				debug: () => {},
-				warn: () => {},
-				error: (fields) => errors.push(fields.alert),
-			}).evaluate("cfg-1", "m-local", message);
-
-			assert.deepEqual(decision.labels, []);
-			assert.equal(decision.move, undefined);
-			assert.deepEqual(errors, []);
-
-			// Probed once, not per filter or per message: every later config on this
-			// process wires no embedder at all, so nothing else attempts the embed.
-			const next = buildFilterConfig(repos(anchorOnlyFilter("mbx-archive")));
-			assert.ok(next);
-			assert.equal(next.embedder, undefined);
-		} finally {
-			if (previous === undefined) {
-				delete process.env.SEARCH_EMBEDDING_PROVIDER;
-			} else {
-				process.env.SEARCH_EMBEDDING_PROVIDER = previous;
-			}
-			_resetMessageEmbedderForTest();
-			_resetEmbeddingCapabilityForTest();
-		}
-	});
-});

package/src/filters/filter-config.ts

@@ -1,52 +1,20 @@
 import type {
-	IFilterAnchorRepository,
 	IFilterRepository,
 	IMessageLabelRepository,
 } from "@remit/data-ports";
-import { isEmbeddingCapabilityUnavailable } from "@remit/search-service/capability";
-import {
-	EMBEDDING_PROVIDER_OFF,
-	readEmbeddingProviderFromEnv,
-} from "@remit/search-service/from-env";
 import type { PlacementMoveService } from "../placement-move.js";
-import { getMessageEmbedder } from "./message-embedder.js";
-import type { FilterConfig, MessageEmbedder } from "./pipeline.js";
+import type { FilterConfig } from "./pipeline.js";
 
 export interface FilterConfigDeps {
 	filterService: IFilterRepository;
-	filterAnchorService: IFilterAnchorRepository;
 	messageLabelService: IMessageLabelRepository;
+	mailboxService: FilterConfig["mailboxService"];
 	placementMoveService?: PlacementMoveService;
 }
 
-/**
- * The env-selected embedder, or none on an instance that cannot embed.
- *
- * `off` embeds nothing by design, and its embedder says so by throwing
- * (EmbeddingDisabledError). The pipeline has a designed skip for a *missing*
- * embedder — semantic filters are passed over and logged at debug — but a
- * present embedder that throws lands in the per-filter catch instead, which is
- * an error-level `filter_anchor_match_failed` for every semantic filter on
- * every synced message. Same outcome, a log nobody can read.
- *
- * `local` on the self-host profiles reaches the same place by a different road:
- * the backend and imap-worker images ship without `@huggingface/transformers`,
- * so the first embed throws ERR_MODULE_NOT_FOUND. The pipeline classifies that
- * one throw through `@remit/search-service/capability` and remembers it, and
- * from then on the config here wires no embedder either — one probe per process,
- * not one per filter per message.
- */
-const embedderFromEnv = (): MessageEmbedder | undefined =>
-	readEmbeddingProviderFromEnv() === EMBEDDING_PROVIDER_OFF ||
-	isEmbeddingCapabilityUnavailable()
-		? undefined
-		: getMessageEmbedder();
-
 /**
  * Assemble the filter config a body-materializing pass runs (RFC 034), shared by
- * the imap-worker's sync path and the backend's read-path backfill so both embed
- * under the same model that produced the anchors — a semantic (anchor-only)
- * filter is evaluated on either path instead of silently skipped.
+ * the imap-worker's sync path and the backend's read-path backfill.
  *
  * Absent the placement mover there is no move path, so filters stay off — a
  * matched filter's actions reuse the same enqueue plumbing the placement mover
@@ -54,16 +22,13 @@ const embedderFromEnv = (): MessageEmbedder | undefined =>
  */
 export const buildFilterConfig = (
 	deps: FilterConfigDeps,
-	embedder?: MessageEmbedder,
 ): FilterConfig | undefined => {
 	const { placementMoveService } = deps;
 	if (!placementMoveService) return undefined;
-	const resolved = embedder ?? embedderFromEnv();
 	return {
 		filterService: deps.filterService,
-		filterAnchorService: deps.filterAnchorService,
 		messageLabelService: deps.messageLabelService,
+		mailboxService: deps.mailboxService,
 		placementMoveService,
-		...(resolved ? { embedder: resolved } : {}),
 	};
 };