@remit/mailbox-service 0.0.112 → 0.0.113

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

@@ -1,87 +0,0 @@
-import assert from "node:assert/strict";
-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 } 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: FilterScope.Standing,
-		matchOperator: FilterMatchOperator.Or,
-		literalClauses: [{ field: FilterClauseField.From, value: "stripe.com" }],
-		actionMailboxId: archive.mailboxId,
-	});
-	filterId = filter.filterId;
-});
-
-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 = {
-	from: "billing@stripe.com",
-	fromName: "Stripe",
-	subject: "Your receipt",
-	text: "Thanks for your payment",
-	listId: "",
-};
-
-describe("buildFilterConfig", () => {
-	it("returns undefined without a placement mover — no move path, filters stay off", () => {
-		const deps = repos();
-		deps.placementMoveService = undefined;
-
-		assert.equal(buildFilterConfig(deps), undefined);
-	});
-
-	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", accountId, "m-1", message);
-
-		assert.deepEqual(decision.move, {
-			destinationMailboxId: archiveId,
-			filterId,
-		});
-	});
-});

package/src/filters/filter-config.ts

@@ -1,34 +0,0 @@
-import type {
-	IFilterRepository,
-	IMessageLabelRepository,
-} from "@remit/data-ports";
-import type { PlacementMoveService } from "../placement-move.js";
-import type { FilterConfig } from "./pipeline.js";
-
-export interface FilterConfigDeps {
-	filterService: IFilterRepository;
-	messageLabelService: IMessageLabelRepository;
-	mailboxService: FilterConfig["mailboxService"];
-	placementMoveService?: PlacementMoveService;
-}
-
-/**
- * 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.
- *
- * 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
- * owns.
- */
-export const buildFilterConfig = (
-	deps: FilterConfigDeps,
-): FilterConfig | undefined => {
-	const { placementMoveService } = deps;
-	if (!placementMoveService) return undefined;
-	return {
-		filterService: deps.filterService,
-		messageLabelService: deps.messageLabelService,
-		mailboxService: deps.mailboxService,
-		placementMoveService,
-	};
-};

package/src/filters/list-id.test.ts

@@ -1,50 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { simpleParser } from "mailparser";
-import { extractListId, normalizeListId } from "./list-id.js";
-
-const parse = async (lines: string[]) =>
-	simpleParser(Buffer.from(lines.join("\r\n")));
-
-describe("normalizeListId", () => {
-	it("extracts the bracketed identifier and folds case", () => {
-		assert.equal(
-			normalizeListId("Weekly News <Weekly.News.Example.COM>"),
-			"weekly.news.example.com",
-		);
-	});
-
-	it("keeps a bare value and folds case", () => {
-		assert.equal(
-			normalizeListId("  Weekly.News.Example.COM  "),
-			"weekly.news.example.com",
-		);
-	});
-
-	it("normalizes an empty value to the empty string", () => {
-		assert.equal(normalizeListId("   "), "");
-	});
-});
-
-describe("extractListId", () => {
-	it("reads and normalizes a List-Id header", async () => {
-		const parsed = await parse([
-			"From: list@example.com",
-			"Subject: hi",
-			"List-Id: Weekly News <weekly.news.example.com>",
-			"",
-			"body",
-		]);
-		assert.equal(extractListId(parsed), "weekly.news.example.com");
-	});
-
-	it("returns the empty string when there is no List-Id header", async () => {
-		const parsed = await parse([
-			"From: alice@example.com",
-			"Subject: hi",
-			"",
-			"body",
-		]);
-		assert.equal(extractListId(parsed), "");
-	});
-});

package/src/filters/match.test.ts

