@remit/storage-service 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/storage-service",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/backends/filesystem.ts

@@ -400,6 +400,27 @@ export const createFilesystemStorageService = (
 		return stats ? { sizeBytes: stats.size } : null;
 	};
 
+	const retrieveOutboxAttachment: StorageService["retrieveOutboxAttachment"] = (
+		accountConfigId,
+		accountId,
+		outboxMessageId,
+		outboxAttachmentId,
+	) =>
+		readFile(
+			join(
+				basePath,
+				buildOutboxAttachmentKey(
+					accountConfigId,
+					accountId,
+					outboxMessageId,
+					outboxAttachmentId,
+				),
+			),
+		).catch((error: unknown) => {
+			if (isStorageNotFoundError(error)) return null;
+			throw error;
+		});
+
 	// This backend has no presigned anything, so the URL addresses the
 	// deployment's own upload route. Its authority is the same HMAC the read side
 	// uses on /content, under the write label, covering the storage key, the
@@ -540,6 +561,7 @@ export const createFilesystemStorageService = (
 		deleteOutboxAttachments,
 		deleteOutboxAttachment,
 		statOutboxAttachment,
+		retrieveOutboxAttachment,
 		createOutboxAttachmentUploadUrl,
 		storeDeduplicated,
 		storeParsedBody,

package/src/backends/s3.ts

@@ -467,6 +467,28 @@ export const createS3StorageService = (
 		return { sizeBytes: head.ContentLength ?? 0 };
 	};
 
+	const retrieveOutboxAttachment: StorageService["retrieveOutboxAttachment"] =
+		async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+			const key = buildOutboxAttachmentKey(
+				accountConfigId,
+				accountId,
+				outboxMessageId,
+				outboxAttachmentId,
+			);
+			const response = await client
+				.send(new GetObjectCommand({ Bucket: bucketName, Key: key }))
+				.catch((error: unknown) => {
+					if (isStorageNotFoundError(error)) return null;
+					throw error;
+				});
+			if (!response) return null;
+			if (!response.Body) {
+				throw new Error(`Empty response body for outbox attachment: ${key}`);
+			}
+			const bytes = await response.Body.transformToByteArray();
+			return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		};
+
 	// The browser PUTs straight to the bucket and these bytes never touch the
 	// API. `ContentLength` on the command hoists `content-length` into
 	// X-Amz-SignedHeaders, so S3 recomputes the signature over the length it was
@@ -718,6 +740,7 @@ export const createS3StorageService = (
 		deleteOutboxAttachments,
 		deleteOutboxAttachment,
 		statOutboxAttachment,
+		retrieveOutboxAttachment,
 		createOutboxAttachmentUploadUrl,
 		storeDeduplicated,
 		storeParsedBody,

package/src/outbox-attachment-retrieve.test.ts

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { createFilesystemStorageService } from "./backends/filesystem.js";
+import { createMockStorageService, type StorageService } from "./storage.js";
+
+const OWNER = {
+	accountConfigId: "cfg-1",
+	accountId: "acc-1",
+	outboxMessageId: "ob-1",
+};
+
+const readsBackWhatWasStored = async (storage: StorageService) => {
+	const content = Buffer.from([0x25, 0x50, 0x44, 0x46, 0x00, 0xff]);
+	await storage.storeOutboxAttachment({
+		...OWNER,
+		outboxAttachmentId: "att-1",
+		content,
+	});
+
+	assert.deepEqual(
+		await storage.retrieveOutboxAttachment(
+			OWNER.accountConfigId,
+			OWNER.accountId,
+			OWNER.outboxMessageId,
+			"att-1",
+		),
+		content,
+	);
+	assert.equal(
+		await storage.retrieveOutboxAttachment(
+			OWNER.accountConfigId,
+			OWNER.accountId,
+			OWNER.outboxMessageId,
+			"att-missing",
+		),
+		null,
+	);
+};
+
+describe("retrieveOutboxAttachment", () => {
+	it("reads back the exact bytes on the filesystem backend, and null for none", async () => {
+		const basePath = await mkdtemp(join(tmpdir(), "remit-outbox-retrieve-"));
+		try {
+			await readsBackWhatWasStored(createFilesystemStorageService(basePath));
+		} finally {
+			await rm(basePath, { recursive: true, force: true });
+		}
+	});
+
+	it("reads back the exact bytes on the mock backend, and null for none", async () => {
+		await readsBackWhatWasStored(createMockStorageService());
+	});
+});

package/src/storage.ts

@@ -266,6 +266,17 @@ export interface StorageService {
 		outboxAttachmentId: string,
 	): Promise<{ sizeBytes: number } | null>;
 
+	/**
+	 * The bytes of one attachment, for building the MIME part it goes out as.
+	 * Null when nothing is stored under the key.
+	 */
+	retrieveOutboxAttachment(
+		accountConfigId: string,
+		accountId: string,
+		outboxMessageId: string,
+		outboxAttachmentId: string,
+	): Promise<Buffer | null>;
+
 	/**
 	 * Mint somewhere to PUT one file. The backend decides what that is — block
 	 * storage direct, or this deployment's upload route — and the caller never
@@ -650,6 +661,12 @@ export const createMockStorageService = (): StorageService => {
 		return content ? { sizeBytes: content.length } : null;
 	};
 
+	const retrieveOutboxAttachment: StorageService["retrieveOutboxAttachment"] =
+		async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) =>
+			storage.get(
+				`mock://${buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId)}`,
+			) ?? null;
+
 	const createOutboxAttachmentUploadUrl: StorageService["createOutboxAttachmentUploadUrl"] =
 		async (params) => ({
 			uploadUrl: `mock://upload/${buildOutboxAttachmentKey(params.accountConfigId, params.accountId, params.outboxMessageId, params.outboxAttachmentId)}?max=${params.sizeBytes}&exp=${params.expiresAt}`,
@@ -805,6 +822,7 @@ export const createMockStorageService = (): StorageService => {
 		deleteOutboxAttachments,
 		deleteOutboxAttachment,
 		statOutboxAttachment,
+		retrieveOutboxAttachment,
 		createOutboxAttachmentUploadUrl,
 		storeDeduplicated,
 		storeParsedBody,