@remit/drizzle-service 0.0.27 → 0.0.29

package/package.json

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

package/src/repos/filter.test.ts

@@ -119,6 +119,82 @@ describe("FilterRepo", () => {
 		);
 	});
 
+	test("update bumps ruleChangedAt when scope changes (reader #266)", async () => {
+		const accountConfigId = randomId();
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Trip out-of-office",
+			scope: FilterScope.Standing,
+		});
+
+		await new Promise((resolve) => setTimeout(resolve, 1100));
+
+		const expiresAt = "2027-01-01T00:00:00+00:00";
+		const updated = await repo.update(accountConfigId, filter.filterId, {
+			scope: FilterScope.Temporary,
+			expiresAt,
+			ttl: Math.floor(new Date(expiresAt).getTime() / 1000),
+			state: FilterState.Active,
+		});
+
+		assert.equal(updated.scope, FilterScope.Temporary);
+		assert.equal(updated.expiresAt, expiresAt);
+		assert.ok(
+			updated.ruleChangedAt > filter.ruleChangedAt,
+			"a scope edit must move ruleChangedAt forward",
+		);
+	});
+
+	test("update bumps ruleChangedAt when only expiresAt changes (reader #266)", async () => {
+		const accountConfigId = randomId();
+		const initialExpiresAt = "2026-08-01T00:00:00+00:00";
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Until my trip",
+			scope: FilterScope.Temporary,
+			expiresAt: initialExpiresAt,
+			ttl: Math.floor(new Date(initialExpiresAt).getTime() / 1000),
+		});
+
+		await new Promise((resolve) => setTimeout(resolve, 1100));
+
+		const extendedExpiresAt = "2026-09-01T00:00:00+00:00";
+		const updated = await repo.update(accountConfigId, filter.filterId, {
+			expiresAt: extendedExpiresAt,
+			ttl: Math.floor(new Date(extendedExpiresAt).getTime() / 1000),
+		});
+
+		assert.equal(updated.expiresAt, extendedExpiresAt);
+		assert.ok(
+			updated.ruleChangedAt > filter.ruleChangedAt,
+			"an expiresAt edit must move ruleChangedAt forward",
+		);
+	});
+
+	test("update to Standing clears expiresAt and ttl at the storage layer, even if the caller didn't null them (reader #266)", async () => {
+		const accountConfigId = randomId();
+		const expiresAt = "2026-08-01T00:00:00+00:00";
+		const filter = await repo.create({
+			accountConfigId,
+			name: "Until my trip",
+			scope: FilterScope.Temporary,
+			expiresAt,
+			ttl: Math.floor(new Date(expiresAt).getTime() / 1000),
+		});
+
+		const updated = await repo.update(accountConfigId, filter.filterId, {
+			scope: FilterScope.Standing,
+		});
+
+		assert.equal(updated.scope, FilterScope.Standing);
+		assert.equal(updated.expiresAt, undefined);
+		assert.equal(updated.ttl, undefined);
+
+		const reread = await repo.get(accountConfigId, filter.filterId);
+		assert.equal(reread.expiresAt, undefined);
+		assert.equal(reread.ttl, undefined);
+	});
+
 	test("update throws NotFoundError for a missing filter", async () => {
 		await assert.rejects(
 			repo.update(randomId(), randomId(), { name: "x" }),

package/src/repos/filter.ts

@@ -5,7 +5,11 @@ import type {
 	ResultList,
 	UpdateFilterInput,
 } from "@remit/data-ports";
-import { FilterMatchOperator, FilterState } from "@remit/domain-enums";
+import {
+	FilterMatchOperator,
+	FilterScope,
+	FilterState,
+} from "@remit/domain-enums";
 import { and, asc, eq, gt, or } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { NotFoundError } from "../error.js";
@@ -15,22 +19,28 @@ import { filterTable } from "../schema.js";
 
 type DB = NodePgDatabase<Record<string, unknown>>;
 
-const PREDICATE_OR_ACTION_FIELDS = [
+const RULE_ASSERTION_FIELDS = [
 	"hasAnchor",
 	"matchOperator",
 	"literalClauses",
 	"actionLabelId",
 	"actionMailboxId",
+	"scope",
+	"expiresAt",
 ] as const satisfies readonly (keyof UpdateFilterInput)[];
 
 const nowSeconds = (): number => Math.floor(Date.now() / 1000);
 
 /**
- * Whether `input` touches the predicate or the action (RFC 034 Decision
- * 3.2) — a plain rename (`name` only) must not bump `ruleChangedAt`.
+ * Whether `input` touches the predicate, the action, the scope, or the
+ * expiry (RFC 034 Decision 3.2, reader #266) — a plain rename (`name` only)
+ * must not bump `ruleChangedAt`. Scope and expiry count as a rule assertion
+ * alongside the predicate/action: re-asserting how long a filter runs is the
+ * same kind of "the user just told Remit something new" moment, and it is
+ * what lets a lapsed filter's back-application be offered again.
  */
-const changesPredicateOrAction = (input: UpdateFilterInput): boolean =>
-	PREDICATE_OR_ACTION_FIELDS.some((field) => field in input);
+const changesRuleAssertion = (input: UpdateFilterInput): boolean =>
+	RULE_ASSERTION_FIELDS.some((field) => field in input);
 
 function rowToFilter(row: typeof filterTable.$inferSelect): FilterItem {
 	return {
@@ -102,20 +112,38 @@ export class FilterRepo implements IFilterRepository {
 	}
 
 	/**
-	 * `ruleChangedAt` only advances when `input` touches the predicate or the
-	 * action — never on a cosmetic `name` edit (RFC 034 Decision 3.2).
+	 * `ruleChangedAt` only advances when `input` touches the predicate, the
+	 * action, the scope, or the expiry — never on a cosmetic `name` edit (RFC
+	 * 034 Decision 3.2, reader #266).
+	 *
+	 * A patch moving `scope` to `Standing` clears `expiresAt`/`ttl` at the SQL
+	 * layer regardless of what `input` carries for them: the caller (the
+	 * backend handler's `resolveFilterScopeExpiry`) already resolved `input` to
+	 * `undefined` for both, but `undefined` in a `.set()` value means "leave
+	 * column alone," not "clear it" — only an explicit `null` does that. This
+	 * keeps the Filter model's invariant that a `Standing` filter never carries
+	 * `expiresAt`/`ttl` (RFC 034 Decision 1.4) true at the storage layer itself,
+	 * not just by caller convention.
 	 */
 	async update(
 		accountConfigId: string,
 		filterId: string,
 		input: UpdateFilterInput,
 	): Promise<FilterItem> {
-		const patch = changesPredicateOrAction(input)
+		const patch = changesRuleAssertion(input)
 			? { ...input, ruleChangedAt: nowSeconds() }
 			: input;
+		const updates: Partial<typeof filterTable.$inferInsert> = {
+			...patch,
+			updatedAt: Date.now(),
+		};
+		if (patch.scope === FilterScope.Standing) {
+			updates.expiresAt = null;
+			updates.ttl = null;
+		}
 		const [row] = await this.db
 			.update(filterTable)
-			.set({ ...patch, updatedAt: Date.now() })
+			.set(updates)
 			.where(
 				and(
 					eq(filterTable.accountConfigId, accountConfigId),

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),
+				),
+			);
+	}
 }