@@ -1,392 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { FilterItem } from "@remit/data-ports";
-import { FilterClauseField, FilterMatchOperator } from "@remit/domain-enums";
-import {
-	clauseMatches,
-	type FilterMessage,
-	literalClausesMatch,
-	literalClauseTerms,
-	selectMoveWinner,
-} from "./match.js";
-
-type FilterClause = FilterItem["literalClauses"][number];
-
-const message = (overrides: Partial<FilterMessage> = {}): FilterMessage => ({
-	from: "alice@acme.example",
-	fromName: "Alice Example",
-	subject: "Q3 invoice attached",
-	text: "Please find the invoice for the quarter attached.",
-	listId: "",
-	...overrides,
-});
-
-const clause = (field: FilterClause["field"], value: string): FilterClause => ({
-	field,
-	value,
-});
-
-describe("clauseMatches", () => {
-	it("matches From against the sender address, case-insensitively", () => {
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.From, "ACME.example"), message()),
-			true,
-		);
-	});
-
-	it("matches From against the sender display name", () => {
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.From, "alice example"), message()),
-			true,
-		);
-	});
-
-	it("matches Subject as a substring", () => {
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.Subject, "invoice"), message()),
-			true,
-		);
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.Subject, "receipt"), message()),
-			false,
-		);
-	});
-
-	it("matches HasWords against subject or body", () => {
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.HasWords, "quarter"), message()),
-			true,
-		);
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.HasWords, "Q3"), message()),
-			true,
-		);
-	});
-
-	it("matches HasWords on the sender display name alone, as search does", () => {
-		const msg = message({
-			from: "booking@mail.example",
-			fromName: "Austrian Airlines Booking",
-			subject: "Your trip to Vienna",
-			text: "Check in opens 24 hours before departure.",
-		});
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.HasWords, "Austrian airlines"),
-				msg,
-			),
-			true,
-		);
-	});
-
-	it("matches HasWords regardless of word order and case", () => {
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.HasWords, "ALICE invoice"),
-				message(),
-			),
-			true,
-		);
-	});
-
-	it("does not match HasWords when one word is missing", () => {
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.HasWords, "invoice receipt"),
-				message(),
-			),
-			false,
-		);
-	});
-
-	it("never matches an empty clause value", () => {
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.HasWords, "   "), message()),
-			false,
-		);
-	});
-
-	it("matches ListId exactly, never as a substring", () => {
-		const msg = message({ listId: "weekly.news.example.com" });
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.ListId, "weekly.news.example.com"),
-				msg,
-			),
-			true,
-		);
-		assert.equal(
-			clauseMatches(clause(FilterClauseField.ListId, "news.example.com"), msg),
-			false,
-		);
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.ListId, "weekly.news.example.com.other"),
-				msg,
-			),
-			false,
-		);
-	});
-
-	it("normalizes ListId brackets and case on both sides", () => {
-		const msg = message({ listId: "weekly.news.example.com" });
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.ListId, "<Weekly.News.Example.COM>"),
-				msg,
-			),
-			true,
-		);
-	});
-
-	it("never matches ListId on a message with no List-Id", () => {
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.ListId, "weekly.news.example.com"),
-				message({ listId: "" }),
-			),
-			false,
-		);
-	});
-
-	it("matches FromDomain on the registrable domain, including subdomains", () => {
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.FromDomain, "github.com"),
-				message({ from: "notifications@github.com" }),
-			),
-			true,
-		);
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.FromDomain, "github.com"),
-				message({ from: "notifications@sub.github.com" }),
-			),
-			true,
-		);
-	});
-
-	it("never matches FromDomain on a look-alike subdomain (public-suffix aware)", () => {
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.FromDomain, "github.com"),
-				message({ from: "attacker@github.com.evil.example" }),
-			),
-			false,
-		);
-	});
-
-	it("matches FromDomain across multi-level public suffixes", () => {
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.FromDomain, "example.co.uk"),
-				message({ from: "hr@mail.example.co.uk" }),
-			),
-			true,
-		);
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.FromDomain, "example.co.uk"),
-				message({ from: "hr@example.co.uk.evil.example" }),
-			),
-			false,
-		);
-	});
-});
-
-describe("literalClausesMatch", () => {
-	it("passes vacuously with no clauses", () => {
-		assert.equal(
-			literalClausesMatch([], FilterMatchOperator.And, message()),
-			true,
-		);
-	});
-
-	it("And requires every clause to match", () => {
-		const clauses = [
-			clause(FilterClauseField.From, "acme.example"),
-			clause(FilterClauseField.Subject, "invoice"),
-		];
-		assert.equal(
-			literalClausesMatch(clauses, FilterMatchOperator.And, message()),
-			true,
-		);
-		assert.equal(
-			literalClausesMatch(
-				[...clauses, clause(FilterClauseField.Subject, "nope")],
-				FilterMatchOperator.And,
-				message(),
-			),
-			false,
-		);
-	});
-
-	it("Or requires only one clause to match", () => {
-		const clauses = [
-			clause(FilterClauseField.Subject, "nope"),
-			clause(FilterClauseField.Subject, "invoice"),
-		];
-		assert.equal(
-			literalClausesMatch(clauses, FilterMatchOperator.Or, message()),
-			true,
-		);
-		assert.equal(
-			literalClausesMatch(
-				[clause(FilterClauseField.Subject, "nope")],
-				FilterMatchOperator.Or,
-				message(),
-			),
-			false,
-		);
-	});
-});
-
-describe("selectMoveWinner", () => {
-	const filter = (
-		filterId: string,
-		actionChangedAt: number,
-		ruleChangedAt = actionChangedAt,
-	): FilterItem => ({ filterId, actionChangedAt, ruleChangedAt }) as FilterItem;
-
-	it("returns undefined with no candidates", () => {
-		assert.equal(selectMoveWinner([]), undefined);
-	});
-
-	it("picks the most-recently action-changed filter", () => {
-		const winner = selectMoveWinner([
-			filter("a", 100),
-			filter("b", 300),
-			filter("c", 200),
-		]);
-		assert.equal(winner?.filterId, "b");
-	});
-
-	it("tie-breaks on filterId when actionChangedAt is identical", () => {
-		const winner = selectMoveWinner([
-			filter("a", 100),
-			filter("c", 100),
-			filter("b", 100),
-		]);
-		assert.equal(winner?.filterId, "c");
-	});
-
-	it("ignores a ruleChangedAt-only bump — extending scope/expiry alone must not promote a filter to move-winner (reader #384)", () => {
-		// filter A's predicate/action last changed at 10:00 (actionChangedAt).
-		// filter B was created at 09:00 and never had its predicate/action
-		// touched since, but a user extended its expiry at 11:00 — bumping only
-		// its ruleChangedAt (RFC 034 Decision 3.2 / #294), not what it matches or
-		// does. B must not out-rank A.
-		const filterA = filter("filter-a", 10_00);
-		const filterB = filter("filter-b", 9_00, 11_00);
-
-		const winner = selectMoveWinner([filterA, filterB]);
-		assert.equal(
-			winner?.filterId,
-			"filter-a",
-			"A still wins: its actionChangedAt (10:00) beats B's (09:00), even though B's ruleChangedAt (11:00) is later",
-		);
-	});
-});
-
-describe("literalClauseTerms (reader #459)", () => {
-	it("narrows From and Subject onto the columns that carry them", () => {
-		assert.deepEqual(
-			literalClauseTerms(
-				[
-					clause(FilterClauseField.From, " alice@acme.example "),
-					clause(FilterClauseField.Subject, "invoice"),
-				],
-				FilterMatchOperator.And,
-			),
-			{
-				terms: [
-					{ field: "sender", contains: "alice@acme.example" },
-					{ field: "subject", contains: "invoice" },
-				],
-				operator: "and",
-			},
-		);
-	});
-
-	it("narrows FromDomain to the registrable domain, which the sender always contains", () => {
-		const narrowing = literalClauseTerms(
-			[clause(FilterClauseField.FromDomain, "billing@mail.acme.example")],
-			FilterMatchOperator.And,
-		);
-
-		assert.deepEqual(narrowing?.terms, [
-			{ field: "sender", contains: "acme.example" },
-		]);
-		assert.equal(
-			clauseMatches(
-				clause(FilterClauseField.FromDomain, "billing@mail.acme.example"),
-				message(),
-			),
-			true,
-		);
-	});
-
-	it("narrows ListId to its canonical form", () => {
-		assert.deepEqual(
-			literalClauseTerms(
-				[clause(FilterClauseField.ListId, "News <Weekly.News.Example.com>")],
-				FilterMatchOperator.And,
-			)?.terms,
-			[{ field: "listId", contains: "weekly.news.example.com" }],
-		);
-	});
-
-	it("returns null for clauses nothing can satisfy, so no query is worth running", () => {
-		assert.equal(
-			literalClauseTerms(
-				[clause(FilterClauseField.From, "   ")],
-				FilterMatchOperator.And,
-			),
-			null,
-		);
-		assert.equal(
-			literalClauseTerms(
-				[clause(FilterClauseField.FromDomain, "not a domain")],
-				FilterMatchOperator.Or,
-			),
-			null,
-		);
-	});
-
-	it("drops an unsatisfiable clause from an Or instead of losing the rest", () => {
-		assert.deepEqual(
-			literalClauseTerms(
-				[
-					clause(FilterClauseField.From, ""),
-					clause(FilterClauseField.Subject, "invoice"),
-				],
-				FilterMatchOperator.Or,
-			),
-			{ terms: [{ field: "subject", contains: "invoice" }], operator: "or" },
-		);
-	});
-
-	it("narrows nothing when an Or reaches a clause no column carries", () => {
-		assert.deepEqual(
-			literalClauseTerms(
-				[
-					clause(FilterClauseField.HasWords, "quarter"),
-					clause(FilterClauseField.Subject, "invoice"),
-				],
-				FilterMatchOperator.Or,
-			),
-			{ terms: [], operator: "or" },
-		);
-	});
-
-	it("narrows nothing for no clauses, matching the vacuous pass of literalClausesMatch", () => {
-		assert.deepEqual(literalClauseTerms([], FilterMatchOperator.And), {
-			terms: [],
-			operator: "and",
-		});
-		assert.equal(
-			literalClausesMatch([], FilterMatchOperator.And, message()),
-			true,
-		);
-	});
-});