@remit/mailbox-service 0.0.91 → 0.0.93

package/src/placement-transition-race.test.ts

@@ -0,0 +1,482 @@
+/**
+ * The three optimistic writers, against a row that moves under them
+ * (docs/architecture/imap-mutations.md R3).
+ *
+ * Each reads a message, does several lookups, then writes where it decided to
+ * put it. Between the read and the write, PLACEMENT_MOVE_PUSH can settle the
+ * same row: that lane rides a standard queue, which the account's FIFO group
+ * does not order against. A blind write then stamps `moving` and the OLD uid
+ * over a folder and uid the mail server has just confirmed — a pair
+ * `carriesForeignUid` reads as consistent, so nothing downstream catches it —
+ * and the event that follows sends the worker after whatever now holds the old
+ * number.
+ *
+ * The repository honours the predicate here the way the real one does, so a
+ * losing write returns `undefined` and lands nothing at all.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IAddressRepository,
+	IMailboxRepository,
+	IMailboxSpecialUseRepository,
+	IMessagePlacementMoveRepository,
+	IMessageRepository,
+	IThreadMessageRepository,
+	PlacementPredicate,
+	PlacementTransitionInput,
+} from "@remit/data-ports";
+import { MessagePlacementUnsettledError } from "@remit/data-ports/errors";
+import { MessageMoveService } from "./message-move.js";
+import { PlacementMoveService } from "./placement-move.js";
+import { NO_JUNK_ROLES } from "./test-helpers/folder-roles.js";
+
+const ACCOUNT = "acc-1";
+const ACCOUNT_CONFIG = "cfg-1";
+const INBOX = "mbx-inbox";
+const ARCHIVE = "mbx-archive";
+const TRASH = "mbx-trash";
+const JUNK = "mbx-junk";
+const MESSAGE_ID = "msg-1";
+
+/** What the row is when each writer reads it. */
+const READ_UID = 42;
+
+/** What the placement push settles it to while the writer is still deciding. */
+const SETTLED_UID = 907;
+
+const mailboxes = [
+	{ mailboxId: INBOX, fullPath: "INBOX", accountId: ACCOUNT, uidValidity: 1 },
+	{
+		mailboxId: ARCHIVE,
+		fullPath: "Archive",
+		accountId: ACCOUNT,
+		uidValidity: 1,
+	},
+	{ mailboxId: TRASH, fullPath: "Trash", accountId: ACCOUNT, uidValidity: 1 },
+	{ mailboxId: JUNK, fullPath: "Junk", accountId: ACCOUNT, uidValidity: 1 },
+];
+
+interface CapturedEvent {
+	type: string;
+	messageId?: string;
+	uid?: number;
+}
+
+interface Row {
+	messageId: string;
+	accountConfigId: string;
+	mailboxId: string;
+	uid: number;
+	status: string;
+	syncStatus: string;
+	abandonedMutation: string;
+	originalMailboxId?: string;
+	originalUid?: number;
+}
+
+const freshRow = (): Row => ({
+	messageId: MESSAGE_ID,
+	accountConfigId: ACCOUNT_CONFIG,
+	mailboxId: INBOX,
+	uid: READ_UID,
+	status: "active",
+	syncStatus: "synced",
+	abandonedMutation: "none",
+});
+
+interface World {
+	row: Row;
+	events: CapturedEvent[];
+	writes: PlacementTransitionInput[];
+	/** Destination folders the listing row was actually moved to. */
+	threadMoves: string[];
+	/** Stand in for the push settling the row onto Archive with Archive's uid. */
+	settleElsewhere: () => void;
+	messageService: IMessageRepository;
+	threadMessageService: IThreadMessageRepository;
+	mailboxService: IMailboxRepository;
+	mailboxSpecialUseService: IMailboxSpecialUseRepository;
+	addressService: IAddressRepository;
+}
+
+const buildWorld = (onLookup?: (world: World) => void): World => {
+	const row = freshRow();
+	const events: CapturedEvent[] = [];
+	const writes: PlacementTransitionInput[] = [];
+
+	const threadMoves: string[] = [];
+	const world = { row, events, writes, threadMoves } as World;
+
+	world.settleElsewhere = () => {
+		row.mailboxId = ARCHIVE;
+		row.uid = SETTLED_UID;
+		row.status = "active";
+		row.syncStatus = "synced";
+		row.originalUid = undefined;
+	};
+
+	world.messageService = {
+		// A snapshot, the way a repository read is one. Handing back the live
+		// object would let the caller's `message` follow the concurrent settle,
+		// and the predicate it builds from it would match by accident.
+		get: async (ids: string | string[]) =>
+			Array.isArray(ids) ? [{ ...row }] : ({ ...row } as unknown),
+		update: async () => row,
+		transitionPlacement: async (
+			_messageId: string,
+			expected: PlacementPredicate,
+			next: PlacementTransitionInput,
+		) => {
+			if (expected.status !== undefined && expected.status !== row.status) {
+				return undefined;
+			}
+			if (
+				expected.mailboxId !== undefined &&
+				expected.mailboxId !== row.mailboxId
+			) {
+				return undefined;
+			}
+			if (expected.uid !== undefined && expected.uid !== row.uid) {
+				return undefined;
+			}
+			writes.push(next);
+			Object.assign(row, next);
+			return row;
+		},
+	} as unknown as IMessageRepository;
+
+	world.threadMessageService = {
+		getByMessageId: async () => ({
+			accountConfigId: ACCOUNT_CONFIG,
+			threadMessageId: "tm-1",
+			messageId: MESSAGE_ID,
+			mailboxId: row.mailboxId,
+			sentDate: 1,
+			isRead: false,
+			isDeleted: false,
+			hasStars: false,
+			hasAttachment: false,
+		}),
+		findAllByMessageId: async () => [],
+		update: async (
+			_accountConfigId: string,
+			_threadMessageId: string,
+			patch: { mailboxId?: string },
+		) => {
+			if (patch.mailboxId) threadMoves.push(patch.mailboxId);
+		},
+	} as unknown as IThreadMessageRepository;
+
+	// Every writer resolves folders between reading the row and writing it, so
+	// this is where the concurrent settle is made to land.
+	world.mailboxService = {
+		get: async (_accountId: string, ids: string | string[]) => {
+			onLookup?.(world);
+			return Array.isArray(ids)
+				? mailboxes.filter((mailbox) => ids.includes(mailbox.mailboxId))
+				: mailboxes.find((mailbox) => mailbox.mailboxId === ids);
+		},
+	} as unknown as IMailboxRepository;
+
+	world.mailboxSpecialUseService = {
+		findTrashMailbox: async () => mailboxes[2],
+		resolveTrashRole: async () => ({ kind: "flagged", mailbox: mailboxes[2] }),
+		resolveJunkRolesForConfig: async () => NO_JUNK_ROLES,
+	} as unknown as IMailboxSpecialUseRepository;
+
+	world.addressService = {
+		reconcileJunkOnlyForMessage: async () => {},
+	} as unknown as IAddressRepository;
+
+	return world;
+};
+
+const buildMoveService = (world: World): MessageMoveService => {
+	const service = new MessageMoveService({
+		messageService: world.messageService,
+		mailboxService: world.mailboxService,
+		mailboxSpecialUseService: world.mailboxSpecialUseService,
+		threadMessageService: world.threadMessageService,
+		addressService: world.addressService,
+		sqsQueueUrl: "http://localhost:9324/000000000000/remit-messages.fifo",
+		moveSettleTimeoutMs: 100,
+		moveSettlePollMs: 10,
+	});
+	(
+		service as unknown as {
+			enqueueEvent: (e: CapturedEvent) => Promise<void>;
+			enqueueEventsBatch: (e: CapturedEvent[]) => Promise<void>;
+		}
+	).enqueueEvent = async (event) => {
+		world.events.push(event);
+	};
+	(
+		service as unknown as {
+			enqueueEventsBatch: (e: CapturedEvent[]) => Promise<void>;
+		}
+	).enqueueEventsBatch = async (batch) => {
+		world.events.push(...batch);
+	};
+	return service;
+};
+
+describe("a user move writes only against the placement it read (R3)", () => {
+	it("moves the message when nothing else touched the row", async () => {
+		const world = buildWorld();
+		const service = buildMoveService(world);
+
+		await service.moveMessage(ACCOUNT_CONFIG, MESSAGE_ID, ARCHIVE, ACCOUNT);
+
+		assert.equal(world.events.length, 1);
+		assert.equal(world.row.status, "moving");
+		assert.equal(world.row.mailboxId, ARCHIVE);
+	});
+
+	it("refuses, and writes nothing, when the row settles elsewhere mid-decision", async () => {
+		let settled = false;
+		const world = buildWorld((w) => {
+			if (settled) return;
+			settled = true;
+			w.settleElsewhere();
+		});
+		const service = buildMoveService(world);
+
+		await assert.rejects(
+			() => service.moveMessage(ACCOUNT_CONFIG, MESSAGE_ID, JUNK, ACCOUNT),
+			(error: unknown) =>
+				error instanceof MessagePlacementUnsettledError &&
+				error.statusCode === 409,
+		);
+
+		assert.deepEqual(world.writes, [], "no placement was written");
+		assert.deepEqual(world.events, [], "and nothing was enqueued");
+		assert.equal(
+			world.row.mailboxId,
+			ARCHIVE,
+			"the winner's placement stands exactly as it left it",
+		);
+		assert.equal(world.row.uid, SETTLED_UID);
+		assert.equal(world.row.status, "active");
+	});
+});
+
+describe("a delete writes only against the placement it read (R3)", () => {
+	it("marks the message when nothing else touched the row", async () => {
+		const world = buildWorld();
+		const service = buildMoveService(world);
+
+		await service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT);
+
+		assert.equal(world.events.length, 1);
+		assert.equal(world.row.status, "moving");
+		assert.equal(world.row.mailboxId, TRASH);
+	});
+
+	it("skips the message, and enqueues nothing for it, when the row settles elsewhere", async () => {
+		let settled = false;
+		const world = buildWorld((w) => {
+			if (settled) return;
+			settled = true;
+			w.settleElsewhere();
+		});
+		const service = buildMoveService(world);
+
+		const { refusedMessageIds } = await service.deleteMessages(
+			ACCOUNT_CONFIG,
+			[MESSAGE_ID],
+			ACCOUNT,
+		);
+
+		assert.deepEqual(
+			refusedMessageIds,
+			[MESSAGE_ID],
+			"the caller is told which rows this delete never claimed",
+		);
+		assert.deepEqual(world.writes, [], "no placement was written");
+		assert.deepEqual(
+			world.events,
+			[],
+			"and no delete was enqueued against a uid the source no longer holds",
+		);
+		assert.equal(world.row.mailboxId, ARCHIVE);
+		assert.equal(world.row.uid, SETTLED_UID);
+	});
+});
+
+// The folder lookup is scoped to one account. The daily brief lists every
+// account's mail, so a selection made there carries rows this lookup cannot
+// resolve — and dropping them silently answered "deleted" over messages still
+// sitting where they were.
+describe("a delete reports a row whose folder it could not resolve", () => {
+	it("refuses it rather than counting it as deleted", async () => {
+		const world = buildWorld();
+		world.row.mailboxId = "mbx-another-account";
+		const service = buildMoveService(world);
+
+		const { refusedMessageIds } = await service.deleteMessages(
+			ACCOUNT_CONFIG,
+			[MESSAGE_ID],
+			ACCOUNT,
+		);
+
+		assert.deepEqual(refusedMessageIds, [MESSAGE_ID]);
+		assert.deepEqual(world.writes, [], "nothing was written");
+		assert.deepEqual(world.events, [], "and nothing was enqueued");
+	});
+});
+
+describe("a permanent delete writes only against the placement it read (R3)", () => {
+	// The row is already in Trash, so the batch takes the expunge path rather
+	// than the move-to-Trash one — a different writer, and the fourth of the
+	// four. Its event names one uid in one folder, so a row that has moved since
+	// the read must not be marked for it: a restore out of Trash settling in
+	// between was overwritten with `deleting`, and the expunge went after the
+	// uid Trash no longer holds.
+	const inTrash = (world: World): void => {
+		world.row.mailboxId = TRASH;
+	};
+
+	it("marks the message when nothing else touched the row", async () => {
+		const world = buildWorld();
+		inTrash(world);
+		const service = buildMoveService(world);
+
+		const { refusedMessageIds } = await service.deleteMessages(
+			ACCOUNT_CONFIG,
+			[MESSAGE_ID],
+			ACCOUNT,
+			{ permanent: true },
+		);
+
+		assert.deepEqual(refusedMessageIds, []);
+		assert.equal(world.row.status, "deleting");
+		assert.equal(world.events.length, 1);
+	});
+
+	it("reports the message, and enqueues nothing, when the row settles elsewhere", async () => {
+		let settled = false;
+		const world = buildWorld((w) => {
+			if (settled) return;
+			settled = true;
+			w.settleElsewhere();
+		});
+		inTrash(world);
+		const service = buildMoveService(world);
+
+		const { refusedMessageIds } = await service.deleteMessages(
+			ACCOUNT_CONFIG,
+			[MESSAGE_ID],
+			ACCOUNT,
+			{ permanent: true },
+		);
+
+		// Reported, never silent: the client removed the row optimistically, and
+		// one that reappears with nothing said is a failure the user cannot act
+		// on — the same class as a button that does nothing (#1229).
+		assert.deepEqual(refusedMessageIds, [MESSAGE_ID]);
+		assert.deepEqual(world.writes, [], "no placement was written");
+		assert.deepEqual(world.events, [], "and no expunge was enqueued");
+		assert.equal(world.row.mailboxId, ARCHIVE);
+		assert.equal(world.row.status, "active");
+	});
+});
+
+describe("a classification filing writes only against the placement it read (R3)", () => {
+	const buildPlacementService = (world: World, onPut?: () => void) => {
+		const markers = new Map<string, unknown>();
+		const pushed: string[] = [];
+		const markerService = {
+			find: async () => markers.get(MESSAGE_ID) ?? null,
+			// The last step between reading the row and writing it, so this is
+			// where a concurrent settle is staged.
+			put: async (input: Record<string, unknown>) => {
+				onPut?.();
+				const marker = { ...input, state: "pending", createdAt: Date.now() };
+				markers.set(MESSAGE_ID, marker);
+				return marker;
+			},
+			updateState: async () => markers.get(MESSAGE_ID),
+			delete: async () => {
+				markers.delete(MESSAGE_ID);
+			},
+		} as unknown as IMessagePlacementMoveRepository;
+
+		const service = new PlacementMoveService({
+			messageService: world.messageService,
+			threadMessageService: world.threadMessageService,
+			markerService,
+			addressService: world.addressService,
+			mailboxSpecialUseService: world.mailboxSpecialUseService,
+			sqsQueueUrl: "http://localhost:9324/000000000000/remit-message-mgmt",
+			moveSettleTimeoutMs: 100,
+			moveSettlePollMs: 10,
+		});
+		(service as unknown as { enqueuePush: () => Promise<void> }).enqueuePush =
+			async () => {
+				pushed.push(MESSAGE_ID);
+			};
+		return { service, markers, pushed };
+	};
+
+	it("files the message when nothing else touched the row", async () => {
+		const world = buildWorld();
+		const { service, markers, pushed } = buildPlacementService(world);
+
+		await service.moveMessage(ACCOUNT_CONFIG, MESSAGE_ID, JUNK, ACCOUNT);
+
+		assert.equal(world.row.mailboxId, JUNK);
+		assert.deepEqual(
+			world.threadMoves,
+			[JUNK],
+			"and the listing row follows the message it describes",
+		);
+		assert.deepEqual(pushed, [MESSAGE_ID]);
+		assert.ok(markers.get(MESSAGE_ID));
+	});
+
+	// The Message row is written first, so a loser leaves nothing behind. Moving
+	// the listing row ahead of the transition made the loser diverge instead: the
+	// listing showed the classification folder while the Message row sat where
+	// the winner put it, and nothing routine reconciles that.
+	it("leaves the listing row alone too when the row settles elsewhere", async () => {
+		const world = buildWorld();
+		const { service, markers, pushed } = buildPlacementService(world, () =>
+			world.settleElsewhere(),
+		);
+
+		await service.moveMessage(ACCOUNT_CONFIG, MESSAGE_ID, JUNK, ACCOUNT);
+
+		assert.deepEqual(world.writes, [], "no placement was written");
+		assert.deepEqual(
+			world.threadMoves,
+			[],
+			"and the listing row never claimed a folder the message is not in",
+		);
+		assert.deepEqual(pushed, [], "and no push was enqueued");
+		assert.equal(
+			markers.get(MESSAGE_ID),
+			undefined,
+			"the marker goes with it: nothing owes IMAP this move",
+		);
+		assert.equal(world.row.mailboxId, ARCHIVE);
+	});
+
+	// A permanent delete has already claimed the row. Waiting the ceiling out and
+	// then throwing drove an ordinary sequence toward the DLQ; there is nothing
+	// left to file, so this skips.
+	it("skips a message a delete has claimed, rather than burning the ceiling", async () => {
+		const world = buildWorld();
+		world.row.status = "deleting";
+		const { service, markers, pushed } = buildPlacementService(world);
+
+		const startedAt = Date.now();
+		await service.moveMessage(ACCOUNT_CONFIG, MESSAGE_ID, JUNK, ACCOUNT);
+
+		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
+		assert.deepEqual(world.writes, []);
+		assert.deepEqual(pushed, []);
+		assert.equal(markers.get(MESSAGE_ID), undefined);
+	});
+});

