@remit/drizzle-service 0.0.66 → 0.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.66",
+  "version": "0.0.67",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",
@@ -18,6 +18,7 @@
     "fix": "biome check --write src"
   },
   "devDependencies": {
+    "@remit/calendar-service": "*",
     "@remit/config-transfer": "*",
     "drizzle-kit": "^0.31.1",
     "tsx": "*"

package/src/index.ts

@@ -1,4 +1,8 @@
 export { CreateFailedConflictError, NotFoundError } from "./error.js";
+export { CalendarCollectionRepo } from "./repos/calendar-collection.js";
+export { CalendarEventIndexRepo } from "./repos/calendar-event-index.js";
+export { CalendarObjectRepo } from "./repos/calendar-object.js";
+export { DrizzleCalendarUnitOfWork } from "./repos/calendar-unit-of-work.js";
 export {
 	type CascadeDeleteLogger,
 	type CascadeDeleter,

package/src/repos/calendar-collection.conformance.sqlite.test.ts

@@ -0,0 +1,23 @@
+import { calendarCollectionRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { calendarTable } from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarCollectionRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createSqliteTestDb({
+			calendars: calendarTable,
+		});
+		close = closeDb;
+		return new CalendarCollectionRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-collection.ts

@@ -0,0 +1,180 @@
+import type {
+	CalendarCollectionItem,
+	CreateCalendarCollectionInput,
+	ICalendarCollectionRepository,
+	UpdateCalendarCollectionInput,
+} from "@remit/data-ports";
+import {
+	deriveCalendarId,
+	normalizeCalendarUrlSegment,
+} from "@remit/data-ports/id";
+import { and, asc, eq, sql } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { NotFoundError } from "../error.js";
+import { calendarTable } from "../schema.js";
+
+type DB = Db<Record<string, unknown>>;
+
+function rowToCalendar(
+	row: typeof calendarTable.$inferSelect,
+): CalendarCollectionItem {
+	return {
+		calendarId: row.calendarId,
+		accountConfigId: row.accountConfigId,
+		urlSegment: row.urlSegment,
+		displayName: row.displayName,
+		color: row.color,
+		componentSet: row.componentSet,
+		source: row.source,
+		timezone: row.timezone,
+		syncSequence: row.syncSequence,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class CalendarCollectionRepo implements ICalendarCollectionRepository {
+	constructor(private db: DB) {}
+
+	/**
+	 * Provisioning is idempotent by construction: `calendarId` is derived, so a
+	 * second create of the same `(accountConfigId, urlSegment)` collides with
+	 * the row it already wrote. The conflict keeps the stored row rather than
+	 * overwriting it — two concurrent first uses of an account must not have the
+	 * loser reset a collection the winner has already had writes against.
+	 */
+	async create(
+		input: CreateCalendarCollectionInput,
+	): Promise<CalendarCollectionItem> {
+		const now = Date.now();
+		const urlSegment = normalizeCalendarUrlSegment(input.urlSegment);
+		const calendarId = deriveCalendarId(input.accountConfigId, urlSegment);
+		const [row] = await this.db
+			.insert(calendarTable)
+			.values({
+				calendarId,
+				accountConfigId: input.accountConfigId,
+				urlSegment,
+				displayName: input.displayName,
+				color: input.color ?? "Cal1",
+				componentSet: input.componentSet ?? "VeventOnly",
+				source: input.source ?? "UserCreated",
+				timezone: input.timezone ?? "",
+				syncSequence: 0,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoUpdate({
+				target: calendarTable.calendarId,
+				set: { updatedAt: now },
+			})
+			.returning();
+		return rowToCalendar(row);
+	}
+
+	async get(
+		accountConfigId: string,
+		calendarId: string,
+	): Promise<CalendarCollectionItem> {
+		const [row] = await this.db
+			.select()
+			.from(calendarTable)
+			.where(
+				and(
+					eq(calendarTable.accountConfigId, accountConfigId),
+					eq(calendarTable.calendarId, calendarId),
+				),
+			);
+		if (!row) {
+			throw new NotFoundError(`Calendar not found: ${calendarId}`);
+		}
+		return rowToCalendar(row);
+	}
+
+	async update(
+		accountConfigId: string,
+		calendarId: string,
+		input: UpdateCalendarCollectionInput,
+	): Promise<CalendarCollectionItem> {
+		const [row] = await this.db
+			.update(calendarTable)
+			.set({ ...input, updatedAt: Date.now() })
+			.where(
+				and(
+					eq(calendarTable.accountConfigId, accountConfigId),
+					eq(calendarTable.calendarId, calendarId),
+				),
+			)
+			.returning();
+		if (!row) {
+			throw new NotFoundError(`Calendar not found: ${calendarId}`);
+		}
+		return rowToCalendar(row);
+	}
+
+	async delete(accountConfigId: string, calendarId: string): Promise<void> {
+		await this.db
+			.delete(calendarTable)
+			.where(
+				and(
+					eq(calendarTable.accountConfigId, accountConfigId),
+					eq(calendarTable.calendarId, calendarId),
+				),
+			);
+	}
+
+	async listByAccountConfig(
+		accountConfigId: string,
+	): Promise<CalendarCollectionItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarTable)
+			.where(eq(calendarTable.accountConfigId, accountConfigId))
+			.orderBy(asc(calendarTable.urlSegment));
+		return rows.map(rowToCalendar);
+	}
+
+	async findByUrlSegment(
+		accountConfigId: string,
+		urlSegment: string,
+	): Promise<CalendarCollectionItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(calendarTable)
+			.where(
+				and(
+					eq(calendarTable.accountConfigId, accountConfigId),
+					eq(calendarTable.urlSegment, normalizeCalendarUrlSegment(urlSegment)),
+				),
+			);
+		return row ? rowToCalendar(row) : null;
+	}
+
+	/**
+	 * One statement, so two writers can never read the same value and stamp it
+	 * on two different objects — which would hide one of them from every later
+	 * sync report that pages by the sequence.
+	 */
+	async bumpSyncSequence(
+		accountConfigId: string,
+		calendarId: string,
+	): Promise<number> {
+		const [row] = await this.db
+			.update(calendarTable)
+			.set({
+				syncSequence: sql`${calendarTable.syncSequence} + 1`,
+				updatedAt: Date.now(),
+			})
+			.where(
+				and(
+					eq(calendarTable.accountConfigId, accountConfigId),
+					eq(calendarTable.calendarId, calendarId),
+				),
+			)
+			.returning();
+		if (!row) {
+			throw new NotFoundError(`Calendar not found: ${calendarId}`);
+		}
+		return row.syncSequence;
+	}
+}

package/src/repos/calendar-event-index.conformance.sqlite.test.ts

@@ -0,0 +1,23 @@
+import { calendarEventIndexRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { calendarEventIndexTable } from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { CalendarEventIndexRepo } from "./calendar-event-index.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarEventIndexRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createSqliteTestDb({
+			calendarEventIndexes: calendarEventIndexTable,
+		});
+		close = closeDb;
+		return new CalendarEventIndexRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-event-index.ts

@@ -0,0 +1,102 @@
+import type {
+	CalendarEventIndexItem,
+	CalendarOccurrenceInput,
+	ICalendarEventIndexRepository,
+} from "@remit/data-ports";
+import { and, asc, eq, gte, lt } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { calendarEventIndexTable } from "../schema.js";
+
+type DB = Db<Record<string, unknown>>;
+
+function rowToOccurrence(
+	row: typeof calendarEventIndexTable.$inferSelect,
+): CalendarEventIndexItem {
+	return {
+		calendarId: row.calendarId,
+		calendarObjectId: row.calendarObjectId,
+		recurrenceId: row.recurrenceId,
+		startAt: row.startAt,
+		endAt: row.endAt,
+		allDay: row.allDay,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class CalendarEventIndexRepo implements ICalendarEventIndexRepository {
+	constructor(private db: DB) {}
+
+	async replaceForObject(
+		calendarId: string,
+		calendarObjectId: string,
+		occurrences: CalendarOccurrenceInput[],
+	): Promise<void> {
+		await this.deleteForObject(calendarId, calendarObjectId);
+		if (occurrences.length === 0) return;
+
+		const now = Date.now();
+		await this.db.insert(calendarEventIndexTable).values(
+			occurrences.map((occurrence) => ({
+				calendarId,
+				calendarObjectId,
+				recurrenceId: occurrence.recurrenceId,
+				startAt: occurrence.startAt,
+				endAt: occurrence.endAt,
+				allDay: occurrence.allDay,
+				createdAt: now,
+				updatedAt: now,
+			})),
+		);
+	}
+
+	async deleteForObject(
+		calendarId: string,
+		calendarObjectId: string,
+	): Promise<void> {
+		await this.db
+			.delete(calendarEventIndexTable)
+			.where(
+				and(
+					eq(calendarEventIndexTable.calendarId, calendarId),
+					eq(calendarEventIndexTable.calendarObjectId, calendarObjectId),
+				),
+			);
+	}
+
+	async listForObject(
+		calendarId: string,
+		calendarObjectId: string,
+	): Promise<CalendarEventIndexItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarEventIndexTable)
+			.where(
+				and(
+					eq(calendarEventIndexTable.calendarId, calendarId),
+					eq(calendarEventIndexTable.calendarObjectId, calendarObjectId),
+				),
+			)
+			.orderBy(asc(calendarEventIndexTable.startAt));
+		return rows.map(rowToOccurrence);
+	}
+
+	async listByStartRange(
+		calendarId: string,
+		startAt: string,
+		endAt: string,
+	): Promise<CalendarEventIndexItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarEventIndexTable)
+			.where(
+				and(
+					eq(calendarEventIndexTable.calendarId, calendarId),
+					gte(calendarEventIndexTable.startAt, startAt),
+					lt(calendarEventIndexTable.startAt, endAt),
+				),
+			)
+			.orderBy(asc(calendarEventIndexTable.startAt));
+		return rows.map(rowToOccurrence);
+	}
+}

package/src/repos/calendar-object.conformance.sqlite.test.ts

@@ -0,0 +1,23 @@
+import { calendarObjectRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { calendarObjectTable } from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { CalendarObjectRepo } from "./calendar-object.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarObjectRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createSqliteTestDb({
+			calendarObjects: calendarObjectTable,
+		});
+		close = closeDb;
+		return new CalendarObjectRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-object.ts

