@remit/drizzle-service 0.0.1

package/src/repos/filter-anchor.test.ts

@@ -0,0 +1,131 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { FilterAnchorRepo } from "./filter-anchor.js";
+
+describe("FilterAnchorRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: FilterAnchorRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new FilterAnchorRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("put creates the row and round-trips the anchor vector", async () => {
+		const accountConfigId = randomId();
+		const filterId = randomId();
+		const anchorMessageId = randomId();
+		const anchorEmbedding = [0.1, -0.2, 0.3, 0];
+
+		const anchor = await repo.put({
+			accountConfigId,
+			filterId,
+			anchorEmbedding,
+			anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+			anchorSourceText: "Your booking is confirmed for...",
+			anchorMessageId,
+		});
+
+		assert.deepEqual(anchor.anchorEmbedding, anchorEmbedding);
+		assert.equal(anchor.anchorMessageId, anchorMessageId);
+	});
+
+	test("get returns null when no anchor exists for the filter", async () => {
+		const anchor = await repo.get(randomId(), randomId());
+		assert.equal(anchor, null);
+	});
+
+	test("put upserts — a re-embed migration overwrites the existing row", async () => {
+		const accountConfigId = randomId();
+		const filterId = randomId();
+		const anchorMessageId = randomId();
+
+		await repo.put({
+			accountConfigId,
+			filterId,
+			anchorEmbedding: [1, 2, 3],
+			anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+			anchorSourceText: "original",
+			anchorMessageId,
+		});
+
+		const migrated = await repo.put({
+			accountConfigId,
+			filterId,
+			anchorEmbedding: [4, 5, 6],
+			anchorEmbeddingId: "amazon.titan-embed-text-v3:0@1536",
+			anchorSourceText: "original",
+			anchorMessageId,
+		});
+
+		assert.deepEqual(migrated.anchorEmbedding, [4, 5, 6]);
+		assert.equal(
+			migrated.anchorEmbeddingId,
+			"amazon.titan-embed-text-v3:0@1536",
+		);
+
+		const reread = await repo.get(accountConfigId, filterId);
+		assert.deepEqual(reread?.anchorEmbedding, [4, 5, 6]);
+	});
+
+	test("listByAccountConfig returns every anchor for the account config", async () => {
+		const accountConfigId = randomId();
+		const filterIdA = randomId();
+		const filterIdB = randomId();
+		const otherConfigId = randomId();
+		const otherFilterId = randomId();
+
+		await repo.put({
+			accountConfigId,
+			filterId: filterIdA,
+			anchorEmbedding: [1, 2, 3],
+			anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+			anchorSourceText: "a",
+			anchorMessageId: randomId(),
+		});
+		await repo.put({
+			accountConfigId,
+			filterId: filterIdB,
+			anchorEmbedding: [4, 5, 6],
+			anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+			anchorSourceText: "b",
+			anchorMessageId: randomId(),
+		});
+		await repo.put({
+			accountConfigId: otherConfigId,
+			filterId: otherFilterId,
+			anchorEmbedding: [7, 8, 9],
+			anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+			anchorSourceText: "other",
+			anchorMessageId: randomId(),
+		});
+
+		const anchors = await repo.listByAccountConfig(accountConfigId);
+		const filterIds = anchors.map((a) => a.filterId).sort();
+		assert.deepEqual(filterIds, [filterIdA, filterIdB].sort());
+	});
+
+	test("delete removes the row", async () => {
+		const accountConfigId = randomId();
+		const filterId = randomId();
+
+		await repo.put({
+			accountConfigId,
+			filterId,
+			anchorEmbedding: [1],
+			anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+			anchorSourceText: "text",
+			anchorMessageId: randomId(),
+		});
+
+		await repo.delete(accountConfigId, filterId);
+
+		assert.equal(await repo.get(accountConfigId, filterId), null);
+	});
+});

package/src/repos/filter-anchor.ts

