@remit/backend 0.0.59 → 0.0.61

package/src/handlers/outbox-attachment.ts

@@ -0,0 +1,97 @@
+import type {
+	MintOutboxAttachmentInput,
+	MintOutboxAttachmentResponse,
+	OutboxAttachmentRejection,
+	OutboxAttachmentResponse,
+} from "@remit/api-openapi-types";
+import { OutboxAttachmentRejectionReason } from "@remit/domain-enums";
+import type {
+	OutboxAttachmentRejectionDetail,
+	OutboxAttachmentRejectionReasonValue,
+} from "@remit/mailbox-service";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { Context } from "openapi-backend";
+import { getAccountConfigIdFromEvent } from "../auth.js";
+import { getClient } from "../service/data-client.js";
+
+const TOO_LARGE: ReadonlySet<OutboxAttachmentRejectionReasonValue> = new Set([
+	OutboxAttachmentRejectionReason.FileTooLarge,
+	OutboxAttachmentRejectionReason.MessageTooLarge,
+	OutboxAttachmentRejectionReason.TooManyAttachments,
+]);
+
+interface RejectionResponse {
+	statusCode: number;
+	body: OutboxAttachmentRejection;
+}
+
+const refuse = (
+	detail: OutboxAttachmentRejectionDetail,
+): RejectionResponse => ({
+	statusCode: TOO_LARGE.has(detail.reason) ? 413 : 400,
+	body: {
+		reason: detail.reason,
+		message: detail.message,
+		limitBytes: detail.limitBytes,
+		usedBytes: detail.usedBytes,
+	},
+});
+
+/**
+ * Reserve room on a draft and hand back somewhere to put the bytes. Small JSON
+ * in, small JSON out — the file itself never passes through here, which is what
+ * lets the upload live on its own fleet and keeps this operation under any
+ * payload ceiling the REST tier has.
+ */
+export const mintOutboxAttachment = async (
+	context: Context,
+	...args: unknown[]
+): Promise<MintOutboxAttachmentResponse | RejectionResponse> => {
+	const event = args[0] as APIGatewayProxyEvent;
+	const accountConfigId = getAccountConfigIdFromEvent(event);
+	const { outboxMessageId } = context.request.params as {
+		outboxMessageId: string;
+	};
+	const input = context.request.requestBody as MintOutboxAttachmentInput;
+
+	const client = await getClient();
+	const result = await client.outboxAttachment.mint({
+		accountConfigId,
+		outboxMessageId,
+		filename: input.filename,
+		contentType: input.contentType,
+		sizeBytes: input.sizeBytes,
+	});
+
+	if (result.outcome === "Rejected") return refuse(result.rejection);
+
+	return result.reservation;
+};
+
+/**
+ * Confirm the upload landed. The size in the response is read back from
+ * storage — on a deployment where the browser PUT straight to block storage
+ * this call is the first the API hears of the bytes, and the client's word for
+ * how many there are is not evidence.
+ */
+export const completeOutboxAttachment = async (
+	context: Context,
+	...args: unknown[]
+): Promise<OutboxAttachmentResponse | RejectionResponse> => {
+	const event = args[0] as APIGatewayProxyEvent;
+	const accountConfigId = getAccountConfigIdFromEvent(event);
+	const { outboxMessageId, outboxAttachmentId } = context.request.params as {
+		outboxMessageId: string;
+		outboxAttachmentId: string;
+	};
+	const client = await getClient();
+	const result = await client.outboxAttachment.complete({
+		accountConfigId,
+		outboxMessageId,
+		outboxAttachmentId,
+	});
+
+	if (result.outcome === "Rejected") return refuse(result.rejection);
+
+	return result.attachment;
+};

package/src/handlers/outbox.test.ts

@@ -17,15 +17,25 @@ import assert from "node:assert/strict";
 import { afterEach, describe, it } from "node:test";
 import type { SQSClient } from "@aws-sdk/client-sqs";
 import type {
+	CreateOutboxAttachmentInput,
 	CreateOutboxMessageInput,
 	IAccountRepository,
+	IOutboxAttachmentRepository,
 	IOutboxMessageRepository,
+	OutboxAttachmentItem,
 	OutboxMessageItem,
 	UpdateOutboxMessageInput,
 } from "@remit/data-ports";
 import { NotFoundError } from "@remit/data-ports/errors";
 import { OutboxMessageStatus } from "@remit/domain-enums";
