@remit/mailbox-service 0.0.111 → 0.0.112

package/src/message-move.ts

@@ -39,6 +39,7 @@ import {
 	placementBindingOf,
 	waitForPlacementToSettle,
 } from "./placement-settled.js";
+import { restoreSourcePlacement } from "./restore-source-placement.js";
 
 /**
  * What a delete batch did not claim. A row whose placement changed between the
@@ -109,6 +110,40 @@ interface MessageCopyEvent {
 	uid: number;
 }
 
+/** An event, and the undo of the local write it was enqueued for. */
+interface UndoableEvent<T> {
+	event: T;
+	handBack: () => Promise<void>;
+}
+
+type BatchEnqueueOutcome =
+	| { outcome: "sent" }
+	| {
+			outcome: "unsent";
+			unsent: UndoableEvent<MessageDeleteEvent>[];
+			fault: unknown;
+	  };
+
+/** Undo every write whose event never left, then fail with the queue's error. */
+const handBackThenThrow = async (
+	fault: unknown,
+	handBacks: ReadonlyArray<() => Promise<void>>,
+): Promise<never> => {
+	const undoFaults: unknown[] = [];
+	for (const handBack of handBacks) {
+		await handBack().catch((undoFault: unknown) => {
+			undoFaults.push(undoFault);
+		});
+	}
+	if (undoFaults.length > 0) {
+		throw new AggregateError(
+			[fault, ...undoFaults],
+			"The queue refused the event, and handing the local write back failed too",
+		);
+	}
+	throw fault;
+};
+
 type MessageMoveQueueEvent =
 	| MessageDeleteEvent
 	| MessageMoveEvent
@@ -443,7 +478,7 @@ export class MessageMoveService {
 		}
 
 		// Collect all events for batch SQS send
-		const events: MessageDeleteEvent[] = [];
+		const events: UndoableEvent<MessageDeleteEvent>[] = [];
 
 		// Process move to trash
 		if (trashMailbox && moveToTrashMessages.length > 0) {
@@ -504,18 +539,27 @@ export class MessageMoveService {
 				);
 
 				events.push({
-					type: "MESSAGE_DELETE",
-					schemaVersion: MUTATION_EVENT_SCHEMA_VERSION,
-					eventId: randomUUID(),
-					timestamp: Date.now(),
-					accountId,
-					messageId,
-					mailboxId: sourceMailbox.mailboxId,
-					mailboxPath: sourceMailbox.fullPath,
-					uid: message.uid,
-					operation: "move_to_trash",
-					destinationMailboxId: trashMailbox.mailboxId,
-					destinationMailboxPath: trashMailbox.fullPath,
+					event: {
+						type: "MESSAGE_DELETE",
+						schemaVersion: MUTATION_EVENT_SCHEMA_VERSION,
+						eventId: randomUUID(),
+						timestamp: Date.now(),
+						accountId,
+						messageId,
+						mailboxId: sourceMailbox.mailboxId,
+						mailboxPath: sourceMailbox.fullPath,
+						uid: message.uid,
+						operation: "move_to_trash",
+						destinationMailboxId: trashMailbox.mailboxId,
+						destinationMailboxPath: trashMailbox.fullPath,
+					},
+					handBack: () =>
+						this.handBackUnsentMove(
+							accountConfigId,
+							messageId,
+							sourceMailbox.mailboxId,
+							message.uid,
+						),
 				});
 			}
 
@@ -573,16 +617,32 @@ export class MessageMoveService {
 			await this.deleteThreadMessagesForMessage(accountConfigId, messageId);
 
 			events.push({
-				type: "MESSAGE_DELETE",
-				schemaVersion: MUTATION_EVENT_SCHEMA_VERSION,
-				eventId: randomUUID(),
-				timestamp: Date.now(),
-				accountId,
-				messageId,
-				mailboxId: sourceMailbox.mailboxId,
-				mailboxPath: sourceMailbox.fullPath,
-				uid: message.uid,
-				operation: "permanent_delete",
+				event: {
+					type: "MESSAGE_DELETE",
+					schemaVersion: MUTATION_EVENT_SCHEMA_VERSION,
+					eventId: randomUUID(),
+					timestamp: Date.now(),
+					accountId,
+					messageId,
+					mailboxId: sourceMailbox.mailboxId,
+					mailboxPath: sourceMailbox.fullPath,
+					uid: message.uid,
+					operation: "permanent_delete",
+				},
+				// The listing rows went above, so the local removal finishes, as the
+				// worker's `handBackDelete` does; the folder's next sync re-projects it.
+				handBack: async () => {
+					const claimed = await this.messageService.transitionPlacement(
+						messageId,
+						{
+							status: MessageStatus.deleting,
+							mailboxId: message.mailboxId,
+							uid: message.uid,
+						},
+						{ status: MessageStatus.deleted },
+					);
+					if (claimed) await this.messageService.delete(messageId);
+				},
 			});
 		}
 