package/src/restore-source-placement.ts

@@ -0,0 +1,157 @@
+import type {
+	IMessageRepository,
+	IThreadMessageRepository,
+	MessageItem,
+	ThreadMessageItem,
+} from "@remit/data-ports";
+import { isNotFoundError } from "@remit/data-ports/errors";
+import { MessageStatus } from "@remit/domain-enums";
+import { buildThreadMessageMoveRevert } from "./thread-message-rows.js";
+
+export interface RestoreSourcePlacementDeps {
+	messageService: Pick<IMessageRepository, "transitionPlacement">;
+	threadMessageService: Pick<
+		IThreadMessageRepository,
+		"findAllByMessageId" | "update"
+	>;
+}
+
+/** Whether the row was still owed a restore when this ran. */
+export type RestoreSourcePlacementOutcome = "restored" | "superseded";
+
+export interface RestoreSourcePlacementInput {
+	accountConfigId: string;
+	messageId: string;
+	sourceMailboxId: string;
+	uid: number;
+	/**
+	 * What the row records about the mutation that will now never happen.
+	 * `synced` where the row is a faithful projection of the source again and
+	 * nothing was refused. `abandoned` where a mutation the user asked for gave
+	 * up, which is a failure the row has to carry (imap-mutations R3).
+	 */
+	syncStatus: MessageItem["syncStatus"];
+	/**
+	 * Which mutation gave up, for the row to carry alongside `abandoned`. The
+	 * hand-back is about to set `status` back to `active`, and `status` was the
+	 * only field naming it — without this the client can see that something was
+	 * abandoned and not what, which is how a move that handed back was reported
+	 * as a failed delete (issue #1229). `none` accompanies every other
+	 * `syncStatus`, so the field never outlives its gate.
+	 */
+	abandonedMutation: MessageItem["abandonedMutation"];
+	/**
+	 * The listing rows, where the caller has already read them to pick this
+	 * outcome. Omitted, they are read here.
+	 */
+	threadMessages?: ThreadMessageItem[];
+}
+
+/**
+ * Put a row back on the pre-mutation source pair and hand its listing rows back
+ * with it.
+ *
+ * `status: moving` has to be cleared here or the row is stuck: a give-up that
+ * writes a sync status and returns leaves the row naming the destination with
+ * the source's uid — the pair `placementBindingOf` calls a lie and
+ * `MessagePlacementUnsettledError` refuses to act on. Nothing routine repairs it
+ * (sync does not touch `status`, and the cursor rebuild's `updateUid` runs only
+ * on a UIDVALIDITY change), so the message is undeletable and unmovable for good
+ * (issue #1005).
+ *
+ * A transition, not a plain update (imap-mutations R3): the restore is only
+ * owed while a mutation is still outstanding on the row, so the predicate is
+ * `moving` or `deleting`. A row another lane has already settled — the
+ * placement-move push runs off a standard queue and is ordered against nothing
+ * on the account's FIFO — is the winner, and dragging it back to a source it
+ * has since left is the corruption this predicate exists to refuse. The loser
+ * writes nothing at all, listing rows included, and answers `superseded`.
+ *
+ * No `message.moved` outbox row: nothing here moved. The optimistic write that
+ * pointed the row at the destination never enqueued one either, so the search
+ * index still holds the source and a revert has nothing to correct.
+ *
+ * The caller must have evidence, not an inference: this writes a placement, and
+ * a placement written on a guess binds live mail to a uid that names somebody
+ * else's message. Two kinds of caller qualify, and nothing else does.
+ *
+ * A terminal resolver reaches here from {@link isMessageGoneFromOpenMailbox}
+ * answering that the message is STILL at `sourceMailboxId`/`uid`, which makes
+ * this the server's own answer rather than a revert on ambiguity (what PR #652
+ * was pulled for).
+ *
+ * A paused-cursor caller reaches here from a `MailboxCursorPausedError` the
+ * openBox guard threw before the outbound command was issued (issue #1203), and
+ * restores the pre-mutation pair off its own event. On a FIRST delivery that is
+ * not an inference but an undo: the command provably never left, so the row is
+ * put back exactly as it was found. A redelivery cannot claim that — the
+ * earlier attempt's tagged OK can be lost with the connection — so it asks
+ * `probePausedPlacement` which folder holds the message and only reaches here
+ * once the answer rules the destination out. Either way the source mailbox is
+ * by definition awaiting a cursor rebuild, which matches its rows by Message-ID
+ * and adjudicates the uid: handing the row back is what puts it in the set the
+ * rebuild walks, since a row still naming the destination is in neither
+ * folder's.
+ *
+ * A row another path deleted while the probe was in flight has nothing left to
+ * restore, and it fails the predicate like any other row that is no longer
+ * owed one. A listing row that other path has already rewritten is its to
+ * finish; the update for it comes back `NotFoundError`, and that is a settled
+ * state here rather than a fault. Throwing on it would escape the caller's
+ * `.catch()` and cost the record its ack and its resync, which is the contract
+ * the terminal resolvers state: never re-thrown.
+ */
+export const restoreSourcePlacement = async (
+	deps: RestoreSourcePlacementDeps,
+	input: RestoreSourcePlacementInput,
+): Promise<RestoreSourcePlacementOutcome> => {
+	const {
+		accountConfigId,
+		messageId,
+		sourceMailboxId,
+		uid,
+		syncStatus,
+		abandonedMutation,
+	} = input;
+
+	const skipNotFound = (error: unknown): void => {
+		if (isNotFoundError(error)) return;
+		throw error;
+	};
+
+	const restored = await deps.messageService.transitionPlacement(
+		messageId,
+		{ status: [MessageStatus.moving, MessageStatus.deleting] },
+		{
+			mailboxId: sourceMailboxId,
+			uid,
+			status: MessageStatus.active,
+			syncStatus,
+			abandonedMutation,
+		},
+	);
+	if (!restored) return "superseded";
+
+	const threadMessages =
+		input.threadMessages ??
+		(await deps.threadMessageService.findAllByMessageId(
+			accountConfigId,
+			messageId,
+		));
+	for (const threadMessage of threadMessages) {
+		const args = buildThreadMessageMoveRevert(
+			threadMessage,
+			uid,
+			sourceMailboxId,
+		);
+		await deps.threadMessageService
+			.update(
+				threadMessage.accountConfigId,
+				threadMessage.threadMessageId,
+				args.set,
+				{ composites: args.composites },
+			)
+			.catch(skipNotFound);
+	}
+	return "restored";
+};

package/src/spam-report.test.ts

@@ -174,9 +174,20 @@ const buildWorld = (
 			if (m) Object.assign(m, patch);
 			return m;
 		},
-		updateForMove: async (id: string, patch: Record<string, unknown>) => {
+		transitionPlacement: async (
+			id: string,
+			_expected: Record<string, unknown>,
+			patch: Record<string, unknown>,
+		) => {
 			const m = messages.get(id);
-			if (m) Object.assign(m, patch);
+			if (!m) return undefined;
+			for (const [field, value] of Object.entries(patch)) {
+				if (value === null) {
+					delete m[field as keyof typeof m];
+					continue;
+				}
+				Object.assign(m, { [field]: value });
+			}
 			return m;
 		},
 		clearSpamReport: async (id: string) => {
@@ -184,14 +195,6 @@ const buildWorld = (
 			if (m) delete m.spamReport;
 			return m;
 		},
-		clearOriginalMailboxId: async (id: string) => {
-			const m = messages.get(id);
-			if (m) {
-				delete m.originalMailboxId;
-				delete m.originalUid;
-			}
-			return m;
-		},
 	} as unknown as IMessageRepository;
 
 	const addressService = {