@remit/drizzle-service 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Drizzle ORM service parameterized by dialect (Postgres / SQLite)",
   "type": "module",
   "main": "src/index.ts",

package/src/index.ts

@@ -10,6 +10,7 @@ export {
 export { DrizzleEnvelopeRepository } from "./repos/envelope.js";
 export { FilterRepo } from "./repos/filter.js";
 export { FilterAnchorRepo } from "./repos/filter-anchor.js";
+export { DrizzleFilterAnchorTransaction } from "./repos/filter-anchor-transaction.js";
 export * from "./repos/i4-account.js";
 export * from "./repos/i4-account-config.js";
 export * from "./repos/i4-account-export-request.js";

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

@@ -0,0 +1,136 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { FilterScope } from "@remit/domain-enums";
+import { NotFoundError } from "../error.js";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { FilterRepo } from "./filter.js";
+import { FilterAnchorRepo } from "./filter-anchor.js";
+import { DrizzleFilterAnchorTransaction } from "./filter-anchor-transaction.js";
+
+describe("DrizzleFilterAnchorTransaction", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let transaction: DrizzleFilterAnchorTransaction;
+	let filterRepo: FilterRepo;
+	let filterAnchorRepo: FilterAnchorRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		transaction = new DrizzleFilterAnchorTransaction(db as never);
+		filterRepo = new FilterRepo(db as never);
+		filterAnchorRepo = new FilterAnchorRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("creates the Filter and its FilterAnchor together", async () => {
+		const accountConfigId = randomId();
+
+		const filter = await transaction.createWithAnchor(
+			{
+				accountConfigId,
+				name: "Booking confirmations",
+				scope: FilterScope.Standing,
+				hasAnchor: true,
+			},
+			{
+				accountConfigId,
+				anchorMessageId: randomId(),
+				anchorEmbedding: [0.1, 0.2, 0.3],
+				anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+				anchorSourceText: "Your booking is confirmed",
+			},
+		);
+
+		assert.equal(filter.hasAnchor, true);
+		const anchor = await filterAnchorRepo.get(accountConfigId, filter.filterId);
+		assert.ok(anchor, "the FilterAnchor row must exist");
+		assert.equal(anchor?.anchorSourceText, "Your booking is confirmed");
+	});
+
+	test("creates a purely-literal Filter when anchor is null", async () => {
+		const accountConfigId = randomId();
+
+		const filter = await transaction.createWithAnchor(
+			{
+				accountConfigId,
+				name: "From billing",
+				scope: FilterScope.Standing,
+				hasAnchor: false,
+			},
+			null,
+		);
+
+		assert.equal(filter.hasAnchor, false);
+		const anchor = await filterAnchorRepo.get(accountConfigId, filter.filterId);
+		assert.equal(anchor, null);
+	});
+
+	test("rolls back the Filter row when the FilterAnchor write fails (#351)", async () => {
+		const accountConfigId = randomId();
+
+		await assert.rejects(() =>
+			transaction.createWithAnchor(
+				{
+					accountConfigId,
+					name: "Broken anchor",
+					scope: FilterScope.Standing,
+					hasAnchor: true,
+				},
+				{
+					accountConfigId,
+					anchorMessageId: randomId(),
+					anchorEmbedding: [0.1, 0.2, 0.3],
+					anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+					// A NOT NULL column at the DB level — simulates a real write
+					// failure on the second half of the pair (network blip,
+					// transient error), the exact case #351 leaves broken today.
+					anchorSourceText: null as unknown as string,
+				},
+			),
+		);
+
+		const filters = await filterRepo.listByAccountConfig(accountConfigId);
+		assert.equal(
+			filters.length,
+			0,
+			"the Filter row must not survive when its anchor write fails",
+		);
+	});
+
+	test("the caller never sees a Filter row with hasAnchor: true and no anchor (#351)", async () => {
+		const accountConfigId = randomId();
+
+		await assert.rejects(() =>
+			transaction.createWithAnchor(
+				{
+					accountConfigId,
+					name: "Broken anchor 2",
+					scope: FilterScope.Standing,
+					hasAnchor: true,
+				},
+				{
+					accountConfigId,
+					anchorMessageId: randomId(),
+					anchorEmbedding: [0.1, 0.2, 0.3],
+					anchorEmbeddingId: "amazon.titan-embed-text-v2:0@1024",
+					anchorSourceText: null as unknown as string,
+				},
+			),
+		);
+
+		const filters = await filterRepo.listByAccountConfig(accountConfigId);
+		const orphan = filters.find((f) => f.hasAnchor);
+		assert.equal(
+			orphan,
+			undefined,
+			"no Filter with hasAnchor: true may exist without a FilterAnchor row",
+		);
+	});
+
+	test("get on a never-created filter still throws NotFoundError (sanity)", async () => {
+		await assert.rejects(filterRepo.get(randomId(), randomId()), NotFoundError);
+	});
+});

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

