@remit/drizzle-service 0.0.1

package/src/repos/i4-account-export-request.ts

@@ -0,0 +1,141 @@
+import type {
+	AccountExportRequestItem,
+	CreateAccountExportRequestInput,
+	IAccountExportRequestRepository,
+	ResultList,
+	UpdateAccountExportRequestInput,
+} from "@remit/data-ports";
+import { eq } 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 { accountExportRequestTable } from "../schema/i4-account-export-request.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+function rowToItem(
+	row: typeof accountExportRequestTable.$inferSelect,
+): AccountExportRequestItem {
+	return {
+		accountExportRequestId: row.accountExportRequestId,
+		accountConfigId: row.accountConfigId,
+		userId: row.userId,
+		state: row.state as AccountExportRequestItem["state"],
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		expiresAt: row.expiresAt ?? undefined,
+		objectKey: row.objectKey ?? undefined,
+		downloadUrl: row.downloadUrl ?? undefined,
+		errorMessage: row.errorMessage ?? undefined,
+	};
+}
+
+export class AccountExportRequestRepo
+	implements IAccountExportRequestRepository
+{
+	constructor(private db: DB) {}
+
+	async create(
+		input: CreateAccountExportRequestInput,
+	): Promise<AccountExportRequestItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.insert(accountExportRequestTable)
+			.values({
+				accountExportRequestId: randomId(),
+				accountConfigId: input.accountConfigId,
+				userId: input.userId,
+				state: input.state ?? "Pending",
+				expiresAt: input.expiresAt,
+				objectKey: input.objectKey,
+				downloadUrl: input.downloadUrl,
+				errorMessage: input.errorMessage,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		return rowToItem(row);
+	}
+
+	async get(accountExportRequestId: string): Promise<AccountExportRequestItem> {
+		const [row] = await this.db
+			.select()
+			.from(accountExportRequestTable)
+			.where(
+				eq(
+					accountExportRequestTable.accountExportRequestId,
+					accountExportRequestId,
+				),
+			);
+		if (!row)
+			throw new NotFoundError(
+				`AccountExportRequest not found: ${accountExportRequestId}`,
+			);
+		return rowToItem(row);
+	}
+
+	async update(
+		accountExportRequestId: string,
+		input: UpdateAccountExportRequestInput,
+	): Promise<AccountExportRequestItem> {
+		const now = Date.now();
+		const updates: Partial<typeof accountExportRequestTable.$inferInsert> = {
+			updatedAt: now,
+		};
+		if (input.state !== undefined) updates.state = input.state;
+		if (input.expiresAt !== undefined) updates.expiresAt = input.expiresAt;
+		if (input.errorMessage !== undefined)
+			updates.errorMessage = input.errorMessage;
+		if (input.objectKey !== undefined) updates.objectKey = input.objectKey;
+
+		const [row] = await this.db
+			.update(accountExportRequestTable)
+			.set(updates)
+			.where(
+				eq(
+					accountExportRequestTable.accountExportRequestId,
+					accountExportRequestId,
+				),
+			)
+			.returning();
+		if (!row)
+			throw new NotFoundError(
+				`AccountExportRequest not found: ${accountExportRequestId}`,
+			);
+		return rowToItem(row);
+	}
+
+	async listByAccountConfig(
+		accountConfigId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<AccountExportRequestItem>> {
+		const limit = options?.limit ?? 100;
+		let _afterCreatedAt: number | undefined;
+
+		if (options?.continuationToken) {
+			const decoded = decodeToken(options.continuationToken);
+			_afterCreatedAt = decoded?.createdAt as number | undefined;
+		}
+
+		const rows = await this.db
+			.select()
+			.from(accountExportRequestTable)
+			.where(eq(accountExportRequestTable.accountConfigId, accountConfigId))
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToItem);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem
+				? {
+						createdAt: lastItem.createdAt,
+						accountExportRequestId: lastItem.accountExportRequestId,
+					}
+				: undefined,
+		);
+	}
+}

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

