@remit/drizzle-service 0.0.38 → 0.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

package/src/index.ts

@@ -31,6 +31,7 @@ export {
 	type PutMessagePlacementMoveInput,
 } from "./repos/i4-message-placement-move.js";
 export * from "./repos/i4-organize-job-request.js";
+export { OutboxAttachmentRepo } from "./repos/i4-outbox-attachment.js";
 export * from "./repos/i4-outbox-message.js";
 export { LabelRepo } from "./repos/label.js";
 export {

package/src/repos/i4-outbox-attachment.test.ts

@@ -0,0 +1,176 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId } from "../test-db.js";
+import { OutboxAttachmentRepo } from "./i4-outbox-attachment.js";
+
+const CAP = { maxTotalBytes: 1000, maxCount: 3, nowSeconds: 1_000_000 };
+
+let harness: Awaited<ReturnType<typeof createTestDb>>;
+let repo: OutboxAttachmentRepo;
+
+const input = (
+	accountConfigId: string,
+	outboxMessageId: string,
+	sizeBytes: number,
+	reservationExpiresAt = CAP.nowSeconds + 900,
+) => ({
+	outboxAttachmentId: randomId(),
+	outboxMessageId,
+	accountId: "acc-1",
+	accountConfigId,
+	filename: "a.bin",
+	contentType: "application/octet-stream",
+	sizeBytes,
+	storageKey: `accounts/${accountConfigId}/acc-1/outbox/${outboxMessageId}/attachments/x`,
+	reservationExpiresAt,
+});
+
+before(async () => {
+	harness = await createTestDb();
+	repo = new OutboxAttachmentRepo(harness.db);
+});
+
+after(async () => {
+	await harness.close();
+});
+
+describe("OutboxAttachmentRepo.reserve", () => {
+	test("counts what a draft already holds and refuses what will not fit", async () => {
+		const cfg = randomId();
+		const draft = randomId();
+
+		assert.strictEqual(
+			(await repo.reserve(input(cfg, draft, 800), CAP)).outcome,
+			"Reserved",
+		);
+
+		const over = await repo.reserve(input(cfg, draft, 300), CAP);
+		assert.strictEqual(over.outcome, "OverByteCap");
+		assert.strictEqual(over.outcome === "OverByteCap" && over.usedBytes, 800);
+	});
+
+	test("refuses past the file-count ceiling", async () => {
+		const cfg = randomId();
+		const draft = randomId();
+		for (let index = 0; index < CAP.maxCount; index += 1) {
+			assert.strictEqual(
+				(await repo.reserve(input(cfg, draft, 1), CAP)).outcome,
+				"Reserved",
+			);
+		}
+
+		const over = await repo.reserve(input(cfg, draft, 1), CAP);
+		assert.strictEqual(over.outcome, "OverCountCap");
+	});
+
+	test("holds the cap when reservations arrive together", async () => {
+		// Counting and inserting are one transaction, so concurrent callers are
+		// ordered by the database rather than each measuring a draft none of them
+		// has written to. This is the whole of the cap.
+		const cfg = randomId();
+		const draft = randomId();
+
+		const results = await Promise.all(
+			Array.from({ length: 6 }, () =>
+				repo.reserve(input(cfg, draft, 300), CAP),
+			),
+		);
+
+		const reserved = results.filter((r) => r.outcome === "Reserved");
+		assert.strictEqual(reserved.length, 3);
+		const rows = await repo.listByOutboxMessage(cfg, draft);
+		assert.strictEqual(rows.length, 3);
+		assert.strictEqual(
+			rows.reduce((total, row) => total + row.sizeBytes, 0),
+			900,
+		);
+	});
+
+	test("a lapsed reservation stops holding room", async () => {
+		const cfg = randomId();
+		const draft = randomId();
+		await repo.reserve(input(cfg, draft, 900, CAP.nowSeconds - 1), CAP);
+
+		assert.strictEqual(
+			(await repo.reserve(input(cfg, draft, 900), CAP)).outcome,
+			"Reserved",
+		);
+	});
+
+	test("another tenant's rows are not counted, and cannot be read", async () => {
+		const draft = randomId();
+		const mine = randomId();
+		const theirs = randomId();
+		await repo.reserve(input(theirs, draft, 900), CAP);
+
+		assert.strictEqual(
+			(await repo.reserve(input(mine, draft, 900), CAP)).outcome,
+			"Reserved",
+		);
+		assert.deepStrictEqual(await repo.listByOutboxMessage(mine, draft), [
+			(await repo.listByOutboxMessage(mine, draft))[0],
+		]);
+	});
+});
+
+describe("OutboxAttachmentRepo.markStored", () => {
+	test("moves a Pending row to Stored at the size storage holds", async () => {
+		const cfg = randomId();
+		const draft = randomId();
+		const reserved = await repo.reserve(input(cfg, draft, 100), CAP);
+		assert.strictEqual(reserved.outcome, "Reserved");
+		if (reserved.outcome !== "Reserved") return;
+
+		const stored = await repo.markStored(
+			cfg,
+			reserved.item.outboxAttachmentId,
+			100,
+		);
+
+		assert.strictEqual(stored?.state, "Stored");
+		// A Stored row holds room forever, so its expiry has nothing left to say.
+		assert.strictEqual(stored?.reservationExpiresAt, 0);
+	});
+
+	test("answers null the second time, so a retry cannot double-confirm", async () => {
+		const cfg = randomId();
+		const draft = randomId();
+		const reserved = await repo.reserve(input(cfg, draft, 100), CAP);
+		assert.strictEqual(reserved.outcome, "Reserved");
+		if (reserved.outcome !== "Reserved") return;
+
+		await repo.markStored(cfg, reserved.item.outboxAttachmentId, 100);
+		assert.strictEqual(
+			await repo.markStored(cfg, reserved.item.outboxAttachmentId, 100),
+			null,
+		);
+	});
+
+	test("refuses to touch another tenant's row", async () => {
+		const cfg = randomId();
+		const draft = randomId();
+		const reserved = await repo.reserve(input(cfg, draft, 100), CAP);
+		assert.strictEqual(reserved.outcome, "Reserved");
+		if (reserved.outcome !== "Reserved") return;
+
+		assert.strictEqual(
+			await repo.markStored(randomId(), reserved.item.outboxAttachmentId, 100),
+			null,
+		);
+	});
+});
+
+describe("OutboxAttachmentRepo deletion", () => {
+	test("deleteByOutboxMessage empties one draft and leaves the rest", async () => {
+		const cfg = randomId();
+		const kept = randomId();
+		const gone = randomId();
+		await repo.reserve(input(cfg, kept, 10), CAP);
+		await repo.reserve(input(cfg, gone, 10), CAP);
+
+		await repo.deleteByOutboxMessage(cfg, gone);
+
+		assert.strictEqual((await repo.listByOutboxMessage(cfg, gone)).length, 0);
+		assert.strictEqual((await repo.listByOutboxMessage(cfg, kept)).length, 1);
+	});
+});

