@remit/drizzle-service 0.0.1

package/src/repos/filter.ts

@@ -0,0 +1,253 @@
+import type {
+	CreateFilterInput,
+	FilterItem,
+	IFilterRepository,
+	ResultList,
+	UpdateFilterInput,
+} from "@remit/data-ports";
+import { FilterMatchOperator, 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";
+import { randomId } from "../id.js";
+import { decodeToken, resultList } from "../pagination.js";
+import { filterTable } from "../schema.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+const PREDICATE_OR_ACTION_FIELDS = [
+	"hasAnchor",
+	"matchOperator",
+	"literalClauses",
+	"actionLabelId",
+	"actionMailboxId",
+] 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`.
+ */
+const changesPredicateOrAction = (input: UpdateFilterInput): boolean =>
+	PREDICATE_OR_ACTION_FIELDS.some((field) => field in input);
+
+function rowToFilter(row: typeof filterTable.$inferSelect): FilterItem {
+	return {
+		filterId: row.filterId,
+		accountConfigId: row.accountConfigId,
+		name: row.name,
+		scope: row.scope,
+		expiresAt: row.expiresAt ?? undefined,
+		ttl: row.ttl ?? undefined,
+		state: row.state,
+		hasAnchor: row.hasAnchor,
+		ruleChangedAt: row.ruleChangedAt,
+		matchOperator: row.matchOperator,
+		literalClauses: row.literalClauses as FilterItem["literalClauses"],
+		actionLabelId: row.actionLabelId,
+		actionMailboxId: row.actionMailboxId,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+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).
+	 */
+	async create(input: CreateFilterInput): Promise<FilterItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.insert(filterTable)
+			.values({
+				filterId: randomId(),
+				accountConfigId: input.accountConfigId,
+				name: input.name,
+				scope: input.scope,
+				expiresAt: input.expiresAt ?? null,
+				ttl: input.ttl ?? null,
+				state: input.state ?? FilterState.Active,
+				hasAnchor: input.hasAnchor ?? false,
+				ruleChangedAt: nowSeconds(),
+				matchOperator: input.matchOperator ?? FilterMatchOperator.And,
+				literalClauses: input.literalClauses ?? [],
+				actionLabelId: input.actionLabelId ?? "None",
+				actionMailboxId: input.actionMailboxId ?? "None",
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		return rowToFilter(row);
+	}
+
+	async get(accountConfigId: string, filterId: string): Promise<FilterItem> {
+		const [row] = await this.db
+			.select()
+			.from(filterTable)
+			.where(
+				and(
+					eq(filterTable.accountConfigId, accountConfigId),
+					eq(filterTable.filterId, filterId),
+				),
+			);
+		if (!row) {
+			throw new NotFoundError(`Filter not found: ${filterId}`);
+		}
+		return rowToFilter(row);
+	}
+
+	/**
+	 * `ruleChangedAt` only advances when `input` touches the predicate or the
+	 * action — never on a cosmetic `name` edit (RFC 034 Decision 3.2).
+	 */
+	async update(
+		accountConfigId: string,
+		filterId: string,
+		input: UpdateFilterInput,
+	): Promise<FilterItem> {
+		const patch = changesPredicateOrAction(input)
+			? { ...input, ruleChangedAt: nowSeconds() }
+			: input;
+		const [row] = await this.db
+			.update(filterTable)
+			.set({ ...patch, updatedAt: Date.now() })
+			.where(
+				and(
+					eq(filterTable.accountConfigId, accountConfigId),
+					eq(filterTable.filterId, filterId),
+				),
+			)
+			.returning();
+		if (!row) {
+			throw new NotFoundError(`Filter not found: ${filterId}`);
+		}
+		return rowToFilter(row);
+	}
+
+	async delete(accountConfigId: string, filterId: string): Promise<void> {
+		await this.db
+			.delete(filterTable)
+			.where(
+				and(
+					eq(filterTable.accountConfigId, accountConfigId),
+					eq(filterTable.filterId, filterId),
+				),
+			);
+	}
+
+	async listByAccountConfig(accountConfigId: string): Promise<FilterItem[]> {
+		const rows = await this.db
+			.select()
+			.from(filterTable)
+			.where(eq(filterTable.accountConfigId, accountConfigId));
+		return rows.map(rowToFilter);
+	}
+
+	/**
+	 * A single signed page of an account config's filters (RFC 034), mirroring
+	 * `MailboxRepo.listByAccount`: a `(createdAt, filterId)` keyset cursor that
+	 * round-trips through `continuationToken`.
+	 */
+	async listPageByAccountConfig(
+		accountConfigId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<FilterItem>> {
+		const limit = options?.limit ?? 100;
+		const cursor = options?.continuationToken
+			? decodeToken(options.continuationToken)
+			: undefined;
+		const after = cursor
+			? {
+					createdAt: cursor.createdAt as number,
+					filterId: cursor.filterId as string,
+				}
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(filterTable)
+			.where(
+				and(
+					eq(filterTable.accountConfigId, accountConfigId),
+					after
+						? or(
+								gt(filterTable.createdAt, after.createdAt),
+								and(
+									eq(filterTable.createdAt, after.createdAt),
+									gt(filterTable.filterId, after.filterId),
+								),
+							)
+						: undefined,
+				),
+			)
+			.orderBy(asc(filterTable.createdAt), asc(filterTable.filterId))
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToFilter);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem
+				? { createdAt: lastItem.createdAt, filterId: lastItem.filterId }
+				: undefined,
+		);
+	}
+
+	/**
+	 * Lists filters via `byAccountAndState` (RFC 034 Decision 1.2) — the
+	 * index-time worker's "what do I evaluate for this account" query.
+	 */
+	async listByAccountAndState(
+		accountConfigId: string,
+		state: FilterItem["state"],
+	): Promise<FilterItem[]> {
+		const rows = await this.db
+			.select()
+			.from(filterTable)
+			.where(
+				and(
+					eq(filterTable.accountConfigId, accountConfigId),
+					eq(filterTable.state, state),
+				),
+			);
+		return rows.map(rowToFilter);
+	}
+
+	/**
+	 * Patches a Temporary filter's `state` to `Expired` when read past its
+	 * `expiresAt` (RFC 034 Decision 1.2). `expiresAt`/`now` are compared
+	 * directly — `state` is only ever a lazily-refreshed cache of that
+	 * comparison. A no-op for a Standing filter (no `expiresAt`) or one already
+	 * Expired.
+	 *
+	 * Postgres has no TTL reaper, so an Expired Temporary row is never deleted by
+	 * a background sweep the way DynamoDB reaps it via the `ttl` attribute. That
+	 * is correct by design: RFC 034 Decision 1.1 makes match-time correctness
+	 * depend on the `expiresAt`/`now` comparison, never on the row's existence —
+	 * the reaper is housekeeping, not a correctness mechanism.
+	 */
+	async refreshExpiry(item: FilterItem): Promise<FilterItem> {
+		if (item.scope !== "Temporary" || !item.expiresAt) return item;
+		if (item.state === FilterState.Expired) return item;
+		if (new Date(item.expiresAt).getTime() > Date.now()) return item;
+
+		const [row] = await this.db
+			.update(filterTable)
+			.set({ state: FilterState.Expired, updatedAt: Date.now() })
+			.where(
+				and(
+					eq(filterTable.accountConfigId, item.accountConfigId),
+					eq(filterTable.filterId, item.filterId),
+				),
+			)
+			.returning();
+		return row ? rowToFilter(row) : item;
+	}
+}

package/src/repos/i4-account-config.test.ts

@@ -0,0 +1,105 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { AccountRepo } from "./i4-account.js";
+import { AccountConfigRepo } from "./i4-account-config.js";
+import { AddressRepo } from "./i4-address.js";
+
+describe("AccountConfigRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: AccountConfigRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new AccountConfigRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("create and get", async () => {
+		const userId = randomId();
+		const cfg = await repo.create({ userId, name: "My Config" });
+
+		assert.ok(cfg.accountConfigId);
+		assert.equal(cfg.userId, userId);
+		assert.equal(cfg.name, "My Config");
+		assert.equal(cfg.state, "active");
+
+		const fetched = await repo.get(cfg.accountConfigId);
+		assert.equal(fetched.accountConfigId, cfg.accountConfigId);
+
+		await repo.delete(cfg.accountConfigId);
+	});
+
+	test("batchGet: WHERE id = ANY($1)", async () => {
+		const userId = randomId();
+		const c1 = await repo.create({ userId });
+		const c2 = await repo.create({ userId });
+
+		const results = await repo.get([c1.accountConfigId, c2.accountConfigId]);
+		assert.equal(results.length, 2);
+
+		await repo.deleteMany([c1.accountConfigId, c2.accountConfigId]);
+	});
+
+	test("batchGet empty array returns []", async () => {
+		const results = await repo.get([]);
+		assert.deepEqual(results, []);
+	});
+
+	test("get throws for missing config", async () => {
+		await assert.rejects(repo.get(randomId()), /not found/i);
+	});
+
+	test("describe assembles collection (accountConfig + account + address)", async () => {
+		const userId = randomId();
+		const cfg = await repo.create({ userId });
+
+		const accountRepo = new AccountRepo(db as never);
+		const addrRepo = new AddressRepo(db as never);
+
+		await accountRepo.create({
+			accountConfigId: cfg.accountConfigId,
+			username: "u",
+			email: "u@test.com",
+			isActive: true,
+			imapHost: "imap.test.com",
+			imapPort: 993,
+			imapTls: true,
+			imapStartTls: false,
+			connectionState: "not_authenticated",
+		});
+
+		await addrRepo.createAddress({
+			addressId: randomId(),
+			accountConfigId: cfg.accountConfigId,
+			localPart: "u",
+			domain: "test.com",
+			normalizedEmail: "u@test.com",
+			normalizedCompound: "u@test.com:u",
+		});
+
+		const desc = await repo.describe(cfg.accountConfigId);
+		assert.equal(desc.accountConfig.length, 1);
+		assert.equal(desc.account.length, 1);
+		assert.equal(desc.address.length, 1);
+
+		await repo.delete(cfg.accountConfigId);
+	});
+
+	test("listAll returns all configs", async () => {
+		const userId = randomId();
+		const c1 = await repo.create({ userId });
+		const c2 = await repo.create({ userId });
+
+		const all = await repo.listAll();
+		const ids = new Set(all.map((c) => c.accountConfigId));
+		assert.ok(ids.has(c1.accountConfigId));
+		assert.ok(ids.has(c2.accountConfigId));
+
+		await repo.deleteMany([c1.accountConfigId, c2.accountConfigId]);
+	});
+});

package/src/repos/i4-account-config.ts

@@ -0,0 +1,257 @@
+import type {
+	AccountConfigDescription,
+	AccountConfigItem,
+	AccountItem,
+	AddressItem,
+	CreateAccountConfigInput,
+	IAccountConfigRepository,
+	ResultList,
+	UpdateAccountConfigInput,
+} from "@remit/data-ports";
+import { and, asc, eq, gt, inArray, 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 {
+	accountConfigTable,
+	accountTable,
+} from "../schema/i4-account-config.js";
+import { addressTable } from "../schema/i4-address.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+function rowToAccountConfig(
+	row: typeof accountConfigTable.$inferSelect,
+): AccountConfigItem {
+	return {
+		accountConfigId: row.accountConfigId,
+		userId: row.userId,
+		name: row.name ?? undefined,
+		state: row.state as AccountConfigItem["state"],
+		deletedAt: row.deletedAt ?? undefined,
+		cascadeStartedAt: row.cascadeStartedAt ?? undefined,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+function rowToAccount(row: typeof accountTable.$inferSelect): AccountItem {
+	return {
+		accountId: row.accountId,
+		accountConfigId: row.accountConfigId,
+		username: row.username,
+		email: row.email,
+		authType: row.authType as AccountItem["authType"],
+		passwordHash: row.passwordHash ?? undefined,
+		oauthRefreshTokenHash: row.oauthRefreshTokenHash ?? undefined,
+		oauthTokenUpdatedAt: row.oauthTokenUpdatedAt ?? undefined,
+		imapHost: row.imapHost,
+		imapPort: row.imapPort,
+		imapTls: row.imapTls,
+		imapStartTls: row.imapStartTls,
+		smtpEnabled: row.smtpEnabled,
+		smtpHost: row.smtpHost,
+		smtpPort: row.smtpPort,
+		smtpTls: row.smtpTls,
+		smtpStartTls: row.smtpStartTls,
+		smtpUsername: row.smtpUsername,
+		smtpPasswordHash: row.smtpPasswordHash ?? undefined,
+		isActive: row.isActive,
+		connectionState: row.connectionState as AccountItem["connectionState"],
+		lastConnectedAt: row.lastConnectedAt ?? undefined,
+		lastSyncAt: row.lastSyncAt ?? undefined,
+		lastError: row.lastError ?? undefined,
+		syncPhase: (row.syncPhase as AccountItem["syncPhase"]) ?? undefined,
+		mailboxCountTotal: row.mailboxCountTotal ?? undefined,
+		mailboxCountSynced: row.mailboxCountSynced ?? undefined,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		deletedAt: row.deletedAt ?? undefined,
+	};
+}
+
+function rowToAddress(row: typeof addressTable.$inferSelect): AddressItem {
+	return {
+		addressId: row.addressId,
+		accountConfigId: row.accountConfigId,
+		displayName: row.displayName ?? undefined,
+		localPart: row.localPart,
+		domain: row.domain,
+		normalizedEmail: row.normalizedEmail,
+		normalizedCompound: row.normalizedCompound,
+		flags: (row.flags ?? {}) as AddressItem["flags"],
+		inboundCount: row.inboundCount,
+		outboundCount: row.outboundCount,
+		replyCount: row.replyCount,
+		lastInboundAt: row.lastInboundAt,
+		lastOutboundAt: row.lastOutboundAt ?? undefined,
+		lastReplyAt: row.lastReplyAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class AccountConfigRepo implements IAccountConfigRepository {
+	constructor(private db: DB) {}
+
+	async create(input: CreateAccountConfigInput): Promise<AccountConfigItem> {
+		const now = Date.now();
+		const accountConfigId = input.accountConfigId ?? randomId();
+		const [row] = await this.db
+			.insert(accountConfigTable)
+			.values({
+				accountConfigId,
+				userId: input.userId,
+				name: input.name,
+				state: input.state ?? "active",
+				deletedAt: input.deletedAt,
+				cascadeStartedAt: input.cascadeStartedAt,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		return rowToAccountConfig(row);
+	}
+
+	async get(accountConfigId: string): Promise<AccountConfigItem>;
+	async get(accountConfigIds: string[]): Promise<AccountConfigItem[]>;
+	async get(
+		accountConfigId: string | string[],
+	): Promise<AccountConfigItem | AccountConfigItem[]> {
+		if (Array.isArray(accountConfigId)) {
+			if (accountConfigId.length === 0) return [];
+			const rows = await this.db
+				.select()
+				.from(accountConfigTable)
+				.where(inArray(accountConfigTable.accountConfigId, accountConfigId));
+			return rows.map(rowToAccountConfig);
+		}
+		const [row] = await this.db
+			.select()
+			.from(accountConfigTable)
+			.where(eq(accountConfigTable.accountConfigId, accountConfigId));
+		if (!row)
+			throw new NotFoundError(`AccountConfig not found: ${accountConfigId}`);
+		return rowToAccountConfig(row);
+	}
+
+	async update(
+		accountConfigId: string,
+		input: UpdateAccountConfigInput,
+	): Promise<AccountConfigItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.update(accountConfigTable)
+			.set({
+				...(input.name !== undefined && { name: input.name }),
+				...(input.state !== undefined && { state: input.state }),
+				...(input.deletedAt !== undefined && { deletedAt: input.deletedAt }),
+				...(input.cascadeStartedAt !== undefined && {
+					cascadeStartedAt: input.cascadeStartedAt,
+				}),
+				updatedAt: now,
+			})
+			.where(eq(accountConfigTable.accountConfigId, accountConfigId))
+			.returning();
+		if (!row)
+			throw new NotFoundError(`AccountConfig not found: ${accountConfigId}`);
+		return rowToAccountConfig(row);
+	}
+
+	async delete(accountConfigId: string): Promise<void> {
+		await this.db
+			.delete(accountConfigTable)
+			.where(eq(accountConfigTable.accountConfigId, accountConfigId));
+	}
+
+	async deleteMany(accountConfigIds: string[]): Promise<void> {
+		if (accountConfigIds.length === 0) return;
+		await this.db
+			.delete(accountConfigTable)
+			.where(inArray(accountConfigTable.accountConfigId, accountConfigIds));
+	}
+
+	async listByUser(
+		userId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<AccountConfigItem>> {
+		const limit = options?.limit ?? 100;
+		const cursor = options?.continuationToken
+			? decodeToken(options.continuationToken)
+			: undefined;
+		const after = cursor
+			? {
+					createdAt: cursor.createdAt as number,
+					accountConfigId: cursor.accountConfigId as string,
+				}
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(accountConfigTable)
+			.where(
+				and(
+					eq(accountConfigTable.userId, userId),
+					after
+						? or(
+								gt(accountConfigTable.createdAt, after.createdAt),
+								and(
+									eq(accountConfigTable.createdAt, after.createdAt),
+									gt(accountConfigTable.accountConfigId, after.accountConfigId),
+								),
+							)
+						: undefined,
+				),
+			)
+			.orderBy(
+				asc(accountConfigTable.createdAt),
+				asc(accountConfigTable.accountConfigId),
+			)
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToAccountConfig);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem
+				? {
+						createdAt: lastItem.createdAt,
+						accountConfigId: lastItem.accountConfigId,
+					}
+				: undefined,
+		);
+	}
+
+	async describe(accountConfigId: string): Promise<AccountConfigDescription> {
+		const [configs, accounts, addresses] = await Promise.all([
+			this.db
+				.select()
+				.from(accountConfigTable)
+				.where(eq(accountConfigTable.accountConfigId, accountConfigId)),
+			this.db
+				.select()
+				.from(accountTable)
+				.where(eq(accountTable.accountConfigId, accountConfigId)),
+			this.db
+				.select()
+				.from(addressTable)
+				.where(eq(addressTable.accountConfigId, accountConfigId)),
+		]);
+		if (configs.length === 0) {
+			throw new NotFoundError(`AccountConfig not found: ${accountConfigId}`);
+		}
+		return {
+			accountConfig: configs.map(rowToAccountConfig),
+			account: accounts.map(rowToAccount),
+			address: addresses.map(rowToAddress),
+		};
+	}
+
+	async listAll(): Promise<AccountConfigItem[]> {
+		const rows = await this.db.select().from(accountConfigTable);
+		return rows.map(rowToAccountConfig);
+	}
+}