@@ -593,7 +653,6 @@ export class MessageMoveService {
 			);
 		}
 
-		// Batch send events to SQS
 		await this.enqueueEventsBatch(events);
 
 		return { refusedMessageIds: refused };
@@ -750,7 +809,14 @@ export class MessageMoveService {
 			uid: message.uid,
 		};
 
-		await this.enqueueEvent(event);
+		await this.enqueueEvent(event, () =>
+			this.handBackUnsentMove(
+				accountConfigId,
+				messageId,
+				sourceMailbox.mailboxId,
+				message.uid,
+			),
+		);
 	};
 
 	/**
@@ -839,14 +905,13 @@ export class MessageMoveService {
 		// the copy at uid=0 with an undelivered event; upsert no-ops on the row
 		// and lets the event be re-enqueued below, keeping the operation
 		// idempotent and the copy re-drivable (issue #75).
-		await this.messageService.upsert({
+		const copyRow = await this.messageService.upsertWithStatus({
 			messageId: newMessageId,
 			mailboxId: destinationMailboxId,
 			uid: 0, // Will be updated by worker after IMAP COPY
 			sequenceNumber: 0, // Will be updated by worker
 			rfc822Size: sourceMessage.rfc822Size,
 			internalDate: sourceMessage.internalDate,
-			messageIdHeader: sourceMessage.messageIdHeader,
 			envelopeId: sourceMessage.envelopeId, // Share envelope with source
 			rootBodyPartId: sourceMessage.rootBodyPartId, // Share body parts with source
 			status: MessageStatus.moving,
@@ -871,7 +936,7 @@ export class MessageMoveService {
 			messageId,
 		);
 
-		await this.threadMessageService.create({
+		const copyListing = await this.threadMessageService.create({
 			accountConfigId: sourceThreadMessage.accountConfigId,
 			threadId: sourceThreadMessage.threadId,
 			messageId: newMessageId,
@@ -923,7 +988,20 @@ export class MessageMoveService {
 			uid: sourceMessage.uid,
 		};
 
-		await this.enqueueEvent(event);
+		await this.enqueueEvent(event, async () => {
+			await this.threadMessageService.deleteMany([
+				{
+					accountConfigId: copyListing.accountConfigId,
+					threadMessageId: copyListing.threadMessageId,
+				},
+			]);
+			if (!copyRow.created) return;
+			await this.messageService.deleteIfPlacement(newMessageId, {
+				status: MessageStatus.moving,
+				mailboxId: destinationMailboxId,
+				uid: 0,
+			});
+		});
 
 		return newMessageId;
 	};
@@ -1053,6 +1131,7 @@ export class MessageMoveService {
 		// another lane won: the row is left alone and not counted, rather than
 		// marked `deleting` for an expunge that would bind somebody else's uid.
 		const messages: MessageItem[] = [];
+		const undo: Array<() => Promise<void>> = [];
 		for (const message of candidates) {
 			const marked = await this.messageService.transitionPlacement(
 				message.messageId,
@@ -1074,11 +1153,29 @@ export class MessageMoveService {
 				continue;
 			}
 			messages.push(marked);
-			await this.updateThreadMessageDeleted(
+			const wasDeleted = await this.updateThreadMessageDeleted(
 				accountConfigId,
 				message.messageId,
 				true,
 			);
+			undo.push(async () => {
+				const restored = await this.messageService.transitionPlacement(
+					message.messageId,
+					{
+						status: MessageStatus.deleting,
+						mailboxId: message.mailboxId,
+						uid: message.uid,
+					},
+					{ status: message.status, syncStatus: message.syncStatus },
+				);
+				if (restored && !wasDeleted) {
+					await this.updateThreadMessageDeleted(
+						accountConfigId,
+						message.messageId,
+						false,
+					);
+				}
+			});
 		}
 
 		this.log.info(
@@ -1103,7 +1200,9 @@ export class MessageMoveService {
 			trashUidValidity,
 		};
 
-		await this.enqueueEvent(event);
+		await this.enqueueEvent(event, async () => {
+			for (const restore of undo) await restore();
+		});
 
 		return { deletedCount: messages.length };
 	};
@@ -1250,7 +1349,7 @@ export class MessageMoveService {
 		accountConfigId: string,
 		messageId: string,
 		isDeleted: boolean,
-	): Promise<void> => {
+	): Promise<boolean> => {
 		const threadMessage = await this.threadMessageService.getByMessageId(
 			accountConfigId,
 			messageId,
@@ -1281,6 +1380,7 @@ export class MessageMoveService {
 			},
 			"Updated ThreadMessage.isDeleted",
 		);
+		return threadMessage.isDeleted;
 	};
 
 	/**
@@ -1292,18 +1392,21 @@ export class MessageMoveService {
 	 */
 	private enqueueEvent = async (
 		event: MessageMoveQueueEvent,
+		handBack: () => Promise<void>,
 	): Promise<void> => {
 		const useFifo = this.queueUrl.endsWith(".fifo");
-		await this.sqs.send(
-			new SendMessageCommand({
-				QueueUrl: this.queueUrl,
-				MessageBody: JSON.stringify(event),
-				...(useFifo && {
-					MessageGroupId: event.accountId,
-					MessageDeduplicationId: event.eventId,
+		await this.sqs
+			.send(
+				new SendMessageCommand({
+					QueueUrl: this.queueUrl,
+					MessageBody: JSON.stringify(event),
+					...(useFifo && {
+						MessageGroupId: event.accountId,
+						MessageDeduplicationId: event.eventId,
+					}),
 				}),
-			}),
-		);
+			)
+			.catch((fault: unknown) => handBackThenThrow(fault, [handBack]));
 
 		this.log.info(
 			{ eventId: event.eventId, type: event.type },
@@ -1319,30 +1422,97 @@ export class MessageMoveService {
 	 * reject it. We detect FIFO queues by the `.fifo` suffix.
 	 */
 	private enqueueEventsBatch = async (
-		events: MessageMoveQueueEvent[],
+		events: UndoableEvent<MessageDeleteEvent>[],
 	): Promise<void> => {
-		if (events.length === 0) return;
+		const enqueued = await this.sendEventsBatch(events);
+		if (enqueued.outcome === "sent") return;
+		await handBackThenThrow(
+			enqueued.fault,
+			enqueued.unsent.map(({ handBack }) => handBack),
+		);
+	};
 
+	// A batch send answers 200 with per-entry refusals in `Failed`.
+	private sendEventsBatch = async (
+		events: UndoableEvent<MessageDeleteEvent>[],
+	): Promise<BatchEnqueueOutcome> => {
 		const SQS_BATCH_SIZE = 10;
 		const useFifo = this.queueUrl.endsWith(".fifo");
 
 		for (let i = 0; i < events.length; i += SQS_BATCH_SIZE) {
 			const batch = events.slice(i, i + SQS_BATCH_SIZE);
-			await this.sqs.send(
-				new SendMessageBatchCommand({
-					QueueUrl: this.queueUrl,
-					Entries: batch.map((event, idx) => ({
-						Id: `${i + idx}`,
-						MessageBody: JSON.stringify(event),
-						...(useFifo && {
-							MessageGroupId: event.accountId,
-							MessageDeduplicationId: event.eventId,
-						}),
-					})),
-				}),
-			);
+			const sent = await this.sqs
+				.send(
+					new SendMessageBatchCommand({
+						QueueUrl: this.queueUrl,
+						Entries: batch.map(({ event }, idx) => ({
+							Id: `${i + idx}`,
+							MessageBody: JSON.stringify(event),
+							...(useFifo && {
+								MessageGroupId: event.accountId,
+								MessageDeduplicationId: event.eventId,
+							}),
+						})),
+					}),
+				)
+				.then(
+					(result) => ({
+						refusedIds: new Set((result.Failed ?? []).map((entry) => entry.Id)),
+					}),
+					(fault: unknown) => ({ fault }),
+				);
+			if ("fault" in sent) {
+				return {
+					outcome: "unsent",
+					unsent: events.slice(i),
+					fault: sent.fault,
+				};
+			}
+			if (sent.refusedIds.size > 0) {
+				const refused = batch.filter((_, idx) =>
+					sent.refusedIds.has(`${i + idx}`),
+				);
+				return {
+					outcome: "unsent",
+					unsent: [...refused, ...events.slice(i + SQS_BATCH_SIZE)],
+					fault: new Error(
+						`The queue refused ${refused.length} of ${events.length} delete event(s)`,
+					),
+				};
+			}
+		}
+
+		if (events.length > 0) {
+			this.log.info({ count: events.length }, "Enqueued message events batch");
 		}
+		return { outcome: "sent" };
+	};
 
-		this.log.info({ count: events.length }, "Enqueued message events batch");
+	private handBackUnsentMove = async (
+		accountConfigId: string,
+		messageId: string,
+		sourceMailboxId: string,
+		uid: number,
+	): Promise<void> => {
+		await restoreSourcePlacement(
+			{
+				messageService: this.messageService,
+				threadMessageService: this.threadMessageService,
+			},
+			{
+				accountConfigId,
+				messageId,
+				sourceMailboxId,
+				uid,
+				syncStatus: MessageSyncStatus.synced,
+				abandonedMutation: MessageMutation.none,
+			},
+		);
+		await this.addressService.reconcileJunkOnlyForMessage(
+			messageId,
+			await this.mailboxSpecialUseService.resolveJunkRolesForConfig(
+				accountConfigId,
+			),
+		);
 	};
 }

package/src/message-read.ts

@@ -0,0 +1,87 @@
+import { isStorageNotFoundError } from "@remit/storage-service";
+
+/**
+ * The slice of `BodySyncService` the read path needs to lazily materialize
+ * deferred per-part objects.
+ */
+export interface BodyPartMaterializer {
+	ensureBodyPartsStored(
+		accountConfigId: string,
+		accountId: string,
+		messageId: string,
+		bodyStorageKey: string,
+	): Promise<unknown>;
+}
+
+export interface MaterializeLogger {
+	warn(obj: Record<string, unknown>, msg: string): void;
+	error(obj: Record<string, unknown>, msg: string): void;
+}
+
+/**
+ * Re-arms the body-sync cue for one message (the read-path slice of
+ * `BodySyncQueueService`).
+ */
+export interface BodySyncCue {
+	requestBodySync(input: {
+		accountId: string;
+		mailboxId: string;
+		messageId: string;
+		uid?: number;
+	}): Promise<void>;
+}
+
+export interface MaterializeResult {
+	/** `false` when the body object was missing — the caller must not serve the body. */
+	ready: boolean;
+}
+
+/**
+ * Materialize the deferred per-part storage objects for a message before any
+ * part is read. Distinguishes the two failure modes the body contract cares
+ * about:
+ *
+ * - Missing storage object (never synced or lost) — re-arm the SYNC_MESSAGE_BODY
+ *   cue so the worker (re)stores the body, and report `ready: false`. Not a
+ *   500: a retry succeeds once the worker catches up.
+ * - Any other error — rethrow so the request 500s and the bug is observable.
+ *   Never swallowed, never "best-effort".
+ *
+ * No-op (`ready: true`) when the body isn't stored yet (no `bodyStorageKey`) or
+ * when the parts were written eagerly.
+ */
+export const materializeBodyParts = async (
+	materializer: BodyPartMaterializer,
+	args: {
+		accountConfigId: string;
+		accountId: string;
+		mailboxId: string;
+		messageId: string;
+		uid?: number;
+		bodyStorageKey: string | undefined;
+		cue: BodySyncCue | undefined;
+		logger: MaterializeLogger;
+	},
+): Promise<MaterializeResult> => {
+	const { accountConfigId, accountId, mailboxId, messageId, uid } = args;
+	if (!args.bodyStorageKey) return { ready: true };
+
+	try {
+		await materializer.ensureBodyPartsStored(
+			accountConfigId,
+			accountId,
+			messageId,
+			args.bodyStorageKey,
+		);
+		return { ready: true };
+	} catch (error: unknown) {
+		if (!isStorageNotFoundError(error)) throw error;
+
+		args.logger.warn(
+			{ messageId, accountId, mailboxId },
+			"Body object missing on read; re-arming body-sync cue and signalling retry",
+		);
+		await args.cue?.requestBodySync({ accountId, mailboxId, messageId, uid });
+		return { ready: false };
+	}
+};

package/src/message-save-retry.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type {
+	AccountItem,
+	IThreadMessageRepository,
+	MailboxItem,
+} from "@remit/data-ports";
+import { MessageSyncService } from "./message-sync.js";
+import { SyncWarningService } from "./sync-warning.js";
+import { eml, FakeImapServer } from "./test-helpers/fake-imap.js";
+import {
+	openStore,
+	type Store,
+	seedAccount,
+	seedMailbox,
+	silentLog,
+} from "./test-helpers/test-store.js";
+
+let store: Store;
+let imap: FakeImapServer;
+let account: AccountItem;
+let inbox: MailboxItem;
+
+beforeEach(async () => {
+	store = await openStore();
+	imap = new FakeImapServer();
+	account = await seedAccount(store);
+	inbox = await seedMailbox(store, account, "INBOX");
+	imap.addFolder("INBOX");
+});
+
+afterEach(() => store.close());
+
+/** The thread store, refusing its first create: the last write of a save. */
+const failingFirstCreate = (
+	inner: IThreadMessageRepository,
+): IThreadMessageRepository => {
+	let refused = false;
+	return Object.assign(Object.create(inner), {
+		create: (...args: Parameters<IThreadMessageRepository["create"]>) => {
+			if (!refused) {
+				refused = true;
+				return Promise.reject(new Error("the thread write failed"));
+			}
+			return inner.create(...args);
+		},
+	});
+};
+
+const syncOnce = (threadMessage: IThreadMessageRepository) => {
+	const connection = imap.connection();
+	return new MessageSyncService(
+		{ getConnection: () => connection, close: async () => {} },
+		store.mailbox,
+		store.mailboxSpecialUse,
+		store.message,
+		store.envelope,
+		store.address,
+		threadMessage,
+		new SyncWarningService(store.syncWarning),
+		silentLog,
+	).syncMessages(inbox.mailboxId, account.accountId, account.accountConfigId);
+};
+
+describe("a message save that fails at its last write", () => {
+	it("is completed by the next round, with one row of each", async () => {
+		imap.deliver(
+			"INBOX",
+			eml({ Subject: "Halfway", "Message-ID": "<halfway@example.test>" }),
+		);
+		const threadMessage = failingFirstCreate(store.threadMessage);
+
+		await syncOnce(threadMessage);
+		await syncOnce(threadMessage);
+
+		const messages = await store.message.listAllByMailbox(inbox.mailboxId);
+		assert.equal(messages.length, 1);
+		const [message] = messages;
+		assert.ok(message);
+		assert.equal(
+			(
+				await store.threadMessage.findAllByMessageId(
+					account.accountConfigId,
+					message.messageId,
+				)
+			).length,
+			1,
+		);
+	});
+});

package/src/message-sync-flags.test.ts

@@ -6,12 +6,14 @@ import type {
 	IEnvelopeRepository,
 	IMailboxRepository,
 	IMessageRepository,
+	ISyncWarningRepository,
 	IThreadMessageRepository,
 	ThreadMessageItem,
 } from "@remit/data-ports";
 import { MessageCategory, MessageSystemFlag } from "@remit/domain-enums";
 import type { ManagedConnectionFactory } from "./connection-factory.js";
 import { MessageSyncService } from "./message-sync.js";
+import { SyncWarningService } from "./sync-warning.js";
 import { noFolderRoles } from "./test-helpers/folder-roles.js";
 import type { ImapEnvelope } from "./types.js";
 
@@ -46,6 +48,8 @@ const captureCreate = (): {
 } => {
 	const inputs: CreateThreadMessageInput[] = [];
 	const repo = {
+		findByMessageId: async () => null,
+		rekeyThread: async () => ({ moved: 0, dropped: 0 }),
 		create: async (input: CreateThreadMessageInput) => {
 			inputs.push(input);
 			return input as unknown as ThreadMessageItem;
@@ -65,6 +69,7 @@ type CreateThreadForMessage = (
 	threadMessageService: IThreadMessageRepository,
 	messageId: string,
 	mailboxId: string,
+	accountId: string,
 	accountConfigId: string,
 	uid: number,
 	internalDate: number,
@@ -84,9 +89,12 @@ const createThreadWithFlags = async (
 		stub<IMailboxRepository>(),
 		noFolderRoles,
 		stub<IMessageRepository>(),
-		stub<IEnvelopeRepository>(),
+		{
+			listQueuedStructureRefetches: async () => [],
+		} as unknown as IEnvelopeRepository,
 		stub<IAddressRepository>(),
 		stub<IThreadMessageRepository>(),
+		new SyncWarningService(stub<ISyncWarningRepository>()),
 	);
 	const { repo, inputs } = captureCreate();
 	const now = Date.now();
@@ -97,6 +105,7 @@ const createThreadWithFlags = async (
 		repo,
 		MESSAGE_ID,
 		MAILBOX_ID,
+		"acct-1",
 		ACCOUNT_CONFIG_ID,
 		42,
 		now,