@@ -0,0 +1,158 @@
+import type {
+	CalendarObjectItem,
+	ICalendarObjectRepository,
+	PutCalendarObjectInput,
+} from "@remit/data-ports";
+import { deriveCalendarObjectId } from "@remit/data-ports/id";
+import { and, asc, eq, gt } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { NotFoundError } from "../error.js";
+import { calendarObjectTable } from "../schema.js";
+
+type DB = Db<Record<string, unknown>>;
+
+function rowToCalendarObject(
+	row: typeof calendarObjectTable.$inferSelect,
+): CalendarObjectItem {
+	return {
+		calendarObjectId: row.calendarObjectId,
+		calendarId: row.calendarId,
+		resourceName: row.resourceName,
+		icalUid: row.icalUid,
+		icalData: row.icalData,
+		etag: row.etag,
+		sequence: row.sequence,
+		syncSequence: row.syncSequence,
+		summary: row.summary,
+		dtStart: row.dtStart,
+		dtEnd: row.dtEnd,
+		allDay: row.allDay,
+		zoneCertainty: row.zoneCertainty,
+		status: row.status,
+		transparency: row.transparency,
+		hasRecurrence: row.hasRecurrence,
+		expandedThrough: row.expandedThrough,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class CalendarObjectRepo implements ICalendarObjectRepository {
+	constructor(private db: DB) {}
+
+	async put(input: PutCalendarObjectInput): Promise<CalendarObjectItem> {
+		const now = Date.now();
+		const calendarObjectId = deriveCalendarObjectId(
+			input.calendarId,
+			input.resourceName,
+		);
+		const values = {
+			...input,
+			calendarObjectId,
+			createdAt: now,
+			updatedAt: now,
+		};
+		const [row] = await this.db
+			.insert(calendarObjectTable)
+			.values(values)
+			.onConflictDoUpdate({
+				target: calendarObjectTable.calendarObjectId,
+				set: { ...input, updatedAt: now },
+			})
+			.returning();
+		return rowToCalendarObject(row);
+	}
+
+	async get(
+		calendarId: string,
+		calendarObjectId: string,
+	): Promise<CalendarObjectItem> {
+		const [row] = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(
+				and(
+					eq(calendarObjectTable.calendarId, calendarId),
+					eq(calendarObjectTable.calendarObjectId, calendarObjectId),
+				),
+			);
+		if (!row) {
+			throw new NotFoundError(`Calendar object not found: ${calendarObjectId}`);
+		}
+		return rowToCalendarObject(row);
+	}
+
+	async delete(calendarId: string, calendarObjectId: string): Promise<void> {
+		await this.db
+			.delete(calendarObjectTable)
+			.where(
+				and(
+					eq(calendarObjectTable.calendarId, calendarId),
+					eq(calendarObjectTable.calendarObjectId, calendarObjectId),
+				),
+			);
+	}
+
+	/**
+	 * A primary-key read, not a scan: `calendarObjectId` is derived from
+	 * `(calendarId, resourceName)`, so the name a client PUT to computes
+	 * straight to the row it wrote.
+	 */
+	async findByResourceName(
+		calendarId: string,
+		resourceName: string,
+	): Promise<CalendarObjectItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(
+				eq(
+					calendarObjectTable.calendarObjectId,
+					deriveCalendarObjectId(calendarId, resourceName),
+				),
+			);
+		return row ? rowToCalendarObject(row) : null;
+	}
+
+	async findByUid(
+		calendarId: string,
+		icalUid: string,
+	): Promise<CalendarObjectItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(
+				and(
+					eq(calendarObjectTable.calendarId, calendarId),
+					eq(calendarObjectTable.icalUid, icalUid),
+				),
+			);
+		return row ? rowToCalendarObject(row) : null;
+	}
+
+	async listByCalendar(calendarId: string): Promise<CalendarObjectItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(eq(calendarObjectTable.calendarId, calendarId))
+			.orderBy(asc(calendarObjectTable.resourceName));
+		return rows.map(rowToCalendarObject);
+	}
+
+	async listChangedSince(
+		calendarId: string,
+		syncSequence: number,
+	): Promise<CalendarObjectItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(
+				and(
+					eq(calendarObjectTable.calendarId, calendarId),
+					gt(calendarObjectTable.syncSequence, syncSequence),
+				),
+			)
+			.orderBy(asc(calendarObjectTable.syncSequence));
+		return rows.map(rowToCalendarObject);
+	}
+}

