@remit/drizzle-service 0.0.103 → 0.0.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.103",
+  "version": "0.0.104",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",
@@ -25,14 +25,15 @@
     "@remit/calendar-service": "*",
     "@remit/config-transfer": "*",
     "drizzle-kit": "^0.31.1",
+    "miniflare": "^4.20260730.0",
     "tsx": "*"
   },
   "dependencies": {
     "@remit/data-ports": "*",
     "@remit/domain-enums": "*",
     "drizzle-orm": "^0.45.2",
-    "short-uuid": "*",
-    "uuid": "*",
+    "short-uuid": "^6.0.3",
+    "uuid": "^13.0.2",
     "@remit/drizzle-sqlite-schema": "*",
     "better-sqlite3": "^12.11.1",
     "@types/better-sqlite3": "^7.6.13"

package/src/repos/account.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { accountRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { composeSqliteRepositories } from "../sqlite-repositories.js";
+import { openD1TestStores } from "../test-d1.js";
+
+let close: (() => Promise<void>) | undefined;
+
+accountRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return composeSqliteRepositories(opened.stores).account;
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

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

@@ -0,0 +1,20 @@
+import { calendarCollectionRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarCollectionRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarCollectionRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-default.d1.test.ts

@@ -0,0 +1,4 @@
+import { openD1TestStores } from "../test-d1.js";
+import { calendarDefaultSuite } from "./calendar-default.suite.js";
+
+calendarDefaultSuite(openD1TestStores);

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

@@ -1,77 +1,4 @@
-import assert from "node:assert/strict";
-import { after, before, describe, test } from "node:test";
-import { provisionDefaultCalendar } from "@remit/calendar-service";
-import type { ICalendarStore } from "@remit/data-ports";
-import type { Db } from "../db.js";
-import {
-	calendarEventIndexTable,
-	calendarObjectTable,
-	calendarTable,
-} from "../schema.js";
-import { createSqliteRepositories } from "../sqlite-repositories.js";
-import { createSqliteTestDb } from "../test-db-sqlite.js";
-import { CalendarCollectionRepo } from "./calendar-collection.js";
+import { openCalendarSqliteTestStores } from "../test-stores.js";
+import { calendarDefaultSuite } from "./calendar-default.suite.js";
 
-const ACCOUNT_CONFIG_ID = "account-config-default";
-
-describe("provisioning the default calendar", () => {
-	let db: Db<Record<string, unknown>>;
-	let close: () => Promise<void>;
-	let store: ICalendarStore;
-
-	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;
-		store = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).calendarStore;
-	});
-
-	after(() => close());
-
-	test("leaves one calendar behind when several first reads arrive together", async () => {
-		const provisioned = await Promise.all(
-			Array.from({ length: 8 }, () =>
-				provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID),
-			),
-		);
-
-		const ids = new Set(provisioned.map((collection) => collection.calendarId));
-		assert.equal(ids.size, 1, "every caller was handed the same calendar");
-
-		const rows = await new CalendarCollectionRepo(db).listByAccountConfig(
-			ACCOUNT_CONFIG_ID,
-		);
-		assert.equal(rows.length, 1);
-		assert.equal(rows[0]?.urlSegment, "default");
-		assert.equal(
-			rows[0]?.syncSequence,
-			0,
-			"a losing provision did not reset a collection the winner may already have written to",
-		);
-	});
-
-	test("a later provision returns the stored collection rather than resetting it", async () => {
-		const repo = new CalendarCollectionRepo(db);
-		const [before] = await repo.listByAccountConfig(ACCOUNT_CONFIG_ID);
-		assert.ok(before);
-		await repo.bumpSyncSequence(ACCOUNT_CONFIG_ID, before.calendarId);
-
-		const again = await provisionDefaultCalendar(
-			store,
-			ACCOUNT_CONFIG_ID,
-			"A different name",
-		);
-
-		assert.equal(again.calendarId, before.calendarId);
-		assert.equal(again.displayName, before.displayName);
-		assert.equal(again.syncSequence, 1);
-	});
-});
+calendarDefaultSuite(openCalendarSqliteTestStores);

