@remit/mailbox-service 0.0.91 → 0.0.92

package/package.json

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

package/src/index.ts

@@ -193,6 +193,7 @@ export {
 	type SyncAccountInfo,
 } from "./mailbox-sync.js";
 export {
+	type DeleteMessagesOutcome,
 	type DeleteOptions,
 	type MessageMoveConfig,
 	type MessageMoveLogger,
@@ -267,6 +268,12 @@ export {
 	resolveMailboxRole,
 	shapeFromMessageData,
 } from "./quarantine.js";
+export {
+	type RestoreSourcePlacementDeps,
+	type RestoreSourcePlacementInput,
+	type RestoreSourcePlacementOutcome,
+	restoreSourcePlacement,
+} from "./restore-source-placement.js";
 export {
 	extractSnippetFromEmail,
 	generateSnippet,
@@ -286,6 +293,12 @@ export {
 	type StaleMessageReconcileDeps,
 	type StaleMessageReconcileResult,
 } from "./stale-message-reconcile.js";
+export {
+	buildThreadMessageMoveRevert,
+	buildThreadMessageTrashUpdate,
+	buildThreadMessageUndelete,
+	type ThreadMessageRowState,
+} from "./thread-message-rows.js";
 export type {
 	FlatMailboxInfo,
 	IImapConnection,

package/src/message-delete-junk-reconcile.test.ts

@@ -30,8 +30,11 @@ const buildWorld = (trashExists: boolean) => {
 		get: async () => [message],
 		update: async (_id: string, patch: Record<string, unknown>) =>
 			Object.assign(message, patch),
-		updateForMove: async (_id: string, patch: Record<string, unknown>) =>
-			Object.assign(message, patch),
+		transitionPlacement: async (
+			_id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => Object.assign(message, patch),
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {

package/src/message-delete-no-trash.test.ts

@@ -52,7 +52,11 @@ const buildWorld = (
 			patches.push(patch);
 			return Object.assign(message, patch);
 		},
-		updateForMove: async (_id: string, patch: Record<string, unknown>) => {
+		transitionPlacement: async (
+			_id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
 			patches.push(patch);
 			return Object.assign(message, patch);
 		},

package/src/message-delete-unsettled-placement.test.ts

@@ -68,11 +68,20 @@ const movingRow = () => ({
 	originalUid: INBOX_UID,
 });
 
-/** The same row after the trash-move handler gave up without confirming. */
+/**
+ * A row a delete gave up on. R3 defines the give-up as a hand-back: the row
+ * goes back on the placement the mail server confirmed, and only then carries
+ * `abandoned`. The pair is honest, so nothing downstream refuses it — the
+ * failure is a statement the reading pane makes, never a gate.
+ */
 const strandedRow = () => ({
-	...movingRow(),
 	messageId: STRANDED_ID,
-	syncStatus: "failed",
+	mailboxId: INBOX,
+	uid: INBOX_UID,
+	status: "active",
+	syncStatus: "abandoned",
+	abandonedMutation: "delete",
+	originalMailboxId: INBOX,
 });
 
 /** An ordinary settled row. */
@@ -127,7 +136,11 @@ const buildWorld = (seed: Array<Record<string, unknown>>) => {
 			patches.push({ messageId: id, patch });
 			return Object.assign(rows.get(id) ?? {}, patch);
 		},
-		updateForMove: async (id: string, patch: Record<string, unknown>) => {
+		transitionPlacement: async (
+			id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
 			patches.push({ messageId: id, patch });
 			return Object.assign(rows.get(id) ?? {}, patch);
 		},
@@ -329,23 +342,18 @@ describe("the gate refuses only a uid that names somebody else (#845.3)", () =>
 		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 
-	it("refuses a row stranded by a move that gave up, without spending the ceiling", async () => {
-		// `syncStatus: failed` with `status: moving` is the shape every handler's
-		// give-up path leaves behind, and only `updateUid` clears it. The pair is
-		// still a lie, so the delete is still refused — but under a reason whose
-		// remedy is a resync, and without a wait that could never succeed.
+	it("acts on a row a delete gave up on, rather than refusing it", async () => {
+		// A give-up hands the row back to the placement the server confirmed
+		// before it stops (R3), so the "Delete again" the reading pane offers is
+		// an ordinary delete. Refusing it — which is what a give-up left `moving`
+		// used to earn — made that button a dead end.
 		const { service, events } = buildWorld([strandedRow()]);
 
 		const startedAt = Date.now();
-		await assert.rejects(
-			() => service.deleteMessages(ACCOUNT_CONFIG, [STRANDED_ID], ACCOUNT),
-			(error: unknown) =>
-				error instanceof MessagePlacementUnsettledError &&
-				error.publicApiError?.details?.reason === "unverified",
-		);
+		await service.deleteMessages(ACCOUNT_CONFIG, [STRANDED_ID], ACCOUNT);
 
-		assert.deepEqual(events, []);
-		assert.ok(Date.now() - startedAt < 100, "refused without waiting");
+		assert.equal(events.length, 1);
+		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 });
 

package/src/message-move-copy.test.ts

@@ -69,6 +69,11 @@ const buildWorld = () => {
 				category: "primary",
 				classificationState: "Examined",
 				hasListUnsubscribe: false,
+				// Settled, which is what a delete's predicate asks for: a row every
+				// repository read carries a status, and leaving it off made the
+				// fixture answer for a state no row is ever in.
+				status: "active",
+				syncStatus: "synced",
 			},
 		],
 	]);
@@ -130,6 +135,19 @@ const buildWorld = () => {
 			if (m) Object.assign(m, patch);
 			return m;
 		},
+		transitionPlacement: async (
+			id: string,
+			expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
+			const m = messages.get(id) as Record<string, unknown> | undefined;
+			if (!m) return undefined;
+			for (const [field, want] of Object.entries(expected)) {
+				if (want !== undefined && m[field] !== want) return undefined;
+			}
+			Object.assign(m, patch);
+			return m;
+		},
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {
@@ -457,7 +475,7 @@ describe("MessageMoveService.copyMessage — deterministic per-folder identity (
 	});
 
 	it("copy then delete of the copy removes the copy row and leaves the original", async () => {
-		const { service, threadRows } = buildWorld();
+		const { service, threadRows, messages } = buildWorld();
 
 		await service.copyMessages(
 			ACCOUNT_CONFIG,
@@ -467,6 +485,15 @@ describe("MessageMoveService.copyMessage — deterministic per-folder identity (
 		);
 		const copyId = deriveCopyMessageId(SOURCE_ID, DEST_MAILBOX);
 
+		// A fresh copy row is `moving` until the server hands back its COPYUID, and
+		// a delete against it would name uid 0. Settle it the way `updateUid`
+		// does, which is also the only state in which a user can see it to delete.
+		Object.assign(messages.get(copyId) ?? {}, {
+			uid: 77,
+			status: "active",
+			syncStatus: "synced",
+		});
+
 		await service.deleteMessages(ACCOUNT_CONFIG, [copyId], ACCOUNT, {
 			permanent: true,
 		});

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

@@ -79,9 +79,12 @@ const buildWorld = (
 	trashContents: TrashMessage[] = [
 		{ messageId: "junk-1", syncStatus: "synced" },
 	],
+	/** Message ids whose placement another lane changed after the read. */
+	transitionsLost: string[] = [],
 ) => {
 	const emptied: string[] = [];
 	const markedDeleting: string[] = [];
+	const markPredicates = new Map<string, unknown>();
 	const events: EnqueuedEvent[] = [];
 	const messagesByMailbox = new Map<string, TrashMessage[]>([
 		[DELETED_FOLDER, [{ messageId: "keepsake-1", syncStatus: "synced" }]],
@@ -96,6 +99,12 @@ const buildWorld = (
 		update: async (messageId: string) => {
 			markedDeleting.push(messageId);
 		},
+		transitionPlacement: async (messageId: string, expected: unknown) => {
+			markPredicates.set(messageId, expected);
+			if (transitionsLost.includes(messageId)) return undefined;
+			markedDeleting.push(messageId);
+			return { messageId };
+		},
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {
@@ -135,7 +144,7 @@ const buildWorld = (
 		events.push(event);
 	};
 
-	return { service, emptied, markedDeleting, events };
+	return { service, emptied, markedDeleting, markPredicates, events };
 };
 
 describe("MessageMoveService.emptyTrash", () => {
@@ -245,6 +254,44 @@ describe("MessageMoveService.emptyTrash", () => {
 		assert.equal(deletedCount, 1);
 	});
 
+	it("predicates each mark on the row it just read, and drops the ones it loses", async () => {
+		// The rows are held by nothing between the listing and the mark, and
+		// PLACEMENT_MOVE_PUSH rides a standard queue this account's FIFO group
+		// does not order (imap-mutations R3). A row that moved under the sweep
+		// must not be marked `deleting` for an expunge that would bind a uid it
+		// no longer has.
+		const { service, markedDeleting, markPredicates } = buildWorld(
+			appointedTrash,
+			[
+				{
+					messageId: "settled-1",
+					syncStatus: "synced",
+					status: "active",
+					mailboxId: REAL_TRASH,
+					uid: 10,
+				},
+				{
+					messageId: "raced-1",
+					syncStatus: "synced",
+					status: "active",
+					mailboxId: REAL_TRASH,
+					uid: 11,
+				},
+			],
+			["raced-1"],
+		);
+
+		const { deletedCount } = await service.emptyTrash(ACCOUNT_CONFIG, ACCOUNT);
+
+		assert.deepEqual(markedDeleting, ["settled-1"]);
+		assert.equal(deletedCount, 1, "a row that lost is not counted either");
+		assert.deepEqual(markPredicates.get("settled-1"), {
+			status: "active",
+			mailboxId: REAL_TRASH,
+			uid: 10,
+		});
+	});
+
 	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-same-mailbox.test.ts

@@ -52,8 +52,11 @@ const buildWorld = () => {
 			Array.isArray(ids) ? [message] : message,
 		update: async (_id: string, patch: Record<string, unknown>) =>
 			Object.assign(message, patch),
-		updateForMove: async (_id: string, patch: Record<string, unknown>) =>
-			Object.assign(message, patch),
+		transitionPlacement: async (
+			_id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => Object.assign(message, patch),
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {

package/src/message-move-unsettled-placement.test.ts

@@ -28,6 +28,7 @@ const ARCHIVE = "mbx-archive";
 const MOVING_ID = "msg-moving";
 const SETTLED_ID = "msg-settled";
 const STRANDED_ID = "msg-stranded";
+const DELETING_ID = "msg-deleting";
 const COPY_ID = "msg-copy";
 
 const INBOX_UID = 42;
@@ -58,11 +59,36 @@ const movingRow = () => ({
 	originalUid: INBOX_UID,
 });
 
-/** The same row after the mover gave up without confirming. */
+/**
+ * A row a mutation gave up on. R3 defines the give-up as a hand-back: the row
+ * goes back on the placement the mail server confirmed, and only then carries
+ * `abandoned`. The pair is honest, so nothing downstream refuses it — the
+ * failure is a statement the reading pane makes, never a gate.
+ */
 const strandedRow = () => ({
-	...movingRow(),
 	messageId: STRANDED_ID,
-	syncStatus: "failed",
+	mailboxId: INBOX,
+	uid: INBOX_UID,
+	status: "active",
+	syncStatus: "abandoned",
+	abandonedMutation: "move",
+	originalMailboxId: INBOX,
+});
+
+/**
+ * The same shape a delete leaves: Trash is already written, the uid is still
+ * INBOX's, and `deleting` is what says so. R3 calls this in flight exactly as
+ * `moving` is — reading only `moving` let a move enqueued behind a delete bind
+ * this pair and be dropped when the delete settled.
+ */
+const deletingRow = () => ({
+	messageId: DELETING_ID,
+	mailboxId: ARCHIVE,
+	uid: INBOX_UID,
+	status: "deleting",
+	syncStatus: "pending",
+	originalMailboxId: INBOX,
+	originalUid: INBOX_UID,
 });
 
 /** An ordinary settled row. */
@@ -118,7 +144,11 @@ const buildWorld = (seed: Array<Record<string, unknown>>) => {
 			patches.push({ messageId: id, patch });
 			return Object.assign(rows.get(id) ?? {}, patch);
 		},
-		updateForMove: async (id: string, patch: Record<string, unknown>) => {
+		transitionPlacement: async (
+			id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
 			patches.push({ messageId: id, patch });
 			return Object.assign(rows.get(id) ?? {}, patch);
 		},
@@ -318,22 +348,31 @@ describe("the move gate refuses only a uid that names somebody else (#665)", ()
 		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 
-	it("refuses a row stranded by a move that gave up, without spending the ceiling", async () => {
-		// `syncStatus: failed` with `status: moving` is what every handler's
-		// give-up path leaves behind, and only `updateUid` clears it. The pair is
-		// still a lie, so the move is still refused — under a reason whose remedy
-		// is a resync, and without a wait that could never succeed.
-		const { service, events } = buildWorld([strandedRow()]);
+	it("waits out a delete in flight rather than binding its borrowed uid", async () => {
+		const { service, events, patches } = buildWorld([deletingRow()]);
 
-		const startedAt = Date.now();
 		await assert.rejects(
-			() => service.moveMessage(ACCOUNT_CONFIG, STRANDED_ID, INBOX, ACCOUNT),
-			(error: unknown) =>
-				error instanceof MessagePlacementUnsettledError &&
-				error.publicApiError?.details?.reason === "unverified",
+			() => service.moveMessage(ACCOUNT_CONFIG, DELETING_ID, INBOX, ACCOUNT),
+			(error: unknown) => error instanceof MessagePlacementUnsettledError,
 		);
 
-		assert.deepEqual(events, []);
-		assert.ok(Date.now() - startedAt < 100, "refused without waiting");
+		assert.deepEqual(events, [], "nothing was enqueued");
+		assert.deepEqual(patches, [], "and no local write was made");
+	});
+
+	it("acts on a row a move gave up on, rather than refusing it", async () => {
+		// A give-up hands the row back to the placement the server confirmed
+		// before it stops (R3), so the folder and uid name the same message and
+		// the user's next move is an ordinary one. Refusing it — which is what a
+		// give-up left `moving` used to earn — made the message unmovable for
+		// good, with nothing routine to repair it.
+		const { service, events } = buildWorld([strandedRow()]);
+
+		const startedAt = Date.now();
+		await service.moveMessage(ACCOUNT_CONFIG, STRANDED_ID, ARCHIVE, ACCOUNT);
+
+		assert.equal(events.length, 1);
+		assert.equal(events[0].type, "MESSAGE_MOVE");
+		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
 	});
 });