@remit/drizzle-service 0.0.1

package/src/repos/message-flag.ts

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+import type {
+	CreateMessageFlagInput,
+	IMessageFlagRepository,
+	MessageFlagItem,
+} from "@remit/data-ports";
+import { and, eq, inArray } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { NotFoundError } from "../error.js";
+import {
+	type MessageDataSchema,
+	messageFlagTable,
+} from "../schema/message-data.js";
+
+type DB = NodePgDatabase<MessageDataSchema>;
+
+function rowToMessageFlag(
+	row: typeof messageFlagTable.$inferSelect,
+): MessageFlagItem {
+	return {
+		messageFlagId: row.messageFlagId,
+		messageId: row.messageId,
+		flagName: row.flagName,
+		setAt: row.setAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class DrizzleMessageFlagRepository implements IMessageFlagRepository {
+	constructor(private db: DB) {}
+
+	async create(input: CreateMessageFlagInput): Promise<MessageFlagItem> {
+		const now = Date.now();
+		const messageFlagId = randomUUID();
+		const [row] = await this.db
+			.insert(messageFlagTable)
+			.values({
+				messageFlagId,
+				messageId: input.messageId,
+				flagName: input.flagName,
+				setAt: input.setAt,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		if (!row) throw new NotFoundError(`MessageFlag create failed`);
+		return rowToMessageFlag(row);
+	}
+
+	async get(messageFlagId: string): Promise<MessageFlagItem>;
+	async get(messageFlagIds: string[]): Promise<MessageFlagItem[]>;
+	async get(
+		idOrIds: string | string[],
+	): Promise<MessageFlagItem | MessageFlagItem[]> {
+		if (Array.isArray(idOrIds)) {
+			if (idOrIds.length === 0) return [];
+			const rows = await this.db
+				.select()
+				.from(messageFlagTable)
+				.where(inArray(messageFlagTable.messageFlagId, idOrIds));
+			return rows.map(rowToMessageFlag);
+		}
+		const [row] = await this.db
+			.select()
+			.from(messageFlagTable)
+			.where(eq(messageFlagTable.messageFlagId, idOrIds));
+		if (!row) throw new NotFoundError(`MessageFlag not found: ${idOrIds}`);
+		return rowToMessageFlag(row);
+	}
+
+	async delete(messageFlagId: string): Promise<void> {
+		await this.db
+			.delete(messageFlagTable)
+			.where(eq(messageFlagTable.messageFlagId, messageFlagId));
+	}
+
+	async deleteMany(messageFlagIds: string[]): Promise<void> {
+		if (messageFlagIds.length === 0) return;
+		await this.db
+			.delete(messageFlagTable)
+			.where(inArray(messageFlagTable.messageFlagId, messageFlagIds));
+	}
+
+	async getFlags(messageId: string): Promise<MessageFlagItem[]> {
+		const rows = await this.db
+			.select()
+			.from(messageFlagTable)
+			.where(eq(messageFlagTable.messageId, messageId));
+		return rows.map(rowToMessageFlag);
+	}
+
+	async hasFlag(messageId: string, flagName: string): Promise<boolean> {
+		const [row] = await this.db
+			.select()
+			.from(messageFlagTable)
+			.where(
+				and(
+					eq(messageFlagTable.messageId, messageId),
+					eq(messageFlagTable.flagName, flagName),
+				),
+			);
+		return row !== undefined;
+	}
+
+	async addFlag(messageId: string, flagName: string): Promise<MessageFlagItem> {
+		const existing = await this.db
+			.select()
+			.from(messageFlagTable)
+			.where(
+				and(
+					eq(messageFlagTable.messageId, messageId),
+					eq(messageFlagTable.flagName, flagName),
+				),
+			);
+		if (existing[0]) return rowToMessageFlag(existing[0]);
+		const now = Date.now();
+		const messageFlagId = randomUUID();
+		const [row] = await this.db
+			.insert(messageFlagTable)
+			.values({
+				messageFlagId,
+				messageId,
+				flagName,
+				setAt: now,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		if (!row) throw new NotFoundError(`MessageFlag addFlag failed`);
+		return rowToMessageFlag(row);
+	}
+
+	async removeFlag(messageId: string, flagName: string): Promise<void> {
+		await this.db
+			.delete(messageFlagTable)
+			.where(
+				and(
+					eq(messageFlagTable.messageId, messageId),
+					eq(messageFlagTable.flagName, flagName),
+				),
+			);
+	}
+
+	async addFlags(messageId: string, flagNames: string[]): Promise<void> {
+		for (const flagName of flagNames) {
+			await this.addFlag(messageId, flagName);
+		}
+	}
+
+	async removeFlags(messageId: string, flagNames: string[]): Promise<void> {
+		if (flagNames.length === 0) return;
+		await this.db
+			.delete(messageFlagTable)
+			.where(
+				and(
+					eq(messageFlagTable.messageId, messageId),
+					inArray(messageFlagTable.flagName, flagNames),
+				),
+			);
+	}
+}

package/src/repos/message-label.test.ts

@@ -0,0 +1,110 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { MessageLabelRepo } from "./message-label.js";
+
+describe("MessageLabelRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: MessageLabelRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new MessageLabelRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("apply is idempotent — the same (messageId, labelId) always derives the same row", async () => {
+		const accountConfigId = randomId();
+		const messageId = randomId();
+		const labelId = randomId();
+
+		const first = await repo.apply({ accountConfigId, messageId, labelId });
+		const second = await repo.apply({ accountConfigId, messageId, labelId });
+
+		assert.equal(first.messageLabelId, second.messageLabelId);
+		assert.equal(
+			first.messageLabelId,
+			MessageLabelRepo.deriveId(messageId, labelId),
+		);
+
+		const rows = await repo.listByMessageId(messageId);
+		assert.equal(rows.length, 1);
+	});
+
+	test("appliedByFilterId is absent for a manually-applied label", async () => {
+		const accountConfigId = randomId();
+		const messageId = randomId();
+		const labelId = randomId();
+
+		const row = await repo.apply({ accountConfigId, messageId, labelId });
+
+		assert.equal(row.appliedByFilterId, undefined);
+	});
+
+	test("appliedByFilterId round-trips for a filter-applied label (RFC 034 Decision 3.3)", async () => {
+		const accountConfigId = randomId();
+		const messageId = randomId();
+		const labelId = randomId();
+		const appliedByFilterId = randomId();
+
+		const row = await repo.apply({
+			accountConfigId,
+			messageId,
+			labelId,
+			appliedByFilterId,
+		});
+
+		assert.equal(row.appliedByFilterId, appliedByFilterId);
+	});
+
+	test("remove deletes the derived row", async () => {
+		const accountConfigId = randomId();
+		const messageId = randomId();
+		const labelId = randomId();
+
+		await repo.apply({ accountConfigId, messageId, labelId });
+		await repo.remove(messageId, labelId);
+
+		const labels = await repo.listByMessageId(messageId);
+		assert.equal(labels.length, 0);
+	});
+
+	test("listByMessageId returns every label on a message", async () => {
+		const accountConfigId = randomId();
+		const messageId = randomId();
+		const labelIdA = randomId();
+		const labelIdB = randomId();
+
+		await repo.apply({ accountConfigId, messageId, labelId: labelIdA });
+		await repo.apply({ accountConfigId, messageId, labelId: labelIdB });
+
+		const labels = await repo.listByMessageId(messageId);
+		const ids = labels.map((l) => l.labelId).sort();
+		assert.deepEqual(ids, [labelIdA, labelIdB].sort());
+	});
+
+	test("listByLabelId scopes to the account and label", async () => {
+		const accountConfigId = randomId();
+		const labelId = randomId();
+		const messageIdA = randomId();
+		const messageIdB = randomId();
+		const foreignAccountConfigId = randomId();
+		const foreignMessageId = randomId();
+
+		await repo.apply({ accountConfigId, messageId: messageIdA, labelId });
+		await repo.apply({ accountConfigId, messageId: messageIdB, labelId });
+		await repo.apply({
+			accountConfigId: foreignAccountConfigId,
+			messageId: foreignMessageId,
+			labelId,
+		});
+
+		const rows = await repo.listByLabelId(accountConfigId, labelId);
+		const messageIds = rows.map((r) => r.messageId).sort();
+		assert.deepEqual(messageIds, [messageIdA, messageIdB].sort());
+	});
+});

package/src/repos/message-label.ts

@@ -0,0 +1,96 @@
+import type {
+	CreateMessageLabelInput,
+	IMessageLabelRepository,
+	MessageLabelItem,
+} from "@remit/data-ports";
+import { and, desc, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { deterministicBase36Id } from "../id.js";
+import { messageLabelTable } from "../schema.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+function rowToMessageLabel(
+	row: typeof messageLabelTable.$inferSelect,
+): MessageLabelItem {
+	return {
+		messageLabelId: row.messageLabelId,
+		messageId: row.messageId,
+		labelId: row.labelId,
+		accountConfigId: row.accountConfigId,
+		appliedByFilterId: row.appliedByFilterId ?? undefined,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class MessageLabelRepo implements IMessageLabelRepository {
+	constructor(private db: DB) {}
+
+	/**
+	 * Deterministic primary key: base36 UUIDv5 of (messageId, labelId), the same
+	 * derivation the electrodb adapter uses, so applying the same label twice is
+	 * idempotent on either backend (RFC 030).
+	 */
+	static deriveId(messageId: string, labelId: string): string {
+		return deterministicBase36Id(`messageLabel:${messageId}:${labelId}`);
+	}
+
+	async apply(input: CreateMessageLabelInput): Promise<MessageLabelItem> {
+		const now = Date.now();
+		const messageLabelId = MessageLabelRepo.deriveId(
+			input.messageId,
+			input.labelId,
+		);
+		const appliedByFilterId = input.appliedByFilterId ?? null;
+		const [row] = await this.db
+			.insert(messageLabelTable)
+			.values({
+				messageLabelId,
+				messageId: input.messageId,
+				labelId: input.labelId,
+				accountConfigId: input.accountConfigId,
+				appliedByFilterId,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoUpdate({
+				target: messageLabelTable.messageLabelId,
+				set: { appliedByFilterId, updatedAt: now },
+			})
+			.returning();
+		return rowToMessageLabel(row);
+	}
+
+	async remove(messageId: string, labelId: string): Promise<void> {
+		const messageLabelId = MessageLabelRepo.deriveId(messageId, labelId);
+		await this.db
+			.delete(messageLabelTable)
+			.where(eq(messageLabelTable.messageLabelId, messageLabelId));
+	}
+
+	async listByMessageId(messageId: string): Promise<MessageLabelItem[]> {
+		const rows = await this.db
+			.select()
+			.from(messageLabelTable)
+			.where(eq(messageLabelTable.messageId, messageId));
+		return rows.map(rowToMessageLabel);
+	}
+
+	async listByLabelId(
+		accountConfigId: string,
+		labelId: string,
+	): Promise<MessageLabelItem[]> {
+		const rows = await this.db
+			.select()
+			.from(messageLabelTable)
+			.where(
+				and(
+					eq(messageLabelTable.accountConfigId, accountConfigId),
+					eq(messageLabelTable.labelId, labelId),
+				),
+			)
+			.orderBy(desc(messageLabelTable.createdAt));
+		return rows.map(rowToMessageLabel);
+	}
+}

package/src/repos/message.sqlite.test.ts

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { eq } from "drizzle-orm";
+import {
+	envelopeId as deriveEnvelopeId,
+	rootBodyPartId as deriveRootBodyPartId,
+} from "../id.js";
+import {
+	type MessageDataSchema,
+	messageDataSchema,
+	outboxTable,
+} from "../schema/message-data.js";
+import { createSqliteTestDb, type SqliteTestDb } from "../test-db-sqlite.js";
+import { DrizzleMessageRepository } from "./message.js";
+
+// Runs the ported message repo against a real better-sqlite3 database
+// (RFC 036 D1). Exercises the SQLite-specific seams: the SAVEPOINT-bracketed
+// transaction, the sqlite outbox table (text-json payload), the unique-
+// violation → CreateFailedConflictError mapping, and the JSON/boolean columns.
+
+describe("DrizzleMessageRepository (sqlite)", () => {
+	let db: SqliteTestDb<MessageDataSchema>;
+	let close: () => Promise<void>;
+	let repo: DrizzleMessageRepository;
+
+	const MESSAGE_ID = "00000000-0000-0000-2222-000000000001";
+	const MAILBOX_ID = "00000000-0000-0000-2222-000000000002";
+	const NOW = 1700000000000;
+
+	const BASE_INPUT = {
+		messageId: MESSAGE_ID,
+		mailboxId: MAILBOX_ID,
+		uid: 42,
+		sequenceNumber: 1,
+		rfc822Size: 1024,
+		internalDate: NOW,
+		messageIdHeader: "<test@example.com>",
+		envelopeId: deriveEnvelopeId(MESSAGE_ID),
+		rootBodyPartId: deriveRootBodyPartId(MESSAGE_ID),
+		status: "active" as const,
+		syncStatus: "synced" as const,
+		hasListUnsubscribe: true,
+		authenticity: { spf: "pass" } as unknown as never,
+	};
+
+	before(async () => {
+		({ db, close } = await createSqliteTestDb(messageDataSchema));
+		repo = new DrizzleMessageRepository(db);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("create returns a MessageItem and writes one outbox row atomically", async () => {
+		const item = await repo.create(BASE_INPUT);
+		assert.equal(item.messageId, MESSAGE_ID);
+		assert.equal(item.status, "active");
+		assert.equal(item.hasListUnsubscribe, true);
+
+		const rows = await db
+			.select()
+			.from(outboxTable)
+			.where(eq(outboxTable.messageId, MESSAGE_ID));
+		assert.equal(rows.length, 1);
+		assert.equal(rows[0].event, "message.created");
+		assert.deepEqual(rows[0].payload, { messageId: MESSAGE_ID });
+	});
+
+	test("boolean and json columns round-trip", async () => {
+		const item = await repo.get(MESSAGE_ID);
+		assert.equal(item.hasListUnsubscribe, true);
+		assert.equal(item.movedByRemit, false);
+		assert.deepEqual(item.authenticity, { spf: "pass" });
+	});
+
+	test("duplicate messageId throws CreateFailedConflictError and rolls back the outbox row", async () => {
+		const before = await db
+			.select()
+			.from(outboxTable)
+			.where(eq(outboxTable.messageId, MESSAGE_ID));
+
+		await assert.rejects(
+			() => repo.create(BASE_INPUT),
+			(err: Error) => err.name === "CreateFailedConflictError",
+		);
+
+		const afterRows = await db
+			.select()
+			.from(outboxTable)
+			.where(eq(outboxTable.messageId, MESSAGE_ID));
+		assert.equal(
+			afterRows.length,
+			before.length,
+			"rolled-back create must not append an outbox row",
+		);
+	});
+
+	test("upsertWithStatus reports created=false for an existing row", async () => {
+		const result = await repo.upsertWithStatus(BASE_INPUT);
+		assert.equal(result.created, false);
+		assert.equal(result.item.messageId, MESSAGE_ID);
+	});
+
+	test("delete removes the message and appends a removal outbox row", async () => {
+		await repo.delete(MESSAGE_ID);
+		await assert.rejects(() => repo.get(MESSAGE_ID));
+
+		const rows = await db
+			.select()
+			.from(outboxTable)
+			.where(eq(outboxTable.messageId, MESSAGE_ID));
+		assert.ok(
+			rows.some((r) => r.event === "message.removed"),
+			"delete must append a message.removed outbox row",
+		);
+	});
+});