@remit/backend 0.0.108 → 0.0.110

package/package.json

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

package/src/derive/enrichThreadRows.test.ts

@@ -9,7 +9,11 @@ import type {
 } from "@remit/data-ports";
 import { deriveAddressId } from "@remit/data-ports/id";
 import { hasAbandonedDelete } from "@remit/data-ports/message-settlement";
-import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
+import {
+	MessageMutation,
+	MessageStatus,
+	MessageSyncStatus,
+} from "@remit/domain-enums";
 import { type EnrichClient, enrichThreadRows } from "./enrichThreadRows.js";
 
 const threadRow = (
@@ -273,22 +277,45 @@ describe("enrichThreadRows — the mutation pair", () => {
 		return result;
 	};
 
-	test("projects the pair an abandoned delete leaves behind", async () => {
+	test("projects the pair an abandoned delete leaves behind, and what it gave up on", async () => {
 		const result = await project({
 			status: MessageStatus.active,
-			syncStatus: MessageSyncStatus.failed,
+			syncStatus: MessageSyncStatus.abandoned,
+			abandonedMutation: MessageMutation.delete,
 		});
 		assert.equal(result?.status, MessageStatus.active);
-		assert.equal(result?.syncStatus, MessageSyncStatus.failed);
+		assert.equal(result?.syncStatus, MessageSyncStatus.abandoned);
+		assert.equal(result?.abandonedMutation, MessageMutation.delete);
 		assert.equal(
 			hasAbandonedDelete({
 				status: result?.status,
 				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
 			}),
 			true,
 		);
 	});
 
+	// Issue #1229. Both give-ups leave the same `status`/`syncStatus` pair, so
+	// the projection has to carry the third field or the client cannot tell a
+	// move that handed back from a delete that was refused.
+	test("projects a move that gave up as a move, never as a delete", async () => {
+		const result = await project({
+			status: MessageStatus.active,
+			syncStatus: MessageSyncStatus.abandoned,
+			abandonedMutation: MessageMutation.move,
+		});
+		assert.equal(result?.abandonedMutation, MessageMutation.move);
+		assert.equal(
+			hasAbandonedDelete({
+				status: result?.status,
+				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
+			}),
+			false,
+		);
+	});
+
 	test("projects a move mid-retry without calling it a give-up", async () => {
 		const result = await project({
 			status: MessageStatus.moving,
@@ -300,6 +327,7 @@ describe("enrichThreadRows — the mutation pair", () => {
 			hasAbandonedDelete({
 				status: result?.status,
 				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
 			}),
 			false,
 		);
@@ -324,6 +352,7 @@ describe("enrichThreadRows — the mutation pair", () => {
 			hasAbandonedDelete({
 				status: result?.status,
 				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
 			}),
 			false,
 		);

package/src/derive/enrichThreadRows.ts

@@ -8,6 +8,7 @@ import type {
 } from "@remit/data-ports";
 import { deriveAddressId } from "@remit/data-ports/id";
 import {
+	MessageMutation,
 	MessageStatus,
 	MessageSyncStatus,
 	SenderTrust,
@@ -63,6 +64,7 @@ const toResponse = (item: ThreadMessageItem): ThreadMessageResponse => ({
 	muted: false,
 	status: MessageStatus.active,
 	syncStatus: MessageSyncStatus.pending,
+	abandonedMutation: MessageMutation.none,
 });
 
 /**
@@ -110,7 +112,8 @@ export const planBatchFetch = (rows: ThreadMessageItem[]): BatchPlan => {
  * Enrich a page of ThreadMessage rows with `senderTrust` and `muted` (both
  * derived from the From Address's flags map), `authenticity`, `autoMoved` and
  * `spamReport`, and the `status`/`syncStatus` pair an IMAP mutation leaves
- * behind (all projected straight from the Message row — no ThreadMessage
+ * behind together with the mutation an abandoned one names (all projected
+ * straight from the Message row — no ThreadMessage
  * column of their own, see `deriveAutoMoved`). `toResponse` seeds that pair
  * with the ordinary inbound values, which the projection then overwrites; a
  * ThreadMessage row whose Message row is missing from the batch is broken in a
@@ -189,7 +192,11 @@ export const enrichThreadRows = async (
 	const settlementByMessageId = new Map(
 		messages.map((m) => [
 			m.messageId,
-			{ status: m.status, syncStatus: m.syncStatus },
+			{
+				status: m.status,
+				syncStatus: m.syncStatus,
+				abandonedMutation: m.abandonedMutation,
+			},
 		]),
 	);
 	const trustByAddressId = new Map(

package/src/derive/filterThreadCriteria.test.ts

@@ -3,6 +3,7 @@ import { describe, it } from "node:test";
 import type { ThreadMessageResponse } from "@remit/api-openapi-types";
 import {
 	MessageCategory,
+	MessageMutation,
 	MessageStatus,
 	MessageSyncStatus,
 	SenderTrust,
@@ -38,6 +39,7 @@ const row = (
 	muted: false,
 	status: MessageStatus.active,
 	syncStatus: MessageSyncStatus.pending,
+	abandonedMutation: MessageMutation.none,
 	...overrides,
 });
 

package/src/handlers/message.test.ts

@@ -43,7 +43,8 @@ describe("settleSpamReportBulk", () => {
 	});
 
 	// A refusal the move gate raises used to collapse to the generic retry copy,
-	// which is a dead end for the reason no retry clears (#665).
+	// which is a dead end (#665). One reason reaches it now — a mutation still in
+	// flight — and it words the wait rather than the server's sentence.
 	it("words a placement refusal from its reason, never from the server's sentence", async () => {
 		const outcome = await settleSpamReportBulk(
 			["msg-1", "msg-2"],
@@ -52,16 +53,15 @@ describe("settleSpamReportBulk", () => {
 					`Message ${messageId} was not acted on: its folder and uid do not name the same message`,
 					"acc-1",
 					messageId,
-					messageId === "msg-1" ? "in_flight" : "unverified",
+					"in_flight",
 				);
 			},
 		);
 
-		const [inFlight, unverified] = outcome.failures?.map((f) => f.reason) ?? [];
-		assert.match(inFlight ?? "", /try again in a moment/i);
-		assert.match(unverified ?? "", /sync the folder/i);
-		assert.doesNotMatch(unverified ?? "", /try again in a moment/i);
-		for (const reason of [inFlight, unverified]) {
+		const reasons = outcome.failures?.map((f) => f.reason) ?? [];
+		assert.equal(reasons.length, 2);
+		for (const reason of reasons) {
+			assert.match(reason ?? "", /try again in a moment/i);
 			assert.notEqual(reason, GENERIC_FAILURE_REASON);
 			assert.doesNotMatch(reason ?? "", /folder and uid/);
 			assert.doesNotMatch(reason ?? "", /acc-1/);

package/src/handlers/message.ts

@@ -368,17 +368,15 @@ const isDesignedFailure = (reason: unknown): reason is Error =>
 
 /**
  * The placement refusal is the one designed outcome whose own message is not
- * the text to ship: it names a uuid and no remedy, and the two reasons do not
- * share a remedy — an in-flight move settles on its own, an abandoned one only
- * clears once the folder is resynced. Worded here off `details.reason`, the way
- * the delete path words the same refusal for the client.
+ * the text to ship: it names a uuid and no remedy. One remedy answers it, and
+ * only one refusal reaches it — a mutation still in flight, which settles on
+ * its own (imap-mutations R3). Worded here, the way the delete path words the
+ * same refusal for the client.
  */
 const placementRefusalReason = (
-	error: MessagePlacementUnsettledError,
+	_error: MessagePlacementUnsettledError,
 ): string =>
-	error.publicApiError?.details?.reason === "unverified"
-		? "An earlier move of this message never finished, so where it sits is unknown. Sync the folder, then report it again."
-		: "This message is still being moved on the mail server. Try again in a moment.";
+	"This message is still being moved on the mail server. Try again in a moment.";
 
 const failureReason = (reason: unknown): string => {
 	if (!isDesignedFailure(reason)) return GENERIC_FAILURE_REASON;
@@ -479,6 +477,7 @@ export const MessageOperations: Record<
 			authenticity: message.authenticity,
 			status: message.status,
 			syncStatus: message.syncStatus,
+			abandonedMutation: message.abandonedMutation,
 			...(autoMoved ? { autoMoved } : {}),
 			...(labels.length > 0 ? { labels } : {}),
 			...(message.spamReport ? { spamReport: message.spamReport } : {}),
@@ -899,7 +898,7 @@ export const MessageBulkOperations: Record<
 		);
 
 		// MessageMoveService handles: Message + ThreadMessage updates + SQS events
-		await client.messageMove.deleteMessages(
+		const { refusedMessageIds } = await client.messageMove.deleteMessages(
 			accountConfigId,
 			messageIds,
 			accountId,
@@ -908,9 +907,14 @@ export const MessageBulkOperations: Record<
 			},
 		);
 
+		// A row whose placement changed under the batch is reported, not dropped.
+		// The response already carries per-row counts, which is the honest shape
+		// for a batch that partly applied — a 409 over it would deny the deletes
+		// that did happen, and silence leaves the client's optimistic removal to
+		// reappear with nothing said (imap-mutations R3).
 		return {
-			successCount: messageIds.length,
-			failureCount: 0,
+			successCount: messageIds.length - refusedMessageIds.length,
+			failureCount: refusedMessageIds.length,
 		};
 	},
 

package/src/handlers/sync-progress.test.ts

@@ -9,7 +9,9 @@ import { describe, it } from "node:test";
 import {
 	computeMessagesSynced,
 	deriveMailboxPhase,
+	type MailboxProgressFields,
 	type MailboxSyncFields,
+	toMailboxSyncProgress,
 } from "./sync-progress.js";
 
 // ─── deriveMailboxPhase tests ───────────────────────────────────────────────
@@ -156,3 +158,48 @@ describe("computeMessagesSynced", () => {
 		assert.equal(computeMessagesSynced(mailbox), 50);
 	});
 });
+
+// ─── toMailboxSyncProgress tests ────────────────────────────────────────────
+
+const mailboxRow = (
+	overrides: Partial<MailboxProgressFields> = {},
+): MailboxProgressFields => ({
+	mailboxId: "mb-1",
+	fullPath: "INBOX",
+	lastMessageSyncAt: 1_700_000_000_000,
+	initialSyncCompletedAt: 1_700_000_000_001,
+	messageCount: 10,
+	lastSyncUid: 1,
+	highWaterMarkUid: 100,
+	...overrides,
+});
+
+describe("toMailboxSyncProgress", () => {
+	// Issue #771: the client cannot tell an arrival from a departure by count —
+	// one message in and one out nets to zero. The highest UID only ever moves
+	// up, so the projection has to carry it or the arrival stays invisible.
+	it("carries the mailbox's highest UID", () => {
+		assert.equal(
+			toMailboxSyncProgress(mailboxRow({ highWaterMarkUid: 4321 }))
+				.highWaterMarkUid,
+			4321,
+		);
+	});
+
+	it("reports the sentinel 0 for a mailbox that has never taken a message", () => {
+		assert.equal(
+			toMailboxSyncProgress(mailboxRow({ highWaterMarkUid: 0 }))
+				.highWaterMarkUid,
+			0,
+		);
+	});
+
+	it("projects identity, phase and totals alongside it", () => {
+		const progress = toMailboxSyncProgress(mailboxRow());
+		assert.equal(progress.mailboxId, "mb-1");
+		assert.equal(progress.fullPath, "INBOX");
+		assert.equal(progress.phase, "complete");
+		assert.equal(progress.messagesTotal, 10);
+		assert.equal(progress.lastSyncedAt, 1_700_000_000_000);
+	});
+});

package/src/handlers/sync-progress.ts

@@ -10,6 +10,21 @@ export type MailboxSyncFields = Pick<
 	| "highWaterMarkUid"
 >;
 
+/** A mailbox row, as far as the sync-status projection reads it. */
+export type MailboxProgressFields = MailboxSyncFields &
+	Pick<MailboxItem, "mailboxId" | "fullPath">;
+
+/** The per-mailbox entry `getSyncStatus` returns. */
+export interface MailboxSyncProgress {
+	mailboxId: string;
+	fullPath: string;
+	phase: string;
+	messagesTotal: number;
+	messagesSynced: number;
+	highWaterMarkUid: number;
+	lastSyncedAt: number | undefined;
+}
+
 /**
  * Derive a per-mailbox sync phase from worker-written sync state.
  *
@@ -62,3 +77,23 @@ export const computeMessagesSynced = (mailbox: MailboxSyncFields): number => {
 
 	return Math.min(Math.max(synced, 0), messagesTotal);
 };
+
+/**
+ * Project a mailbox row into its sync-status entry.
+ *
+ * `highWaterMarkUid` is carried through because a total cannot tell an arrival
+ * from a departure: a message landing in the same sync round that another one
+ * leaves nets to zero, and the client's freshness check saw nothing (#771). The
+ * highest UID only ever moves up, so it names the arrival on its own.
+ */
+export const toMailboxSyncProgress = (
+	mailbox: MailboxProgressFields,
+): MailboxSyncProgress => ({
+	mailboxId: mailbox.mailboxId,
+	fullPath: mailbox.fullPath,
+	phase: deriveMailboxPhase(mailbox),
+	messagesTotal: mailbox.messageCount ?? 0,
+	messagesSynced: computeMessagesSynced(mailbox),
+	highWaterMarkUid: mailbox.highWaterMarkUid ?? 0,
+	lastSyncedAt: mailbox.lastMessageSyncAt || undefined,
+});

package/src/handlers/sync.ts

@@ -12,7 +12,7 @@ import { sqsClient } from "../service/sqs.js";
 import { triggerAccountSync } from "../service/trigger-sync.js";
 import type { OperationHandler, SyncOperationIds } from "../types.js";
 import { assertAccountOwnership } from "./account-ownership.js";
-import { computeMessagesSynced, deriveMailboxPhase } from "./sync-progress.js";
+import { toMailboxSyncProgress } from "./sync-progress.js";
 
 interface SyncTriggerDeps {
 	sqsClient: SQSClient;
@@ -114,14 +114,7 @@ export const SyncOperations: Record<
 			mailboxCountTotal: account.mailboxCountTotal,
 			mailboxCountSynced: account.mailboxCountSynced,
 			lastSyncAt: account.lastSyncAt,
-			mailboxes: mailboxes.map((mailbox) => ({
-				mailboxId: mailbox.mailboxId,
-				fullPath: mailbox.fullPath,
-				phase: deriveMailboxPhase(mailbox),
-				messagesTotal: mailbox.messageCount ?? 0,
-				messagesSynced: computeMessagesSynced(mailbox),
-				lastSyncedAt: mailbox.lastMessageSyncAt || undefined,
-			})),
+			mailboxes: mailboxes.map(toMailboxSyncProgress),
 		};
 	},
 };