@remit/backend 0.0.25 → 0.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

package/src/derive/autoMoved.test.ts

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { MessageItem } from "@remit/data-ports";
+import { PlacementAction, PlacementConfidence } from "@remit/domain-enums";
+import { deriveAutoMoved } from "./autoMoved.js";
+
+type AutoMovedInput = Pick<
+	MessageItem,
+	"movedByRemit" | "placementVerdict" | "filterMove"
+>;
+
+const confidentVerdict = {
+	action: PlacementAction.MoveToInbox,
+	confidence: PlacementConfidence.Confident,
+	fromPlacement: "junk",
+	reasons: ["provider=spam", "dmarc=pass"],
+	dryRun: false,
+	decidedAt: 1_700_000_000_000,
+};
+
+const filterMove = {
+	filterId: "flt-1",
+	sourceMailboxId: "mb-inbox",
+	destinationMailboxId: "mb-travel",
+	decidedAt: 1_700_000_000_000,
+};
+
+describe("deriveAutoMoved", () => {
+	it("returns undefined when the message was not moved by Remit", () => {
+		const message: AutoMovedInput = {
+			movedByRemit: false,
+			placementVerdict: confidentVerdict,
+		};
+		assert.equal(deriveAutoMoved(message), undefined);
+	});
+
+	it("projects a standing-filter move to its mailbox ids and filter id", () => {
+		const message: AutoMovedInput = { movedByRemit: true, filterMove };
+		assert.deepEqual(deriveAutoMoved(message), {
+			fromMailboxId: "mb-inbox",
+			destinationMailboxId: "mb-travel",
+			filterId: "flt-1",
+		});
+	});
+
+	it("never leaks the classifier action/fromPlacement for a filter move", () => {
+		const result = deriveAutoMoved({ movedByRemit: true, filterMove });
+		assert.equal(result?.action, undefined);
+		assert.equal(result?.fromPlacement, undefined);
+	});
+
+	it("a filter move outranks a co-present placement verdict", () => {
+		// Both a filter move and a classifier verdict can be recorded; the filter's
+		// exclusive move is what ultimately placed the message (RFC 034 Dec. 3.1).
+		const message: AutoMovedInput = {
+			movedByRemit: true,
+			filterMove,
+			placementVerdict: confidentVerdict,
+		};
+		assert.deepEqual(deriveAutoMoved(message), {
+			fromMailboxId: "mb-inbox",
+			destinationMailboxId: "mb-travel",
+			filterId: "flt-1",
+		});
+	});
+
+	it("projects a confident classifier move to action + fromPlacement", () => {
+		const message: AutoMovedInput = {
+			movedByRemit: true,
+			placementVerdict: confidentVerdict,
+		};
+		assert.deepEqual(deriveAutoMoved(message), {
+			action: PlacementAction.MoveToInbox,
+			fromPlacement: "junk",
+		});
+	});
+
+	it("drops an unsure classifier verdict", () => {
+		const message: AutoMovedInput = {
+			movedByRemit: true,
+			placementVerdict: {
+				...confidentVerdict,
+				confidence: PlacementConfidence.Unsure,
+			},
+		};
+		assert.equal(deriveAutoMoved(message), undefined);
+	});
+
+	it("drops a dry-run classifier verdict", () => {
+		const message: AutoMovedInput = {
+			movedByRemit: true,
+			placementVerdict: { ...confidentVerdict, dryRun: true },
+		};
+		assert.equal(deriveAutoMoved(message), undefined);
+	});
+
+	it("does not crash on legacy verdict-less, filter-less moved data", () => {
+		// A message moved before either the verdict or the filter marker existed:
+		// movedByRemit is set but nothing is derivable. Must return undefined, not
+		// throw (issue #223 back-compat).
+		const message: AutoMovedInput = { movedByRemit: true };
+		assert.equal(deriveAutoMoved(message), undefined);
+	});
+});

package/src/derive/autoMoved.ts

