@remit/mailbox-service 0.0.110 → 0.0.112

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

@@ -1,378 +0,0 @@
-/**
- * Issue #665. While a placement move is in flight the Message row names the
- * destination folder but still carries the SOURCE folder's uid, so a user move
- * that binds the pair as it stands sends the worker to `openBox(destination)`
- * and `moveMessages([uid])` — the destination folder's own message at that uid,
- * carried off to wherever the user pointed. The reachable press is Undo on the
- * auto-moved badge, inside the seconds before the placement push confirms.
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	IAddressRepository,
-	IMailboxRepository,
-	IMailboxSpecialUseRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-} from "@remit/data-ports";
-import { MessagePlacementUnsettledError } from "@remit/data-ports/errors";
-import { MessageMoveService } from "./message-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 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;
-const ARCHIVE_UID = 907;
-const SETTLED_UID = 11;
-
-interface CapturedEvent {
-	type: string;
-	messageId?: string;
-	uid?: number;
-	sourceMailboxPath?: string;
-	destinationMailboxPath?: string;
-}
-
-const mailboxes = [
-	{ mailboxId: INBOX, fullPath: "INBOX", accountId: ACCOUNT },
-	{ mailboxId: ARCHIVE, fullPath: "Archive", accountId: ACCOUNT },
-];
-
-/** A row mid-move: Archive is already written, the uid is still INBOX's. */
-const movingRow = () => ({
-	messageId: MOVING_ID,
-	mailboxId: ARCHIVE,
-	uid: INBOX_UID,
-	status: "moving",
-	syncStatus: "pending",
-	originalMailboxId: INBOX,
-	originalUid: INBOX_UID,
-});
-
-/**
- * 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 = () => ({
-	messageId: STRANDED_ID,
-	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. */
-const settledRow = () => ({
-	messageId: SETTLED_ID,
-	mailboxId: INBOX,
-	uid: SETTLED_UID,
-	status: "active",
-	syncStatus: "synced",
-});
-
-/**
- * A freshly copied row: `moving` until COPYUID lands, with no server-side uid
- * at all and no move behind it. Its uid is not ready; it does not name anyone.
- */
-const freshCopyRow = () => ({
-	messageId: COPY_ID,
-	mailboxId: ARCHIVE,
-	uid: 0,
-	status: "moving",
-	syncStatus: "pending",
-});
-
-const buildWorld = (seed: Array<Record<string, unknown>>) => {
-	const patches: Array<{ messageId: string; patch: Record<string, unknown> }> =
-		[];
-	const events: CapturedEvent[] = [];
-	const rows = new Map<string, Record<string, unknown>>(
-		seed.map((row): [string, Record<string, unknown>] => [
-			String(row.messageId),
-			row,
-		]),
-	);
-
-	/** What `updateUid` writes when the placement move confirms. */
-	const settle = (messageId: string) => {
-		Object.assign(rows.get(messageId) ?? {}, {
-			uid: ARCHIVE_UID,
-			status: "active",
-			syncStatus: "synced",
-		});
-	};
-
-	const messageService = {
-		get: async (ids: string | string[]) =>
-			Array.isArray(ids)
-				? ids.flatMap((id) => {
-						const row = rows.get(id);
-						return row ? [row] : [];
-					})
-				: rows.get(ids),
-		update: async (id: string, patch: Record<string, unknown>) => {
-			patches.push({ messageId: id, patch });
-			return Object.assign(rows.get(id) ?? {}, patch);
-		},
-		transitionPlacement: async (
-			id: string,
-			_expected: Record<string, unknown>,
-			patch: Record<string, unknown>,
-		) => {
-			patches.push({ messageId: id, patch });
-			return Object.assign(rows.get(id) ?? {}, patch);
-		},
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		getByMessageId: async (_cfg: string, messageId: string) => ({
-			accountConfigId: ACCOUNT_CONFIG,
-			threadMessageId: `tm-${messageId}`,
-			messageId,
-			threadId: "thr-1",
-			mailboxId: rows.get(messageId)?.mailboxId,
-			sentDate: 1,
-			isRead: false,
-			isDeleted: false,
-			hasStars: false,
-			hasAttachment: false,
-		}),
-		update: async () => {},
-	} as unknown as IThreadMessageRepository;
-
-	const mailboxService = {
-		get: async (_accountId: string, ids: string | string[]) =>
-			Array.isArray(ids)
-				? mailboxes.filter((mailbox) => ids.includes(mailbox.mailboxId))
-				: mailboxes.find((mailbox) => mailbox.mailboxId === ids),
-	} as unknown as IMailboxRepository;
-
-	const mailboxSpecialUseService = {
-		findTrashMailbox: async () => null,
-		resolveJunkRolesForConfig: async () => NO_JUNK_ROLES,
-	} as unknown as IMailboxSpecialUseRepository;
-
-	const addressService = {
-		reconcileJunkOnlyForMessage: async () => {},
-	} as unknown as IAddressRepository;
-
-	const service = new MessageMoveService({
-		messageService,
-		mailboxService,
-		mailboxSpecialUseService,
-		threadMessageService,
-		addressService,
-		sqsQueueUrl: "http://localhost:9324/000000000000/remit-messages.fifo",
-		moveSettleTimeoutMs: 200,
-		moveSettlePollMs: 10,
-	});
-
-	(
-		service as unknown as { enqueueEvent: (e: CapturedEvent) => Promise<void> }
-	).enqueueEvent = async (event) => {
-		events.push(event);
-	};
-
-	return { service, patches, events, rows, settle };
-};
-
-describe("a move never binds the folder/uid pair of an in-flight move (#665)", () => {
-	it("binds the confirmed pair once the placement move settles", async () => {
-		const { service, events, settle } = buildWorld([movingRow()]);
-
-		setTimeout(() => settle(MOVING_ID), 30);
-		await service.moveMessage(ACCOUNT_CONFIG, MOVING_ID, INBOX, ACCOUNT);
-
-		assert.equal(events.length, 1);
-		assert.equal(events[0].type, "MESSAGE_MOVE");
-		assert.equal(
-			events[0].sourceMailboxPath,
-			"Archive",
-			"the folder the confirmed move left the message in",
-		);
-		assert.equal(
-			events[0].uid,
-			ARCHIVE_UID,
-			"and that folder's own uid, never the source folder's",
-		);
-		assert.equal(events[0].destinationMailboxPath, "INBOX");
-	});
-
-	it("refuses the move, and touches nothing, when the placement never settles", async () => {
-		const { service, patches, events, rows } = buildWorld([movingRow()]);
-
-		await assert.rejects(
-			() => service.moveMessage(ACCOUNT_CONFIG, MOVING_ID, INBOX, ACCOUNT),
-			(error: unknown) =>
-				error instanceof MessagePlacementUnsettledError &&
-				error.statusCode === 409 &&
-				error.publicApiError?.code === "message_placement_unsettled" &&
-				error.publicApiError?.details?.messageId === MOVING_ID &&
-				error.publicApiError?.details?.accountId === ACCOUNT &&
-				error.publicApiError?.details?.reason === "in_flight",
-		);
-
-		assert.deepEqual(events, [], "nothing was enqueued");
-		assert.deepEqual(patches, [], "and no local write was made");
-		assert.equal(rows.get(MOVING_ID)?.mailboxId, ARCHIVE);
-		assert.equal(rows.get(MOVING_ID)?.uid, INBOX_UID);
-	});
-
-	it("never answers the same-mailbox skip from a folder the message has not reached", async () => {
-		// The skip compares the row's `mailboxId` against the destination. An
-		// in-flight move has already written that folder optimistically, so the
-		// comparison would report the message home and return a silent success
-		// for a move the server has not made.
-		const { service, events } = buildWorld([movingRow()]);
-
-		await assert.rejects(
-			() => service.moveMessage(ACCOUNT_CONFIG, MOVING_ID, ARCHIVE, ACCOUNT),
-			MessagePlacementUnsettledError,
-		);
-
-		assert.deepEqual(events, []);
-	});
-
-	it("moves no part of a batch when one row is in flight", async () => {
-		// All-or-nothing: the settled row is movable on its own and a per-row
-		// gate would have moved it before reaching the refusal.
-		const { service, patches, events } = buildWorld([
-			settledRow(),
-			movingRow(),
-		]);
-
-		await assert.rejects(
-			() =>
-				service.moveMessages(
-					ACCOUNT_CONFIG,
-					[SETTLED_ID, MOVING_ID],
-					ARCHIVE,
-					ACCOUNT,
-				),
-			MessagePlacementUnsettledError,
-		);
-
-		assert.deepEqual(
-			events,
-			[],
-			"the settled row was not moved alongside the refusal",
-		);
-		assert.deepEqual(patches, []);
-	});
-
-	it("moves the whole batch once the in-flight row settles", async () => {
-		const { service, events, settle } = buildWorld([settledRow(), movingRow()]);
-
-		setTimeout(() => settle(MOVING_ID), 30);
-		await service.moveMessages(
-			ACCOUNT_CONFIG,
-			[SETTLED_ID, MOVING_ID],
-			INBOX,
-			ACCOUNT,
-		);
-
-		assert.deepEqual(
-			events.map((event) => [event.messageId, event.uid]),
-			[[MOVING_ID, ARCHIVE_UID]],
-			"the settled row was already in INBOX and skipped; the moved row went with the confirmed uid",
-		);
-	});
-
-	it("waits one row's ceiling for a batch, not one per row", async () => {
-		const rows = [movingRow(), movingRow(), movingRow()].map((row, index) => ({
-			...row,
-			messageId: `${MOVING_ID}-${index}`,
-		}));
-		const { service } = buildWorld(rows);
-
-		const startedAt = Date.now();
-		await assert.rejects(
-			() =>
-				service.moveMessages(
-					ACCOUNT_CONFIG,
-					rows.map((row) => row.messageId),
-					INBOX,
-					ACCOUNT,
-				),
-			MessagePlacementUnsettledError,
-		);
-
-		assert.ok(
-			Date.now() - startedAt < 500,
-			"three rows refused within one 200ms ceiling, not three",
-		);
-	});
-});
-
-describe("the move gate refuses only a uid that names somebody else (#665)", () => {
-	it("moves a freshly copied row rather than waiting on it", async () => {
-		// A copy is `moving` with no server-side uid yet. That uid is not ready,
-		// which is not the same as naming another folder's message.
-		const { service, events } = buildWorld([freshCopyRow()]);
-
-		const startedAt = Date.now();
-		await service.moveMessage(ACCOUNT_CONFIG, COPY_ID, INBOX, ACCOUNT);
-
-		assert.equal(events.length, 1);
-		assert.equal(events[0].type, "MESSAGE_MOVE");
-		assert.ok(Date.now() - startedAt < 100, "and never entered the wait");
-	});
-
-	it("waits out a delete in flight rather than binding its borrowed uid", async () => {
-		const { service, events, patches } = buildWorld([deletingRow()]);
-
-		await assert.rejects(
-			() => service.moveMessage(ACCOUNT_CONFIG, DELETING_ID, INBOX, ACCOUNT),
-			(error: unknown) => error instanceof MessagePlacementUnsettledError,
-		);
-
-		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");
-	});
-});

