Add full-day event support (#67)

* Add full-day event support

* Address PR review feedback for full-day events

Author: felixgollnhuber

prisma/migrations/20260427120000_add_event_type/migration.sql

@@ -0,0 +1,4 @@
+CREATE TYPE "EventType" AS ENUM ('TIME_GRID', 'FULL_DAY');
+
+ALTER TABLE "Event"
+ADD COLUMN "type" "EventType" NOT NULL DEFAULT 'TIME_GRID';

prisma/schema.prisma

@@ -11,10 +11,16 @@ enum EventStatus {
   CLOSED
 }
 
+enum EventType {
+  TIME_GRID
+  FULL_DAY
+}
+
 model Event {
   id                     String             @id @default(cuid())
   slug                   String             @unique
   title                  String
+  type                   EventType          @default(TIME_GRID)
   timezone               String
   slotMinutes            Int                @default(30)
   meetingDurationMinutes Int                @default(60)

src/app/api/events/[slug]/availability/route.test.ts

@@ -72,6 +72,46 @@ describe("PUT /api/events/[slug]/availability", () => {
     expect(response.headers.get("cache-control")).toContain("private, no-store");
   });
 
+  it("accepts long full-day availability selections beyond 31 days", async () => {
+    saveAvailability.mockResolvedValue({
+      snapshot: {
+        id: "event_1",
+      },
+    });
+    const selectedSlotStarts = Array.from({ length: 1001 }, (_, index) =>
+      new Date(Date.UTC(2026, 0, 1 + index)).toISOString(),
+    );
+
+    const { PUT } = await import("./route");
+    const response = await PUT(
+      new Request("https://tempoll.example.com/api/events/full-day-event/availability", {
+        method: "PUT",
+        body: JSON.stringify({
+          selectedSlotStarts,
+        }),
+        headers: {
+          "Accept-Language": "en-US",
+          "Content-Type": "application/json",
+        },
+      }),
+      {
+        params: Promise.resolve({
+          slug: "full-day-event",
+        }),
+      },
+    );
+
+    expect(saveAvailability).toHaveBeenCalledWith(
+      "full-day-event",
+      "en",
+      {
+        selectedSlotStarts,
+      },
+      "participant_1.secret-token",
+    );
+    expect(response.status).toBe(200);
+  });
+
   it("returns the domain-auth error for missing or expired participant sessions", async () => {
     saveAvailability.mockRejectedValue(unauthorized("participant_session_missing"));
 

src/app/api/events/[slug]/ics/route.test.ts

@@ -16,6 +16,7 @@ describe("GET /api/events/[slug]/ics", () => {
       snapshot: {
         slug: "team-sync",
         title: "Team Sync",
+        eventType: "time_grid",
         timezone: "Europe/Vienna",
         status: "CLOSED",
         finalizedSlot: {
@@ -55,11 +56,52 @@ describe("GET /api/events/[slug]/ics", () => {
     expect(body).toContain("URL:http://localhost:3000/e/team-sync");
   });
 
+  it("returns an all-day calendar file for closed full-day events", async () => {
+    getPublicEventSnapshot.mockResolvedValue({
+      snapshot: {
+        slug: "offsite-days",
+        title: "Offsite Days",
+        eventType: "full_day",
+        timezone: "Europe/Vienna",
+        status: "CLOSED",
+        finalizedSlot: {
+          slotStart: "2026-04-01T22:00:00.000Z",
+          slotEnd: "2026-04-02T22:00:00.000Z",
+          dateKey: "2026-04-02",
+          label: "Thu, Apr 2",
+          localLabel: null,
+          availableCount: 2,
+          participantIds: ["p1", "p2"],
+        },
+      },
+    });
+
+    const { GET } = await import("./route");
+    const response = await GET(
+      new Request("https://tempoll.example.com/api/events/offsite-days/ics", {
+        headers: {
+          "Accept-Language": "en-US",
+        },
+      }),
+      {
+        params: Promise.resolve({
+          slug: "offsite-days",
+        }),
+      },
+    );
+
+    const body = await response.text();
+    expect(body).toContain("DTSTART;VALUE=DATE:20260402");
+    expect(body).toContain("DTEND;VALUE=DATE:20260403");
+    expect(body).not.toContain("DTSTART;TZID=");
+  });
+
   it("returns 404 when no fixed date exists", async () => {
     getPublicEventSnapshot.mockResolvedValue({
       snapshot: {
         slug: "team-sync",
         title: "Team Sync",
+        eventType: "time_grid",
         timezone: "Europe/Vienna",
         status: "OPEN",
         finalizedSlot: null,

src/app/api/events/[slug]/ics/route.ts

@@ -35,6 +35,8 @@ export async function GET(request: Request, { params }: Context) {
     timezone: event.snapshot.timezone,
     slotStart: event.snapshot.finalizedSlot.slotStart,
     slotEnd: event.snapshot.finalizedSlot.slotEnd,
+    allDayDateKey:
+      event.snapshot.eventType === "full_day" ? event.snapshot.finalizedSlot.dateKey : null,
     url: buildPublicEventUrl(event.snapshot.slug),
   });
 

src/app/api/events/route.test.ts

@@ -51,6 +51,7 @@ describe("POST /api/events", () => {
     );
 
     expect(createEvent).toHaveBeenCalledWith({
+      eventType: "time_grid",
       title: "Sprint Planning",
       timezone: "Europe/Vienna",
       dates: ["2026-03-30"],
@@ -63,6 +64,41 @@ describe("POST /api/events", () => {
     expect(response.status).toBe(201);
   });
 
+  it("passes full-day event creation through to the service", async () => {
+    const { POST } = await import("./route");
+    const response = await POST(
+      new Request("https://tempoll.example.com/api/events", {
+        method: "POST",
+        body: JSON.stringify({
+          eventType: "full_day",
+          title: "Offsite Days",
+          timezone: "Europe/Vienna",
+          dates: ["2026-03-30", "2026-03-31"],
+          dayStartMinutes: 540,
+          dayEndMinutes: 600,
+          slotMinutes: 30,
+          meetingDurationMinutes: 60,
+        }),
+        headers: {
+          "Accept-Language": "en-US",
+          "Content-Type": "application/json",
+        },
+      }),
+    );
+
+    expect(createEvent).toHaveBeenCalledWith({
+      eventType: "full_day",
+      title: "Offsite Days",
+      timezone: "Europe/Vienna",
+      dates: ["2026-03-30", "2026-03-31"],
+      dayStartMinutes: 540,
+      dayEndMinutes: 600,
+      slotMinutes: 30,
+      meetingDurationMinutes: 60,
+    });
+    expect(response.status).toBe(201);
+  });
+
   it("returns a 429 with Retry-After when the create-event limit is exceeded", async () => {
     enforceRateLimit.mockImplementation(() => {
       throw tooManyRequests("event_create_rate_limited", 900);

src/components/create-event-form.test.tsx

@@ -268,6 +268,44 @@ describe("CreateEventForm", () => {
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
+  it("creates a full-day event without showing time-slot controls", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-04-02T10:00:00.000Z"));
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        manageKey: "manage-key-123",
+      }),
+    });
+    global.fetch = fetchMock as typeof fetch;
+
+    renderCreateEventForm();
+    vi.useRealTimers();
+    const user = userEvent.setup();
+
+    await user.type(screen.getByLabelText("Event title"), "Offsite days");
+    await user.click(screen.getByRole("radio", { name: /Full days/i }));
+
+    expect(screen.queryByRole("combobox", { name: "Daily start" })).not.toBeInTheDocument();
+    expect(screen.queryByRole("combobox", { name: "Slot size" })).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: "Create event" }));
+
+    await waitFor(() => {
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+
+    const [, requestInit] = fetchMock.mock.calls[0] as [string, RequestInit];
+    const payload = JSON.parse(String(requestInit.body)) as {
+      dates: string[];
+      eventType: string;
+    };
+
+    expect(payload.eventType).toBe("full_day");
+    expect(payload.dates).toEqual(["2026-04-03"]);
+  });
+
   it("submits the optional notification email when alerts are available", async () => {
     const user = userEvent.setup();
     const fetchMock = vi.fn().mockResolvedValue({