@remit/mailbox-service 0.0.56 → 0.0.58

package/package.json

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

package/src/index.ts

@@ -254,6 +254,7 @@ export {
 } from "./snippet.js";
 export {
 	MoveNotSettledError,
+	NoJunkMailboxError,
 	type SpamReportConfig,
 	type SpamReportLogger,
 	type SpamReportParams,

package/src/outbox-queue.test.ts

@@ -0,0 +1,157 @@
+/**
+ * A message with nobody to send to must be refused where the person who pressed
+ * Send can see the refusal.
+ *
+ * `@minItems(1)` on `CreateOutboxMessageInput.toAddresses` was the only check
+ * anywhere on the path, and neither route into the queue passes it: `send`
+ * takes a stored draft, which the update endpoint will happily strip every
+ * address off, and `createAndSend` reaches nodemailer with whatever it was
+ * handed. Nodemailer refuses an empty envelope inside the SMTP worker, so the
+ * message dies in the DLQ and the composer reports a send that went nowhere.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IAccountRepository,
+	IOutboxMessageRepository,
+	OutboxMessageItem,
+} from "@remit/data-ports";
+import { BadRequestError } from "@remit/data-ports/errors";
+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 draft = (overrides: Partial<OutboxMessageItem>): 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>",
+		status: OutboxMessageStatus.draft,
+		createdAt: 0,
+		updatedAt: 0,
+		...overrides,
+	}) as OutboxMessageItem;
+
+interface Harness {
+	service: OutboxQueueService;
+	enqueued: string[];
+	created: number;
+	statusWrites: string[];
+}
+
+const createHarness = (stored: OutboxMessageItem): Harness => {
+	const harness: Harness = {
+		service: undefined as unknown as OutboxQueueService,
+		enqueued: [],
+		created: 0,
+		statusWrites: [],
+	};
+
+	const outboxMessageService = {
+		get: async () => stored,
+		create: async (input: Record<string, unknown>) => {
+			harness.created += 1;
+			return draft(input as Partial<OutboxMessageItem>);
+		},
+		updateStatus: async (
+			_configId: string,
+			_id: string,
+			status: OutboxMessageItem["status"],
+		) => {
+			harness.statusWrites.push(status);
+			return draft({ status });
+		},
+	} as unknown as IOutboxMessageRepository;
+
+	harness.service = new OutboxQueueService({
+		outboxMessageService,
+		outboxAttachmentService: {} 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;
+};
+
+const sendInput = (overrides: Record<string, unknown>) => ({
+	accountId: ACCOUNT_ID,
+	accountConfigId: ACCOUNT_CONFIG_ID,
+	fromAddress: "me@example.com",
+	toAddresses: [] as string[],
+	...overrides,
+});
+
+describe("OutboxQueueService and a message with nowhere to go", () => {
+	it("refuses to queue a stored draft that has lost every address", async () => {
+		const harness = createHarness(
+			draft({ toAddresses: [], ccAddresses: [], bccAddresses: [] }),
+		);
+
+		await assert.rejects(
+			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
+			(error: unknown) => {
+				assert.ok(error instanceof BadRequestError);
+				assert.equal(error.statusCode, 400);
+				return true;
+			},
+		);
+
+		assert.deepEqual(harness.statusWrites, [], "it stayed a draft");
+		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
+	});
+
+	it("queues a draft addressed only in Bcc — that envelope is real", async () => {
+		const harness = createHarness(
+			draft({ toAddresses: [], bccAddresses: ["them@example.com"] }),
+		);
+
+		await harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+
+		assert.deepEqual(harness.statusWrites, [OutboxMessageStatus.queued]);
+		assert.equal(harness.enqueued.length, 1);
+	});
+
+	it("refuses a send-immediately create with no addresses, before writing a row", async () => {
+		const harness = createHarness(draft({}));
+
+		await assert.rejects(
+			() => harness.service.createAndSend(sendInput({})),
+			(error: unknown) => {
+				assert.ok(error instanceof BadRequestError);
+				assert.equal(error.statusCode, 400);
+				return true;
+			},
+		);
+
+		assert.equal(harness.created, 0, "no queued row was left behind");
+		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
+	});
+
+	it("still creates and queues a send-immediately message that has a recipient", async () => {
+		const harness = createHarness(draft({}));
+
+		await harness.service.createAndSend(
+			sendInput({ toAddresses: ["them@example.com"] }),
+		);
+
+		assert.equal(harness.created, 1);
+		assert.equal(harness.enqueued.length, 1);
+	});
+});

package/src/outbox-queue.ts

@@ -5,7 +5,7 @@ import type {
 	IOutboxMessageRepository,
 	OutboxMessageItem,
 } from "@remit/data-ports";
-import { ConflictError } from "@remit/data-ports/errors";
+import { BadRequestError, ConflictError } from "@remit/data-ports/errors";
 import { OutboxMessageStatus } from "@remit/domain-enums";
 import { createQueueProducer } from "@remit/sqs-client/producer";
 import type { OutboxAttachmentService } from "./outbox-attachment.js";
@@ -64,6 +64,29 @@ export interface UpdateDraftInput {
 	references?: string[];
 }
 
+/**
+ * Nobody to send to. `@minItems(1)` on the create input is the only thing that
+ * has ever stood between a zero-recipient message and nodemailer, which refuses
+ * an empty envelope — and refuses it inside the SMTP worker, where the failure
+ * lands in the DLQ rather than in front of the person who pressed Send. Neither
+ * route into the queue passes that schema: a draft is created with a recipient
+ * and can be edited down to none, and `send` never sees the create input at all.
+ *
+ * Cc and Bcc count. A message addressed only in Bcc is a real message with a
+ * real envelope; only a message with no address anywhere has nowhere to go.
+ */
+const hasNowhereToGo = (message: {
+	toAddresses?: string[];
+	ccAddresses?: string[];
+	bccAddresses?: string[];
+}): boolean =>
+	(message.toAddresses?.length ?? 0) === 0 &&
+	(message.ccAddresses?.length ?? 0) === 0 &&
+	(message.bccAddresses?.length ?? 0) === 0;
+
+const NO_RECIPIENT_MESSAGE =
+	"This message has nobody to send to. Add a recipient before sending it.";
+
 const generateMessageId = (domain: string): string => {
 	const timestamp = Date.now();
 	const random = randomUUID().replace(/-/g, "").slice(0, 16);
@@ -198,6 +221,10 @@ export class OutboxQueueService {
 			);
 		}
 
+		if (hasNowhereToGo(existing)) {
+			throw new BadRequestError(NO_RECIPIENT_MESSAGE);
+		}
+
 		const updated = await this.outboxMessageService.updateStatus(
 			accountConfigId,
 			outboxMessageId,
@@ -217,6 +244,10 @@ export class OutboxQueueService {
 	createAndSend = async (
 		input: CreateDraftInput,
 	): Promise<OutboxMessageItem> => {
+		if (hasNowhereToGo(input)) {
+			throw new BadRequestError(NO_RECIPIENT_MESSAGE);
+		}
+
 		const domain = extractDomain(input.fromAddress);
 		const messageIdValue = generateMessageId(domain);
 

package/src/spam-report.test.ts

@@ -10,10 +10,15 @@ import type {
 	IMessageRepository,
 	IThreadMessageRepository,
 } from "@remit/data-ports";
+import { deriveAddressId } from "@remit/data-ports/id";
 import { AddressRole } from "@remit/domain-enums";
 import { FlagPushService } from "./flag-push.js";
 import { MessageMoveService } from "./message-move.js";
-import { MoveNotSettledError, SpamReportService } from "./spam-report.js";
+import {
+	MoveNotSettledError,
+	NoJunkMailboxError,
+	SpamReportService,
+} from "./spam-report.js";
 
 const ACCOUNT = "acc-1";
 const ACCOUNT_CONFIG = "cfg-1";
@@ -21,7 +26,8 @@ const ACCOUNT_EMAIL = "me@example.com";
 const INBOX_MAILBOX = "mbx-inbox";
 const JUNK_MAILBOX = "mbx-junk";
 const MESSAGE_ID = "msg-1";
-const ADDRESS_ID = "addr-1";
+const SENDER_EMAIL = "sender@example.com";
+const ADDRESS_ID = deriveAddressId(ACCOUNT_CONFIG, SENDER_EMAIL);
 const THREAD_ID = "thread-1";
 
 interface ThreadRow {
@@ -59,10 +65,21 @@ const buildWorld = (
 		startMailbox?: string;
 		fromEmail?: string;
 		originalMailboxId?: string;
+		/** Whether the sender was ever harvested into an `address` row. */
+		harvestedSender?: boolean;
+		/** Flags already standing on the harvested sender's row. */
+		senderFlags?: Record<string, unknown>;
+		junkMailbox?: { mailboxId: string; fullPath: string } | null;
 	} = {},
 ): World => {
 	const startMailbox = opts.startMailbox ?? INBOX_MAILBOX;
-	const fromEmail = opts.fromEmail ?? "sender@example.com";
+	const fromEmail = opts.fromEmail ?? SENDER_EMAIL;
+	const fromAddressId = deriveAddressId(ACCOUNT_CONFIG, fromEmail);
+	const harvestedSender = opts.harvestedSender ?? true;
+	const junkMailbox =
+		opts.junkMailbox === undefined
+			? { mailboxId: JUNK_MAILBOX, fullPath: "Junk" }
+			: opts.junkMailbox;
 
 	const messages = new Map<string, Record<string, unknown>>([
 		[
@@ -85,9 +102,11 @@ const buildWorld = (
 		],
 	]);
 
-	const addresses = new Map<string, { flags: AddressFlags }>([
-		[ADDRESS_ID, { flags: {} }],
-	]);
+	const addresses = new Map<string, { flags: AddressFlags }>(
+		harvestedSender
+			? [[fromAddressId, { flags: (opts.senderFlags ?? {}) as AddressFlags }]]
+			: [],
+	);
 
 	const threadRows: ThreadRow[] = [
 		{
@@ -134,7 +153,8 @@ const buildWorld = (
 					{
 						envelopeAddressId: "ea-1",
 						messageId: id,
-						addressId: ADDRESS_ID,
+						addressId: fromAddressId,
+						displayName: "Spammy Sender",
 						normalizedEmail: fromEmail,
 						addressRole: AddressRole.From,
 						addressOrder: 0,
@@ -173,6 +193,17 @@ const buildWorld = (
 	} as unknown as IMessageRepository;
 
 	const addressService = {
+		getAddress: async (_accountConfigId: string, addressIds: string[]) =>
+			addressIds
+				.filter((id) => addresses.has(id))
+				.map((id) => ({ addressId: id, ...addresses.get(id) })),
+		// Deliberately destructive on conflict, mirroring the real repo's
+		// `onConflictDoUpdate`: a caller that upserts over a row it did not
+		// create loses what stood on it.
+		upsertAddress: async (input: { addressId: string }) => {
+			addresses.set(input.addressId, { flags: {} });
+			return { ...input, flags: {} };
+		},
 		mergeFlags: async (
 			_accountConfigId: string,
 			addressId: string,
@@ -199,10 +230,7 @@ const buildWorld = (
 	} as unknown as IAccountRepository;
 
 	const mailboxSpecialUseService = {
-		findJunkMailbox: async () => ({
-			mailboxId: JUNK_MAILBOX,
-			fullPath: "Junk",
-		}),
+		findJunkMailbox: async () => junkMailbox,
 		findTrashMailbox: async () => null,
 	} as unknown as IMailboxSpecialUseRepository;
 
@@ -399,9 +427,133 @@ describe("SpamReportService.reportSpam", () => {
 		assert.ok(message !== undefined);
 		assert.ok((message.spamReport as { reportedAt: number }).reportedAt > 0);
 	});
+
+	it("refuses to mint a row for a sender address carrying no @ at all", async () => {
+		// slice() around a lastIndexOf of -1 splits "no-at-sign" into a
+		// plausible-looking local part and domain, so a length check alone
+		// waves the one input it exists to catch straight through into a
+		// corrupt address row.
+		const { service, addresses } = buildWorld({
+			harvestedSender: false,
+			fromEmail: "no-at-sign",
+		});
+
+		await assert.rejects(
+			() =>
+				service.reportSpam({
+					accountConfigId: ACCOUNT_CONFIG,
+					accountId: ACCOUNT,
+					messageId: MESSAGE_ID,
+				}),
+			/not a usable email address/,
+		);
+
+		assert.equal(addresses.size, 0);
+	});
+
+	it("reports a message whose sender was never harvested into an address row", async () => {
+		// The row is what carries the blocked flag, and harvesting is what
+		// ordinarily writes it. When it is absent, blocking the sender used to
+		// throw NotFoundError and take the whole report down with it — the
+		// message never reached Junk and the user got a retry that could not
+		// work (test.remit.email, 18 Aug 2026).
+		const { service, messages, addresses, sent } = buildWorld({
+			harvestedSender: false,
+		});
+
+		await service.reportSpam({
+			accountConfigId: ACCOUNT_CONFIG,
+			accountId: ACCOUNT,
+			messageId: MESSAGE_ID,
+			setBy: "user-1",
+		});
+
+		const address = addresses.get(ADDRESS_ID);
+		assert.equal(address?.flags.blocked?.value, true);
+
+		const message = messages.get(MESSAGE_ID);
+		assert.equal(message?.mailboxId, JUNK_MAILBOX);
+		assert.equal(moveEvents(sent).length, 1);
+	});
+
+	it("keeps the junkOnly mark that withholds the sender from autocomplete", async () => {
+		// Report spam adds the block; it is not a sighting of the sender and
+		// must not carry an upsert's on-conflict behaviour onto a row it did
+		// not create. The mark that withholds a spammer from autocomplete (#822)
+		// lives in these same flags, and clearing it here would put the spammer
+		// back in the compose picker — the opposite of what the button means.
+		const { service, addresses } = buildWorld({
+			senderFlags: {
+				junkOnly: { value: true, setAt: 1, setBy: "junk-harvest" },
+			},
+		});
+
+		await service.reportSpam({
+			accountConfigId: ACCOUNT_CONFIG,
+			accountId: ACCOUNT,
+			messageId: MESSAGE_ID,
+			setBy: "user-1",
+		});
+
+		const flags = addresses.get(ADDRESS_ID)?.flags as Record<string, unknown>;
+		assert.equal((flags.blocked as { value: boolean }).value, true);
+		assert.deepEqual(flags.junkOnly, {
+			value: true,
+			setAt: 1,
+			setBy: "junk-harvest",
+		});
+	});
+
+	it("names the missing Junk folder and changes nothing when the account has none", async () => {
+		const { service, messages, addresses, sent, markerPuts } = buildWorld({
+			junkMailbox: null,
+		});
+
+		await assert.rejects(
+			() =>
+				service.reportSpam({
+					accountConfigId: ACCOUNT_CONFIG,
+					accountId: ACCOUNT,
+					messageId: MESSAGE_ID,
+				}),
+			(error: unknown) =>
+				error instanceof NoJunkMailboxError &&
+				/no Junk folder/.test(error.message) &&
+				/Create one/.test(error.message),
+		);
+
+		// Nothing half-applied: no sender blocked, no report stamp on a message
+		// still sitting where it was, no move, no keyword marker.
+		assert.equal(addresses.get(ADDRESS_ID)?.flags.blocked, undefined);
+		const message = messages.get(MESSAGE_ID);
+		assert.equal(message?.spamReport, undefined);
+		assert.equal(message?.mailboxId, INBOX_MAILBOX);
+		assert.equal(moveEvents(sent).length, 0);
+		assert.equal(markerPuts.length, 0);
+	});
 });
 
 describe("SpamReportService.notSpam", () => {
+	it("mints no address row for a sender that was never harvested", async () => {
+		// A sender with no row has no block to lift, so the flag write is
+		// already true. Creating the row to write it would put an address
+		// nothing ever harvested into the address book, where autocomplete
+		// would then offer it.
+		const { service, messages, addresses } = buildWorld({
+			harvestedSender: false,
+			startMailbox: JUNK_MAILBOX,
+		});
+
+		await service.notSpam({
+			accountConfigId: ACCOUNT_CONFIG,
+			accountId: ACCOUNT,
+			messageId: MESSAGE_ID,
+		});
+
+		assert.equal(addresses.size, 0);
+		assert.equal(messages.get(MESSAGE_ID)?.spamReport, undefined);
+	});
+
 	it("restores the original mailbox and clears the flag without setting trust", async () => {
 		const { service, messages, addresses } = buildWorld();
 

package/src/spam-report.ts

@@ -5,6 +5,7 @@ import type {
 	IMessageRepository,
 	MessageItem,
 } from "@remit/data-ports";
+import { deriveAddressId } from "@remit/data-ports/id";
 import {
 	AddressRole,
 	MessageKeywordFlag,
@@ -33,6 +34,22 @@ export class MoveNotSettledError extends Error {
 	}
 }
 
+/**
+ * The account advertises no Junk folder and has none under any conventional
+ * name, so there is nowhere to file the report. A designed, user-facing
+ * outcome — the user has to create the folder, and no amount of retrying
+ * changes that — so it carries its own text through the bulk handler's
+ * allowlist rather than being flattened to the generic retry copy.
+ */
+export class NoJunkMailboxError extends Error {
+	constructor() {
+		super(
+			"This account has no Junk folder. Create one named Junk or Spam in your mail provider, then report this message again.",
+		);
+		this.name = "NoJunkMailboxError";
+	}
+}
+
 const noopLogger: SpamReportLogger = {
 	info: () => {},
 	error: () => {},
@@ -86,9 +103,20 @@ export class SpamReportService {
 			config.moveSettlePollMs ?? DEFAULT_MOVE_SETTLE_POLL_MS;
 	}
 
+	/**
+	 * The sender to act on. `addressId` is derived rather than read off the
+	 * envelope row so it always names the row `ensureSenderAddress` writes and
+	 * the harvester writes — one derivation, one row, whatever the envelope
+	 * happens to carry.
+	 */
 	private resolveFromAddress = async (
+		accountConfigId: string,
 		messageId: string,
-	): Promise<{ addressId: string; normalizedEmail: string }> => {
+	): Promise<{
+		addressId: string;
+		normalizedEmail: string;
+		displayName: string;
+	}> => {
 		const description = await this.messageService.describe(messageId);
 		const from = description.envelopeAddress.find(
 			(a) => a.addressRole === AddressRole.From,
@@ -96,7 +124,65 @@ export class SpamReportService {
 		if (!from) {
 			throw new Error(`Message ${messageId} has no From address to act on`);
 		}
-		return { addressId: from.addressId, normalizedEmail: from.normalizedEmail };
+		return {
+			addressId: deriveAddressId(accountConfigId, from.normalizedEmail),
+			normalizedEmail: from.normalizedEmail,
+			displayName: from.displayName ?? "",
+		};
+	};
+
+	/**
+	 * The list form answers `[]` for a row that is not there, where the single
+	 * form throws — absence is a case both callers handle, not a fault.
+	 */
+	private senderIsKnown = async (
+		accountConfigId: string,
+		addressId: string,
+	): Promise<boolean> => {
+		const [known] = await this.addressService.getAddress(accountConfigId, [
+			addressId,
+		]);
+		return known !== undefined;
+	};
+
+	/**
+	 * Blocking a sender owns the row it writes to. Harvesting is what ordinarily
+	 * creates it, but a message whose harvest never landed — or whose row was
+	 * taken by a cascade — still has a sender the user is entitled to block, and
+	 * a missing row used to abort report-spam before the message ever reached
+	 * Junk. The id is the harvester's own derivation, so this converges on the
+	 * one row rather than minting a parallel one.
+	 *
+	 * A row that already exists is left exactly as it stands. Reporting spam is
+	 * evidence about the sender, never about the account's standing record of
+	 * them: an upsert here would carry whatever the upsert path does on
+	 * conflict — today a display name chosen by the spammer, and any flag a
+	 * later sighting-clearing rule hangs off it — into an operation that means
+	 * the opposite.
+	 */
+	private ensureSenderAddress = async (
+		accountConfigId: string,
+		from: { addressId: string; normalizedEmail: string; displayName: string },
+	): Promise<void> => {
+		const separator = from.normalizedEmail.lastIndexOf("@");
+		const localPart = from.normalizedEmail.slice(0, separator);
+		const domain = from.normalizedEmail.slice(separator + 1);
+		if (separator < 0 || localPart.length === 0 || domain.length === 0) {
+			throw new Error(
+				`Sender address ${from.normalizedEmail} is not a usable email address`,
+			);
+		}
+		if (await this.senderIsKnown(accountConfigId, from.addressId)) return;
+		await this.addressService.upsertAddress({
+			addressId: from.addressId,
+			accountConfigId,
+			localPart,
+			domain,
+			normalizedEmail: from.normalizedEmail,
+			normalizedCompound:
+				`${from.displayName.toLowerCase()} ${from.normalizedEmail}`.trim(),
+			displayName: from.displayName,
+		});
 	};
 
 	/**
@@ -128,12 +214,24 @@ export class SpamReportService {
 		const { accountConfigId, accountId, messageId, setBy } = params;
 		const now = Date.now();
 
-		const from = await this.resolveFromAddress(messageId);
+		// Resolved before anything is written: with nowhere to file the report,
+		// the operation cannot happen, and a blocked sender plus a `spamReport`
+		// stamp on a message still sitting in the inbox is a report that half
+		// happened. Fail here and the press changed nothing.
+		const junkMailbox =
+			await this.mailboxSpecialUseService.findJunkMailbox(accountId);
+		if (!junkMailbox) {
+			this.log.error({ accountId, messageId }, "No Junk mailbox for account");
+			throw new NoJunkMailboxError();
+		}
+
+		const from = await this.resolveFromAddress(accountConfigId, messageId);
 		const account = await this.accountService.get(accountId);
 		const isOwnAddress =
 			from.normalizedEmail.toLowerCase() === account.email.toLowerCase();
 
 		if (!isOwnAddress) {
+			await this.ensureSenderAddress(accountConfigId, from);
 			await this.addressService.mergeFlags(accountConfigId, from.addressId, {
 				blocked: { value: true, setAt: now, setBy },
 			});
@@ -153,12 +251,6 @@ export class SpamReportService {
 			spamReport: { reportedAt: now },
 		});
 
-		const junkMailbox =
-			await this.mailboxSpecialUseService.findJunkMailbox(accountId);
-		if (!junkMailbox) {
-			throw new Error(`No Junk mailbox found for account ${accountId}`);
-		}
-
 		const alreadyInJunk = before.mailboxId === junkMailbox.mailboxId;
 
 		await this.messageMoveService.moveMessage(
@@ -200,10 +292,15 @@ export class SpamReportService {
 	notSpam = async (params: SpamReportParams): Promise<void> => {
 		const { accountConfigId, accountId, messageId } = params;
 
-		const from = await this.resolveFromAddress(messageId);
-		await this.addressService.mergeFlags(accountConfigId, from.addressId, {
-			blocked: null,
-		});
+		// Unblocking a sender the account has no row for is already true, and
+		// minting one here would put an address nothing ever harvested into the
+		// address book — the withdrawal of a judgement is not a sighting.
+		const from = await this.resolveFromAddress(accountConfigId, messageId);
+		if (await this.senderIsKnown(accountConfigId, from.addressId)) {
+			await this.addressService.mergeFlags(accountConfigId, from.addressId, {
+				blocked: null,
+			});
+		}
 
 		const message = await this.messageService.get(messageId);