@@ -0,0 +1,105 @@
+import type {
+	CreateFilterAnchorInput,
+	FilterAnchorItem,
+	IFilterAnchorRepository,
+} from "@remit/data-ports";
+import { and, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { filterAnchorTable } from "../schema.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+function rowToFilterAnchor(
+	row: typeof filterAnchorTable.$inferSelect,
+): FilterAnchorItem {
+	return {
+		accountConfigId: row.accountConfigId,
+		filterId: row.filterId,
+		anchorEmbedding: row.anchorEmbedding as number[],
+		anchorEmbeddingId: row.anchorEmbeddingId,
+		anchorSourceText: row.anchorSourceText,
+		anchorMessageId: row.anchorMessageId,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+/**
+ * Postgres counterpart to `FilterAnchorService` (remit-electrodb-service). The
+ * anchor vector is persisted inline on the row (RFC 034 Decision 2.1/2.3); the
+ * pgvector store's per-message chunk vectors are read only by the search
+ * service when it builds the anchor, never re-derived here at match time.
+ */
+export class FilterAnchorRepo implements IFilterAnchorRepository {
+	constructor(private db: DB) {}
+
+	/**
+	 * Upsert — a filter's anchor is (re)computed once at save time (RFC 034
+	 * Decision 2.1) and again only by an explicit re-embed migration
+	 * (Decision 2.4).
+	 */
+	async put(input: CreateFilterAnchorInput): Promise<FilterAnchorItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.insert(filterAnchorTable)
+			.values({
+				accountConfigId: input.accountConfigId,
+				filterId: input.filterId,
+				anchorEmbedding: input.anchorEmbedding,
+				anchorEmbeddingId: input.anchorEmbeddingId,
+				anchorSourceText: input.anchorSourceText,
+				anchorMessageId: input.anchorMessageId,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoUpdate({
+				target: [filterAnchorTable.accountConfigId, filterAnchorTable.filterId],
+				set: {
+					anchorEmbedding: input.anchorEmbedding,
+					anchorEmbeddingId: input.anchorEmbeddingId,
+					anchorSourceText: input.anchorSourceText,
+					anchorMessageId: input.anchorMessageId,
+					updatedAt: now,
+				},
+			})
+			.returning();
+		return rowToFilterAnchor(row);
+	}
+
+	async get(
+		accountConfigId: string,
+		filterId: string,
+	): Promise<FilterAnchorItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(filterAnchorTable)
+			.where(
+				and(
+					eq(filterAnchorTable.accountConfigId, accountConfigId),
+					eq(filterAnchorTable.filterId, filterId),
+				),
+			);
+		return row ? rowToFilterAnchor(row) : null;
+	}
+
+	async listByAccountConfig(
+		accountConfigId: string,
+	): Promise<FilterAnchorItem[]> {
+		const rows = await this.db
+			.select()
+			.from(filterAnchorTable)
+			.where(eq(filterAnchorTable.accountConfigId, accountConfigId));
+		return rows.map(rowToFilterAnchor);
+	}
+
+	async delete(accountConfigId: string, filterId: string): Promise<void> {
+		await this.db
+			.delete(filterAnchorTable)
+			.where(
+				and(
+					eq(filterAnchorTable.accountConfigId, accountConfigId),
+					eq(filterAnchorTable.filterId, filterId),
+				),
+			);
+	}
+}

package/src/repos/filter.test.ts

@@ -0,0 +1,279 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { FilterScope, FilterState } from "@remit/domain-enums";
+import { NotFoundError } from "../error.js";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { FilterRepo } from "./filter.js";
+
+describe("FilterRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: FilterRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new FilterRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("create fills in every defaulted field, never leaving it absent", async () => {
+		const accountConfigId = randomId();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Booking confirmations",
+			scope: FilterScope.Standing,
+		});
+
+		assert.equal(filter.state, FilterState.Active);
+		assert.equal(filter.hasAnchor, false);
+		assert.equal(filter.literalClauses.length, 0);
+		assert.equal(filter.actionLabelId, "None");
+		assert.equal(filter.actionMailboxId, "None");
+		assert.ok(
+			filter.ruleChangedAt > 0,
+			"ruleChangedAt should be set on create",
+		);
+		assert.equal(filter.expiresAt, undefined);
+		assert.equal(filter.ttl, undefined);
+	});
+
+	test("a Temporary filter round-trips expiresAt and ttl", async () => {
+		const accountConfigId = randomId();
+		const expiresAt = "2026-08-01T00:00:00+02:00";
+		const ttl = Math.floor(new Date(expiresAt).getTime() / 1000);
+
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Until my trip",
+			scope: FilterScope.Temporary,
+			expiresAt,
+			ttl,
+		});
+
+		assert.equal(filter.scope, FilterScope.Temporary);
+		assert.equal(filter.expiresAt, expiresAt);
+		assert.equal(filter.ttl, ttl);
+	});
+
+	test("create round-trips literal clauses", async () => {
+		const accountConfigId = randomId();
+		const literalClauses = [
+			{ field: "From", value: "billing@example.com" },
+			{ field: "Subject", value: "invoice" },
+		] as const;
+
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Invoices",
+			scope: FilterScope.Standing,
+			literalClauses: [...literalClauses],
+		});
+
+		assert.deepEqual(filter.literalClauses, literalClauses);
+	});
+
+	test("get throws NotFoundError for a missing filter", async () => {
+		await assert.rejects(repo.get(randomId(), randomId()), NotFoundError);
+	});
+
+	test("update does not bump ruleChangedAt on a cosmetic rename", async () => {
+		const accountConfigId = randomId();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Newsletter admin",
+			scope: FilterScope.Standing,
+		});
+
+		const renamed = await repo.update(accountConfigId, filter.filterId, {
+			name: "Newsletter admin (renamed)",
+		});
+
+		assert.equal(renamed.name, "Newsletter admin (renamed)");
+		assert.equal(
+			renamed.ruleChangedAt,
+			filter.ruleChangedAt,
+			"a name-only edit must not move ruleChangedAt (RFC 034 Decision 3.2)",
+		);
+	});
+
+	test("update bumps ruleChangedAt when the action changes", async () => {
+		const accountConfigId = randomId();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Move to archive",
+			scope: FilterScope.Standing,
+		});
+
+		await new Promise((resolve) => setTimeout(resolve, 1100));
+
+		const updated = await repo.update(accountConfigId, filter.filterId, {
+			actionMailboxId: randomId(),
+		});
+
+		assert.ok(
+			updated.ruleChangedAt > filter.ruleChangedAt,
+			"an action edit must move ruleChangedAt forward",
+		);
+	});
+
+	test("update throws NotFoundError for a missing filter", async () => {
+		await assert.rejects(
+			repo.update(randomId(), randomId(), { name: "x" }),
+			NotFoundError,
+		);
+	});
+
+	test("listByAccountConfig and listByAccountAndState scope to the account", async () => {
+		const accountConfigId = randomId();
+		const other = randomId();
+
+		const standing = await repo.create({
+			accountConfigId,
+			name: "Standing",
+			scope: FilterScope.Standing,
+		});
+		await repo.create({
+			accountConfigId: other,
+			name: "Foreign",
+			scope: FilterScope.Standing,
+		});
+
+		const all = await repo.listByAccountConfig(accountConfigId);
+		assert.equal(all.length, 1);
+		assert.equal(all[0]?.filterId, standing.filterId);
+
+		const active = await repo.listByAccountAndState(
+			accountConfigId,
+			FilterState.Active,
+		);
+		assert.equal(active.length, 1);
+		assert.equal(active[0]?.filterId, standing.filterId);
+
+		const expired = await repo.listByAccountAndState(
+			accountConfigId,
+			FilterState.Expired,
+		);
+		assert.equal(expired.length, 0);
+	});
+
+	test("refreshExpiry leaves a Standing filter untouched", async () => {
+		const accountConfigId = randomId();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Standing",
+			scope: FilterScope.Standing,
+		});
+
+		const result = await repo.refreshExpiry(filter);
+		assert.equal(result.state, FilterState.Active);
+	});
+
+	test("refreshExpiry leaves a not-yet-expired Temporary filter Active", async () => {
+		const accountConfigId = randomId();
+		const future = new Date(Date.now() + 86_400_000).toISOString();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Until tomorrow",
+			scope: FilterScope.Temporary,
+			expiresAt: future,
+			ttl: Math.floor(new Date(future).getTime() / 1000),
+		});
+
+		const result = await repo.refreshExpiry(filter);
+		assert.equal(result.state, FilterState.Active);
+	});
+
+	test("refreshExpiry lazily patches a past-expiresAt Temporary filter to Expired", async () => {
+		const accountConfigId = randomId();
+		const past = new Date(Date.now() - 86_400_000).toISOString();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Until yesterday",
+			scope: FilterScope.Temporary,
+			expiresAt: past,
+			ttl: Math.floor(new Date(past).getTime() / 1000) + 172_800,
+		});
+
+		assert.equal(filter.state, FilterState.Active, "starts Active on create");
+
+		const result = await repo.refreshExpiry(filter);
+		assert.equal(result.state, FilterState.Expired);
+
+		const reread = await repo.get(accountConfigId, filter.filterId);
+		assert.equal(
+			reread.state,
+			FilterState.Expired,
+			"the patch is persisted, not just returned",
+		);
+	});
+
+	test("delete removes the row", async () => {
+		const accountConfigId = randomId();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "To delete",
+			scope: FilterScope.Standing,
+		});
+
+		await repo.delete(accountConfigId, filter.filterId);
+
+		await assert.rejects(
+			repo.get(accountConfigId, filter.filterId),
+			NotFoundError,
+		);
+	});
+
+	test("listPageByAccountConfig round-trips a continuationToken across pages", async () => {
+		const accountConfigId = randomId();
+		const created = await Promise.all([
+			repo.create({
+				accountConfigId,
+				name: "One",
+				scope: FilterScope.Standing,
+			}),
+			repo.create({
+				accountConfigId,
+				name: "Two",
+				scope: FilterScope.Standing,
+			}),
+			repo.create({
+				accountConfigId,
+				name: "Three",
+				scope: FilterScope.Standing,
+			}),
+		]);
+
+		const first = await repo.listPageByAccountConfig(accountConfigId, {
+			limit: 2,
+		});
+		assert.equal(first.items.length, 2);
+		assert.ok(
+			first.continuationToken,
+			"a full page returns a continuationToken",
+		);
+
+		const second = await repo.listPageByAccountConfig(accountConfigId, {
+			limit: 2,
+			continuationToken: first.continuationToken,
+		});
+		assert.equal(second.items.length, 1);
+		assert.equal(
+			second.continuationToken,
+			undefined,
+			"the last page carries no continuationToken",
+		);
+
+		const seen = new Set([
+			...first.items.map((f) => f.filterId),
+			...second.items.map((f) => f.filterId),
+		]);
+		assert.equal(
+			seen.size,
+			created.length,
+			"every filter is paged exactly once",
+		);
+	});
+});