@remit/mailbox-service 0.0.71 → 0.0.73

package/package.json

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

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

@@ -13,6 +13,7 @@ import {
 	MessageMoveService,
 	NoTrashMailboxError,
 	StaleTrashAppointmentError,
+	UnconfirmedTrashMailboxError,
 } from "./message-move.js";
 
 const ACCOUNT = "acc-1";
@@ -200,14 +201,34 @@ describe("delete only expunges when it was asked to", () => {
 		);
 	});
 
-	it("expunges a message already inside a Trash that resolves by name", async () => {
-		// D4a: the rows were selected and the dialog named the consequence, so
-		// consent is per message. Empty Trash has no such consent and refuses.
-		const { service, events } = buildWorld(
+	it("refuses to expunge a message already inside a Trash that only resolves by name", async () => {
+		// #876: a message already sitting in the guessed folder used to fall
+		// straight through to an expunge, on the same name guess Empty Trash
+		// refuses to act on. Deleting it is exactly as unrecoverable, so it
+		// demands the same confirmed evidence — nobody, neither the user nor the
+		// server, ever said this folder is Trash.
+		const { service, patches, events, message } = buildWorld(
 			{ kind: "proposed", mailbox: { mailboxId: TRASH, fullPath: "Trash" } },
 			TRASH,
 		);
 
+		await assert.rejects(
+			() => service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT),
+			(error: unknown) =>
+				error instanceof UnconfirmedTrashMailboxError &&
+				error.statusCode === 409 &&
+				error.publicApiError?.details?.reason === "unconfirmed" &&
+				error.publicApiError?.details?.accountId === ACCOUNT,
+		);
+
+		assert.deepEqual(events, []);
+		assert.deepEqual(patches, []);
+		assert.equal(message.mailboxId, TRASH);
+	});
+
+	it("expunges a message already inside a confirmed Trash", async () => {
+		const { service, events } = buildWorld(flaggedTrash, TRASH);
+
 		await service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT);
 
 		assert.deepEqual(

package/src/message-move.ts

@@ -162,7 +162,8 @@ export class StaleTrashAppointmentError extends FolderRoleUnresolvedError {
 
 /**
  * A folder resolves as Trash by its name alone. Enough to move mail into,
- * never enough to expunge — so only the Empty Trash path raises it.
+ * never enough to expunge — raised by Empty Trash and by a delete that would
+ * expunge a message already sitting in that folder.
  */
 export class UnconfirmedTrashMailboxError extends FolderRoleUnresolvedError {
 	name = "UnconfirmedTrashMailboxError";
@@ -307,12 +308,13 @@ export class MessageMoveService {
 		const wantsPermanentDelete =
 			options.permanent === true || options.toTrash === false;
 
-		const trashGate = wantsPermanentDelete
+		const trashResolution = wantsPermanentDelete
 			? null
-			: trashMailboxAt(
-					await this.mailboxSpecialUseService.resolveTrashRole(accountId),
-					"resolved",
-				);
+			: await this.mailboxSpecialUseService.resolveTrashRole(accountId);
+
+		const trashGate = trashResolution
+			? trashMailboxAt(trashResolution, "resolved")
+			: null;
 
 		if (trashGate && !trashGate.allowed) {
 			this.log.error(
@@ -324,6 +326,34 @@ export class MessageMoveService {
 
 		const trashMailbox = trashGate ? trashGate.mailbox : null;
 
+		// A message already sitting in the folder resolved as Trash deletes by
+		// expunging it, not by moving it — the same unrecoverable act Empty
+		// Trash performs, so it demands the same confirmed evidence. The name
+		// guess ("resolved") is enough to file mail into; it is never enough to
+		// destroy mail that is already there. Checked once, before any local
+		// write, so a batch that touches such a message is refused whole rather
+		// than partially expunged.
+		if (!wantsPermanentDelete && trashResolution && trashMailbox) {
+			const deletesInPlace = messages.some(
+				(message) => message.mailboxId === trashMailbox.mailboxId,
+			);
+
+			if (deletesInPlace) {
+				const confirmedTrashGate = trashMailboxAt(trashResolution, "confirmed");
+				if (!confirmedTrashGate.allowed) {
+					this.log.error(
+						{
+							accountId,
+							messageCount: messages.length,
+							reason: confirmedTrashGate.reason,
+						},
+						"Refused to delete: this account's Trash is not confirmed",
+					);
+					throw trashRefusal(confirmedTrashGate.reason, accountId);
+				}
+			}
+		}
+
 		// Group messages by operation type
 		const moveToTrashMessages: Array<{
 			messageId: string;

package/src/outbox-queue-settled-row.test.ts

@@ -0,0 +1,128 @@
+/**
+ * A row the SMTP worker settled has to be a row the user can still act on.
+ *
+ * `sending` is not: `send` takes draft, failed and blocked, and `deleteDraft`
+ * those three plus `unfiled`, so a send that never reached the server left a
+ * row that 409s on both buttons forever (#951). The worker now settles that
+ * row instead of dead-lettering it, and these are the two moves the settled
+ * status has to accept for the settle to be worth anything.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IAccountRepository,
+	IOutboxMessageRepository,
+	OutboxMessageItem,
+} from "@remit/data-ports";
+import { OutboxMessageStatus } from "@remit/domain-enums";
+import type { OutboxAttachmentService } from "./outbox-attachment.js";
+import { OutboxQueueService } from "./outbox-queue.js";
+
+const ACCOUNT_CONFIG_ID = "cfg-1";
+const ACCOUNT_ID = "acc-1";
+const OUTBOX_MESSAGE_ID = "ob-1";
+
+const row = (status: OutboxMessageItem["status"]): OutboxMessageItem =>
+	({
+		outboxMessageId: OUTBOX_MESSAGE_ID,
+		accountId: ACCOUNT_ID,
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		fromAddress: "me@example.com",
+		toAddresses: ["them@example.com"],
+		ccAddresses: [],
+		bccAddresses: [],
+		references: [],
+		messageIdValue: "<m1@example.com>",
+		lastError: "SMTP connection failed: ECONNREFUSED",
+		status,
+		createdAt: 0,
+		updatedAt: 0,
+	}) as unknown as OutboxMessageItem;
+
+interface Harness {
+	service: OutboxQueueService;
+	enqueued: string[];
+	statusWrites: string[];
+	deleted: string[];
+	discarded: string[];
+}
+
+const createHarness = (stored: OutboxMessageItem): Harness => {
+	const harness: Harness = {
+		service: undefined as unknown as OutboxQueueService,
+		enqueued: [],
+		statusWrites: [],
+		deleted: [],
+		discarded: [],
+	};
+
+	const outboxMessageService = {
+		get: async () => stored,
+		updateStatus: async (
+			_configId: string,
+			_id: string,
+			status: OutboxMessageItem["status"],
+		) => {
+			harness.statusWrites.push(status);
+			return { ...stored, status };
+		},
+		delete: async (_configId: string, id: string) => {
+			harness.deleted.push(id);
+		},
+	} as unknown as IOutboxMessageRepository;
+
+	harness.service = new OutboxQueueService({
+		outboxMessageService,
+		outboxAttachmentService: {
+			discardAll: async (_configId: string, _accountId: string, id: string) => {
+				harness.discarded.push(id);
+			},
+		} as unknown as OutboxAttachmentService,
+		accountService: {} as unknown as IAccountRepository,
+		sqsSmtpQueueUrl: "http://localhost/queue",
+		sqsClient: {
+			send: async (command: { input: { MessageBody: string } }) => {
+				harness.enqueued.push(command.input.MessageBody);
+				return {};
+			},
+		} as never,
+	});
+
+	return harness;
+};
+
+describe("a row the worker settled at `failed`", () => {
+	it("is sendable again — Retry is the whole point of settling there", async () => {
+		const harness = createHarness(row(OutboxMessageStatus.failed));
+
+		await harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+
+		assert.deepEqual(harness.statusWrites, [OutboxMessageStatus.queued]);
+		assert.equal(harness.enqueued.length, 1);
+	});
+
+	it("is discardable — the other way out of the Outbox", async () => {
+		const harness = createHarness(row(OutboxMessageStatus.failed));
+
+		await harness.service.deleteDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+
+		assert.deepEqual(harness.deleted, [OUTBOX_MESSAGE_ID]);
+		assert.deepEqual(harness.discarded, [OUTBOX_MESSAGE_ID]);
+	});
+});
+
+describe("a row the worker settled at `unfiled`", () => {
+	it("is discardable but never sendable — the server may already hold it", async () => {
+		const harness = createHarness(row(OutboxMessageStatus.unfiled));
+
+		await assert.rejects(
+			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
+			/cannot be sent again/,
+		);
+		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
+
+		await harness.service.deleteDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+		assert.deepEqual(harness.deleted, [OUTBOX_MESSAGE_ID]);
+	});
+});