@@ -0,0 +1,45 @@
+import type {
+	CreateFilterAnchorInput,
+	CreateFilterInput,
+	FilterItem,
+	IFilterAnchorTransaction,
+} from "@remit/data-ports";
+import type { Db } from "../db.js";
+import { runInTransaction } from "../tx.js";
+import { FilterRepo } from "./filter.js";
+import { FilterAnchorRepo } from "./filter-anchor.js";
+
+type DB = Db<Record<string, unknown>>;
+
+/**
+ * Runs the `Filter` create and its optional `FilterAnchor` write in one
+ * transaction (#351): a failure on either side rolls back both, so a
+ * `Filter` row can never persist with `hasAnchor: true` and no matching
+ * `FilterAnchor` row, and a `FilterAnchor` write failure surfaces as a
+ * failed create request rather than a silently-broken filter.
+ */
+export class DrizzleFilterAnchorTransaction
+	implements IFilterAnchorTransaction
+{
+	constructor(private db: DB) {}
+
+	createWithAnchor(
+		filterInput: CreateFilterInput,
+		anchorInput: Omit<CreateFilterAnchorInput, "filterId"> | null,
+	): Promise<FilterItem> {
+		return runInTransaction(this.db, async (tx) => {
+			const filterRepo = new FilterRepo(tx as never);
+			const filter = await filterRepo.create(filterInput);
+
+			if (anchorInput) {
+				const filterAnchorRepo = new FilterAnchorRepo(tx as never);
+				await filterAnchorRepo.put({
+					...anchorInput,
+					filterId: filter.filterId,
+				});
+			}
+
+			return filter;
+		});
+	}
+}

package/src/repos/label.ts

@@ -2,12 +2,14 @@ import type {
 	CreateLabelInput,
 	ILabelRepository,
 	LabelItem,
+	ResultList,
 	UpdateLabelInput,
 } from "@remit/data-ports";
-import { and, eq } from "drizzle-orm";
+import { and, asc, eq, gt, or } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { NotFoundError } from "../error.js";
 import { randomId } from "../id.js";
+import { decodeToken, resultList } from "../pagination.js";
 import { labelTable } from "../schema.js";
 
 type DB = NodePgDatabase<Record<string, unknown>>;
@@ -107,6 +109,58 @@ export class LabelRepo implements ILabelRepository {
 		return rows.map(rowToLabel);
 	}
 