package/src/message-sync-address-spoof.test.ts

@@ -1,293 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	CreateAddressInput,
-	CreateEnvelopeAddressInput,
-	CreateThreadMessageInput,
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMailboxRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MailboxItem,
-	MessageItem,
-	ThreadMessageItem,
-} from "@remit/data-ports";
-import type { ManagedConnectionFactory } from "./connection-factory.js";
-import { type AccountFolderRoles, MessageSyncService } from "./message-sync.js";
-import { NO_FOLDER_ROLES, noFolderRoles } from "./test-helpers/folder-roles.js";
-import type { ImapAddress, ImapEnvelope, ImapMessage } from "./types.js";
-
-const stub = <T>(): T => ({}) as T;
-
-const emptyEnvelope: ImapEnvelope = {
-	date: new Date(0).toISOString(),
-	messageId: "<root@example.com>",
-	subject: "Subject",
-	from: [],
-	sender: [],
-	replyTo: [],
-	to: [],
-	cc: [],
-	bcc: [],
-	inReplyTo: "",
-};
-
-interface Saved {
-	addresses: CreateAddressInput[];
-	envelopeAddresses: CreateEnvelopeAddressInput[];
-	threadMessages: CreateThreadMessageInput[];
-}
-
-const harvest = async (envelope: Partial<ImapEnvelope>): Promise<Saved> => {
-	const saved: Saved = {
-		addresses: [],
-		envelopeAddresses: [],
-		threadMessages: [],
-	};
-
-	const messageService = {
-		upsertWithStatus: async (input: unknown) => ({
-			item: input as MessageItem,
-			created: true,
-		}),
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		create: async (input: CreateThreadMessageInput) => {
-			saved.threadMessages.push(input);
-			return input as unknown as ThreadMessageItem;
-		},
-	} as unknown as IThreadMessageRepository;
-
-	const envelopeService = {
-		upsertEnvelope: async () => {},
-		upsertBodyParts: async () => {},
-	} as unknown as IEnvelopeRepository;
-
-	const addressService = {
-		upsertCorrespondentAddress: async (input: CreateAddressInput) => {
-			saved.addresses.push(input);
-		},
-		upsertEnvelopeAddress: async (input: CreateEnvelopeAddressInput) => {
-			saved.envelopeAddresses.push(input);
-		},
-	} as unknown as IAddressRepository;
-
-	const service = new MessageSyncService(
-		stub<ManagedConnectionFactory>(),
-		stub<IMailboxRepository>(),
-		noFolderRoles,
-		messageService,
-		envelopeService,
-		addressService,
-		threadMessageService,
-	);
-
-	const msg = {
-		uid: 42,
-		seq: 1,
-		size: 100,
-		internalDate: new Date(0),
-		flags: [],
-		envelope: { ...emptyEnvelope, ...envelope },
-	} as unknown as ImapMessage;
-
-	await (
-		service as unknown as {
-			saveMessage: (
-				mailbox: MailboxItem,
-				accountId: string,
-				accountConfigId: string,
-				msg: ImapMessage,
-				roles: AccountFolderRoles,
-			) => Promise<unknown>;
-		}
-	).saveMessage(
-		{ mailboxId: "mbx-1", fullPath: "INBOX" } as MailboxItem,
-		"acct-1",
-		"cfg-1",
-		msg,
-		NO_FOLDER_ROLES,
-	);
-
-	return saved;
-};
-
-const spoof: ImapAddress = {
-	name: "matthijs@ischen.nl",
-	mailbox: "aramirez",
-	host: "secresaludguaviare.gov.co",
-};
-
-const onlyAddress = async (
-	envelope: Partial<ImapEnvelope>,
-): Promise<CreateAddressInput> => {
-	const { addresses } = await harvest(envelope);
-	assert.equal(addresses.length, 1);
-	const [input] = addresses;
-	assert.ok(input);
-	return input;
-};
-
-describe("harvesting an envelope display name", () => {
-	it("drops a name that is an address the row does not own", async () => {
-		const input = await onlyAddress({ from: [spoof] });
-
-		assert.equal(input.displayName, "");
-		assert.equal(input.normalizedEmail, "aramirez@secresaludguaviare.gov.co");
-		assert.equal(
-			input.normalizedCompound,
-			"aramirez@secresaludguaviare.gov.co",
-		);
-	});
-
-	it("keeps what a name says besides the address it claims", async () => {
-		const input = await onlyAddress({
-			from: [{ ...spoof, name: "Matthijs <matthijs@ischen.nl>" }],
-		});
-
-		assert.equal(input.displayName, "Matthijs");
-		assert.equal(
-			input.normalizedCompound,
-			"matthijs aramirez@secresaludguaviare.gov.co",
-		);
-	});
-
-	it("keeps a name a sender wrote its own support address into", async () => {
-		const input = await onlyAddress({
-			from: [
-				{
-					name: "Support (support@acme.com)",
-					mailbox: "noreply",
-					host: "acme.com",
-				},
-			],
-		});
-
-		assert.equal(input.displayName, "Support");
-	});
-
-	it("keeps a name that is the address it labels", async () => {
-		const input = await onlyAddress({
-			from: [
-				{
-					name: "ING@ing-nl-mailing.nl",
-					mailbox: "ing",
-					host: "ing-nl-mailing.nl",
-				},
-			],
-		});
-
-		assert.equal(input.displayName, "ING@ing-nl-mailing.nl");
-		assert.equal(
-			input.normalizedCompound,
-			"ing@ing-nl-mailing.nl ing@ing-nl-mailing.nl",
-		);
-	});
-
-	it("keeps a non-ASCII name that is the address it labels", async () => {
-		const input = await onlyAddress({
-			from: [
-				{ name: "Özcan@example.com", mailbox: "Özcan", host: "example.com" },
-			],
-		});
-
-		assert.equal(input.displayName, "Özcan@example.com");
-	});
-
-	it("keeps an ordinary human name", async () => {
-		const input = await onlyAddress({
-			from: [
-				{ name: "Matthijs van Henten", mailbox: "matthijs", host: "ischen.nl" },
-			],
-		});
-
-		assert.equal(input.displayName, "Matthijs van Henten");
-		assert.equal(
-			input.normalizedCompound,
-			"matthijs van henten matthijs@ischen.nl",
-		);
-	});
-
-	it("drops the name on every harvested envelope role", async () => {
-		const { addresses } = await harvest({
-			from: [spoof],
-			sender: [spoof],
-			replyTo: [spoof],
-			to: [spoof],
-			cc: [spoof],
-			bcc: [spoof],
-		});
-
-		assert.equal(addresses.length, 6);
-		for (const input of addresses) {
-			assert.equal(input.displayName, "");
-		}
-	});
-
-	it("still harvests the address from every envelope role", async () => {
-		const named = (mailbox: string): ImapAddress[] => [
-			{ name: "Someone", mailbox, host: "example.com" },
-		];
-		const { addresses } = await harvest({
-			from: named("from"),
-			sender: named("sender"),
-			replyTo: named("reply-to"),
-			to: named("to"),
-			cc: named("cc"),
-			bcc: named("bcc"),
-		});
-
-		assert.deepEqual(
-			addresses.map((input) => input.normalizedEmail),
-			[
-				"from@example.com",
-				"sender@example.com",
-				"reply-to@example.com",
-				"to@example.com",
-				"cc@example.com",
-				"bcc@example.com",
-			],
-		);
-		for (const input of addresses) {
-			assert.equal(input.displayName, "Someone");
-		}
-	});
-
-	it("drops the name on the envelope the message header renders", async () => {
-		const { envelopeAddresses } = await harvest({ from: [spoof] });
-
-		assert.equal(envelopeAddresses.length, 1);
-		assert.equal(envelopeAddresses[0]?.displayName, "");
-	});
-
-	it("keeps the sender label's text and drops only the address", async () => {
-		const { threadMessages } = await harvest({
-			from: [{ ...spoof, name: "Support <matthijs@ischen.nl>" }],
-		});
-
-		assert.equal(threadMessages[0]?.fromName, "Support");
-	});
-
-	it("drops the sender label the message list shows", async () => {
-		const { threadMessages } = await harvest({ from: [spoof] });
-
-		assert.equal(threadMessages.length, 1);
-		assert.equal(threadMessages[0]?.fromName, undefined);
-		assert.equal(
-			threadMessages[0]?.fromEmail,
-			"aramirez@secresaludguaviare.gov.co",
-		);
-	});
-
-	it("keeps the sender label when it is an ordinary name", async () => {
-		const { threadMessages } = await harvest({
-			from: [
-				{ name: "Alejandro Ramirez", mailbox: "aramirez", host: "example.gov" },
-			],
-		});
-
-		assert.equal(threadMessages[0]?.fromName, "Alejandro Ramirez");
-	});
-});