package/src/repos/calendar-put.sqlite.test.ts

@@ -0,0 +1,205 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import {
+	provisionDefaultCalendar,
+	putCalendarObject,
+} from "@remit/calendar-service";
+import type {
+	CalendarUnitOfWorkRepositories,
+	ICalendarUnitOfWork,
+} from "@remit/data-ports";
+import type { Db } from "../db.js";
+import {
+	calendarEventIndexTable,
+	calendarObjectTable,
+	calendarTable,
+} from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { DrizzleCalendarUnitOfWork } from "./calendar-unit-of-work.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-1";
+
+const RESOURCE = [
+	"BEGIN:VCALENDAR",
+	"VERSION:2.0",
+	"BEGIN:VEVENT",
+	"UID:atomic@example.com",
+	"DTSTART:20260826T090000Z",
+	"DTEND:20260826T100000Z",
+	"SUMMARY:Quarterly review",
+	"RRULE:FREQ=WEEKLY;COUNT=3",
+	"END:VEVENT",
+	"END:VCALENDAR",
+	"",
+].join("\r\n");
+
+/**
+ * Fails the third of the write set's three writes. The occurrence rows are
+ * written last, so a failure there is the case that proves the boundary: the
+ * object row and the sequence bump are already in the transaction when it
+ * happens.
+ */
+class FailingIndexUnitOfWork implements ICalendarUnitOfWork {
+	constructor(private inner: ICalendarUnitOfWork) {}
+
+	transaction<T>(
+		fn: (repos: CalendarUnitOfWorkRepositories) => Promise<T>,
+	): Promise<T> {
+		return this.inner.transaction((repos) =>
+			fn({
+				...repos,
+				calendarEventIndex: {
+					...repos.calendarEventIndex,
+					replaceForObject: () => {
+						throw new Error("the index write failed");
+					},
+				},
+			}),
+		);
+	}
+}
+
+describe("the calendar write path against sqlite", () => {
+	let db: Db<Record<string, unknown>>;
+	let close: () => Promise<void>;
+	let unitOfWork: ICalendarUnitOfWork;
+	let calendarId: string;
+
+	before(async () => {
+		const created = await createSqliteTestDb({
+			calendars: calendarTable,
+			calendarObjects: calendarObjectTable,
+			calendarEventIndexes: calendarEventIndexTable,
+		});
+		db = created.db as unknown as Db<Record<string, unknown>>;
+		close = created.close;
+		unitOfWork = new DrizzleCalendarUnitOfWork(db);
+		const collection = await provisionDefaultCalendar(
+			unitOfWork,
+			ACCOUNT_CONFIG_ID,
+		);
+		calendarId = collection.calendarId;
+	});
+
+	after(() => close());
+
+	const objects = () => db.select().from(calendarObjectTable);
+	const occurrences = () => db.select().from(calendarEventIndexTable);
+
+	test("writes the object, its occurrences and the sequence bump together", async () => {
+		const result = await putCalendarObject(unitOfWork, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "review.ics",
+			icalData: RESOURCE,
+		});
+
+		assert.ok(result.ok);
+		assert.equal(result.value.icalData, RESOURCE);
+		assert.equal(
+			(await objects())[0]?.icalData,
+			RESOURCE,
+			"the stored row holds the input bytes, CRLF and all",
+		);
+		assert.equal(result.value.syncSequence, 1);
+		assert.equal((await objects()).length, 1);
+		assert.equal(
+			(await occurrences()).filter(
+				(row) => row.calendarObjectId === result.value.calendarObjectId,
+			).length,
+			3,
+		);
+	});
+
+	test("a failing index write leaves no object behind", async () => {
+		const before = await objects();
+
+		await assert.rejects(
+			putCalendarObject(new FailingIndexUnitOfWork(unitOfWork), {
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId,
+				resourceName: "doomed.ics",
+				icalData: RESOURCE,
+			}),
+			/the index write failed/,
+		);
+
+		const after = await objects();
+		assert.equal(after.length, before.length);
+		assert.equal(
+			after.some((row) => row.resourceName === "doomed.ics"),
+			false,
+		);
+	});
+
+	test("a failing index write leaves the collection's sequence where it was", async () => {
+		const [before] = await db.select().from(calendarTable);
+
+		await assert.rejects(
+			putCalendarObject(new FailingIndexUnitOfWork(unitOfWork), {
+				accountConfigId: ACCOUNT_CONFIG_ID,
+				calendarId,
+				resourceName: "doomed-again.ics",
+				icalData: RESOURCE,
+			}),
+			/the index write failed/,
+		);
+
+		const [after] = await db.select().from(calendarTable);
+		assert.equal(after?.syncSequence, before?.syncSequence);
+	});
+
+	test("a refused resource writes nothing at all", async () => {
+		const before = await objects();
+		const [collectionBefore] = await db.select().from(calendarTable);
+
+		const result = await putCalendarObject(unitOfWork, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "backwards.ics",
+			icalData: [
+				"BEGIN:VCALENDAR",
+				"VERSION:2.0",
+				"BEGIN:VEVENT",
+				"UID:backwards@example.com",
+				"DTSTART:20260826T100000Z",
+				"DTEND:20260826T090000Z",
+				"END:VEVENT",
+				"END:VCALENDAR",
+				"",
+			].join("\r\n"),
+		});
+
+		assert.ok(!result.ok);
+		assert.equal(result.error.code, "BackwardsEnd");
+		assert.equal((await objects()).length, before.length);
+		const [collectionAfter] = await db.select().from(calendarTable);
+		assert.equal(collectionAfter?.syncSequence, collectionBefore?.syncSequence);
+	});
+
+	test("rewriting a resource replaces its occurrences rather than adding to them", async () => {
+		const first = await putCalendarObject(unitOfWork, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "shrinking.ics",
+			icalData: RESOURCE,
+		});
+		assert.ok(first.ok);
+
+		const second = await putCalendarObject(unitOfWork, {
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			calendarId,
+			resourceName: "shrinking.ics",
+			icalData: RESOURCE.replace("COUNT=3", "COUNT=1"),
+		});
+		assert.ok(second.ok);
+
+		assert.equal(second.value.calendarObjectId, first.value.calendarObjectId);
+		assert.equal(
+			(await occurrences()).filter(
+				(row) => row.calendarObjectId === second.value.calendarObjectId,
+			).length,
+			1,
+		);
+	});
+});