+	/**
+	 * A single signed page of an account config's labels (issue #26), mirroring
+	 * `FilterRepo.listPageByAccountConfig`: a `(createdAt, labelId)` keyset
+	 * cursor that round-trips through `continuationToken`.
+	 */
+	async listPageByAccountConfig(
+		accountConfigId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<LabelItem>> {
+		const limit = options?.limit ?? 100;
+		const cursor = options?.continuationToken
+			? decodeToken(options.continuationToken)
+			: undefined;
+		const after = cursor
+			? {
+					createdAt: cursor.createdAt as number,
+					labelId: cursor.labelId as string,
+				}
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(labelTable)
+			.where(
+				and(
+					eq(labelTable.accountConfigId, accountConfigId),
+					after
+						? or(
+								gt(labelTable.createdAt, after.createdAt),
+								and(
+									eq(labelTable.createdAt, after.createdAt),
+									gt(labelTable.labelId, after.labelId),
+								),
+							)
+						: undefined,
+				),
+			)
+			.orderBy(asc(labelTable.createdAt), asc(labelTable.labelId))
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToLabel);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem
+				? { createdAt: lastItem.createdAt, labelId: lastItem.labelId }
+				: undefined,
+		);
+	}
+
 	async findByNormalizedName(
 		accountConfigId: string,
 		normalizedName: string,

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

@@ -107,4 +107,55 @@ describe("MessageLabelRepo", () => {
 		const messageIds = rows.map((r) => r.messageId).sort();
 		assert.deepEqual(messageIds, [messageIdA, messageIdB].sort());
 	});
+
+	test("listByMessageIds batch-fetches across several messages in one call", async () => {
+		const accountConfigId = randomId();
+		const messageIdA = randomId();
+		const messageIdB = randomId();
+		const messageIdC = randomId();
+		const labelId = randomId();
+
+		await repo.apply({ accountConfigId, messageId: messageIdA, labelId });
+		await repo.apply({ accountConfigId, messageId: messageIdB, labelId });
+
+		const rows = await repo.listByMessageIds([
+			messageIdA,
+			messageIdB,
+			messageIdC,
+		]);
+		const messageIds = rows.map((r) => r.messageId).sort();
+		assert.deepEqual(messageIds, [messageIdA, messageIdB].sort());
+	});
+
+	test("listByMessageIds returns nothing for an empty list", async () => {
+		const rows = await repo.listByMessageIds([]);
+		assert.deepEqual(rows, []);
+	});
+
+	test("removeAllByLabelId clears every MessageLabel row for the label, scoped to the account", 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,
+		});
+
+		await repo.removeAllByLabelId(accountConfigId, labelId);
+
+		assert.deepEqual(await repo.listByMessageId(messageIdA), []);
+		assert.deepEqual(await repo.listByMessageId(messageIdB), []);
+		const foreignRows = await repo.listByLabelId(
+			foreignAccountConfigId,
+			labelId,
+		);
+		assert.equal(foreignRows.length, 1);
+	});
 });

package/src/repos/message-label.ts

@@ -3,7 +3,7 @@ import type {
 	IMessageLabelRepository,
 	MessageLabelItem,
 } from "@remit/data-ports";
-import { and, desc, eq } from "drizzle-orm";
+import { and, desc, eq, inArray } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { deterministicBase36Id } from "../id.js";
 import { messageLabelTable } from "../schema.js";
@@ -77,6 +77,15 @@ export class MessageLabelRepo implements IMessageLabelRepository {
 		return rows.map(rowToMessageLabel);
 	}
 
+	async listByMessageIds(messageIds: string[]): Promise<MessageLabelItem[]> {
+		if (messageIds.length === 0) return [];
+		const rows = await this.db
+			.select()
+			.from(messageLabelTable)
+			.where(inArray(messageLabelTable.messageId, messageIds));
+		return rows.map(rowToMessageLabel);
+	}
+
 	async listByLabelId(
 		accountConfigId: string,
 		labelId: string,
@@ -93,4 +102,18 @@ export class MessageLabelRepo implements IMessageLabelRepository {
 			.orderBy(desc(messageLabelTable.createdAt));
 		return rows.map(rowToMessageLabel);
 	}
+
+	async removeAllByLabelId(
+		accountConfigId: string,
+		labelId: string,
+	): Promise<void> {
+		await this.db
+			.delete(messageLabelTable)
+			.where(
+				and(
+					eq(messageLabelTable.accountConfigId, accountConfigId),
+					eq(messageLabelTable.labelId, labelId),
+				),
+			);
+	}
 }