@remit/drizzle-service 0.0.40 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",
@@ -13,7 +13,7 @@
   },
   "scripts": {
     "test:typecheck": "tsgo --noEmit -p tsconfig.json",
-    "test:run": "node --env-file=../../localhost-test-unit-sqlite.env --import tsx --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=90 --test 'src/**/*.test.ts'",
+    "test:run": "node $NODE_TEST_FLAGS --env-file=../../localhost-test-unit-sqlite.env --import tsx --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=90 --test 'src/**/*.test.ts'",
     "test": "npm run test:typecheck && npm run test:run",
     "fix": "biome check --write src"
   },

package/src/index.ts

@@ -33,6 +33,7 @@ export {
 export * from "./repos/i4-organize-job-request.js";
 export { OutboxAttachmentRepo } from "./repos/i4-outbox-attachment.js";
 export * from "./repos/i4-outbox-message.js";
+export { SenderSignerStandingRepo } from "./repos/i4-sender-signer-standing.js";
 export { LabelRepo } from "./repos/label.js";
 export {
 	DrizzleMessageRepository,

package/src/repos/i4-address.test.ts

@@ -98,6 +98,45 @@ describe("AddressRepo", () => {
 		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
 	});
 
+	test("three inbound messages promote a person-shaped sender to wellknown", async () => {
+		const addr = await repo.createAddress(makeAddressInput(randomId()));
+		const now = Date.now();
+
+		for (let i = 0; i < 3; i++) {
+			await repo.incrementInboundCount(
+				addr.accountConfigId,
+				addr.addressId,
+				now,
+				false,
+			);
+		}
+
+		const updated = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(updated.flags?.wellknown?.value, true);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
+	test("a bulk sender never reaches wellknown on inbound volume alone", async () => {
+		const addr = await repo.createAddress(makeAddressInput(randomId()));
+		const now = Date.now();
+
+		for (let i = 0; i < 5; i++) {
+			await repo.incrementInboundCount(
+				addr.accountConfigId,
+				addr.addressId,
+				now,
+				true,
+			);
+		}
+
+		const updated = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(updated.inboundCount, 5);
+		assert.equal(updated.flags?.wellknown, undefined);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
 	test("createEnvelopeAddress and getEnvelopeAddress", async () => {
 		const messageId = randomUUID();
 		const addressId = randomUUID();

package/src/repos/i4-address.ts

@@ -396,13 +396,14 @@ export class AddressRepo implements IAddressRepository {
 		accountConfigId: string,
 		addressId: string,
 		now: number,
-		_isBulk?: boolean,
+		isBulk?: boolean,
 	): Promise<void> {
 		const current = await this.getAddress(accountConfigId, addressId);
 		const post = {
 			...current,
 			inboundCount: (current.inboundCount ?? 0) + 1,
 			lastInboundAt: now,
+			isBulk: isBulk ?? false,
 		};
 		if (shouldPromoteWellknown(post, now)) {
 			const nextFlags: AddressFlags = {

package/src/repos/i4-sender-signer-standing.test.ts

@@ -0,0 +1,188 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { eq } from "drizzle-orm";
+import { NotFoundError } from "../error.js";
+import { senderSignerStandingTable } from "../schema.js";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { SenderSignerStandingRepo } from "./i4-sender-signer-standing.js";
+
+describe("SenderSignerStandingRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: SenderSignerStandingRepo;
+
+	const rowsFor = async (accountConfigId: string) =>
+		db
+			.select()
+			.from(senderSignerStandingTable)
+			.where(eq(senderSignerStandingTable.accountConfigId, accountConfigId));
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new SenderSignerStandingRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("observing a new key inserts one row at a count of one", async () => {
+		const accountConfigId = randomId();
+		const observedAt = 1_700_000_000_000;
+
+		const standing = await repo.observe({
+			accountConfigId,
+			senderKey: "vip.example",
+			signerDomain: "esp.example",
+			observedAt,
+		});
+
+		assert.equal(standing.messageCount, 1);
+		assert.equal(standing.firstSeenAt, observedAt);
+		assert.equal(standing.lastSeenAt, observedAt);
+		assert.equal(standing.userAffirmedAt, 0);
+		assert.equal((await rowsFor(accountConfigId)).length, 1);
+	});
+
+	test("observing the same key again increments the count in place rather than inserting a second row", async () => {
+		const accountConfigId = randomId();
+		const key = {
+			accountConfigId,
+			senderKey: "vip.example",
+			signerDomain: "esp.example",
+		};
+
+		await repo.observe({ ...key, observedAt: 1_700_000_000_000 });
+		await repo.observe({ ...key, observedAt: 1_700_000_060_000 });
+		const third = await repo.observe({
+			...key,
+			observedAt: 1_700_000_120_000,
+		});
+
+		assert.equal(third.messageCount, 3);
+		const rows = await rowsFor(accountConfigId);
+		assert.equal(rows.length, 1);
+		assert.equal(rows[0]?.messageCount, 3);
+	});
+
+	// The failure this guards is silent: naming first_seen_at in the conflict
+	// `set` makes every message reset the key's age, so standing reads as
+	// brand-new forever and nothing downstream can tell.
+	test("a repeat leaves firstSeenAt at the first observation while lastSeenAt follows the latest", async () => {
+		const accountConfigId = randomId();
+		const key = {
+			accountConfigId,
+			senderKey: "list.example",
+			signerDomain: "unverified",
+		};
+		const first = 1_600_000_000_000;
+
+		await repo.observe({ ...key, observedAt: first });
+		await repo.observe({ ...key, observedAt: first + 3_600_000 });
+		const latest = await repo.observe({
+			...key,
+			observedAt: first + 7_200_000,
+		});
+
+		assert.equal(latest.firstSeenAt, first);
+		assert.equal(latest.lastSeenAt, first + 7_200_000);
+
+		const [row] = await rowsFor(accountConfigId);
+		assert.equal(row?.firstSeenAt, first);
+		assert.equal(row?.lastSeenAt, first + 7_200_000);
+	});
+
+	test("an out-of-order observation still counts, and never rewrites firstSeenAt", async () => {
+		const accountConfigId = randomId();
+		const key = {
+			accountConfigId,
+			senderKey: "delayed.example",
+			signerDomain: "esp.example",
+		};
+		const first = 1_650_000_000_000;
+
+		await repo.observe({ ...key, observedAt: first });
+		const older = await repo.observe({
+			...key,
+			observedAt: first - 86_400_000,
+		});
+
+		assert.equal(older.messageCount, 2);
+		assert.equal(older.firstSeenAt, first);
+	});
+
+	test("the same sender under two signer domains keeps two independent rows", async () => {
+		const accountConfigId = randomId();
+		const observedAt = 1_700_000_000_000;
+
+		await repo.observe({
+			accountConfigId,
+			senderKey: "shop.example",
+			signerDomain: "esp-one.example",
+			observedAt,
+		});
+		await repo.observe({
+			accountConfigId,
+			senderKey: "shop.example",
+			signerDomain: "esp-one.example",
+			observedAt,
+		});
+		const other = await repo.observe({
+			accountConfigId,
+			senderKey: "shop.example",
+			signerDomain: "esp-two.example",
+			observedAt,
+		});
+
+		assert.equal(other.messageCount, 1);
+		assert.equal((await rowsFor(accountConfigId)).length, 2);
+	});
+
+	test("standing never crosses accounts", async () => {
+		const mine = randomId();
+		const theirs = randomId();
+		const key = {
+			senderKey: "shared.example",
+			signerDomain: "esp.example",
+			observedAt: 1_700_000_000_000,
+		};
+
+		await repo.observe({ accountConfigId: mine, ...key });
+		await repo.observe({ accountConfigId: mine, ...key });
+		const foreign = await repo.observe({ accountConfigId: theirs, ...key });
+
+		assert.equal(foreign.messageCount, 1);
+		assert.equal(
+			(await repo.get(mine, key.senderKey, key.signerDomain)).messageCount,
+			2,
+		);
+	});
+
+	test("get raises NotFoundError for a key that was never observed", async () => {
+		await assert.rejects(
+			repo.get(randomId(), "stranger.example", "esp.example"),
+			(error) => error instanceof NotFoundError,
+		);
+	});
+
+	test("get reads back the row the last observation returned", async () => {
+		const accountConfigId = randomId();
+		const key = {
+			accountConfigId,
+			senderKey: "readback.example",
+			signerDomain: "esp.example",
+		};
+
+		const written = await repo.observe({
+			...key,
+			observedAt: 1_700_000_000_000,
+		});
+		const read = await repo.get(
+			accountConfigId,
+			key.senderKey,
+			key.signerDomain,
+		);
+
+		assert.deepEqual(read, written);
+	});
+});

package/src/repos/i4-sender-signer-standing.ts

@@ -0,0 +1,101 @@
+import type {
+	ISenderSignerStandingRepository,
+	ObserveSenderSignerStandingInput,
+	SenderSignerStandingItem,
+} from "@remit/data-ports";
+import { and, eq, sql } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { NotFoundError } from "../error.js";
+import { senderSignerStandingTable } from "../schema.js";
+
+type DB = Db<Record<string, unknown>>;
+
+function rowToStanding(
+	row: typeof senderSignerStandingTable.$inferSelect,
+): SenderSignerStandingItem {
+	return {
+		accountConfigId: row.accountConfigId,
+		senderKey: row.senderKey,
+		signerDomain: row.signerDomain,
+		messageCount: row.messageCount,
+		firstSeenAt: row.firstSeenAt,
+		lastSeenAt: row.lastSeenAt,
+		userAffirmedAt: row.userAffirmedAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class SenderSignerStandingRepo
+	implements ISenderSignerStandingRepository
+{
+	constructor(private db: DB) {}
+
+	async observe(
+		input: ObserveSenderSignerStandingInput,
+	): Promise<SenderSignerStandingItem> {
+		const now = Date.now();
+		// `first_seen_at` is deliberately absent from the conflict `set`.
+		// onConflictDoUpdate writes only the columns it names, so naming it here
+		// would let every message reset the key's age to its own arrival and the
+		// standing this row exists to record would never be older than the last
+		// message. The mirror-image mistake — a conflict path that must reset a
+		// timestamp and would silently inherit the old one by omitting it — is at
+		// i4-message-flag-push.ts:70.
+		const [row] = await this.db
+			.insert(senderSignerStandingTable)
+			.values({
+				accountConfigId: input.accountConfigId,
+				senderKey: input.senderKey,
+				signerDomain: input.signerDomain,
+				messageCount: 1,
+				firstSeenAt: input.observedAt,
+				lastSeenAt: input.observedAt,
+				userAffirmedAt: 0,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoUpdate({
+				target: [
+					senderSignerStandingTable.accountConfigId,
+					senderSignerStandingTable.senderKey,
+					senderSignerStandingTable.signerDomain,
+				],
+				set: {
+					messageCount: sql`${senderSignerStandingTable.messageCount} + 1`,
+					lastSeenAt: input.observedAt,
+					updatedAt: now,
+				},
+			})
+			.returning();
+		if (!row) {
+			throw new Error(
+				`Failed to upsert SenderSignerStanding: ${input.accountConfigId}/${input.senderKey}/${input.signerDomain}`,
+			);
+		}
+		return rowToStanding(row);
+	}
+
+	async get(
+		accountConfigId: string,
+		senderKey: string,
+		signerDomain: string,
+	): Promise<SenderSignerStandingItem> {
+		const [row] = await this.db
+			.select()
+			.from(senderSignerStandingTable)
+			.where(
+				and(
+					eq(senderSignerStandingTable.accountConfigId, accountConfigId),
+					eq(senderSignerStandingTable.senderKey, senderKey),
+					eq(senderSignerStandingTable.signerDomain, signerDomain),
+				),
+			);
+		if (!row) {
+			throw new NotFoundError(
+				`SenderSignerStanding not found: ${senderKey}/${signerDomain}`,
+			);
+		}
+		return rowToStanding(row);
+	}
+}

package/src/repos/message.ts

@@ -59,6 +59,7 @@ function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
 		status: row.status,
 		syncStatus: row.syncStatus,
 		category: row.category,
+		authenticityVerdict: row.authenticityVerdict,
 		hasListUnsubscribe: row.hasListUnsubscribe,
 		movedByRemit: row.movedByRemit,
 		createdAt: row.createdAt,
@@ -184,6 +185,8 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			status: input.status ?? ("active" as const),
 			syncStatus: input.syncStatus ?? ("pending" as const),
 			category: input.category ?? ("uncategorized" as const),
+			authenticityVerdict:
+				input.authenticityVerdict ?? ("NotEvaluated" as const),
 			hasListUnsubscribe: input.hasListUnsubscribe ?? false,
 			movedByRemit: input.movedByRemit ?? false,
 			messageIdHeader: input.messageIdHeader ?? null,
@@ -365,6 +368,9 @@ export class DrizzleMessageRepository implements IMessageRepository {
 				? { syncStatus: input.syncStatus }
 				: {}),
 			...(input.category !== undefined ? { category: input.category } : {}),
+			...(input.authenticityVerdict !== undefined
+				? { authenticityVerdict: input.authenticityVerdict }
+				: {}),
 			...(input.hasListUnsubscribe !== undefined
 				? { hasListUnsubscribe: input.hasListUnsubscribe }
 				: {}),

package/src/repos/sender-signer-standing.conformance.sqlite.test.ts

@@ -0,0 +1,23 @@
+import { senderSignerStandingRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { senderSignerStandingTable } from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { SenderSignerStandingRepo } from "./i4-sender-signer-standing.js";
+
+let close: (() => Promise<void>) | undefined;
+
+senderSignerStandingRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createSqliteTestDb({
+			senderSignerStandings: senderSignerStandingTable,
+		});
+		close = closeDb;
+		return new SenderSignerStandingRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/schema.ts

@@ -14,6 +14,7 @@ export const labelTable = entities.labels;
 export const mailboxAttributeEntryTable = entities.mailboxAttributeEntries;
 export const mailboxFlagTable = entities.mailboxFlags;
 export const messageLabelTable = entities.messageLabels;
+export const senderSignerStandingTable = entities.senderSignerStandings;
 export * from "./schema/i4-account-config.js";
 export * from "./schema/i4-account-export-request.js";
 export * from "./schema/i4-account-setting.js";