-import { OutboxQueueService } from "@remit/mailbox-service";
+import {
+	OutboxAttachmentService,
+	OutboxQueueService,
+} from "@remit/mailbox-service";
+import {
+	createMockStorageService,
+	type StorageService,
+} from "@remit/storage-service";
 import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
 import type { Context } from "openapi-backend";
 import { deriveAccountConfigId } from "../auth.js";
@@ -33,6 +43,7 @@ import { handleError } from "../error.js";
 import { formatResponse } from "../response.js";
 import {
 	_resetForTest,
+	getClient,
 	type RemitClient,
 	setClient,
 } from "../service/data-client.js";
@@ -138,13 +149,83 @@ const accountRepository = {
 	}),
 } as unknown as IAccountRepository;
 
+let installedStorage: StorageService | null = null;
+let attachmentRows = new Map<string, OutboxAttachmentItem>();
+
+/** Rows only — this suite asserts what a discard takes, not how bytes move. */
+const createAttachmentRepository = (
+	rows: Map<string, OutboxAttachmentItem>,
+): IOutboxAttachmentRepository =>
+	({
+		reserve: async (input: CreateOutboxAttachmentInput) => {
+			const item = {
+				...input,
+				state: "Pending",
+				createdAt: 0,
+				updatedAt: 0,
+			} as OutboxAttachmentItem;
+			rows.set(item.outboxAttachmentId, item);
+			return { outcome: "Reserved", item };
+		},
+		listByOutboxMessage: async (
+			_accountConfigId: string,
+			outboxMessageId: string,
+		) =>
+			[...rows.values()].filter(
+				(row) => row.outboxMessageId === outboxMessageId,
+			),
+		deleteByOutboxMessage: async (
+			_accountConfigId: string,
+			outboxMessageId: string,
+		) => {
+			for (const row of [...rows.values()]) {
+				if (row.outboxMessageId === outboxMessageId) {
+					rows.delete(row.outboxAttachmentId);
+				}
+			}
+		},
+		deleteLapsedReservations: async (
+			accountConfigId: string,
+			outboxMessageId: string,
+			nowSeconds: number,
+		) => {
+			const gone: string[] = [];
+			for (const row of [...rows.values()]) {
+				if (
+					row.accountConfigId === accountConfigId &&
+					row.outboxMessageId === outboxMessageId &&
+					row.state === "Pending" &&
+					row.reservationExpiresAt < nowSeconds
+				) {
+					rows.delete(row.outboxAttachmentId);
+					gone.push(row.outboxAttachmentId);
+				}
+			}
+			return gone;
+		},
+		deleteMany: async (_accountConfigId: string, ids: string[]) => {
+			for (const id of ids) rows.delete(id);
+		},
+	}) as unknown as IOutboxAttachmentRepository;
+
 const installClient = (): void => {
 	const outboxMessage = createInMemoryOutboxRepository();
+	const storage = createMockStorageService();
+	attachmentRows = new Map<string, OutboxAttachmentItem>();
+	const outboxAttachmentService = new OutboxAttachmentService({
+		outboxMessageService: outboxMessage,
+		outboxAttachmentService: createAttachmentRepository(attachmentRows),
+		storage,
+	});
+	installedStorage = storage;
 	setClient({
 		outboxMessage,
+		storage,
 		account: accountRepository,
+		outboxAttachment: outboxAttachmentService,
 		outboxQueue: new OutboxQueueService({
 			outboxMessageService: outboxMessage,
+			outboxAttachmentService,
 			accountService: accountRepository,
 			sqsSmtpQueueUrl: "http://localhost:9324/queue/outbox-test",
 			sqsClient: acceptingSqsClient(),
@@ -292,3 +373,168 @@ describe("an outbox entry that has left draft (#604)", () => {
 		assert.equal(body.subject, "still editing");
 	});
 });
+
+describe("discarding a draft that carries files (#679)", () => {
+	it("takes the stored bytes with it, leaving nothing behind", async () => {
+		installClient();
+		const storage = installedStorage;
+		assert.ok(storage);
+
+		const draft = await createDraft(
+			requestContext({}),
+			authorizedEvent({
+				accountId: ACCOUNT_ID,
+				toAddresses: ["recipient@example.com"],
+			}),
+		);
+		const outboxMessageId = String(draft.outboxMessageId);
+
+		const client = await getClient();
+		const minted = await client.outboxAttachment.mint({
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			outboxMessageId,
+			filename: "receipt.pdf",
+			contentType: "application/pdf",
+			sizeBytes: 16,
+		});
+		assert.equal(minted.outcome, "Minted");
+		// A mint reserves in the ledger; nothing is uploaded yet, so what a discard
+		// has to take with it is the reservation, not an object.
+		// A mint writes a row; nothing is uploaded yet, so what a discard has to
+		// take with it is the row, not an object.
+		assert.equal(attachmentRows.size, 1);
+
+		const response = await respond(() =>
+			deleteDraft(
+				requestContext({ params: { outboxMessageId } }),
+				authorizedEvent(),
+			),
+		);
+
+		assert.equal(response.statusCode, 204);
+		// Nothing else references these objects, so a row that goes without them
+		// leaves bytes no sweep collects.
+		assert.deepEqual(
+			await storage.listOutboxAttachments(
+				ACCOUNT_CONFIG_ID,
+				ACCOUNT_ID,
+				outboxMessageId,
+			),
+			[],
+		);
+		assert.equal(attachmentRows.size, 0);
+	});
+});
+
+describe("attachmentIds on a draft update (#679)", () => {
+	const seed = async (): Promise<{
+		outboxMessageId: string;
+		ids: string[];
+	}> => {
+		const draft = await createDraft(
+			requestContext({}),
+			authorizedEvent({
+				accountId: ACCOUNT_ID,
+				toAddresses: ["recipient@example.com"],
+			}),
+		);
+		const outboxMessageId = String(draft.outboxMessageId);
+		const client = await getClient();
+		const ids: string[] = [];
+		for (const filename of ["one.txt", "two.txt"]) {
+			const minted = await client.outboxAttachment.mint({
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				outboxMessageId,
+				filename,
+				contentType: "text/plain",
+				sizeBytes: 8,
+			});
+			assert.equal(minted.outcome, "Minted");
+			if (minted.outcome !== "Minted") throw new Error("unreachable");
+			ids.push(minted.reservation.outboxAttachmentId);
+		}
+		return { outboxMessageId, ids };
+	};
+
+	const patch = (outboxMessageId: string, requestBody: unknown) =>
+		respond(() =>
+			updateDraft(
+				requestContext({ params: { outboxMessageId }, requestBody }),
+				authorizedEvent(),
+			),
+		);
+
+	it("absent leaves the files alone — a subject-only save keeps them", async () => {
+		installClient();
+		const { outboxMessageId } = await seed();
+
+		const response = await patch(outboxMessageId, { subject: "still typing" });
+
+		assert.equal(response.statusCode, 200);
+		const body = JSON.parse(response.body) as { attachments: unknown[] };
+		assert.equal(body.attachments.length, 2);
+		assert.equal(attachmentRows.size, 2);
+	});
+
+	it("present and empty removes every file", async () => {
+		installClient();
+		const { outboxMessageId } = await seed();
+
+		const response = await patch(outboxMessageId, { attachmentIds: [] });
+
+		assert.equal(response.statusCode, 200);
+		assert.deepEqual(
+			(JSON.parse(response.body) as { attachments: unknown[] }).attachments,
+			[],
+		);
+		assert.equal(attachmentRows.size, 0);
+	});
+
+	it("present with ids keeps those and removes the rest, bytes included", async () => {
+		installClient();
+		const { outboxMessageId, ids } = await seed();
+		const storage = installedStorage;
+		assert.ok(storage);
+		await storage.storeOutboxAttachment({
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			accountId: ACCOUNT_ID,
+			outboxMessageId,
+			outboxAttachmentId: ids[1],
+			content: Buffer.from("dropped"),
+		});
+
+		const response = await patch(outboxMessageId, {
+			attachmentIds: [ids[0]],
+		});
+
+		assert.equal(response.statusCode, 200);
+		const body = JSON.parse(response.body) as {
+			attachments: { outboxAttachmentId: string }[];
+		};
+		assert.deepEqual(
+			body.attachments.map((item) => item.outboxAttachmentId),
+			[ids[0]],
+		);
+		assert.equal(
+			await storage.statOutboxAttachment(
+				ACCOUNT_CONFIG_ID,
+				ACCOUNT_ID,
+				outboxMessageId,
+				ids[1],
+			),
+			null,
+		);
+	});
+
+	it("an unknown id is a no-op, not a reason to drop the known ones", async () => {
+		installClient();
+		const { outboxMessageId, ids } = await seed();
+
+		const response = await patch(outboxMessageId, {
+			attachmentIds: [...ids, "never-existed"],
+		});
+
+		assert.equal(response.statusCode, 200);
+		assert.equal(attachmentRows.size, 2);
+	});
+});

package/src/handlers/outbox.ts

@@ -3,7 +3,10 @@ import type {
 	OutboxMessageResponse,
 	UpdateOutboxMessageInput,
 } from "@remit/api-openapi-types";
-import type { OutboxMessageItem } from "@remit/data-ports";
+import type {
+	OutboxAttachmentItem,
+	OutboxMessageItem,
+} from "@remit/data-ports";
 import { ForbiddenError } from "@remit/data-ports/errors";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import type { Context } from "openapi-backend";
@@ -11,13 +14,31 @@ import { getAccountConfigIdFromEvent } from "../auth.js";
 import { getClient } from "../service/data-client.js";
 import type {
 	OperationHandler,
+	OutboxAttachmentOperationIds,
 	OutboxDetailOperationIds,
 	OutboxOperationIds,
 } from "../types.js";
+import {
+	completeOutboxAttachment,
+	mintOutboxAttachment,
+} from "./outbox-attachment.js";
+
+const toAttachmentResponse = (
+	item: OutboxAttachmentItem,
+): OutboxMessageResponse["attachments"][number] => ({
+	outboxAttachmentId: item.outboxAttachmentId,
+	outboxMessageId: item.outboxMessageId,
+	filename: item.filename,
+	contentType: item.contentType,
+	sizeBytes: item.sizeBytes,
+	state: item.state,
+});
 
 const toOutboxMessageResponse = (
 	item: OutboxMessageItem,
+	attachments: OutboxAttachmentItem[] = [],
 ): OutboxMessageResponse => ({
+	attachments: attachments.map(toAttachmentResponse),
 	outboxMessageId: item.outboxMessageId,
 	accountId: item.accountId,
 	fromAddress: item.fromAddress,
@@ -118,7 +139,7 @@ export const OutboxOperations: Record<
 		});
 
 		return {
-			items: result.items.map(toOutboxMessageResponse),
+			items: result.items.map((item) => toOutboxMessageResponse(item)),
 			continuationToken: result.continuationToken,
 		};
 	},
@@ -145,7 +166,10 @@ export const OutboxDetailOperations: Record<
 			accountConfigId,
 			outboxMessageId,
 		);
-		return toOutboxMessageResponse(outbox);
+		return toOutboxMessageResponse(
+			outbox,
+			await client.outboxAttachment.listFor(accountConfigId, outboxMessageId),
+		);
 	},
 
 	OutboxDetailOperations_updateOutboxMessage: async (
@@ -176,7 +200,23 @@ export const OutboxDetailOperations: Record<
 				references: input.references,
 			},
 		);
