@remit/drizzle-service 0.0.26 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "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/i4-mailbox.sqlite.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { after, before, describe, test } from "node:test";
+import { MailboxSyncStatus } from "@remit/domain-enums";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { mailboxTable } from "../schema.js";
@@ -66,6 +67,33 @@ describe("MailboxRepo (sqlite)", () => {
 		const reread = await repo.get(accountId, created.mailboxId);
 		assert.equal(reread.highestModseq, "9007199254740993");
 	});
+
+	test("renameChildPaths marks each child pending along with its new path (#290)", async () => {
+		// A renamed parent is set pending by the caller; its children's new paths
+		// are equally absent from the server until MAILBOX_RENAME lands, so they
+		// must be pending too — otherwise a reconcile in that window reaps the
+		// child as server-deleted.
+		const accountId = randomUUID();
+		const parent = await repo.create({
+			...makeMailboxInput(accountId, "Work"),
+			syncStatus: MailboxSyncStatus.pending,
+		});
+		const child = await repo.create({
+			...makeMailboxInput(accountId, "Work/sub"),
+			syncStatus: MailboxSyncStatus.synced,
+		});
+
+		await repo.renameChildPaths(accountId, "Work", "Projects", "/");
+
+		const renamedChild = await repo.get(accountId, child.mailboxId);
+		assert.equal(renamedChild.fullPath, "Projects/sub");
+		assert.equal(renamedChild.syncStatus, MailboxSyncStatus.pending);
+
+		// The parent row is untouched by this call (its own path/status is the
+		// caller's job).
+		const parentRow = await repo.get(accountId, parent.mailboxId);
+		assert.equal(parentRow.fullPath, "Work");
+	});
 });
 
 /**

package/src/repos/i4-mailbox.ts

@@ -6,7 +6,7 @@ import type {
 	ResultList,
 	UpdateMailboxInput,
 } from "@remit/data-ports";
-import { MailboxCursorState } from "@remit/domain-enums";
+import { MailboxCursorState, MailboxSyncStatus } from "@remit/domain-enums";
 import { and, asc, eq, gt, inArray, or } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import shortUuid from "short-uuid";
@@ -341,7 +341,13 @@ export class MailboxRepo implements IMailboxRepository {
 		const children = await this.findByPathPrefix(accountId, oldPath, delimiter);
 		for (const child of children) {
 			const newChildPath = child.fullPath.replace(oldPath, newPath);
-			await this.update(accountId, child.mailboxId, { fullPath: newChildPath });
+			// Mark the child pending, like the renamed parent: its new path is not
+			// on the server until MAILBOX_RENAME lands, so a reconcile running in
+			// that window must not reap it as server-deleted (#290).
+			await this.update(accountId, child.mailboxId, {
+				fullPath: newChildPath,
+				syncStatus: MailboxSyncStatus.pending,
+			});
 		}
 	}
 }