package/src/repos/calendar-default.suite.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { provisionDefaultCalendar } from "@remit/calendar-service";
+import type { ICalendarStore } from "@remit/data-ports";
+import type { RepositoryDb } from "../db.js";
+import { composeSqliteRepositories } from "../sqlite-repositories.js";
+import type { OpenTestStores } from "../test-stores.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-default";
+
+export const calendarDefaultSuite = (open: OpenTestStores): void => {
+	describe("provisioning the default calendar", () => {
+		let db: RepositoryDb<Record<string, unknown>>;
+		let close: () => Promise<void>;
+		let store: ICalendarStore;
+
+		before(async () => {
+			const opened = await open();
+			db = opened.stores.app.db;
+			close = opened.close;
+			store = composeSqliteRepositories(opened.stores).calendarStore;
+		});
+
+		after(() => close());
+
+		test("leaves one calendar behind when several first reads arrive together", async () => {
+			const provisioned = await Promise.all(
+				Array.from({ length: 8 }, () =>
+					provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID),
+				),
+			);
+
+			const ids = new Set(
+				provisioned.map((collection) => collection.calendarId),
+			);
+			assert.equal(ids.size, 1, "every caller was handed the same calendar");
+
+			const rows = await new CalendarCollectionRepo(db).listByAccountConfig(
+				ACCOUNT_CONFIG_ID,
+			);
+			assert.equal(rows.length, 1);
+			assert.equal(rows[0]?.urlSegment, "default");
+			assert.equal(
+				rows[0]?.syncSequence,
+				0,
+				"a losing provision did not reset a collection the winner may already have written to",
+			);
+		});
+
+		test("a later provision returns the stored collection rather than resetting it", async () => {
+			const repo = new CalendarCollectionRepo(db);
+			const [before] = await repo.listByAccountConfig(ACCOUNT_CONFIG_ID);
+			assert.ok(before);
+			await repo.bumpSyncSequence(ACCOUNT_CONFIG_ID, before.calendarId);
+
+			const again = await provisionDefaultCalendar(
+				store,
+				ACCOUNT_CONFIG_ID,
+				"A different name",
+			);
+
+			assert.equal(again.calendarId, before.calendarId);
+			assert.equal(again.displayName, before.displayName);
+			assert.equal(again.syncSequence, 1);
+		});
+	});
+};

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

@@ -0,0 +1,20 @@
+import { calendarEventIndexRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarEventIndexRepo } from "./calendar-event-index.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarEventIndexRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarEventIndexRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-feed-token.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { calendarFeedTokenRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarFeedTokenRepo } from "./calendar-feed-token.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarFeedTokenRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarFeedTokenRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

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

@@ -0,0 +1,20 @@
+import { calendarObjectRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarObjectRepo } from "./calendar-object.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarObjectRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarObjectRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

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

@@ -0,0 +1,4 @@
+import { openD1TestStores } from "../test-d1.js";
+import { calendarPutSuite } from "./calendar-put.suite.js";
+
+calendarPutSuite(openD1TestStores);

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

@@ -1,210 +1,4 @@
-import assert from "node:assert/strict";
-import { after, before, describe, test } from "node:test";
-import {
-	prepareCalendarObject,
-	provisionDefaultCalendar,
-	putCalendarObject,
-} from "@remit/calendar-service";
-import type {
-	CalendarRepositories,
-	CalendarWrite,
-	ICalendarStore,
-} from "@remit/data-ports";
-import type { Db } from "../db.js";
-import {
-	calendarEventIndexTable,
-	calendarObjectTable,
-	calendarTable,
-} from "../schema.js";
-import { createSqliteRepositories } from "../sqlite-repositories.js";
-import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { openCalendarSqliteTestStores } from "../test-stores.js";
+import { calendarPutSuite } from "./calendar-put.suite.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");
-
-/**
- * Appends a write that fails to every commit: a resource put into a collection
- * that does not exist, which the store refuses at its last statement. Every
- * statement of the real write set has run by then, so a failure there is the
- * case that proves the boundary.
- */
-class FailingLastWriteStore implements ICalendarStore {
-	constructor(private inner: ICalendarStore) {}
-
-	get repos(): CalendarRepositories {
-		return this.inner.repos;
-	}
-
-	async commit(writes: readonly CalendarWrite[]): Promise<void> {
-		const orphan = await prepareCalendarObject(
-			{ timezone: "" },
-			{
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				calendarId: "no-such-calendar",
-				resourceName: "orphan.ics",
-				icalData: RESOURCE,
-			},
-		);
-		assert.ok(orphan.ok);
-		await this.inner.commit([...writes, orphan.value]);
-	}
-}
-
-describe("the calendar write path against sqlite", () => {
-	let db: Db<Record<string, unknown>>;
-	let close: () => Promise<void>;
-	let store: ICalendarStore;
-	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;
-		store = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).calendarStore;
-		const collection = await provisionDefaultCalendar(store, 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(store, {
-			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 write in the batch leaves no object behind", async () => {
-		const before = await objects();
-
-		await assert.rejects(
-			putCalendarObject(new FailingLastWriteStore(store), {
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				calendarId,
-				resourceName: "doomed.ics",
-				icalData: RESOURCE,
-			}),
-			/NOT NULL constraint failed/,
-		);
-
-		const after = await objects();
-		assert.equal(after.length, before.length);
-		assert.equal(
-			after.some((row) => row.resourceName === "doomed.ics"),
-			false,
-		);
-	});
-
-	test("a failing write in the batch leaves the collection's sequence where it was", async () => {
-		const [before] = await db.select().from(calendarTable);
-
-		await assert.rejects(
-			putCalendarObject(new FailingLastWriteStore(store), {
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				calendarId,
-				resourceName: "doomed-again.ics",
-				icalData: RESOURCE,
-			}),
-			/NOT NULL constraint 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(store, {
-			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(store, {
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			calendarId,
-			resourceName: "shrinking.ics",
-			icalData: RESOURCE,
-		});
-		assert.ok(first.ok);
-
-		const second = await putCalendarObject(store, {
-			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,
-		);
-	});
-});
+calendarPutSuite(openCalendarSqliteTestStores);