package/src/repos/calendar-unit-of-work.ts

@@ -0,0 +1,27 @@
+import type {
+	CalendarUnitOfWorkRepositories,
+	ICalendarUnitOfWork,
+} from "@remit/data-ports";
+import type { Db } from "../db.js";
+import { runInTransaction } from "../tx.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+import { CalendarEventIndexRepo } from "./calendar-event-index.js";
+import { CalendarObjectRepo } from "./calendar-object.js";
+
+type DB = Db<Record<string, unknown>>;
+
+export class DrizzleCalendarUnitOfWork implements ICalendarUnitOfWork {
+	constructor(private db: DB) {}
+
+	transaction<T>(
+		fn: (repos: CalendarUnitOfWorkRepositories) => Promise<T>,
+	): Promise<T> {
+		return runInTransaction(this.db, (tx) =>
+			fn({
+				calendarCollection: new CalendarCollectionRepo(tx as never),
+				calendarObject: new CalendarObjectRepo(tx as never),
+				calendarEventIndex: new CalendarEventIndexRepo(tx as never),
+			}),
+		);
+	}
+}

package/src/schema.ts

@@ -8,6 +8,9 @@
 
 import * as entities from "@remit/drizzle-sqlite-schema";
 
+export const calendarTable = entities.calendarCollections;
+export const calendarObjectTable = entities.calendarObjects;
+export const calendarEventIndexTable = entities.calendarEventIndexes;
 export const filterAnchorTable = entities.filterAnchors;
 export const filterTable = entities.filters;
 export const labelTable = entities.labels;