@remit/data-ports 0.0.83 → 0.0.85

package/dist/conformance/calendar-collection.js

@@ -0,0 +1,251 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { CalendarColor, CalendarSource } from "@remit/domain-enums";
+import { deriveCalendarId } from "../id.js";
+export function calendarCollectionRepositoryConformance(harness) {
+    describe("ICalendarCollectionRepository conformance", () => {
+        let repo;
+        before(async () => {
+            repo = await harness.createRepository();
+        });
+        after(() => harness.teardown());
+        test("create derives calendarId from the account config and the url segment", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "default",
+                displayName: "Calendar",
+            });
+            assert.equal(calendar.calendarId, deriveCalendarId(accountConfigId, "default"));
+            assert.equal(calendar.color, CalendarColor.Cal1);
+            assert.equal(calendar.source, CalendarSource.UserCreated);
+            assert.equal(calendar.componentSet, "VeventOnly");
+            assert.equal(calendar.timezone, "");
+            assert.equal(calendar.syncSequence, 0);
+        });
+        test("create is idempotent, so first-use provisioning never forks a second collection", async () => {
+            const accountConfigId = harness.makeId();
+            const first = await repo.create({
+                accountConfigId,
+                urlSegment: "default",
+                displayName: "Calendar",
+                source: CalendarSource.Default,
+            });
+            const second = await repo.create({
+                accountConfigId,
+                urlSegment: "default",
+                displayName: "Calendar",
+                source: CalendarSource.Default,
+            });
+            assert.equal(second.calendarId, first.calendarId);
+            const all = await repo.listByAccountConfig(accountConfigId);
+            assert.equal(all.length, 1);
+        });
+        test("createExclusive refuses a segment the account already uses", async () => {
+            const accountConfigId = harness.makeId();
+            const first = await repo.createExclusive({
+                accountConfigId,
+                urlSegment: "work",
+                displayName: "Work",
+            });
+            const second = await repo.createExclusive({
+                accountConfigId,
+                urlSegment: "work",
+                displayName: "Work again",
+            });
+            assert.ok(first);
+            assert.equal(second, null);
+            assert.equal((await repo.get(accountConfigId, first.calendarId)).displayName, "Work", "the loser never overwrote the calendar the winner made");
+        });
+        test("get throws a not-found error for a missing collection", async () => {
+            await assert.rejects(repo.get(harness.makeId(), harness.makeId()), (error) => harness.isNotFoundError(error));
+        });
+        test("update changes the display overlay, never the key", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "work",
+                displayName: "Work",
+            });
+            const updated = await repo.update(accountConfigId, calendar.calendarId, {
+                displayName: "Work & Travel",
+                color: CalendarColor.Cal4,
+                timezone: "Europe/Amsterdam",
+            });
+            assert.equal(updated.calendarId, calendar.calendarId);
+            assert.equal(updated.urlSegment, "work");
+            assert.equal(updated.displayName, "Work & Travel");
+            assert.equal(updated.color, CalendarColor.Cal4);
+            assert.equal(updated.timezone, "Europe/Amsterdam");
+        });
+        test("update throws a not-found error for a missing collection", async () => {
+            await assert.rejects(repo.update(harness.makeId(), harness.makeId(), {
+                displayName: "x",
+            }), (error) => harness.isNotFoundError(error));
+        });
+        test("findByUrlSegment resolves the path segment a client bookmarked", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "personal",
+                displayName: "Personal",
+            });
+            const found = await repo.findByUrlSegment(accountConfigId, "personal");
+            assert.equal(found?.calendarId, calendar.calendarId);
+            assert.equal(await repo.findByUrlSegment(accountConfigId, "nonexistent"), null);
+        });
+        test("a segment stored in one casing is found in another, and by its derived id", async () => {
+            // The id derivation folds case; the stored column has to fold with it,
+            // or one DAV path resolves through `findByUrlSegment` and not through a
+            // `get` by derived id.
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "Work-Calendar",
+                displayName: "Work",
+            });
+            assert.equal(calendar.urlSegment, "work-calendar");
+            assert.equal(calendar.calendarId, deriveCalendarId(accountConfigId, "WORK-CALENDAR"));
+            assert.equal((await repo.findByUrlSegment(accountConfigId, "WORK-CALENDAR"))
+                ?.calendarId, calendar.calendarId);
+            assert.equal((await repo.get(accountConfigId, calendar.calendarId)).urlSegment, "work-calendar");
+        });
+        test("listByAccountConfig scopes to the account config", async () => {
+            const accountConfigId = harness.makeId();
+            const other = harness.makeId();
+            const mine = await repo.create({
+                accountConfigId,
+                urlSegment: "default",
+                displayName: "Mine",
+            });
+            await repo.create({
+                accountConfigId: other,
+                urlSegment: "default",
+                displayName: "Foreign",
+            });
+            const calendars = await repo.listByAccountConfig(accountConfigId);
+            assert.equal(calendars.length, 1);
+            assert.equal(calendars[0]?.calendarId, mine.calendarId);
+        });
+        test("bumpSyncSequence hands every caller a distinct increasing value", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "seq",
+                displayName: "Seq",
+            });
+            const sequences = [];
+            for (let i = 0; i < 5; i += 1) {
+                sequences.push(await repo.bumpSyncSequence(accountConfigId, calendar.calendarId));
+            }
+            assert.deepEqual(sequences, [1, 2, 3, 4, 5]);
+            const reread = await repo.get(accountConfigId, calendar.calendarId);
+            assert.equal(reread.syncSequence, 5);
+        });
+        // Every write and every delete of an object in the collection goes through
+        // this bump, which makes the collection the one timestamp that only moves
+        // forward — the calendar feed serves it as Last-Modified, and a validator
+        // that moved backwards on a delete would tell a subscriber its stale copy
+        // is still good.
+        test("bumpSyncSequence carries the collection's modification time forward", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "touched",
+                displayName: "Touched",
+            });
+            await repo.bumpSyncSequence(accountConfigId, calendar.calendarId);
+            const bumped = await repo.get(accountConfigId, calendar.calendarId);
+            assert.ok(bumped.updatedAt >= calendar.updatedAt);
+            assert.equal(bumped.createdAt, calendar.createdAt);
+        });
+        test("bumpSyncSequence throws a not-found error for a missing collection", async () => {
+            await assert.rejects(repo.bumpSyncSequence(harness.makeId(), harness.makeId()), (error) => harness.isNotFoundError(error));
+        });
+        test("a collection starts with no subscription and empty fetch bookkeeping", async () => {
+            const calendar = await repo.create({
+                accountConfigId: harness.makeId(),
+                urlSegment: "plain",
+                displayName: "Plain",
+            });
+            assert.equal(calendar.subscriptionUrl, "");
+            assert.equal(calendar.subscriptionEnabled, false);
+            assert.equal(calendar.subscriptionCheckedAt, 0);
+            assert.equal(calendar.subscriptionFetchedAt, 0);
+            assert.equal(calendar.subscriptionError, "");
+        });
+        test("listEnabledSubscriptions returns enabled subscriptions across account configs and nothing else", async () => {
+            const first = harness.makeId();
+            const second = harness.makeId();
+            const subscribed = await repo.create({
+                accountConfigId: first,
+                urlSegment: "feed",
+                displayName: "Feed",
+                source: CalendarSource.Subscribed,
+                subscriptionUrl: "https://calendar.example/feed.ics",
+                subscriptionEnabled: true,
+            });
+            const elsewhere = await repo.create({
+                accountConfigId: second,
+                urlSegment: "feed",
+                displayName: "Feed",
+                source: CalendarSource.Subscribed,
+                subscriptionUrl: "https://calendar.example/other.ics",
+                subscriptionEnabled: true,
+            });
+            const paused = await repo.create({
+                accountConfigId: first,
+                urlSegment: "paused",
+                displayName: "Paused",
+                source: CalendarSource.Subscribed,
+                subscriptionUrl: "https://calendar.example/paused.ics",
+                subscriptionEnabled: true,
+            });
+            await repo.update(first, paused.calendarId, {
+                subscriptionEnabled: false,
+            });
+            await repo.create({
+                accountConfigId: first,
+                urlSegment: "own",
+                displayName: "Own",
+            });
+            const ids = (await repo.listEnabledSubscriptions())
+                .filter((calendar) => calendar.accountConfigId === first ||
+                calendar.accountConfigId === second)
+                .map((calendar) => calendar.calendarId)
+                .sort();
+            assert.deepEqual(ids, [subscribed.calendarId, elsewhere.calendarId].sort());
+        });
+        test("update records a fetch outcome on the collection", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "fetched",
+                displayName: "Fetched",
+                source: CalendarSource.Subscribed,
+                subscriptionUrl: "https://calendar.example/feed.ics",
+                subscriptionEnabled: true,
+            });
+            const updated = await repo.update(accountConfigId, calendar.calendarId, {
+                subscriptionCheckedAt: 2_000,
+                subscriptionFetchedAt: 1_000,
+                subscriptionError: "the feed answered 404",
+            });
+            assert.equal(updated.subscriptionCheckedAt, 2_000);
+            assert.equal(updated.subscriptionFetchedAt, 1_000);
+            assert.equal(updated.subscriptionError, "the feed answered 404");
+            assert.equal(updated.subscriptionUrl, "https://calendar.example/feed.ics");
+            assert.equal(updated.subscriptionEnabled, true);
+        });
+        test("delete removes the row", async () => {
+            const accountConfigId = harness.makeId();
+            const calendar = await repo.create({
+                accountConfigId,
+                urlSegment: "gone",
+                displayName: "Gone",
+            });
+            await repo.delete(accountConfigId, calendar.calendarId);
+            await assert.rejects(repo.get(accountConfigId, calendar.calendarId), (error) => harness.isNotFoundError(error));
+        });
+    });
+}

