@remit/drizzle-service 0.0.32 → 0.0.33

package/package.json

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

package/src/repos/filter.test.ts

@@ -36,6 +36,10 @@ describe("FilterRepo", () => {
 			filter.ruleChangedAt > 0,
 			"ruleChangedAt should be set on create",
 		);
+		assert.ok(
+			filter.actionChangedAt > 0,
+			"actionChangedAt should be set on create",
+		);
 		assert.equal(filter.expiresAt, undefined);
 		assert.equal(filter.ttl, undefined);
 	});
@@ -97,9 +101,14 @@ describe("FilterRepo", () => {
 			filter.ruleChangedAt,
 			"a name-only edit must not move ruleChangedAt (RFC 034 Decision 3.2)",
 		);
+		assert.equal(
+			renamed.actionChangedAt,
+			filter.actionChangedAt,
+			"a name-only edit must not move actionChangedAt either",
+		);
 	});
 
-	test("update bumps ruleChangedAt when the action changes", async () => {
+	test("update bumps both ruleChangedAt and actionChangedAt when the action changes", async () => {
 		const accountConfigId = randomId();
 		const filter = await repo.create({
 			accountConfigId,
@@ -117,9 +126,13 @@ describe("FilterRepo", () => {
 			updated.ruleChangedAt > filter.ruleChangedAt,
 			"an action edit must move ruleChangedAt forward",
 		);
+		assert.ok(
+			updated.actionChangedAt > filter.actionChangedAt,
+			"an action edit must move actionChangedAt forward too — it is what a matching message's exclusive move goes by",
+		);
 	});
 
-	test("update bumps ruleChangedAt when scope changes (reader #266)", async () => {
+	test("update bumps ruleChangedAt but NOT actionChangedAt when scope changes (reader #266, #384)", async () => {
 		const accountConfigId = randomId();
 		const filter = await repo.create({
 			accountConfigId,
@@ -141,11 +154,16 @@ describe("FilterRepo", () => {
 		assert.equal(updated.expiresAt, expiresAt);
 		assert.ok(
 			updated.ruleChangedAt > filter.ruleChangedAt,
-			"a scope edit must move ruleChangedAt forward",
+			"a scope edit must move ruleChangedAt forward, so a lapsed filter's back-application can be offered again",
+		);
+		assert.equal(
+			updated.actionChangedAt,
+			filter.actionChangedAt,
+			"a scope edit changes the filter's lifecycle, not what it matches or does — it must not move actionChangedAt, or it would wrongly promote the filter to move-winner",
 		);
 	});
 
-	test("update bumps ruleChangedAt when only expiresAt changes (reader #266)", async () => {
+	test("update bumps ruleChangedAt but NOT actionChangedAt when only expiresAt changes (reader #266, #384)", async () => {
 		const accountConfigId = randomId();
 		const initialExpiresAt = "2026-08-01T00:00:00+00:00";
 		const filter = await repo.create({
@@ -169,6 +187,11 @@ describe("FilterRepo", () => {
 			updated.ruleChangedAt > filter.ruleChangedAt,
 			"an expiresAt edit must move ruleChangedAt forward",
 		);
+		assert.equal(
+			updated.actionChangedAt,
+			filter.actionChangedAt,
+			"extending a filter's expiry alone must not promote it to move-winner (reader #384) — actionChangedAt must not move",
+		);
 	});
 
 	test("update to Standing clears expiresAt and ttl at the storage layer, even if the caller didn't null them (reader #266)", async () => {

package/src/repos/filter.ts

@@ -29,6 +29,20 @@ const RULE_ASSERTION_FIELDS = [
 	"expiresAt",
 ] as const satisfies readonly (keyof UpdateFilterInput)[];
 
+/**
+ * The subset of {@link RULE_ASSERTION_FIELDS} that changes what a filter
+ * matches or what it does — excluding `scope`/`expiresAt`, which only change
+ * how long the filter runs. Backs `actionChangedAt` (reader #384), the
+ * narrower signal `selectMoveWinner` reads for exclusive-move precedence.
+ */
+const ACTION_ASSERTION_FIELDS = [
+	"hasAnchor",
+	"matchOperator",
+	"literalClauses",
+	"actionLabelId",
+	"actionMailboxId",
+] as const satisfies readonly (keyof UpdateFilterInput)[];
+
 const nowSeconds = (): number => Math.floor(Date.now() / 1000);
 
 /**
@@ -38,10 +52,24 @@ const nowSeconds = (): number => Math.floor(Date.now() / 1000);
  * 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.
+ *
+ * This is deliberately broader than {@link changesActionAssertion} — it backs
+ * `ruleChangedAt`, the settings UI's back-apply-offer signal, not exclusive-
+ * move precedence (reader #384).
  */
 const changesRuleAssertion = (input: UpdateFilterInput): boolean =>
 	RULE_ASSERTION_FIELDS.some((field) => field in input);
 
+/**
+ * Whether `input` touches the predicate or the action — never `scope` or
+ * `expiresAt` (reader #384). Backs `actionChangedAt`, which `selectMoveWinner`
+ * reads to decide an exclusive-move conflict: extending a filter's expiry or
+ * flipping Standing/Temporary changes its lifecycle, not where a matching
+ * message goes, so it must not promote the filter to move-winner.
+ */
+const changesActionAssertion = (input: UpdateFilterInput): boolean =>
+	ACTION_ASSERTION_FIELDS.some((field) => field in input);
+
 function rowToFilter(row: typeof filterTable.$inferSelect): FilterItem {
 	return {
 		filterId: row.filterId,
@@ -53,6 +81,7 @@ function rowToFilter(row: typeof filterTable.$inferSelect): FilterItem {
 		state: row.state,
 		hasAnchor: row.hasAnchor,
 		ruleChangedAt: row.ruleChangedAt,
+		actionChangedAt: row.actionChangedAt,
 		matchOperator: row.matchOperator,
 		literalClauses: row.literalClauses as FilterItem["literalClauses"],
 		actionLabelId: row.actionLabelId,
@@ -66,12 +95,13 @@ export class FilterRepo implements IFilterRepository {
 	constructor(private db: DB) {}
 
 	/**
-	 * `ruleChangedAt` is set to the same instant as creation: a new filter's
-	 * predicate/action is, by definition, freshly asserted (RFC 034 Decision
-	 * 3.2).
+	 * `ruleChangedAt` and `actionChangedAt` are both set to the same instant as
+	 * creation: a new filter's predicate/action (and its scope/expiry) are, by
+	 * definition, freshly asserted (RFC 034 Decision 3.2).
 	 */
 	async create(input: CreateFilterInput): Promise<FilterItem> {
 		const now = Date.now();
+		const createdRuleChangedAt = nowSeconds();
 		const [row] = await this.db
 			.insert(filterTable)
 			.values({
@@ -83,7 +113,8 @@ export class FilterRepo implements IFilterRepository {
 				ttl: input.ttl ?? null,
 				state: input.state ?? FilterState.Active,
 				hasAnchor: input.hasAnchor ?? false,
-				ruleChangedAt: nowSeconds(),
+				ruleChangedAt: createdRuleChangedAt,
+				actionChangedAt: createdRuleChangedAt,
 				matchOperator: input.matchOperator ?? FilterMatchOperator.And,
 				literalClauses: input.literalClauses ?? [],
 				actionLabelId: input.actionLabelId ?? "None",
@@ -112,9 +143,13 @@ export class FilterRepo implements IFilterRepository {
 	}
 
 	/**
-	 * `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).
+	 * `ruleChangedAt` 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). `actionChangedAt` advances only for the
+	 * narrower predicate/action subset (reader #384): a scope/expiresAt-only
+	 * edit bumps `ruleChangedAt` (so a lapsed filter's back-application can be
+	 * offered again) without touching `actionChangedAt`, so it cannot flip
+	 * `selectMoveWinner`'s exclusive-move precedence.
 	 *
 	 * A patch moving `scope` to `Standing` clears `expiresAt`/`ttl` at the SQL
 	 * layer regardless of what `input` carries for them: the caller (the
@@ -130,9 +165,12 @@ export class FilterRepo implements IFilterRepository {
 		filterId: string,
 		input: UpdateFilterInput,
 	): Promise<FilterItem> {
-		const patch = changesRuleAssertion(input)
-			? { ...input, ruleChangedAt: nowSeconds() }
-			: input;
+		const changedAt = nowSeconds();
+		const patch = {
+			...input,
+			...(changesRuleAssertion(input) ? { ruleChangedAt: changedAt } : {}),
+			...(changesActionAssertion(input) ? { actionChangedAt: changedAt } : {}),
+		};
 		const updates: Partial<typeof filterTable.$inferInsert> = {
 			...patch,
 			updatedAt: Date.now(),