@remit/calendar-service 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/calendar-service",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "iCalendar (RFC 5545) parsing, projection and recurrence expansion over the calendar store",
   "type": "module",
   "main": "src/index.ts",

package/src/expand.test.ts

@@ -328,6 +328,24 @@ describe("expandCalendar", () => {
 		assert.notEqual(expansion.expandedThrough, "");
 	});
 
+	it("marks a series whose first occurrence falls past the horizon", async () => {
+		// The rule's own first instance is excluded, so the iterator's first slot
+		// is 2029 and the horizon closes in 2027. Nothing is written, but the
+		// series is not complete: `""` here would hide it from the live expansion
+		// and the event would render nowhere, ever.
+		const expansion = await expand(
+			singleEvent(
+				"DTSTART:20250301T090000Z",
+				"DTEND:20250301T100000Z",
+				"RRULE:FREQ=YEARLY;INTERVAL=4",
+				"EXDATE:20250301T090000Z",
+			),
+		);
+
+		assert.deepEqual(expansion.occurrences, []);
+		assert.equal(expansion.expandedThrough, "2025-03-01T09:00:00Z");
+	});
+
 	it("says nothing about a horizon for a series that ends inside it", async () => {
 		const expansion = await expand(
 			singleEvent(

package/src/expand.ts

@@ -107,7 +107,7 @@ interface Walk {
 	occurrences: CalendarOccurrenceInput[];
 	/** Whether the walk stopped on a bound rather than on the series ending. */
 	truncated: boolean;
-	/** Start of the last slot the iterator itself produced, or `""` for none. */
+	/** Start of the last slot the walk collected, or `""` when it collected none. */
 	lastIteratedStart: string;
 }
 
@@ -258,12 +258,19 @@ export const expandCalendar = (
 		maxSteps: Number.POSITIVE_INFINITY,
 	});
 
+	// Every truncated walk is marked, including one that collected nothing — a
+	// series whose first occurrence lands past the horizon. Its index is empty
+	// from the series start, which is the honest floor to write; `""` would
+	// claim the whole series is held and the live expansion would never run.
 	return {
 		occurrences: walk.occurrences,
-		expandedThrough:
-			walk.truncated && walk.lastIteratedStart
-				? toUtcIso(Date.parse(walk.lastIteratedStart))
-				: "",
+		expandedThrough: walk.truncated
+			? toUtcIso(
+					walk.lastIteratedStart
+						? Date.parse(walk.lastIteratedStart)
+						: seriesStart,
+				)
+			: "",
 	};
 };
 

package/src/feed.test.ts

@@ -49,6 +49,10 @@ const object = (
 		updatedAt,
 	}) as CalendarObjectItem;
 
+/** Content lines as a subscriber reads them, with RFC 5545 3.1 folding undone. */
+const unfolded = (icalData: string): string =>
+	icalData.replace(/\r\n[ \t]/g, "");
+
 describe("a feed token", () => {
 	it("is base64url over the declared number of random bytes", () => {
 		const minted = mintCalendarFeedToken();
@@ -122,6 +126,49 @@ describe("the calendar a feed serves", () => {
 		assert.match(feed.icalData, /SUMMARY:Stand-up/);
 	});
 
+	it("escapes the separators a name may carry", () => {
+		const feed = buildCalendarFeed(
+			collection({ displayName: "Work, Home; C:\\shared" }),
+			[],
+		);
+
+		assert.match(
+			unfolded(feed.icalData),
+			/X-WR-CALNAME:Work\\, Home\\; C:\\\\shared\r\n/,
+		);
+	});
+
+	it("cannot be made to smuggle a component through its name", () => {
+		const feed = buildCalendarFeed(
+			collection({
+				displayName:
+					"Work\r\nBEGIN:VEVENT\r\nUID:injected\r\nDTSTART:20250101T000000Z\r\nSUMMARY:pwned\r\nEND:VEVENT",
+			}),
+			[
+				object(
+					"a.ics",
+					singleEvent("SUMMARY:Stand-up", "DTSTART:20260907T090000Z"),
+				),
+			],
+		);
+		const served = unfolded(feed.icalData);
+
+		assert.equal(served.match(/^BEGIN:VEVENT\r\n/gm)?.length, 1);
+		assert.doesNotMatch(served, /^UID:injected/m);
+		assert.doesNotMatch(served, /^SUMMARY:pwned/m);
+		assert.match(served, /X-WR-CALNAME:Work\\nBEGIN:VEVENT\\nUID:injected/);
+	});
+
+	it("leaves no bare carriage return in what it serves", () => {
+		const feed = buildCalendarFeed(
+			collection({ displayName: "Work\rHome" }),
+			[],
+		);
+
+		assert.match(unfolded(feed.icalData), /X-WR-CALNAME:Work\\nHome\r\n/);
+		assert.doesNotMatch(feed.icalData, /\r(?!\n)/);
+	});
+
 	it("carries the collection's zone so a client reads floating times the same way", () => {
 		const feed = buildCalendarFeed(
 			collection({ timezone: "Europe/Amsterdam" }),

package/src/feed.ts

@@ -80,6 +80,24 @@ export const redactCalendarFeedPath = (path: string): string =>
 		? path
 		: `${CALENDAR_FEED_PATH_PREFIX}<redacted>${CALENDAR_FEED_PATH_SUFFIX}`;
 
+/**
+ * A TEXT value as RFC 5545 3.3.11 writes one.
+ *
+ * ical.js escapes TEXT only for the properties in its design set, and no `X-`
+ * property is in it, so a value goes out verbatim: a comma or a semicolon
+ * reads back as a value list, and a line break as the start of a whole
+ * component the subscriber never had. TEXT has no encoding for a control
+ * character, so one is dropped rather than served.
+ */
+const escapeIcalText = (value: string): string =>
+	value
+		.replace(/\\/g, "\\\\")
+		.replace(/;/g, "\\;")
+		.replace(/,/g, "\\,")
+		.replace(/\r\n|\r|\n/g, "\\n")
+		// biome-ignore lint/suspicious/noControlCharactersInRegex: RFC 5545 TEXT excludes CONTROL.
+		.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+
 /** The bytes a feed serves, and what a conditional request needs to skip them. */
 export interface CalendarFeed {
 	icalData: string;
@@ -106,9 +124,15 @@ export const buildCalendarFeed = (
 	feed.updatePropertyWithValue("prodid", CALENDAR_PRODID);
 	feed.updatePropertyWithValue("version", "2.0");
 	feed.updatePropertyWithValue("calscale", "GREGORIAN");
-	feed.updatePropertyWithValue("x-wr-calname", collection.displayName);
+	feed.updatePropertyWithValue(
+		"x-wr-calname",
+		escapeIcalText(collection.displayName),
+	);
 	if (collection.timezone !== "") {
-		feed.updatePropertyWithValue("x-wr-timezone", collection.timezone);
+		feed.updatePropertyWithValue(
+			"x-wr-timezone",
+			escapeIcalText(collection.timezone),
+		);
 	}
 
 	const zonesSeen = new Set<string>();

package/src/window.test.ts

@@ -245,6 +245,52 @@ describe("listCalendarInstances", () => {
 		assert.equal(instances[0]?.summary, "Weekly one-to-one");
 	});
 
+	it("expands a series whose index is empty because its first occurrence is past the horizon", async () => {
+		const calendar = collection();
+		// The rule's own first instance is excluded, so the first occurrence is in
+		// 2029 and the horizon closed in 2027. The index holds no row at all, and
+		// the only thing that can serve the event is the live expansion.
+		const distant = await store(
+			calendar,
+			"distant.ics",
+			ical(
+				"BEGIN:VCALENDAR",
+				"VERSION:2.0",
+				"BEGIN:VEVENT",
+				"UID:distant@example.com",
+				"DTSTART:20250301T090000Z",
+				"DTEND:20250301T100000Z",
+				"SUMMARY:Leap day review",
+				"RRULE:FREQ=YEARLY;INTERVAL=4",
+				"EXDATE:20250301T090000Z",
+				"END:VEVENT",
+				"END:VCALENDAR",
+			),
+		);
+
+		assert.deepEqual(distant.rows, [], "the index really is empty");
+		assert.deepEqual(
+			await repositories([distant]).calendarObject.listIncompleteExpansions(
+				calendar.calendarId,
+				"2029-04-01T00:00:00Z",
+			),
+			[distant.object],
+			"and the resource is still offered to the live expansion",
+		);
+
+		const instances = await listCalendarInstances(
+			repositories([distant]),
+			[calendar],
+			{ from: "2029-03-01T00:00:00Z", to: "2029-04-01T00:00:00Z" },
+		);
+
+		assert.deepEqual(
+			instances.map((instance) => instance.startAt),
+			["2029-03-01T09:00:00Z"],
+		);
+		assert.equal(instances[0]?.summary, "Leap day review");
+	});
+
 	it("serves a live-expanded series from one source, never twice", async () => {
 		const calendar = collection();
 		const openEnded = await store(