@remit/drizzle-service 0.0.1

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

@@ -0,0 +1,188 @@
+import assert from "node:assert";
+import { after, before, describe, test } from "node:test";
+import { createTestDb, randomId, type TestDb } from "../test-db.js";
+import { MailboxRepo } from "./i4-mailbox.js";
+
+function makeMailboxInput(accountId: string, fullPath = "INBOX") {
+	return {
+		accountId,
+		namespaceType: "personal" as const,
+		namespacePrefix: "",
+		hierarchyDelimiter: "/",
+		fullPath,
+		uidValidity: 1,
+		uidNext: 1,
+		highestModseq: 0,
+		messageCount: 0,
+		unseenCount: 5,
+		deletedCount: 0,
+		totalSize: 0,
+		lastSyncUid: 0,
+		highWaterMarkUid: 0,
+		lastMessageSyncAt: Date.now(),
+	};
+}
+
+describe("MailboxRepo", () => {
+	let db: TestDb;
+	let close: () => Promise<void>;
+	let repo: MailboxRepo;
+
+	before(async () => {
+		({ db, close } = await createTestDb());
+		repo = new MailboxRepo(db as never);
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("create and get", async () => {
+		const accountId = randomId();
+		const mailbox = await repo.create(makeMailboxInput(accountId));
+		assert.ok(mailbox.mailboxId);
+		assert.equal(mailbox.fullPath, "INBOX");
+
+		const fetched = await repo.get(accountId, mailbox.mailboxId);
+		assert.equal(fetched.mailboxId, mailbox.mailboxId);
+
+		await repo.delete(accountId, mailbox.mailboxId);
+	});
+
+	test("batchGet: WHERE id = ANY($1)", async () => {
+		const accountId = randomId();
+		const m1 = await repo.create(makeMailboxInput(accountId, "INBOX"));
+		const m2 = await repo.create(makeMailboxInput(accountId, "Sent"));
+
+		const results = await repo.get(accountId, [m1.mailboxId, m2.mailboxId]);
+		assert.equal(results.length, 2);
+
+		await repo.deleteMany(accountId, [m1.mailboxId, m2.mailboxId]);
+	});
+
+	test("batchGet empty array returns []", async () => {
+		const results = await repo.get(randomId(), []);
+		assert.deepEqual(results, []);
+	});
+
+	test("findByPath finds existing mailbox", async () => {
+		const accountId = randomId();
+		await repo.create(makeMailboxInput(accountId, "Work/Projects"));
+
+		const found = await repo.findByPath(accountId, "Work/Projects");
+		assert.ok(found);
+		assert.equal(found.fullPath, "Work/Projects");
+	});
+
+	test("findByPath returns null when not found", async () => {
+		const result = await repo.findByPath(randomId(), "INBOX");
+		assert.equal(result, null);
+	});
+
+	test("getOrCreateByPath creates when missing", async () => {
+		const accountId = randomId();
+		const mailbox = await repo.getOrCreateByPath(
+			accountId,
+			"Drafts",
+			makeMailboxInput(accountId, "Drafts"),
+		);
+		assert.equal(mailbox.fullPath, "Drafts");
+
+		const again = await repo.getOrCreateByPath(
+			accountId,
+			"Drafts",
+			makeMailboxInput(accountId, "Drafts"),
+		);
+		assert.equal(again.mailboxId, mailbox.mailboxId, "idempotent");
+	});
+
+	test("findByPathPrefix finds children", async () => {
+		const accountId = randomId();
+		await repo.create(makeMailboxInput(accountId, "Work"));
+		await repo.create(makeMailboxInput(accountId, "Work/Projects"));
+		await repo.create(makeMailboxInput(accountId, "Work/Projects/Alpha"));
+
+		const children = await repo.findByPathPrefix(accountId, "Work");
+		assert.ok(children.some((m) => m.fullPath === "Work/Projects"));
+		assert.ok(children.some((m) => m.fullPath === "Work/Projects/Alpha"));
+		assert.equal(
+			children.find((m) => m.fullPath === "Work"),
+			undefined,
+			"prefix itself not included",
+		);
+	});
+
+	test("renameChildPaths updates all children", async () => {
+		const accountId = randomId();
+		await repo.create(makeMailboxInput(accountId, "OldName/Sub1"));
+		await repo.create(makeMailboxInput(accountId, "OldName/Sub2"));
+
+		await repo.renameChildPaths(accountId, "OldName", "NewName");
+
+		const sub1 = await repo.findByPath(accountId, "NewName/Sub1");
+		const sub2 = await repo.findByPath(accountId, "NewName/Sub2");
+		assert.ok(sub1, "Sub1 renamed");
+		assert.ok(sub2, "Sub2 renamed");
+	});
+
+	test("cross-tenant: get refuses a foreign account", async () => {
+		const accountId = randomId();
+		const other = randomId();
+		const mailbox = await repo.create(makeMailboxInput(accountId));
+
+		await assert.rejects(
+			() => repo.get(other, mailbox.mailboxId),
+			/Mailbox not found/,
+		);
+		assert.deepEqual(await repo.get(other, [mailbox.mailboxId]), []);
+		const owned = await repo.get(accountId, [mailbox.mailboxId]);
+		assert.equal(owned.length, 1);
+
+		await repo.delete(accountId, mailbox.mailboxId);
+	});
+
+	test("cross-tenant: update refuses a foreign account and leaves the row unchanged", async () => {
+		const accountId = randomId();
+		const other = randomId();
+		const mailbox = await repo.create(makeMailboxInput(accountId));
+
+		await assert.rejects(
+			() => repo.update(other, mailbox.mailboxId, { messageCount: 99 }),
+			/Mailbox not found/,
+		);
+		const still = await repo.get(accountId, mailbox.mailboxId);
+		assert.equal(still.messageCount, 0);
+
+		await repo.delete(accountId, mailbox.mailboxId);
+	});
+
+	test("cross-tenant: delete is a no-op for a foreign account", async () => {
+		const accountId = randomId();
+		const other = randomId();
+		const mailbox = await repo.create(makeMailboxInput(accountId));
+
+		await repo.delete(other, mailbox.mailboxId);
+		const still = await repo.get(accountId, mailbox.mailboxId);
+		assert.equal(still.mailboxId, mailbox.mailboxId);
+
+		await repo.delete(accountId, mailbox.mailboxId);
+	});
+
+	test("cross-tenant: deleteMany only removes ids owned by the tenant", async () => {
+		const accountA = randomId();
+		const accountB = randomId();
+		const a = await repo.create(makeMailboxInput(accountA));
+		const b = await repo.create(makeMailboxInput(accountB));
+
+		await repo.deleteMany(accountA, [a.mailboxId, b.mailboxId]);
+
+		await assert.rejects(
+			() => repo.get(accountA, a.mailboxId),
+			/Mailbox not found/,
+		);
+		const survived = await repo.get(accountB, b.mailboxId);
+		assert.equal(survived.mailboxId, b.mailboxId);
+
+		await repo.delete(accountB, b.mailboxId);
+	});
+});

package/src/repos/i4-mailbox.ts

@@ -0,0 +1,347 @@
+import { randomUUID } from "node:crypto";
+import type {
+	CreateMailboxInput,
+	IMailboxRepository,
+	MailboxItem,
+	ResultList,
+	UpdateMailboxInput,
+} from "@remit/data-ports";
+import { MailboxCursorState } 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";
+import { NotFoundError } from "../error.js";
+import { decodeToken, resultList } from "../pagination.js";
+import { mailboxTable } from "../schema/i4-mailbox.js";
+
+const base36Translator = shortUuid.createTranslator(
+	shortUuid.constants.uuid25Base36,
+);
+const generateMailboxId = () => base36Translator.fromUUID(randomUUID());
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+export function rowToMailbox(
+	row: typeof mailboxTable.$inferSelect,
+): MailboxItem {
+	return {
+		mailboxId: row.mailboxId,
+		accountId: row.accountId,
+		namespaceType: row.namespaceType as MailboxItem["namespaceType"],
+		namespacePrefix: row.namespacePrefix,
+		hierarchyDelimiter: row.hierarchyDelimiter,
+		fullPath: row.fullPath,
+		uidValidity: row.uidValidity,
+		uidNext: row.uidNext,
+		highestModseq: row.highestModseq,
+		messageCount: row.messageCount,
+		unseenCount: row.unseenCount,
+		deletedCount: row.deletedCount,
+		totalSize: row.totalSize,
+		lastSyncUid: row.lastSyncUid,
+		highWaterMarkUid: row.highWaterMarkUid,
+		lastMessageSyncAt: row.lastMessageSyncAt,
+		initialSyncCompletedAt: row.initialSyncCompletedAt ?? undefined,
+		parentMailboxId: row.parentMailboxId,
+		syncStatus: (row.syncStatus as MailboxItem["syncStatus"]) ?? undefined,
+		cursorState: (row.cursorState as MailboxItem["cursorState"]) ?? undefined,
+		oldPath: row.oldPath ?? undefined,
+		specialUse: (row.specialUse as MailboxItem["specialUse"]) ?? undefined,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class MailboxRepo implements IMailboxRepository {
+	constructor(private db: DB) {}
+
+	async create(input: CreateMailboxInput): Promise<MailboxItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.insert(mailboxTable)
+			.values({
+				mailboxId: generateMailboxId(),
+				accountId: input.accountId,
+				namespaceType: input.namespaceType ?? "personal",
+				namespacePrefix: input.namespacePrefix,
+				hierarchyDelimiter: input.hierarchyDelimiter,
+				fullPath: input.fullPath,
+				uidValidity: input.uidValidity,
+				uidNext: input.uidNext,
+				highestModseq: input.highestModseq,
+				messageCount: input.messageCount,
+				unseenCount: input.unseenCount,
+				deletedCount: input.deletedCount,
+				totalSize: input.totalSize,
+				lastSyncUid: input.lastSyncUid,
+				highWaterMarkUid: input.highWaterMarkUid,
+				lastMessageSyncAt: input.lastMessageSyncAt,
+				initialSyncCompletedAt: input.initialSyncCompletedAt,
+				parentMailboxId: input.parentMailboxId ?? "",
+				syncStatus: input.syncStatus,
+				cursorState: input.cursorState ?? MailboxCursorState.normal,
+				oldPath: input.oldPath,
+				specialUse: input.specialUse ?? null,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		return rowToMailbox(row);
+	}
+
+	async get(accountId: string, mailboxId: string): Promise<MailboxItem>;
+	async get(accountId: string, mailboxIds: string[]): Promise<MailboxItem[]>;
+	async get(
+		accountId: string,
+		mailboxId: string | string[],
+	): Promise<MailboxItem | MailboxItem[]> {
+		if (Array.isArray(mailboxId)) {
+			if (mailboxId.length === 0) return [];
+			const rows = await this.db
+				.select()
+				.from(mailboxTable)
+				.where(
+					and(
+						eq(mailboxTable.accountId, accountId),
+						inArray(mailboxTable.mailboxId, mailboxId),
+					),
+				);
+			return rows.map(rowToMailbox);
+		}
+		const [row] = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					eq(mailboxTable.mailboxId, mailboxId),
+				),
+			);
+		if (!row) throw new NotFoundError(`Mailbox not found: ${mailboxId}`);
+		return rowToMailbox(row);
+	}
+
+	async update(
+		accountId: string,
+		mailboxId: string,
+		input: UpdateMailboxInput,
+		remove?: (keyof UpdateMailboxInput)[],
+	): Promise<MailboxItem> {
+		const now = Date.now();
+		const updates: Partial<typeof mailboxTable.$inferInsert> = {
+			updatedAt: now,
+		};
+
+		if (input.namespaceType !== undefined)
+			updates.namespaceType = input.namespaceType;
+		if (input.namespacePrefix !== undefined)
+			updates.namespacePrefix = input.namespacePrefix;
+		if (input.hierarchyDelimiter !== undefined)
+			updates.hierarchyDelimiter = input.hierarchyDelimiter;
+		if (input.fullPath !== undefined) updates.fullPath = input.fullPath;
+		if (input.uidValidity !== undefined)
+			updates.uidValidity = input.uidValidity;
+		if (input.uidNext !== undefined) updates.uidNext = input.uidNext;
+		if (input.highestModseq !== undefined)
+			updates.highestModseq = input.highestModseq;
+		if (input.messageCount !== undefined)
+			updates.messageCount = input.messageCount;
+		if (input.unseenCount !== undefined)
+			updates.unseenCount = input.unseenCount;
+		if (input.deletedCount !== undefined)
+			updates.deletedCount = input.deletedCount;
+		if (input.totalSize !== undefined) updates.totalSize = input.totalSize;
+		if (input.lastSyncUid !== undefined)
+			updates.lastSyncUid = input.lastSyncUid;
+		if (input.highWaterMarkUid !== undefined)
+			updates.highWaterMarkUid = input.highWaterMarkUid;
+		if (input.lastMessageSyncAt !== undefined)
+			updates.lastMessageSyncAt = input.lastMessageSyncAt;
+		if (input.initialSyncCompletedAt !== undefined)
+			updates.initialSyncCompletedAt = input.initialSyncCompletedAt;
+		if (input.parentMailboxId !== undefined)
+			updates.parentMailboxId = input.parentMailboxId;
+		if (input.syncStatus !== undefined) updates.syncStatus = input.syncStatus;
+		if (input.cursorState !== undefined)
+			updates.cursorState = input.cursorState;
+		if (input.oldPath !== undefined) updates.oldPath = input.oldPath;
+		if (input.specialUse !== undefined) updates.specialUse = input.specialUse;
+
+		if (remove) {
+			for (const field of remove) {
+				if (field === "syncStatus") updates.syncStatus = null;
+				if (field === "oldPath") updates.oldPath = null;
+				if (field === "specialUse") updates.specialUse = null;
+			}
+		}
+
+		const [row] = await this.db
+			.update(mailboxTable)
+			.set(updates)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					eq(mailboxTable.mailboxId, mailboxId),
+				),
+			)
+			.returning();
+		if (!row) throw new NotFoundError(`Mailbox not found: ${mailboxId}`);
+		return rowToMailbox(row);
+	}
+
+	async resolveAccountId(mailboxId: string): Promise<string | null> {
+		const [row] = await this.db
+			.select({ accountId: mailboxTable.accountId })
+			.from(mailboxTable)
+			.where(eq(mailboxTable.mailboxId, mailboxId));
+		return row?.accountId ?? null;
+	}
+
+	async delete(accountId: string, mailboxId: string): Promise<void> {
+		await this.db
+			.delete(mailboxTable)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					eq(mailboxTable.mailboxId, mailboxId),
+				),
+			);
+	}
+
+	async deleteMany(accountId: string, mailboxIds: string[]): Promise<void> {
+		if (mailboxIds.length === 0) return;
+		await this.db
+			.delete(mailboxTable)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					inArray(mailboxTable.mailboxId, mailboxIds),
+				),
+			);
+	}
+
+	async listByAccount(
+		accountId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<MailboxItem>> {
+		const limit = options?.limit ?? 100;
+		const cursor = options?.continuationToken
+			? decodeToken(options.continuationToken)
+			: undefined;
+		const after = cursor
+			? {
+					createdAt: cursor.createdAt as number,
+					mailboxId: cursor.mailboxId as string,
+				}
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					after
+						? or(
+								gt(mailboxTable.createdAt, after.createdAt),
+								and(
+									eq(mailboxTable.createdAt, after.createdAt),
+									gt(mailboxTable.mailboxId, after.mailboxId),
+								),
+							)
+						: undefined,
+				),
+			)
+			.orderBy(asc(mailboxTable.createdAt), asc(mailboxTable.mailboxId))
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToMailbox);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem
+				? { createdAt: lastItem.createdAt, mailboxId: lastItem.mailboxId }
+				: undefined,
+		);
+	}
+
+	async listAllByAccount(accountId: string): Promise<MailboxItem[]> {
+		const rows = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(eq(mailboxTable.accountId, accountId));
+		return rows.map(rowToMailbox);
+	}
+
+	async findByPath(
+		accountId: string,
+		fullPath: string,
+	): Promise<MailboxItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					eq(mailboxTable.fullPath, fullPath),
+				),
+			);
+		return row ? rowToMailbox(row) : null;
+	}
+
+	async getOrCreateByPath(
+		accountId: string,
+		fullPath: string,
+		defaults: Omit<CreateMailboxInput, "accountId" | "fullPath">,
+	): Promise<MailboxItem> {
+		const existing = await this.findByPath(accountId, fullPath);
+		if (existing) return existing;
+		return this.create({ accountId, fullPath, ...defaults });
+	}
+
+	async findByPathPrefix(
+		accountId: string,
+		pathPrefix: string,
+		delimiter = "/",
+	): Promise<MailboxItem[]> {
+		const rows = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(eq(mailboxTable.accountId, accountId));
+		const fullPrefix = `${pathPrefix}${delimiter}`;
+		return rows
+			.filter((r) => r.fullPath.startsWith(fullPrefix))
+			.map(rowToMailbox);
+	}
+
+	async findBySyncStatus(
+		accountId: string,
+		syncStatus: NonNullable<MailboxItem["syncStatus"]>,
+	): Promise<MailboxItem[]> {
+		const rows = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(
+				and(
+					eq(mailboxTable.accountId, accountId),
+					eq(mailboxTable.syncStatus, syncStatus),
+				),
+			);
+		return rows.map(rowToMailbox);
+	}
+
+	async renameChildPaths(
+		accountId: string,
+		oldPath: string,
+		newPath: string,
+		delimiter = "/",
+	): Promise<void> {
+		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 });
+		}
+	}
+}