@remit/mailbox-service 0.0.89 → 0.0.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.89",
+  "version": "0.0.90",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -252,6 +252,7 @@ export {
 	resolveExhaustedPlacementMoveFailure,
 } from "./placement-move-terminal.js";
 export {
+	carriesForeignUid,
 	isPlacementUnsettled,
 	type PlacementBinding,
 	placementBindingOf,

package/src/message-move-empty-trash.test.ts

@@ -46,8 +46,27 @@ const proposedDeletedFolder: RoleResolution<TrashMailbox> = {
 interface TrashMessage {
 	messageId: string;
 	syncStatus: string;
+	status?: string;
+	mailboxId?: string;
+	uid?: number;
+	originalMailboxId?: string;
+	originalUid?: number;
 }
 
+/**
+ * A row mid-move into Trash: the folder is already written, the uid is still
+ * the inbox's, and only `status: moving` says so.
+ */
+const movingIntoTrash = (messageId: string, uid: number): TrashMessage => ({
+	messageId,
+	syncStatus: "pending",
+	status: "moving",
+	mailboxId: REAL_TRASH,
+	uid,
+	originalMailboxId: "mbx-inbox",
+	originalUid: uid,
+});
+
 interface EnqueuedEvent {
 	type: string;
 	schemaVersion?: number;
@@ -194,22 +213,38 @@ describe("MessageMoveService.emptyTrash", () => {
 		assert.equal(deletedCount, 3);
 	});
 
-	it("marks and counts a message whose move to Trash has not settled", async () => {
-		// The user saw the message in Trash and asked for the folder to be
-		// emptied. Skipping it reports a number the folder contradicts, and the
-		// queue is per-account FIFO, so the move has landed on the server before
-		// the expunge is even delivered.
+	it("marks and counts a message whose sync is merely pending", async () => {
+		// `syncStatus: pending` is where every freshly synced inbound row sits
+		// forever; it says nothing about where the message is. The user saw it in
+		// Trash and asked for the folder to be emptied, and skipping it would
+		// report a number the folder contradicts.
 		const { service, markedDeleting } = buildWorld(appointedTrash, [
 			{ messageId: "settled-1", syncStatus: "synced" },
-			{ messageId: "still-moving-1", syncStatus: "pending" },
+			{ messageId: "pending-1", syncStatus: "pending" },
 		]);
 
 		const { deletedCount } = await service.emptyTrash(ACCOUNT_CONFIG, ACCOUNT);
 
-		assert.deepEqual(markedDeleting, ["settled-1", "still-moving-1"]);
+		assert.deepEqual(markedDeleting, ["settled-1", "pending-1"]);
 		assert.equal(deletedCount, 2);
 	});
 
+	it("leaves a row whose move into Trash has not settled unmarked and uncounted", async () => {
+		// Issue #1217. Marking it `deleting` overwrites the `moving` its own
+		// MESSAGE_MOVE reads to decide there is still work to do, so that move
+		// returns without touching IMAP and the worker's expunge then binds the
+		// inbox's uid against whatever Trash really holds at it.
+		const { service, markedDeleting } = buildWorld(appointedTrash, [
+			{ messageId: "settled-1", syncStatus: "synced" },
+			movingIntoTrash("moving-1", 10),
+		]);
+
+		const { deletedCount } = await service.emptyTrash(ACCOUNT_CONFIG, ACCOUNT);
+
+		assert.deepEqual(markedDeleting, ["settled-1"]);
+		assert.equal(deletedCount, 1);
+	});
+
 	it("reports the same count when pressed twice before the worker runs", async () => {
 		// The rows it marked are still in that folder, so N stays true and the
 		// re-mark is idempotent. Reporting 0 the second time while still

package/src/message-move.ts

@@ -34,6 +34,7 @@ import {
 } from "@remit/domain-enums";
 import { createQueueProducer } from "@remit/sqs-client/producer";
 import {
+	bindsForeignUid,
 	type PlacementBinding,
 	placementBindingOf,
 	waitForPlacementToSettle,
@@ -917,10 +918,22 @@ export class MessageMoveService {
 			trashMailbox.mailboxId,
 		);
 
-		const messages = await this.messageService.listAllByMailbox(
+		const rows = await this.messageService.listAllByMailbox(
 			trashMailbox.mailboxId,
 		);
 
+		// Reconciles, never waits (imap-mutations R2). A row whose move into
+		// Trash has not settled names this folder while still carrying the SOURCE
+		// folder's uid, and marking it `deleting` overwrites the only marker that
+		// says so: its own MESSAGE_MOVE then reads the row as settled and returns
+		// without moving anything, and the worker's expunge binds that borrowed
+		// uid against whatever Trash really holds at it. Left as it stands, that
+		// move runs ahead of this expunge in the account's FIFO group and settles
+		// the row, so the message is in Trash by the time the sweep reaches it and
+		// goes with the rest of this same press — only the count below is one
+		// short of what the sweep ends up removing.
+		const messages = rows.filter((message) => !bindsForeignUid(message));
+
 		// Mark all as deleting locally
 		for (const message of messages) {
 			await this.messageService.update(message.messageId, {

package/src/placement-settled.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { describe, test } from "node:test";
 import type { MessageItem } from "@remit/data-ports";
 import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
-import { placementBindingOf } from "./placement-settled.js";
+import { carriesForeignUid, placementBindingOf } from "./placement-settled.js";
 
 /**
  * Pins `placementBindingOf` directly. It is the guard #1098/#1143 depend on and
@@ -70,3 +70,48 @@ describe("placementBindingOf", () => {
 		);
 	});
 });
+
+/**
+ * The same question with the `status` gate off, for callers that resolve a uid
+ * off a row some other operation may have re-marked on its way past (#1217).
+ */
+describe("carriesForeignUid", () => {
+	test("holds whatever an operation has since written to `status`", () => {
+		for (const status of [
+			MessageStatus.moving,
+			MessageStatus.deleting,
+			MessageStatus.active,
+		]) {
+			assert.equal(carriesForeignUid(row({ status })), true, status);
+		}
+	});
+
+	test("is false once `updateUid` settles the move", () => {
+		// The settle writes the destination's own uid and drops `originalUid` in
+		// the same statement, so a destination counter that hands back the
+		// source's number cannot leave the row reading foreign forever.
+		assert.equal(
+			carriesForeignUid(
+				row({
+					status: MessageStatus.active,
+					syncStatus: MessageSyncStatus.synced,
+					originalUid: undefined,
+				}),
+			),
+			false,
+		);
+	});
+
+	test("is false for a row that was never moved", () => {
+		assert.equal(
+			carriesForeignUid(
+				row({ originalUid: undefined, originalMailboxId: undefined }),
+			),
+			false,
+		);
+	});
+
+	test("is false once a restore points the row back at that folder", () => {
+		assert.equal(carriesForeignUid(row({ mailboxId: "mbx-src" })), false);
+	});
+});

package/src/placement-settled.ts

@@ -29,19 +29,33 @@ export const isPlacementUnsettled = (
  * never moved, so its uid names nothing but itself — a freshly copied row is
  * `moving` with `uid: 0` until COPYUID lands, which is a uid that is not ready,
  * not a uid that names somebody else's message.
+ *
+ * Answered without reference to `status`, because `status` is not what clears
+ * it: `updateUid` does, dropping `originalUid` in the same statement that
+ * writes the destination's own, and a restore does by pointing `mailboxId`
+ * back at `originalMailboxId`. An operation that rewrites `status` on its way
+ * past — Empty Trash marking a whole folder `deleting` — leaves the pair
+ * untouched, so anything that resolves a uid off a row it did not settle
+ * itself asks this rather than the binding below (issue #1217).
  */
-export const bindsForeignUid = (
+export const carriesForeignUid = (
 	message: Pick<
 		MessageItem,
-		"status" | "mailboxId" | "uid" | "originalMailboxId" | "originalUid"
+		"mailboxId" | "uid" | "originalMailboxId" | "originalUid"
 	>,
 ): boolean =>
-	isPlacementUnsettled(message) &&
 	message.originalUid !== undefined &&
 	message.originalUid === message.uid &&
 	message.originalMailboxId !== undefined &&
 	message.originalMailboxId !== message.mailboxId;
 
+export const bindsForeignUid = (
+	message: Pick<
+		MessageItem,
+		"status" | "mailboxId" | "uid" | "originalMailboxId" | "originalUid"
+	>,
+): boolean => isPlacementUnsettled(message) && carriesForeignUid(message);
+
 /**
  * `in_flight` — a mover is still working on the row, so waiting resolves it.
  * `abandoned` — the last attempt failed (`syncStatus: failed`) and the row is