fix(ics): don't wipe existing events when remote fetch fails (#383)

Author: agurod42

packages/calendar/src/ics/utils/fetch-adapter.ts

@@ -19,46 +19,38 @@ interface IcsSourceFetcher {
   fetchEvents: () => Promise<FetchEventsResult>;
 }
 
-const createIcsSourceFetcher = (
-  config: IcsSourceFetcherConfig,
-): IcsSourceFetcher => {
-  const fetchRemoteIcal = async (): Promise<string | null> => {
-    try {
-      const { ical } = await pullRemoteCalendar(
-        "ical",
-        config.url,
-        config.safeFetchOptions,
-      );
-      return ical;
-    } catch {
-      return null;
-    }
+const createIcsSourceFetcher = (config: IcsSourceFetcherConfig): IcsSourceFetcher => {
+  /**
+   * Lets pullRemoteCalendar errors propagate. The previous behavior swallowed
+   * them and returned null, which caused ingestSource to treat the empty result
+   * as "the source authoritatively has zero events" and delete every existing
+   * event_state for the calendar on the next tick. Surfacing the error lets the
+   * cron mark the run as failed and leave existing events intact for retry.
+   */
+  const fetchRemoteIcal = async (): Promise<string> => {
+    const { ical } = await pullRemoteCalendar("ical", config.url, config.safeFetchOptions);
+    return ical;
   };
 
   const fetchEvents = async (): Promise<FetchEventsResult> => {
     const ical = await fetchRemoteIcal();
-
     if (!ical) {
-      return { events: [] };
+      /*
+       * Defensive: pullRemoteCalendar already throws on invalid/empty bodies,
+       * but if a future change ever returns an empty string here, treat it as
+       * unchanged rather than authoritative-empty to keep the no-wipe invariant.
+       */
+      return { events: [], unchanged: true };
     }
-
-    const { changed } = await createSnapshot(
-      config.database,
-      config.calendarId,
-      ical,
-    );
-
+    const { changed } = await createSnapshot(config.database, config.calendarId, ical);
     if (!changed) {
       return { events: [], unchanged: true };
     }
-
     const calendar = parseIcsCalendarLenient({
       icsString: ical,
       patches: [coerceCompliantDate],
     });
-
     const parsed = parseIcsEvents(calendar);
-
     const events: SourceEvent[] = parsed.map((event) => ({
       availability: event.availability,
       description: event.description,
@@ -73,7 +65,6 @@ const createIcsSourceFetcher = (
       title: event.title,
       uid: event.uid,
     }));
-
     return { events };
   };
 

packages/calendar/tests/ics/utils/fetch-adapter.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+const { mockPullRemoteCalendar } = vi.hoisted(() => ({
+  mockPullRemoteCalendar: vi.fn<(...args: unknown[]) => Promise<{ ical: string }>>(),
+}));
+const { mockCreateSnapshot } = vi.hoisted(() => ({
+  mockCreateSnapshot: vi.fn<(...args: unknown[]) => Promise<{ changed: boolean }>>(),
+}));
+
+vi.mock("../../../src/ics/utils/pull-remote-calendar", () => ({
+  pullRemoteCalendar: mockPullRemoteCalendar,
+}));
+vi.mock("../../../src/ics/utils/create-snapshot", () => ({
+  createSnapshot: mockCreateSnapshot,
+}));
+
+const MINIMAL_ICS = [
+  "BEGIN:VCALENDAR",
+  "VERSION:2.0",
+  "PRODID:-//test//test//EN",
+  "BEGIN:VEVENT",
+  "UID:event-1@test",
+  "DTSTAMP:20260517T000000Z",
+  "DTSTART:20260517T120000Z",
+  "DTEND:20260517T130000Z",
+  "SUMMARY:Test",
+  "END:VEVENT",
+  "END:VCALENDAR",
+].join("\r\n");
+
+const buildConfig = () => ({
+  calendarId: "calendar-1",
+  url: "https://example.com/calendar.ics",
+  database: {} as never,
+});
+
+describe("createIcsSourceFetcher", () => {
+  beforeEach(() => {
+    mockPullRemoteCalendar.mockReset();
+    mockCreateSnapshot.mockReset();
+  });
+
+  it("propagates fetch errors instead of returning empty events", async () => {
+    /*
+     * Regression: previously this path returned {events: []}, which caused
+     * ingestSource to delete every existing event_state on a transient hiccup.
+     */
+    const { createIcsSourceFetcher } = await import("../../../src/ics/utils/fetch-adapter");
+    mockPullRemoteCalendar.mockRejectedValueOnce(new Error("network unreachable"));
+
+    const fetcher = createIcsSourceFetcher(buildConfig());
+
+    await expect(fetcher.fetchEvents()).rejects.toThrow("network unreachable");
+    expect(mockCreateSnapshot).not.toHaveBeenCalled();
+  });
+
+  it("returns parsed events on a successful changed fetch", async () => {
+    const { createIcsSourceFetcher } = await import("../../../src/ics/utils/fetch-adapter");
+    mockPullRemoteCalendar.mockResolvedValueOnce({ ical: MINIMAL_ICS });
+    mockCreateSnapshot.mockResolvedValueOnce({ changed: true });
+
+    const fetcher = createIcsSourceFetcher(buildConfig());
+    const result = await fetcher.fetchEvents();
+
+    expect(result.events).toHaveLength(1);
+    expect(result.events[0]?.uid).toBe("event-1@test");
+    expect(result.unchanged).toBeUndefined();
+  });
+
+  it("returns unchanged when snapshot content has not changed", async () => {
+    const { createIcsSourceFetcher } = await import("../../../src/ics/utils/fetch-adapter");
+    mockPullRemoteCalendar.mockResolvedValueOnce({ ical: MINIMAL_ICS });
+    mockCreateSnapshot.mockResolvedValueOnce({ changed: false });
+
+    const fetcher = createIcsSourceFetcher(buildConfig());
+    const result = await fetcher.fetchEvents();
+
+    expect(result.events).toEqual([]);
+    expect(result.unchanged).toBe(true);
+  });
+});