package/dist/conformance/calendar-event-index.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarEventIndexRepository } from "../interfaces/calendar-event-index.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+export declare function calendarEventIndexRepositoryConformance(harness: RepositoryConformanceHarness<ICalendarEventIndexRepository>): void;

package/dist/conformance/calendar-event-index.js

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { CalendarEventStatus, CalendarTransparency } from "@remit/domain-enums";
+const occurrence = (recurrenceId, startAt, endAt, overrides = {}) => ({
+    recurrenceId,
+    startAt,
+    endAt,
+    allDay: false,
+    summary: "Stand-up",
+    status: CalendarEventStatus.Confirmed,
+    transparency: CalendarTransparency.Opaque,
+    ...overrides,
+});
+export function calendarEventIndexRepositoryConformance(harness) {
+    describe("ICalendarEventIndexRepository conformance", () => {
+        let repo;
+        before(async () => {
+            repo = await harness.createRepository();
+        });
+        after(() => harness.teardown());
+        test("replaceForObject writes the master occurrence under an empty recurrenceId", async () => {
+            const calendarId = harness.makeId();
+            const calendarObjectId = harness.makeId();
+            await repo.replaceForObject(calendarId, calendarObjectId, [
+                occurrence("", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+            ]);
+            const rows = await repo.listForObject(calendarId, calendarObjectId);
+            assert.equal(rows.length, 1);
+            assert.equal(rows[0]?.recurrenceId, "");
+            assert.equal(rows[0]?.startAt, "2026-08-26T07:00:00Z");
+        });
+        test("replaceForObject drops the occurrences a shortened series no longer has", async () => {
+            const calendarId = harness.makeId();
+            const calendarObjectId = harness.makeId();
+            await repo.replaceForObject(calendarId, calendarObjectId, [
+                occurrence("2026-08-26T07:00:00Z", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+                occurrence("2026-09-02T07:00:00Z", "2026-09-02T07:00:00Z", "2026-09-02T08:00:00Z"),
+            ]);
+            await repo.replaceForObject(calendarId, calendarObjectId, [
+                occurrence("2026-08-26T07:00:00Z", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+            ]);
+            const rows = await repo.listForObject(calendarId, calendarObjectId);
+            assert.deepEqual(rows.map((row) => row.recurrenceId), ["2026-08-26T07:00:00Z"]);
+        });
+        test("replaceForObject leaves the other resources of the collection alone", async () => {
+            const calendarId = harness.makeId();
+            const mine = harness.makeId();
+            const other = harness.makeId();
+            await repo.replaceForObject(calendarId, other, [
+                occurrence("", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+            ]);
+            await repo.replaceForObject(calendarId, mine, []);
+            assert.equal((await repo.listForObject(calendarId, other)).length, 1);
+            assert.equal((await repo.listForObject(calendarId, mine)).length, 0);
+        });
+        test("listByStartRange returns occurrences in start order, half-open on the end", async () => {
+            const calendarId = harness.makeId();
+            const calendarObjectId = harness.makeId();
+            await repo.replaceForObject(calendarId, calendarObjectId, [
+                occurrence("2026-09-02T07:00:00Z", "2026-09-02T07:00:00Z", "2026-09-02T08:00:00Z"),
+                occurrence("2026-08-26T07:00:00Z", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+                occurrence("2026-09-09T07:00:00Z", "2026-09-09T07:00:00Z", "2026-09-09T08:00:00Z"),
+            ]);
+            const rows = await repo.listByStartRange(calendarId, "2026-08-26T07:00:00Z", "2026-09-09T07:00:00Z");
+            assert.deepEqual(rows.map((row) => row.startAt), ["2026-08-26T07:00:00Z", "2026-09-02T07:00:00Z"]);
+        });
+        test("listByStartRange scopes to the collection", async () => {
+            const calendarId = harness.makeId();
+            const other = harness.makeId();
+            await repo.replaceForObject(calendarId, harness.makeId(), [
+                occurrence("", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+            ]);
+            await repo.replaceForObject(other, harness.makeId(), [
+                occurrence("", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+            ]);
+            const rows = await repo.listByStartRange(calendarId, "2026-08-01T00:00:00Z", "2026-09-01T00:00:00Z");
+            assert.equal(rows.length, 1);
+        });
+        test("an occurrence keeps its own summary, status and transparency", async () => {
+            const calendarId = harness.makeId();
+            const calendarObjectId = harness.makeId();
+            await repo.replaceForObject(calendarId, calendarObjectId, [
+                occurrence("2026-08-26T07:00:00Z", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+                occurrence("2026-09-02T07:00:00Z", "2026-09-02T07:00:00Z", "2026-09-02T08:00:00Z", {
+                    summary: "Stand-up (moved)",
+                    status: CalendarEventStatus.Cancelled,
+                    transparency: CalendarTransparency.Transparent,
+                }),
+            ]);
+            const rows = await repo.listForObject(calendarId, calendarObjectId);
+            assert.deepEqual(rows.map((row) => [row.summary, row.status, row.transparency]), [
+                [
+                    "Stand-up",
+                    CalendarEventStatus.Confirmed,
+                    CalendarTransparency.Opaque,
+                ],
+                [
+                    "Stand-up (moved)",
+                    CalendarEventStatus.Cancelled,
+                    CalendarTransparency.Transparent,
+                ],
+            ]);
+        });
+        test("deleteForObject removes every occurrence of one resource", async () => {
+            const calendarId = harness.makeId();
+            const calendarObjectId = harness.makeId();
+            await repo.replaceForObject(calendarId, calendarObjectId, [
+                occurrence("", "2026-08-26T07:00:00Z", "2026-08-26T08:00:00Z"),
+            ]);
+            await repo.deleteForObject(calendarId, calendarObjectId);
+            assert.equal((await repo.listForObject(calendarId, calendarObjectId)).length, 0);
+        });
+    });
+}

package/dist/conformance/calendar-feed-token.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarFeedTokenRepository } from "../interfaces/calendar-feed-token.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+export declare function calendarFeedTokenRepositoryConformance(harness: RepositoryConformanceHarness<ICalendarFeedTokenRepository>): void;

package/dist/conformance/calendar-feed-token.js

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { deriveCalendarFeedTokenId } from "../id.js";
+const hashOf = (label) => label.padEnd(64, "0");
+export function calendarFeedTokenRepositoryConformance(harness) {
+    describe("ICalendarFeedTokenRepository conformance", () => {
+        let repo;
+        before(async () => {
+            repo = await harness.createRepository();
+        });
+        after(() => harness.teardown());
+        test("put derives the id from the calendar and starts unrotated", async () => {
+            const accountConfigId = harness.makeId();
+            const calendarId = harness.makeId();
+            const minted = await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("a"),
+            });
+            assert.equal(minted.feedTokenId, deriveCalendarFeedTokenId(calendarId));
+            assert.equal(minted.calendarId, calendarId);
+            assert.equal(minted.tokenHash, hashOf("a"));
+            assert.equal(minted.rotatedAt, 0);
+            assert.ok(minted.createdAt > 0);
+        });
+        test("a second put rotates the one address rather than adding another", async () => {
+            const accountConfigId = harness.makeId();
+            const calendarId = harness.makeId();
+            const minted = await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("b"),
+            });
+            const rotated = await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("c"),
+            });
+            assert.equal(rotated.feedTokenId, minted.feedTokenId);
+            assert.equal(rotated.tokenHash, hashOf("c"));
+            assert.equal(rotated.createdAt, minted.createdAt, "the feed is the same feed under a new secret");
+            assert.ok(rotated.rotatedAt > 0, "a replacement is distinguishable from a first mint");
+            assert.equal(await repo.findByTokenHash(hashOf("b")), null, "the address that was rotated away no longer resolves");
+            assert.equal((await repo.findByTokenHash(hashOf("c")))?.calendarId, calendarId);
+        });
+        test("findByCalendar answers only for the account config that owns it", async () => {
+            const accountConfigId = harness.makeId();
+            const stranger = harness.makeId();
+            const calendarId = harness.makeId();
+            await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("d"),
+            });
+            assert.equal((await repo.findByCalendar(accountConfigId, calendarId))?.tokenHash, hashOf("d"));
+            assert.equal(await repo.findByCalendar(stranger, calendarId), null);
+            assert.equal(await repo.findByCalendar(accountConfigId, harness.makeId()), null);
+        });
+        test("findByTokenHash is unscoped, and names the owner it found", async () => {
+            const accountConfigId = harness.makeId();
+            const calendarId = harness.makeId();
+            await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("e"),
+            });
+            const found = await repo.findByTokenHash(hashOf("e"));
+            assert.equal(found?.accountConfigId, accountConfigId);
+            assert.equal(found?.calendarId, calendarId);
+            assert.equal(await repo.findByTokenHash(hashOf("nothing")), null);
+        });
+        test("delete stops the address resolving", async () => {
+            const accountConfigId = harness.makeId();
+            const calendarId = harness.makeId();
+            await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("f"),
+            });
+            await repo.delete(accountConfigId, calendarId);
+            assert.equal(await repo.findByTokenHash(hashOf("f")), null);
+            assert.equal(await repo.findByCalendar(accountConfigId, calendarId), null);
+        });
+        test("delete leaves another account config's address alone", async () => {
+            const accountConfigId = harness.makeId();
+            const stranger = harness.makeId();
+            const calendarId = harness.makeId();
+            await repo.put({
+                accountConfigId,
+                calendarId,
+                tokenHash: hashOf("g"),
+            });
+            await repo.delete(stranger, calendarId);
+            assert.equal((await repo.findByTokenHash(hashOf("g")))?.calendarId, calendarId);
+        });
+    });
+}