-		return toOutboxMessageResponse(updated);
+
+		// Absent means "leave the files alone" — a body that only carries a subject
+		// must not strip them. Present states exactly what the draft keeps, so an
+		// empty list is a real instruction to remove them all.
+		if (input.attachmentIds !== undefined) {
+			await client.outboxAttachment.retainOnly(
+				accountConfigId,
+				updated.accountId,
+				outboxMessageId,
+				input.attachmentIds,
+			);
+		}
+
+		return toOutboxMessageResponse(
+			updated,
+			await client.outboxAttachment.listFor(accountConfigId, outboxMessageId),
+		);
 	},
 
 	OutboxDetailOperations_deleteOutboxMessage: async (
@@ -215,4 +255,13 @@ export const OutboxDetailOperations: Record<
 		);
 		return toOutboxMessageResponse(sent);
 	},
+
+	OutboxDetailOperations_mintOutboxAttachment: mintOutboxAttachment,
+};
+
+export const OutboxAttachmentOperations: Record<
+	OutboxAttachmentOperationIds,
+	OperationHandler<OutboxAttachmentOperationIds>
+> = {
+	OutboxAttachmentOperations_completeOutboxAttachment: completeOutboxAttachment,
 };

package/src/service/compose-sqlite.ts

@@ -22,6 +22,7 @@ import {
 	MessagePlacementMoveRepo,
 	messageDataSchema,
 	OrganizeJobRequestRepo,
+	OutboxAttachmentRepo,
 	OutboxMessageRepo,
 	QuarantineRepo,
 } from "@remit/drizzle-service";