@@ -0,0 +1,94 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { AccountSettingRepo } from "./i4-account-setting.js";
+
+describe("AccountSettingRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: AccountSettingRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new AccountSettingRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("upsert and get", async () => {
+		const accountConfigId = randomId();
+		await repo.upsert({
+			accountConfigId,
+			name: "Theme",
+			value: { kind: "String", value: "dark" },
+		});
+
+		const setting = await repo.get(accountConfigId, "Theme");
+		assert.ok(setting);
+		assert.equal(setting.name, "Theme");
+		assert.deepEqual(setting.value, { kind: "String", value: "dark" });
+
+		await repo.delete(accountConfigId, "Theme");
+	});
+
+	test("upsert is idempotent (overwrites)", async () => {
+		const accountConfigId = randomId();
+		await repo.upsert({
+			accountConfigId,
+			name: "Density",
+			value: { kind: "String", value: "compact" },
+		});
+		await repo.upsert({
+			accountConfigId,
+			name: "Density",
+			value: { kind: "String", value: "comfortable" },
+		});
+
+		const setting = await repo.get(accountConfigId, "Density");
+		assert.deepEqual(setting?.value, { kind: "String", value: "comfortable" });
+
+		await repo.delete(accountConfigId, "Density");
+	});
+
+	test("get returns null when setting absent", async () => {
+		const setting = await repo.get(randomId(), "Theme");
+		assert.equal(setting, null);
+	});
+
+	test("listByAccountConfig returns all settings ordered by name", async () => {
+		const accountConfigId = randomId();
+		await repo.upsert({
+			accountConfigId,
+			name: "Theme",
+			value: { kind: "String", value: "dark" },
+		});
+		await repo.upsert({
+			accountConfigId,
+			name: "Density",
+			value: { kind: "String", value: "compact" },
+		});
+
+		const settings = await repo.listByAccountConfig(accountConfigId);
+		assert.equal(settings.length, 2);
+		assert.equal(settings[0].name, "Density");
+		assert.equal(settings[1].name, "Theme");
+
+		await repo.delete(accountConfigId, "Theme");
+		await repo.delete(accountConfigId, "Density");
+	});
+
+	test("delete removes the setting", async () => {
+		const accountConfigId = randomId();
+		await repo.upsert({
+			accountConfigId,
+			name: "Theme",
+			value: { kind: "Boolean", value: true },
+		});
+		await repo.delete(accountConfigId, "Theme");
+
+		const setting = await repo.get(accountConfigId, "Theme");
+		assert.equal(setting, null);
+	});
+});

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