package/dist/conformance/calendar-object.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarObjectRepository } from "../interfaces/calendar-object.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+export declare function calendarObjectRepositoryConformance(harness: RepositoryConformanceHarness<ICalendarObjectRepository>): void;

package/dist/conformance/calendar-object.js

@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { CalendarEventStatus, CalendarTransparency, ZoneCertainty, } from "@remit/domain-enums";
+import { deriveCalendarObjectId } from "../id.js";
+const ICAL_DATA = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "BEGIN:VEVENT",
+    "UID:conformance@example.com",
+    "DTSTART:20260826T090000Z",
+    "DTEND:20260826T100000Z",
+    "SUMMARY:Stand-up",
+    "END:VEVENT",
+    "END:VCALENDAR",
+    "",
+].join("\r\n");
+const objectInput = (calendarId, overrides = {}) => ({
+    calendarId,
+    resourceName: "conformance.ics",
+    icalUid: "conformance@example.com",
+    icalData: ICAL_DATA,
+    etag: "a".repeat(64),
+    sequence: 0,
+    syncSequence: 1,
+    summary: "Stand-up",
+    dtStart: "2026-08-26T09:00:00+00:00",
+    dtEnd: "2026-08-26T10:00:00+00:00",
+    allDay: false,
+    zoneCertainty: ZoneCertainty.Explicit,
+    status: CalendarEventStatus.Confirmed,
+    transparency: CalendarTransparency.Opaque,
+    hasRecurrence: false,
+    expandedThrough: "",
+    ...overrides,
+});
+export function calendarObjectRepositoryConformance(harness) {
+    describe("ICalendarObjectRepository conformance", () => {
+        let repo;
+        before(async () => {
+            repo = await harness.createRepository();
+        });
+        after(() => harness.teardown());
+        test("put derives calendarObjectId from the collection and the resource name", async () => {
+            const calendarId = harness.makeId();
+            const object = await repo.put(objectInput(calendarId));
+            assert.equal(object.calendarObjectId, deriveCalendarObjectId(calendarId, "conformance.ics"));
+        });
+        test("put stores the iCalendar bytes verbatim, CRLF intact", async () => {
+            const calendarId = harness.makeId();
+            await repo.put(objectInput(calendarId));
+            const stored = await repo.findByResourceName(calendarId, "conformance.ics");
+            assert.equal(stored?.icalData, ICAL_DATA);
+            assert.ok(stored?.icalData.includes("\r\n"));
+        });
+        test("put rewrites the same resource rather than forking a duplicate", async () => {
+            const calendarId = harness.makeId();
+            await repo.put(objectInput(calendarId));
+            const second = await repo.put(objectInput(calendarId, {
+                summary: "Stand-up (moved)",
+                etag: "b".repeat(64),
+                syncSequence: 2,
+            }));
+            assert.equal(second.summary, "Stand-up (moved)");
+            assert.equal(second.syncSequence, 2);
+            const all = await repo.listByCalendar(calendarId);
+            assert.equal(all.length, 1);
+        });
+        test("get throws a not-found error for a missing resource", async () => {
+            await assert.rejects(repo.get(harness.makeId(), harness.makeId()), (error) => harness.isNotFoundError(error));
+        });
+        test("find answers with null where get throws", async () => {
+            const calendarId = harness.makeId();
+            const object = await repo.put(objectInput(calendarId));
+            assert.equal((await repo.find(calendarId, object.calendarObjectId))?.icalData, ICAL_DATA);
+            assert.equal(await repo.find(calendarId, harness.makeId()), null);
+            assert.equal(await repo.find(harness.makeId(), object.calendarObjectId), null, "a resource is only found through the collection that holds it");
+        });
+        test("listIncompleteExpansions returns only the series whose index stops short", async () => {
+            const calendarId = harness.makeId();
+            await repo.put(objectInput(calendarId, { resourceName: "complete.ics" }));
+            const incomplete = await repo.put(objectInput(calendarId, {
+                resourceName: "incomplete.ics",
+                expandedThrough: "2026-01-01T00:00:00Z",
+            }));
+            assert.deepEqual((await repo.listIncompleteExpansions(calendarId, "2026-06-01T00:00:00Z")).map((object) => object.calendarObjectId), [incomplete.calendarObjectId], "a resource with no expandedThrough is complete and never appears");
+            assert.deepEqual(await repo.listIncompleteExpansions(calendarId, "2025-06-01T00:00:00Z"), [], "and one whose index already reaches the window does not either");
+        });
+        test("findByResourceName returns null for a name the collection does not hold", async () => {
+            assert.equal(await repo.findByResourceName(harness.makeId(), "absent.ics"), null);
+        });
+        test("findByUid resolves the resource carrying an iCalendar UID", async () => {
+            const calendarId = harness.makeId();
+            const object = await repo.put(objectInput(calendarId));
+            const found = await repo.findByUid(calendarId, "conformance@example.com");
+            assert.equal(found?.calendarObjectId, object.calendarObjectId);
+            assert.equal(await repo.findByUid(calendarId, "absent@example.com"), null);
+        });
+        test("listByUidPrefix finds the resources whose UID starts with the prefix, in one collection", async () => {
+            const calendarId = harness.makeId();
+            const other = harness.makeId();
+            const tail = await repo.put(objectInput(calendarId, {
+                resourceName: "tail.ics",
+                icalUid: "root@example.com/following/1",
+            }));
+            await repo.put(objectInput(calendarId, {
+                resourceName: "root.ics",
+                icalUid: "root@example.com",
+            }));
+            await repo.put(objectInput(calendarId, {
+                resourceName: "lookalike.ics",
+                icalUid: "root@example.comx/following/2",
+            }));
+            await repo.put(objectInput(other, {
+                resourceName: "elsewhere.ics",
+                icalUid: "root@example.com/following/3",
+            }));
+            const found = await repo.listByUidPrefix(calendarId, "root@example.com/following/");
+            assert.deepEqual(found.map((object) => object.calendarObjectId), [tail.calendarObjectId]);
+        });
+        test("listByCalendar scopes to the collection", async () => {
+            const calendarId = harness.makeId();
+            const other = harness.makeId();
+            const mine = await repo.put(objectInput(calendarId));
+            await repo.put(objectInput(other));
+            const objects = await repo.listByCalendar(calendarId);
+            assert.equal(objects.length, 1);
+            assert.equal(objects[0]?.calendarObjectId, mine.calendarObjectId);
+        });
+        test("listChangedSince returns later writes in change order, excluding the token itself", async () => {
+            const calendarId = harness.makeId();
+            await repo.put(objectInput(calendarId, {
+                resourceName: "one.ics",
+                icalUid: "one@example.com",
+                syncSequence: 1,
+            }));
+            await repo.put(objectInput(calendarId, {
+                resourceName: "two.ics",
+                icalUid: "two@example.com",
+                syncSequence: 2,
+            }));
+            await repo.put(objectInput(calendarId, {
+                resourceName: "three.ics",
+                icalUid: "three@example.com",
+                syncSequence: 3,
+            }));
+            const changed = await repo.listChangedSince(calendarId, 1);
+            assert.deepEqual(changed.map((object) => object.resourceName), ["two.ics", "three.ics"]);
+        });
+        test("delete removes the row", async () => {
+            const calendarId = harness.makeId();
+            const object = await repo.put(objectInput(calendarId));
+            await repo.delete(calendarId, object.calendarObjectId);
+            await assert.rejects(repo.get(calendarId, object.calendarObjectId), (error) => harness.isNotFoundError(error));
+        });
+    });
+}

package/dist/conformance/calendar-suggestion.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarSuggestionRepository } from "../interfaces/calendar-suggestion.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+export declare function calendarSuggestionRepositoryConformance(harness: RepositoryConformanceHarness<ICalendarSuggestionRepository>): void;