@@ -59,6 +60,7 @@ export const buildSqliteClient = async (): Promise<RemitClient> => {
 		message: new DrizzleMessageRepository(messageDataDb),
 		messageFlag: new DrizzleMessageFlagRepository(messageDataDb),
 		outboxMessage: new OutboxMessageRepo(genericDb),
+		outboxAttachment: new OutboxAttachmentRepo(genericDb),
 		threadMessage: new DrizzleThreadMessageRepository(genericDb),
 		envelope: new DrizzleEnvelopeRepository(messageDataDb),
 		accountExportRequest: new AccountExportRequestRepo(genericDb),

package/src/service/create-remit-client.ts

@@ -18,6 +18,7 @@ import type {
 	IMessagePlacementMoveRepository,
 	IMessageRepository,
 	IOrganizeJobRequestRepository,
+	IOutboxAttachmentRepository,
 	IOutboxMessageRepository,
 	IQuarantineRepository,
 	IThreadMessageRepository,
@@ -33,6 +34,7 @@ import {
 	type IImapConnection,
 	MailboxQueueService,
 	MessageMoveService,
+	OutboxAttachmentService,
 	OutboxQueueService,
 	PlacementMoveService,
 	SpamReportService,
@@ -144,6 +146,7 @@ export interface RemitClient {
 	flagQueue: FlagQueueService;
 	mailboxQueue: MailboxQueueService;
 	messageMove: MessageMoveService;
+	outboxAttachment: OutboxAttachmentService;
 	outboxQueue: OutboxQueueService;
 
 	// Report-spam / not-spam (block-and-move, unified from the old separate
@@ -166,6 +169,7 @@ export interface RemitClientRepositories {
 	message: IMessageRepository;
 	messageFlag: IMessageFlagRepository;
 	outboxMessage: IOutboxMessageRepository;
+	outboxAttachment: IOutboxAttachmentRepository;
 	threadMessage: IThreadMessageRepository;
 	envelope: IEnvelopeRepository;
 	accountExportRequest: IAccountExportRequestRepository;
@@ -356,6 +360,15 @@ export const createRemitClient = (deps: RemitClientDeps): RemitClient => {
 		logger,
 	});
 
+	// One instance, shared with the queue service below: the per-draft chain that
+	// makes the attachment cap safe under concurrency lives on it, and a discard
+	// racing an upload has to take the same lock the upload does.
+	const outboxAttachmentService = new OutboxAttachmentService({
+		outboxMessageService: repositories.outboxMessage,
+		outboxAttachmentService: repositories.outboxAttachment,
+		storage,
+	});
+
 	const bodySync = new BodySyncService(
 		repositories.message,
 		storage,
@@ -408,8 +421,10 @@ export const createRemitClient = (deps: RemitClientDeps): RemitClient => {
 			logger,
 		}),
 		messageMove: messageMoveService,
+		outboxAttachment: outboxAttachmentService,
 		outboxQueue: new OutboxQueueService({
 			outboxMessageService: repositories.outboxMessage,
+			outboxAttachmentService,
 			accountService: repositories.account,
 			sqsSmtpQueueUrl,
 			logger,

package/src/types.ts

@@ -63,6 +63,8 @@ export type OperationIds =
 	| "OutboxDetailOperations_updateOutboxMessage"
 	| "OutboxDetailOperations_deleteOutboxMessage"
 	| "OutboxDetailOperations_sendOutboxMessage"
+	| "OutboxDetailOperations_mintOutboxAttachment"
+	| "OutboxAttachmentOperations_completeOutboxAttachment"
 	| "AddressOperations_searchAddresses"
 	| "AddressDetailOperations_updateAddress";
 
@@ -159,6 +161,11 @@ export type OutboxDetailOperationIds = MatchPrefix<
 	OperationIds
 >;
 
+export type OutboxAttachmentOperationIds = MatchPrefix<
+	"OutboxAttachmentOperations_",
+	OperationIds
+>;
+
 export type AddressOperationIds = MatchPrefix<
 	"AddressOperations_",
 	OperationIds