@@ -0,0 +1,92 @@
+import { createHash } from "node:crypto";
+import type {
+	AccountSettingItem,
+	AccountSettingValue,
+	IAccountSettingRepository,
+	UpsertAccountSettingInput,
+} from "@remit/data-ports";
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { accountSettingTable } from "../schema/i4-account-setting.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+// The PG store derives its own deterministic id from the composite key. It is
+// stable within this backend but not byte-identical to the DDB base36 UUIDv5
+// id — the two stores key the same row differently by design.
+function deriveId(accountConfigId: string, name: string): string {
+	return createHash("sha256")
+		.update(`accountSetting:${accountConfigId}:${name}`)
+		.digest("hex");
+}
+
+function rowToAccountSetting(
+	row: typeof accountSettingTable.$inferSelect,
+): AccountSettingItem {
+	return {
+		accountSettingId: row.accountSettingId,
+		accountConfigId: row.accountConfigId,
+		name: row.name,
+		value: row.value as AccountSettingValue,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class AccountSettingRepo implements IAccountSettingRepository {
+	constructor(private db: DB) {}
+
+	async get(
+		accountConfigId: string,
+		name: string,
+	): Promise<AccountSettingItem | null> {
+		const accountSettingId = deriveId(accountConfigId, name);
+		const [row] = await this.db
+			.select()
+			.from(accountSettingTable)
+			.where(eq(accountSettingTable.accountSettingId, accountSettingId));
+		return row ? rowToAccountSetting(row) : null;
+	}
+
+	async listByAccountConfig(
+		accountConfigId: string,
+	): Promise<AccountSettingItem[]> {
+		const rows = await this.db
+			.select()
+			.from(accountSettingTable)
+			.where(eq(accountSettingTable.accountConfigId, accountConfigId))
+			.orderBy(accountSettingTable.name);
+		return rows.map(rowToAccountSetting);
+	}
+
+	async upsert(input: UpsertAccountSettingInput): Promise<AccountSettingItem> {
+		const now = Date.now();
+		const accountSettingId = deriveId(input.accountConfigId, input.name);
+		const [row] = await this.db
+			.insert(accountSettingTable)
+			.values({
+				accountSettingId,
+				accountConfigId: input.accountConfigId,
+				name: input.name,
+				value: input.value as never,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoUpdate({
+				target: accountSettingTable.accountSettingId,
+				set: {
+					value: input.value as never,
+					updatedAt: now,
+				},
+			})
+			.returning();
+		return rowToAccountSetting(row);
+	}
+
+	async delete(accountConfigId: string, name: string): Promise<void> {
+		const accountSettingId = deriveId(accountConfigId, name);
+		await this.db
+			.delete(accountSettingTable)
+			.where(eq(accountSettingTable.accountSettingId, accountSettingId));
+	}
+}

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

@@ -0,0 +1,223 @@
+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 { MailboxRepo } from "./i4-mailbox.js";
+
+function makeAccountInput(accountConfigId: string) {
+	return {
+		accountConfigId,
+		username: "testuser",
+		email: "test@example.com",
+		isActive: true,
+		imapHost: "imap.example.com",
+		imapPort: 993,
+		imapTls: true,
+		imapStartTls: false,
+		connectionState: "not_authenticated" as const,
+	};
+}
+
+describe("AccountRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: AccountRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new AccountRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("create and get", async () => {
+		const accountConfigId = randomId();
+		const account = await repo.create(makeAccountInput(accountConfigId));
+
+		assert.ok(account.accountId, "accountId generated");
+		assert.equal(account.accountConfigId, accountConfigId);
+		assert.equal(account.authType, "password");
+
+		const fetched = await repo.get(account.accountId);
+		assert.equal(fetched.accountId, account.accountId);
+
+		await repo.delete(account.accountId);
+	});
+
+	test("batchGet: WHERE id = ANY($1)", async () => {
+		const accountConfigId = randomId();
+		const a1 = await repo.create(makeAccountInput(accountConfigId));
+		const a2 = await repo.create(makeAccountInput(accountConfigId));
+
+		const results = await repo.get([a1.accountId, a2.accountId]);
+		assert.equal(results.length, 2);
+
+		await repo.deleteMany([a1.accountId, a2.accountId]);
+	});
+
+	test("batchGet with empty array returns []", async () => {
+		const results = await repo.get([]);
+		assert.deepEqual(results, []);
+	});
+
+	test("get throws NotFoundError for missing account", async () => {
+		await assert.rejects(repo.get(randomId()), /not found/i);
+	});
+
+	test("markAuthenticated clears lastError and sets connectionState", async () => {
+		const created = await repo.create({
+			...makeAccountInput(randomId()),
+			lastError: "previous failure",
+		});
+
+		const updated = await repo.markAuthenticated(created.accountId);
+
+		assert.equal(updated.connectionState, "authenticated");
+		assert.equal(updated.lastError, undefined);
+		assert.ok((updated.lastConnectedAt ?? 0) > 0);
+
+		await repo.delete(created.accountId);
+	});
+
+	test("incrementMailboxSynced atomically increments counter", async () => {
+		const account = await repo.create({
+			...makeAccountInput(randomId()),
+			syncPhase: "syncing_others",
+			mailboxCountTotal: 3,
+			mailboxCountSynced: 0,
+		});
+
+		const updated = await repo.incrementMailboxSynced(account.accountId);
+		assert.equal(updated.mailboxCountSynced, 1);
+		assert.equal(updated.syncPhase, "syncing_others");
+
+		await repo.delete(account.accountId);
+	});
+
+	test("incrementMailboxSynced transitions to complete when all done", async () => {
+		const account = await repo.create({
+			...makeAccountInput(randomId()),
+			syncPhase: "syncing_others",
+			mailboxCountTotal: 2,
+			mailboxCountSynced: 1,
+		});
+
+		const updated = await repo.incrementMailboxSynced(account.accountId);
+		assert.equal(updated.mailboxCountSynced, 2);
+		assert.equal(updated.syncPhase, "complete");
+
+		await repo.delete(account.accountId);
+	});
+
+	test("incrementMailboxSynced clamps to total on duplicate completions", async () => {
+		const account = await repo.create({
+			...makeAccountInput(randomId()),
+			syncPhase: "syncing_others",
+			mailboxCountTotal: 2,
+			mailboxCountSynced: 2,
+		});
+
+		const updated = await repo.incrementMailboxSynced(account.accountId);
+		assert.equal(updated.mailboxCountSynced, 2, "should clamp to total");
+		assert.equal(updated.syncPhase, "complete");
+
+		await repo.delete(account.accountId);
+	});
+
+	test("list paginates without dupes, gaps, or non-termination", async () => {
+		const accountConfigId = randomId();
+		const created: string[] = [];
+		for (let i = 0; i < 5; i++) {
+			const account = await repo.create(makeAccountInput(accountConfigId));
+			created.push(account.accountId);
+		}
+
+		const seen: string[] = [];
+		let continuationToken: string | undefined;
+		let pages = 0;
+		do {
+			const page = await repo.list(accountConfigId, {
+				limit: 2,
+				continuationToken,
+			});
+			seen.push(...page.items.map((a) => a.accountId));
+			continuationToken = page.continuationToken;
+			pages++;
+			assert.ok(pages < 10, "pagination must terminate");
+		} while (continuationToken);
+
+		assert.equal(seen.length, 5, "every row returned exactly once");
+		assert.equal(new Set(seen).size, 5, "no duplicates across pages");
+		assert.deepEqual([...seen].sort(), [...created].sort(), "no gaps");
+
+		await repo.deleteMany(created);
+	});
+
+	test("describe assembles account + mailbox collection", async () => {
+		const accountConfigId = randomId();
+		const account = await repo.create(makeAccountInput(accountConfigId));
+
+		const mailboxRepo = new MailboxRepo(db as never);
+		await mailboxRepo.create({
+			accountId: account.accountId,
+			namespaceType: "personal",
+			namespacePrefix: "",
+			hierarchyDelimiter: "/",
+			fullPath: "INBOX",
+			uidValidity: 1,
+			uidNext: 1,
+			highestModseq: 0,
+			messageCount: 0,
+			unseenCount: 0,
+			deletedCount: 0,
+			totalSize: 0,
+			lastSyncUid: 0,
+			highWaterMarkUid: 0,
+			lastMessageSyncAt: Date.now(),
+		});
+
+		const desc = await repo.describe(account.accountId);
+		assert.equal(desc.account.length, 1);
+		assert.equal(desc.mailbox.length, 1);
+		assert.equal(desc.mailbox[0].fullPath, "INBOX");
+
+		await repo.delete(account.accountId);
+	});
+
+	test("listAllAccountsPage paginates without dupes, gaps, or non-termination", async () => {
+		const accountConfigId = randomId();
+		const created: string[] = [];
+		for (let i = 0; i < 5; i++) {
+			const account = await repo.create(makeAccountInput(accountConfigId));
+			created.push(account.accountId);
+		}
+
+		const seen: string[] = [];
+		let cursor: string | undefined;
+		let pages = 0;
+		do {
+			const page = await repo.listAllAccountsPage({ limit: 2, cursor });
+			seen.push(...page.items.map((a) => a.accountId));
+			cursor = page.cursor ?? undefined;
+			pages++;
+			assert.ok(pages < 50, "pagination must terminate");
+		} while (cursor);
+
+		for (const accountId of created) {
+			assert.ok(
+				seen.includes(accountId),
+				`created account ${accountId} must appear in a page`,
+			);
+		}
+		const seenCreated = seen.filter((id) => created.includes(id));
+		assert.equal(
+			new Set(seenCreated).size,
+			seenCreated.length,
+			"no duplicates across pages",
+		);
+
+		await repo.deleteMany(created);
+	});
+});