@@ -3,19 +3,47 @@ import type { MessageItem } from "@remit/data-ports";
 import { PlacementConfidence } from "@remit/domain-enums";
 
 /**
- * Project a Message's internal placement verdict to the public `AutoMovedInfo`
- * shape. Present only for a real, in-effect auto-move — `movedByRemit` is
- * true, the verdict is `Confident`, and it was not a dry run. Confidence,
- * dryRun, decidedAt and reasons are internal diagnostics and never cross to
- * the wire; the client derives everything else (whether the move is still in
- * effect, the undo target) from `action`/`fromPlacement` plus current
- * placement.
+ * Project a Message's internal auto-move state to the public `AutoMovedInfo`
+ * shape. Present only for a real, in-effect auto-move; absent otherwise, so a
+ * message synced before either mechanism existed (no `filterMove`, no
+ * `placementVerdict`) projects nothing and renders no badge.
+ *
+ * Two mechanisms move mail and both raise `movedByRemit`:
+ *
+ * 1. A standing filter (RFC 034) records a `filterMove` marker naming the
+ *    source folder, the destination folder, and the filter. It has no
+ *    classifier direction/role, so the projection carries mailbox ids
+ *    (`fromMailboxId`/`destinationMailboxId`) and the `filterId` for the
+ *    Settings link — an arbitrary destination the Inbox/Junk-shaped `action`
+ *    cannot name.
+ * 2. The Tier 0 classifier records a `placementVerdict`. Its `action`
+ *    (MoveToInbox/MoveToJunk) and `fromPlacement` (inbox/junk/other) are the
+ *    only fields that cross to the wire; confidence, dryRun, decidedAt and
+ *    reasons stay internal.
+ *
+ * The filter marker outranks the verdict check: a matched filter's move is
+ * exclusive and outranks the classifier's placement move at index time (RFC 034
+ * Decision 3.1), so a message carrying both was ultimately moved by the filter.
+ * The client derives everything else (whether the move is still in effect, the
+ * undo target) from these fields plus current placement.
  */
 export const deriveAutoMoved = (
-	message: Pick<MessageItem, "movedByRemit" | "placementVerdict">,
+	message: Pick<
+		MessageItem,
+		"movedByRemit" | "placementVerdict" | "filterMove"
+	>,
 ): AutoMovedInfo | undefined => {
 	if (message.movedByRemit !== true) return undefined;
 
+	const filterMove = message.filterMove;
+	if (filterMove) {
+		return {
+			fromMailboxId: filterMove.sourceMailboxId,
+			destinationMailboxId: filterMove.destinationMailboxId,
+			filterId: filterMove.filterId,
+		};
+	}
+
 	const verdict = message.placementVerdict;
 	if (!verdict) return undefined;
 	if (verdict.confidence !== PlacementConfidence.Confident) return undefined;

package/src/service/create-remit-client.ts

@@ -33,6 +33,7 @@ import {
 	MailboxQueueService,
 	MessageMoveService,
 	OutboxQueueService,
+	PlacementMoveService,
 } from "@remit/mailbox-service";
 import { createSearchService, type SearchService } from "@remit/search-service";
 import {
@@ -287,6 +288,34 @@ export const createRemitClient = (deps: RemitClientDeps): RemitClient => {
 		bodySyncQueue,
 	} = deps;
 
+	// The read-path body backfill (describeMessage / getRawMessage →
+	// fetchAndGetBody) materializes a body that was never sync-synced, and must
+	// run the account's standing filters the same way the imap-worker's sync path
+	// does. Without this, a message a user opens before background body-sync is
+	// classified but never filter-evaluated — and once its body is stored the
+	// filter-capable sync path skips it, so an explicit standing filter silently
+	// never fires (issue #223). Only the explicit user-rule half is wired here;
+	// heuristic classifier placement stays on the sync path. Wired like
+	// `sync-message-body.ts`, over the message-management queue's local-first
+	// PlacementMoveService; filters stay off when that queue is unset.
+	const placementMoveQueueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+	const placementMoveService = placementMoveQueueUrl
+		? new PlacementMoveService({
+				messageService: repositories.message,
+				threadMessageService: repositories.threadMessage,
+				markerService: repositories.placementMove,
+				sqsQueueUrl: placementMoveQueueUrl,
+			})
+		: undefined;
+	const filterConfig = placementMoveService
+		? {
+				filterService: repositories.filter,
+				filterAnchorService: repositories.filterAnchor,
+				messageLabelService: repositories.messageLabel,
+				placementMoveService,
+			}
+		: undefined;
+
 	const bodySync = new BodySyncService(
 		repositories.message,
 		storage,
@@ -294,6 +323,8 @@ export const createRemitClient = (deps: RemitClientDeps): RemitClient => {
 		repositories.address,
 		repositories.envelope,
 		logger,
+		undefined,
+		filterConfig,
 	);
 
 	const flagPushService = new FlagPushService({