package/src/repos/i4-outbox-attachment.ts

@@ -0,0 +1,213 @@
+import type {
+	CreateOutboxAttachmentInput,
+	IOutboxAttachmentRepository,
+	OutboxAttachmentCap,
+	OutboxAttachmentItem,
+	ReserveOutboxAttachmentResult,
+} from "@remit/data-ports";
+import { holdsRoom } from "@remit/data-ports";
+import { and, eq, inArray, lt } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { NotFoundError } from "../error.js";
+import { outboxAttachmentTable } from "../schema/i4-outbox-attachment.js";
+import { runInTransaction } from "../tx.js";
+
+type DB = Db<Record<string, unknown>>;
+
+function rowToOutboxAttachment(
+	row: typeof outboxAttachmentTable.$inferSelect,
+): OutboxAttachmentItem {
+	return {
+		outboxAttachmentId: row.outboxAttachmentId,
+		outboxMessageId: row.outboxMessageId,
+		accountId: row.accountId,
+		accountConfigId: row.accountConfigId,
+		filename: row.filename,
+		contentType: row.contentType,
+		sizeBytes: row.sizeBytes,
+		state: row.state as OutboxAttachmentItem["state"],
+		storageKey: row.storageKey,
+		reservationExpiresAt: row.reservationExpiresAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class OutboxAttachmentRepo implements IOutboxAttachmentRepository {
+	constructor(private db: DB) {}
+
+	/**
+	 * The per-message cap: the count and the insert are one transaction, on the
+	 * transaction's own handle, so a concurrent reservation cannot land between
+	 * them. See the port's contract for the invariant this owes its callers and
+	 * what an adapter on another engine has to do to keep it.
+	 */
+	async reserve(
+		input: CreateOutboxAttachmentInput,
+		cap: OutboxAttachmentCap,
+	): Promise<ReserveOutboxAttachmentResult> {
+		return runInTransaction(this.db, async (tx) => {
+			const existing = await tx
+				.select()
+				.from(outboxAttachmentTable)
+				.where(
+					and(
+						eq(outboxAttachmentTable.accountConfigId, input.accountConfigId),
+						eq(outboxAttachmentTable.outboxMessageId, input.outboxMessageId),
+					),
+				);
+
+			const live = existing
+				.map(rowToOutboxAttachment)
+				.filter((item) => holdsRoom(item, cap.nowSeconds));
+			const usedBytes = live.reduce((total, item) => total + item.sizeBytes, 0);
+
+			if (live.length >= cap.maxCount) {
+				return { outcome: "OverCountCap", usedBytes };
+			}
+			if (usedBytes + input.sizeBytes > cap.maxTotalBytes) {
+				return { outcome: "OverByteCap", usedBytes };
+			}
+
+			const now = Date.now();
+			const [row] = await tx
+				.insert(outboxAttachmentTable)
+				.values({
+					outboxAttachmentId: input.outboxAttachmentId,
+					outboxMessageId: input.outboxMessageId,
+					accountId: input.accountId,
+					accountConfigId: input.accountConfigId,
+					filename: input.filename,
+					contentType: input.contentType,
+					sizeBytes: input.sizeBytes,
+					state: "Pending",
+					storageKey: input.storageKey,
+					reservationExpiresAt: input.reservationExpiresAt,
+					createdAt: now,
+					updatedAt: now,
+				})
+				.returning();
+
+			return { outcome: "Reserved", item: rowToOutboxAttachment(row) };
+		});
+	}
+
+	async get(
+		accountConfigId: string,
+		outboxAttachmentId: string,
+	): Promise<OutboxAttachmentItem> {
+		const [row] = await this.db
+			.select()
+			.from(outboxAttachmentTable)
+			.where(
+				and(
+					eq(outboxAttachmentTable.accountConfigId, accountConfigId),
+					eq(outboxAttachmentTable.outboxAttachmentId, outboxAttachmentId),
+				),
+			)
+			.limit(1);
+		if (!row) {
+			throw new NotFoundError(`No outbox attachment ${outboxAttachmentId}`);
+		}
+		return rowToOutboxAttachment(row);
+	}
+
+	async listByOutboxMessage(
+		accountConfigId: string,
+		outboxMessageId: string,
+	): Promise<OutboxAttachmentItem[]> {
+		const rows = await this.db
+			.select()
+			.from(outboxAttachmentTable)
+			.where(
+				and(
+					eq(outboxAttachmentTable.accountConfigId, accountConfigId),
+					eq(outboxAttachmentTable.outboxMessageId, outboxMessageId),
+				),
+			);
+		return rows.map(rowToOutboxAttachment);
+	}
+
+	/**
+	 * Only a Pending row that has not lapsed may become Stored, and the update
+	 * says so in its WHERE rather than in a preceding read — two completions for
+	 * the same upload cannot both believe they were the one that confirmed it.
+	 */
+	async markStored(
+		accountConfigId: string,
+		outboxAttachmentId: string,
+		sizeBytes: number,
+	): Promise<OutboxAttachmentItem | null> {
+		const [row] = await this.db
+			.update(outboxAttachmentTable)
+			.set({
+				state: "Stored",
+				sizeBytes,
+				// Stored rows hold room forever, so the expiry has nothing left to
+				// say. Zero is that, explicitly.
+				reservationExpiresAt: 0,
+				updatedAt: Date.now(),
+			})
+			.where(
+				and(
+					eq(outboxAttachmentTable.accountConfigId, accountConfigId),
+					eq(outboxAttachmentTable.outboxAttachmentId, outboxAttachmentId),
+					eq(outboxAttachmentTable.state, "Pending"),
+				),
+			)
+			.returning();
+
+		return row ? rowToOutboxAttachment(row) : null;
+	}
+
+	async deleteLapsedReservations(
+		accountConfigId: string,
+		outboxMessageId: string,
+		nowSeconds: number,
+	): Promise<string[]> {
+		const rows = await this.db
+			.delete(outboxAttachmentTable)
+			.where(
+				and(
+					eq(outboxAttachmentTable.accountConfigId, accountConfigId),
+					eq(outboxAttachmentTable.outboxMessageId, outboxMessageId),
+					eq(outboxAttachmentTable.state, "Pending"),
+					lt(outboxAttachmentTable.reservationExpiresAt, nowSeconds),
+				),
+			)
+			.returning();
+		return rows.map((row) => row.outboxAttachmentId);
+	}
+
+	async deleteMany(
+		accountConfigId: string,
+		outboxAttachmentIds: string[],
+	): Promise<void> {
+		if (outboxAttachmentIds.length === 0) return;
+		await this.db
+			.delete(outboxAttachmentTable)
+			.where(
+				and(
+					eq(outboxAttachmentTable.accountConfigId, accountConfigId),
+					inArray(
+						outboxAttachmentTable.outboxAttachmentId,
+						outboxAttachmentIds,
+					),
+				),
+			);
+	}
+
+	async deleteByOutboxMessage(
+		accountConfigId: string,
+		outboxMessageId: string,
+	): Promise<void> {
+		await this.db
+			.delete(outboxAttachmentTable)
+			.where(
+				and(
+					eq(outboxAttachmentTable.accountConfigId, accountConfigId),
+					eq(outboxAttachmentTable.outboxMessageId, outboxMessageId),
+				),
+			);
+	}
+}

package/src/schema/i4-outbox-attachment.ts

@@ -0,0 +1,3 @@
+import * as entities from "@remit/drizzle-sqlite-schema";
+
+export const outboxAttachmentTable = entities.outboxAttachments;

package/src/schema.ts

@@ -23,6 +23,7 @@ export * from "./schema/i4-mailbox-lock.js";
 export * from "./schema/i4-message-flag-push.js";
 export * from "./schema/i4-message-placement-move.js";
 export * from "./schema/i4-organize-job-request.js";
+export * from "./schema/i4-outbox-attachment.js";
 export * from "./schema/i4-outbox-message.js";
 export * from "./schema/message-data.js";
 export * from "./schema/quarantine.js";