@remit/data-ports 0.0.52 → 0.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/data-ports",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/conformance/calendar-collection.ts

@@ -59,6 +59,29 @@ export function calendarCollectionRepositoryConformance(
 			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()),

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

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
+import { CalendarEventStatus, CalendarTransparency } from "@remit/domain-enums";
 import type { ICalendarEventIndexRepository } from "../interfaces/calendar-event-index.js";
 import type { CalendarOccurrenceInput } from "../types.js";
 import type { RepositoryConformanceHarness } from "./harness.js";
@@ -8,11 +9,16 @@ const occurrence = (
 	recurrenceId: string,
 	startAt: string,
 	endAt: string,
+	overrides: Partial<CalendarOccurrenceInput> = {},
 ): CalendarOccurrenceInput => ({
 	recurrenceId,
 	startAt,
 	endAt,
 	allDay: false,
+	summary: "Stand-up",
+	status: CalendarEventStatus.Confirmed,
+	transparency: CalendarTransparency.Opaque,
+	...overrides,
 });
 
 export function calendarEventIndexRepositoryConformance(
@@ -139,6 +145,46 @@ export function calendarEventIndexRepositoryConformance(
 			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();

package/src/conformance/calendar-object.ts

@@ -107,6 +107,49 @@ export function calendarObjectRepositoryConformance(
 			);
 		});
 
+		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"),

package/src/interfaces/calendar-collection.ts

@@ -12,6 +12,18 @@ export interface ICalendarCollectionRepository {
 	 * request without a prior read.
 	 */
 	create(input: CreateCalendarCollectionInput): Promise<CalendarCollectionItem>;
+	/**
+	 * Writes the collection, or answers `null` when its `urlSegment` is already
+	 * taken in this account config.
+	 *
+	 * The distinction from `create` is who asked. Provisioning wants the row
+	 * whoever got there first wrote; a person naming a calendar wants to be told
+	 * the name is taken, and handing them somebody else's calendar instead is a
+	 * silent merge of two things they meant to keep apart.
+	 */
+	createExclusive(
+		input: CreateCalendarCollectionInput,
+	): Promise<CalendarCollectionItem | null>;
 	get(
 		accountConfigId: string,
 		calendarId: string,

package/src/interfaces/calendar-object.ts

@@ -6,6 +6,16 @@ export interface ICalendarObjectRepository {
 		calendarId: string,
 		calendarObjectId: string,
 	): Promise<CalendarObjectItem>;
+	/**
+	 * The resource under an id, or `null` when the collection does not hold it.
+	 * `get` throws instead, which is right for a caller that already knows the
+	 * resource exists; a request naming one is asking whether it does, and that
+	 * is an answer rather than a fault.
+	 */
+	find(
+		calendarId: string,
+		calendarObjectId: string,
+	): Promise<CalendarObjectItem | null>;
 	delete(calendarId: string, calendarObjectId: string): Promise<void>;
 	findByResourceName(
 		calendarId: string,
@@ -21,6 +31,17 @@ export interface ICalendarObjectRepository {
 		icalUid: string,
 	): Promise<CalendarObjectItem | null>;
 	listByCalendar(calendarId: string): Promise<CalendarObjectItem[]>;
+	/**
+	 * The resources whose occurrence rows stop before `instant` — the series a
+	 * range read has to expand for itself because the index does not reach that
+	 * far. Narrow by construction: a resource that fits inside the expansion
+	 * horizon carries no `expandedThrough` and never appears here, so a view of
+	 * an ordinary calendar reads no iCalendar text at all.
+	 */
+	listIncompleteExpansions(
+		calendarId: string,
+		instant: string,
+	): Promise<CalendarObjectItem[]>;
 	/**
 	 * Everything written to the collection after `syncSequence`, in change
 	 * order — the read behind a WebDAV-Sync report. Exclusive of the token