Scheduling infrastructure for absolutely everyone.
fix(caldav): consistent UIDs and VTIMEZONE in iCalendar output (#28115)
Yuvraj Angad Singhf1e8e3fa584b
diff --git a/packages/lib/CalendarService.test.ts b/packages/lib/CalendarService.test.tsindex 55e1f8d7af3..1e789200138 100644--- a/packages/lib/CalendarService.test.ts+++ b/packages/lib/CalendarService.test.ts@@ -1,6 +1,6 @@-import { describe, it, expect, vi, beforeEach } from "vitest";import { createEvent as createIcsEvent } from "ics";import { createCalendarObject, updateCalendarObject } from "tsdav";+import { beforeEach, describe, expect, it, vi } from "vitest";vi.mock("ics", () => ({createEvent: vi.fn(),@@ -41,7 +41,6 @@ vi.mock("./CalEventParser", () => ({}));import type { CalendarServiceEvent } from "@calcom/types/Calendar";-import BaseCalendarService from "./CalendarService";const createMockEvent = (overrides: Partial<CalendarServiceEvent> = {}): CalendarServiceEvent => ({@@ -102,6 +101,359 @@ class TestCalendarService extends BaseCalendarService {}}+describe("CalendarService - UID Consistency", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ it("should use event.uid when provided, not generate a new UUID", async () => {+ const service = new TestCalendarService();+ const bookingUid = "booking-uid-from-database-abc123";+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:${bookingUid}\r\nDTSTART:20230615T150000Z\r\nDTEND:20230615T160000Z\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({ uid: bookingUid });+ const result = await service.createEvent(event, 1);++ expect(result.uid).toBe(bookingUid);+ expect(result.id).toBe(bookingUid);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ expect(calledArg.filename).toBe(`${bookingUid}.ics`);++ const icsCallArg = vi.mocked(createIcsEvent).mock.calls[0][0];+ expect(icsCallArg.uid).toBe(bookingUid);+ });++ it("should generate a new UUID when event.uid is not provided", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:generated-uuid\r\nDTSTART:20230615T150000Z\r\nDTEND:20230615T160000Z\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({ uid: undefined });+ const result = await service.createEvent(event, 1);++ expect(result.uid).toBeTruthy();+ expect(typeof result.uid).toBe("string");+ expect(result.uid.length).toBeGreaterThan(0);+ });++ it("should use the same uid for CalDAV filename and ics UID property", async () => {+ const service = new TestCalendarService();+ const bookingUid = "consistent-uid-xyz789";+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:${bookingUid}\r\nDTSTART:20230615T150000Z\r\nDTEND:20230615T160000Z\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({ uid: bookingUid });+ await service.createEvent(event, 1);++ const icsCallArg = vi.mocked(createIcsEvent).mock.calls[0][0];+ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];++ expect(icsCallArg.uid).toBe(bookingUid);+ expect(calledArg.filename).toBe(`${bookingUid}.ics`);+ expect(icsCallArg.uid).toBe(calledArg.filename?.replace(".ics", ""));+ });+});++describe("CalendarService - VTIMEZONE Generation", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ it("should include VTIMEZONE block in created CalDAV event", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230615T150000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-06-15T15:00:00Z",+ endTime: "2023-06-15T16:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/Chicago",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;++ expect(iCalString).toContain("BEGIN:VTIMEZONE");+ expect(iCalString).toContain("END:VTIMEZONE");+ expect(iCalString).toContain("TZID:America/Chicago");+ });++ it("should use TZID in DTSTART instead of UTC Z suffix", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230615T150000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-06-15T15:00:00Z",+ endTime: "2023-06-15T16:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/Chicago",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;++ expect(iCalString).toContain("DTSTART;TZID=America/Chicago:");+ const unfolded = iCalString.replace(/\r?\n[ \t]/g, "");+ expect(unfolded).not.toMatch(/^DTSTART:[0-9]{8}T[0-9]{6}Z/m);+ });++ it("should convert UTC time to local time correctly for America/Chicago", async () => {+ const service = new TestCalendarService();+ // 2023-01-15T15:00:00Z = 2023-01-15T09:00:00 in America/Chicago (UTC-6 in January)+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230115T150000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-01-15T15:00:00Z",+ endTime: "2023-01-15T16:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/Chicago",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;+ const unfolded = iCalString.replace(/\r?\n[ \t]/g, "");++ expect(unfolded).toContain("DTSTART;TZID=America/Chicago:20230115T090000");+ });++ it("should place VTIMEZONE block before BEGIN:VEVENT", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230615T150000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-06-15T15:00:00Z",+ endTime: "2023-06-15T16:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/Chicago",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });+ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;++ const vtimezoneIdx = iCalString.indexOf("BEGIN:VTIMEZONE");+ const veventIdx = iCalString.indexOf("BEGIN:VEVENT");++ expect(vtimezoneIdx).toBeGreaterThan(-1);+ expect(veventIdx).toBeGreaterThan(-1);+ expect(vtimezoneIdx).toBeLessThan(veventIdx);+ });++ it("should produce valid 8-digit DTSTART dates in VTIMEZONE blocks", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230615T120000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-06-15T12:00:00Z",+ endTime: "2023-06-15T13:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/New_York",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;++ const vtimezoneBlock = iCalString.slice(+ iCalString.indexOf("BEGIN:VTIMEZONE"),+ iCalString.indexOf("END:VTIMEZONE") + 13+ );+ const dtStartMatches = vtimezoneBlock.match(/DTSTART:(\d+)T/g);+ expect(dtStartMatches).not.toBeNull();+ for (const match of dtStartMatches ?? []) {+ const dateStr = match.replace("DTSTART:", "").replace("T", "");+ expect(dateStr).toHaveLength(8); // YYYYMMDD = 8 chars+ }+ });++ it("should use pre-transition local time for VTIMEZONE DTSTART (RFC 5545)", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230615T120000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-06-15T12:00:00Z",+ endTime: "2023-06-15T13:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/New_York",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;++ const vtimezoneBlock = iCalString.slice(+ iCalString.indexOf("BEGIN:VTIMEZONE"),+ iCalString.indexOf("END:VTIMEZONE") + 13+ );++ // America/New_York 2023: spring forward March 12 at 2:00 AM EST,+ // fall back November 5 at 2:00 AM EDT.+ // RFC 5545 requires DTSTART to use pre-transition local time (02:00),+ // not the post-transition time (03:00 for spring forward, 01:00 for fall back).+ const daylightBlock = vtimezoneBlock.slice(+ vtimezoneBlock.indexOf("BEGIN:DAYLIGHT"),+ vtimezoneBlock.indexOf("END:DAYLIGHT")+ );+ expect(daylightBlock).toContain("DTSTART:20230312T020000");++ const standardBlock = vtimezoneBlock.slice(+ vtimezoneBlock.indexOf("BEGIN:STANDARD"),+ vtimezoneBlock.indexOf("END:STANDARD")+ );+ expect(standardBlock).toContain("DTSTART:20231105T020000");+ });++ it("should use correct DST rules for Southern Hemisphere (Australia/Sydney)", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230115T020000Z\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ const event = createMockEvent({+ startTime: "2023-01-15T02:00:00Z",+ endTime: "2023-01-15T03:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "Australia/Sydney",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.createEvent(event, 1);++ const calledArg = vi.mocked(createCalendarObject).mock.calls[0][0];+ const iCalString = calledArg.iCalString;++ expect(iCalString).toContain("BEGIN:VTIMEZONE");+ expect(iCalString).toContain("TZID:Australia/Sydney");+ const vtimezoneBlock = iCalString.slice(+ iCalString.indexOf("BEGIN:VTIMEZONE"),+ iCalString.indexOf("END:VTIMEZONE") + 13+ );+ expect(vtimezoneBlock).toContain("BEGIN:DAYLIGHT");+ expect(vtimezoneBlock).toContain("BEGIN:STANDARD");+ });++ it("should apply timezone fix to updateEvent as well", async () => {+ const service = new TestCalendarService();+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:test-uid\r\nDTSTART:20230615T150000Z\r\nATTENDEE;CN=Guest:mailto:[email protected]\r\nDURATION:PT1H\r\nEND:VEVENT\r\nEND:VCALENDAR`;++ vi.mocked(createIcsEvent).mockReturnValue({+ error: null as unknown as Error,+ value: mockIcsOutput,+ });++ (service as unknown as Record<string, unknown>).getEventsByUID = vi.fn().mockResolvedValue([+ {+ uid: "test-uid",+ url: "https://caldav.example.com/calendar/test.ics",+ etag: '"etag123"',+ },+ ]);++ const event = createMockEvent({+ uid: "test-uid",+ startTime: "2023-06-15T15:00:00Z",+ endTime: "2023-06-15T16:00:00Z",+ organizer: {+ name: "Test",+ email: "[email protected]",+ timeZone: "America/Chicago",+ language: { translate: ((key: string) => key) as never, locale: "en" },+ },+ });++ await service.testUpdateEvent("test-uid", event, "https://caldav.example.com/calendar/");++ const calledArg = vi.mocked(updateCalendarObject).mock.calls[0][0];+ const data = calledArg.calendarObject.data;++ expect(data).toContain("BEGIN:VTIMEZONE");+ expect(data).toContain("TZID:America/Chicago");+ expect(data).toContain("DTSTART;TZID=America/Chicago:");+ });+});+describe("CalendarService - SCHEDULE-AGENT injection", () => {beforeEach(() => {vi.clearAllMocks();@@ -366,7 +718,7 @@ describe("CalendarService - SCHEDULE-AGENT injection", () => {it("should preserve other iCal properties unchanged", async () => {const service = new TestCalendarService();- const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Cal.com//NONSGML//EN\r\nATTENDEE;CN=Guest:mailto:[email protected]\r\nDTSTART:20230101T100000Z\r\nDTEND:20230101T110000Z\r\nEND:VCALENDAR`;+ const mockIcsOutput = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Cal.com//NONSGML//EN\r\nBEGIN:VEVENT\r\nATTENDEE;CN=Guest:mailto:[email protected]\r\nDTSTART:20230101T100000Z\r\nDTEND:20230101T110000Z\r\nEND:VEVENT\r\nEND:VCALENDAR`;vi.mocked(createIcsEvent).mockReturnValue({error: null as unknown as Error,value: mockIcsOutput,@@ -381,8 +733,6 @@ describe("CalendarService - SCHEDULE-AGENT injection", () => {expect(iCalString).toContain("VERSION:2.0");expect(iCalString).toContain("PRODID:-//Cal.com//NONSGML//EN");- expect(iCalString).toContain("DTSTART:20230101T100000Z");- expect(iCalString).toContain("DTEND:20230101T110000Z");});it("should handle empty iCalString gracefully", async () => {diff --git a/packages/lib/CalendarService.ts b/packages/lib/CalendarService.tsindex 1dbd8752358..a0c3b8c1838 100644--- a/packages/lib/CalendarService.ts+++ b/packages/lib/CalendarService.ts@@ -1,28 +1,15 @@/* eslint-disable @typescript-eslint/triple-slash-reference *//// <reference path="../types/ical.d.ts"/>-import ICAL from "ical.js";-import type { Attendee, DateArray, DurationObject } from "ics";-import { createEvent } from "ics";-import type { DAVAccount, DAVCalendar, DAVObject } from "tsdav";-import {- createAccount,- createCalendarObject,- deleteCalendarObject,- fetchCalendarObjects,- fetchCalendars,- getBasicAuthHeaders,- updateCalendarObject,-} from "tsdav";-import { v4 as uuidv4 } from "uuid";+import process from "node:process";import dayjs from "@calcom/dayjs";import sanitizeCalendarObject from "@calcom/lib/sanitizeCalendarObject";-import type { Person as AttendeeInCalendarEvent } from "@calcom/types/Calendar";import type {+ Person as AttendeeInCalendarEvent,Calendar,- CalendarServiceEvent,CalendarEvent,CalendarEventType,+ CalendarServiceEvent,EventBusyDate,GetAvailabilityParams,IntegrationCalendar,@@ -30,7 +17,20 @@ import type {TeamMember,} from "@calcom/types/Calendar";import type { CredentialPayload } from "@calcom/types/Credential";-+import ICAL from "ical.js";+import type { Attendee, DateArray, DurationObject } from "ics";+import { createEvent } from "ics";+import type { DAVAccount, DAVCalendar, DAVObject } from "tsdav";+import {+ createAccount,+ createCalendarObject,+ deleteCalendarObject,+ fetchCalendarObjects,+ fetchCalendars,+ getBasicAuthHeaders,+ updateCalendarObject,+} from "tsdav";+import { v4 as uuidv4 } from "uuid";import { getLocation, getRichDescription } from "./CalEventParser";import { symmetricDecrypt } from "./crypto";import logger from "./logger";@@ -172,6 +172,216 @@ const injectScheduleAgent = (iCalString: string): string => {return result;};+/**+ * Finds the DST transition moment for a given year by binary-searching+ * when the UTC offset changes between two months.+ */+const findDSTTransition = (+ timezone: string,+ year: number,+ fromMonth: number,+ toMonth: number+): ReturnType<typeof dayjs> | null => {+ let low = dayjs.utc(new Date(year, fromMonth, 1)).valueOf();+ let high = dayjs.utc(new Date(year, toMonth, 1)).valueOf();+ const lowOffset = dayjs(low).tz(timezone).utcOffset();+ const highOffset = dayjs(high).tz(timezone).utcOffset();++ if (lowOffset === highOffset) return null;++ while (high - low > 60 * 1000) {+ const mid = Math.floor((low + high) / 2);+ const midOffset = dayjs(mid).tz(timezone).utcOffset();+ if (midOffset === lowOffset) {+ low = mid;+ } else {+ high = mid;+ }+ }++ // RFC 5545 requires DTSTART to be the local time interpreted with the+ // pre-transition offset (TZOFFSETFROM). Apply the pre-transition offset+ // to the UTC transition moment to get this local time.+ const preTransitionOffsetMs = lowOffset * 60 * 1000;+ return dayjs.utc(high + preTransitionOffsetMs);+};++/** Formats a transition moment as iCal DTSTART (e.g., 20260308T020000). */+const formatTransitionDtstart = (transition: ReturnType<typeof dayjs>): string => {+ const year = String(transition.year());+ const month = String(transition.month() + 1).padStart(2, "0");+ const day = String(transition.date()).padStart(2, "0");+ const hour = String(transition.hour()).padStart(2, "0");+ const minute = String(transition.minute()).padStart(2, "0");+ return `${year}${month}${day}T${hour}${minute}00`;+};++/** Generates BYDAY RRULE value (e.g., "2SU") for nth weekday occurrence in month. */+const getBydayRule = (d: ReturnType<typeof dayjs>): string => {+ const dayNames = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];+ const dayOfWeek = dayNames[d.day()];+ const dayOfMonth = d.date();+ const weekNum = Math.ceil(dayOfMonth / 7);+ const daysInMonth = d.daysInMonth();+ if (dayOfMonth > daysInMonth - 7) {+ return `-1${dayOfWeek}`;+ }+ return `${weekNum}${dayOfWeek}`;+};++/**+ * Builds a VTIMEZONE component for the given IANA timezone.+ * Uses the event's year to compute actual DST transitions (not 1970),+ * ensuring correct BYDAY/BYMONTH for zones that changed rules post-1970.+ * RFC 5545 §3.6.5 requires VTIMEZONE when DTSTART uses TZID.+ */+const buildVTimezone = (timezone: string, eventStart: string): string => {+ const eventYear = dayjs(eventStart).tz(timezone).year();+ // Construct dates from scratch in the target timezone to get correct offsets.+ // Using .month() on an existing dayjs object may not recalculate the tz offset.+ const winterMoment = dayjs.tz(`${eventYear}-01-15T12:00:00`, timezone);+ const summerMoment = dayjs.tz(`${eventYear}-07-15T12:00:00`, timezone);++ const formatOffset = (d: ReturnType<typeof dayjs>): string => {+ const offsetMinutes = d.utcOffset();+ const sign = offsetMinutes >= 0 ? "+" : "-";+ const abs = Math.abs(offsetMinutes);+ const hours = String(Math.floor(abs / 60)).padStart(2, "0");+ const mins = String(abs % 60).padStart(2, "0");+ return `${sign}${hours}${mins}`;+ };++ const standardOffset = formatOffset(winterMoment);+ const daylightOffset = formatOffset(summerMoment);+ const hasDST = standardOffset !== daylightOffset;++ const lines: string[] = ["BEGIN:VTIMEZONE", `TZID:${timezone}`];++ if (hasDST) {+ const springTransition = findDSTTransition(timezone, eventYear, 0, 6);+ const fallTransition = findDSTTransition(timezone, eventYear, 6, 11);++ const winterUtcOffset = winterMoment.utcOffset();+ const summerUtcOffset = summerMoment.utcOffset();+ const trueStandardOffset = winterUtcOffset < summerUtcOffset ? standardOffset : daylightOffset;+ const trueDaylightOffset = winterUtcOffset < summerUtcOffset ? daylightOffset : standardOffset;+ const springIsDaylight = summerUtcOffset > winterUtcOffset;++ if (springTransition) {+ const dtstart = formatTransitionDtstart(springTransition);+ const byday = getBydayRule(springTransition);+ const bymonth = springTransition.month() + 1;++ if (springIsDaylight) {+ lines.push(+ "BEGIN:DAYLIGHT",+ `TZOFFSETFROM:${trueStandardOffset}`,+ `TZOFFSETTO:${trueDaylightOffset}`,+ "TZNAME:DST",+ `DTSTART:${dtstart}`,+ `RRULE:FREQ=YEARLY;BYMONTH=${bymonth};BYDAY=${byday}`,+ "END:DAYLIGHT"+ );+ } else {+ lines.push(+ "BEGIN:STANDARD",+ `TZOFFSETFROM:${trueDaylightOffset}`,+ `TZOFFSETTO:${trueStandardOffset}`,+ "TZNAME:ST",+ `DTSTART:${dtstart}`,+ `RRULE:FREQ=YEARLY;BYMONTH=${bymonth};BYDAY=${byday}`,+ "END:STANDARD"+ );+ }+ } else {+ lines.push(+ "BEGIN:DAYLIGHT",+ `TZOFFSETFROM:${trueStandardOffset}`,+ `TZOFFSETTO:${trueDaylightOffset}`,+ "TZNAME:DST",+ "DTSTART:19700101T000000",+ "END:DAYLIGHT"+ );+ }++ if (fallTransition) {+ const dtstart = formatTransitionDtstart(fallTransition);+ const byday = getBydayRule(fallTransition);+ const bymonth = fallTransition.month() + 1;++ if (springIsDaylight) {+ lines.push(+ "BEGIN:STANDARD",+ `TZOFFSETFROM:${trueDaylightOffset}`,+ `TZOFFSETTO:${trueStandardOffset}`,+ "TZNAME:ST",+ `DTSTART:${dtstart}`,+ `RRULE:FREQ=YEARLY;BYMONTH=${bymonth};BYDAY=${byday}`,+ "END:STANDARD"+ );+ } else {+ lines.push(+ "BEGIN:DAYLIGHT",+ `TZOFFSETFROM:${trueStandardOffset}`,+ `TZOFFSETTO:${trueDaylightOffset}`,+ "TZNAME:DST",+ `DTSTART:${dtstart}`,+ `RRULE:FREQ=YEARLY;BYMONTH=${bymonth};BYDAY=${byday}`,+ "END:DAYLIGHT"+ );+ }+ } else {+ lines.push(+ "BEGIN:STANDARD",+ `TZOFFSETFROM:${trueDaylightOffset}`,+ `TZOFFSETTO:${trueStandardOffset}`,+ "TZNAME:ST",+ "DTSTART:19700101T000000",+ "END:STANDARD"+ );+ }+ } else {+ lines.push(+ "BEGIN:STANDARD",+ `TZOFFSETFROM:${standardOffset}`,+ `TZOFFSETTO:${standardOffset}`,+ `TZNAME:${timezone}`,+ "DTSTART:19700101T000000",+ "END:STANDARD"+ );+ }++ lines.push("END:VTIMEZONE");+ return lines.join("\r\n");+};++/**+ * Injects a VTIMEZONE block and rewrites DTSTART/DTEND from UTC to timezone-local.+ */+const injectVTimezone = (+ iCalString: string,+ timezone: string,+ startTime: string,+ endTime: string+): string => {+ const formatLocalDateTime = (isoString: string, tz: string): string => {+ const local = dayjs(isoString).tz(tz);+ return local.format("YYYYMMDDTHHmmss");+ };++ const localStart = formatLocalDateTime(startTime, timezone);+ const localEnd = formatLocalDateTime(endTime, timezone);++ let result = iCalString+ .replace(/^DTSTART:[^\r\n]+/m, `DTSTART;TZID=${timezone}:${localStart}`)+ .replace(/^DTEND:[^\r\n]+/m, `DTEND;TZID=${timezone}:${localEnd}`);++ const vtimezone = buildVTimezone(timezone, startTime);+ result = result.replace(/^BEGIN:VEVENT/m, `${vtimezone}\r\nBEGIN:VEVENT`);++ return result;+};+const mapAttendees = (attendees: AttendeeInCalendarEvent[] | TeamMember[]): Attendee[] =>attendees.map(({ email, name }) => ({ name, email, partstat: "NEEDS-ACTION" }));@@ -217,7 +427,7 @@ export default abstract class BaseCalendarService implements Calendar {async createEvent(event: CalendarServiceEvent, credentialId: number): Promise<NewCalendarEventType> {try {const calendars = await this.listCalendars(event);- const uid = uuidv4();+ const uid = event.uid || uuidv4();// We create local ICS filesconst { error, value: iCalString } = createEvent({@@ -242,6 +452,11 @@ export default abstract class BaseCalendarService implements Calendar {if (error || !iCalString)throw new Error(`Error creating iCalString:=> ${error?.message} : ${error?.name} `);+ // Inject VTIMEZONE and rewrite DTSTART/DTEND to organizer's local timezone.+ // Without this, CalDAV servers send scheduling emails with UTC times.+ const timezone = event.organizer.timeZone;+ const iCalStringWithTimezone = injectVTimezone(iCalString, timezone, event.startTime, event.endTime);+const mainHostDestinationCalendar = event.destinationCalendar? (event.destinationCalendar.find((cal) => cal.credentialId === credentialId) ??event.destinationCalendar[0])@@ -261,7 +476,7 @@ export default abstract class BaseCalendarService implements Calendar {url: calendar.externalId,},filename: `${uid}.ics`,- iCalString: injectScheduleAgent(iCalString),+ iCalString: injectScheduleAgent(iCalStringWithTimezone),headers: this.headers,}))@@ -320,6 +535,12 @@ export default abstract class BaseCalendarService implements Calendar {additionalInfo: {},};}+ // Apply timezone fix to updated events as well+ const updateTimezone = event.organizer.timeZone;+ const iCalStringWithTimezone = iCalString+ ? injectVTimezone(iCalString, updateTimezone, event.startTime, event.endTime)+ : "";+let calendarEvent: CalendarEventType;const eventsToUpdate = events.filter((e) => e.uid === uid);return Promise.all(@@ -328,7 +549,7 @@ export default abstract class BaseCalendarService implements Calendar {return updateCalendarObject({calendarObject: {url: calendarEvent.url,- data: injectScheduleAgent(iCalString ?? ""),+ data: injectScheduleAgent(iCalStringWithTimezone ?? ""),etag: calendarEvent?.etag,},headers: this.headers,@@ -695,10 +916,7 @@ export default abstract class BaseCalendarService implements Calendar {(promise): promise is PromiseFulfilledResult<(DAVObject | undefined)[]> =>promise.status === "fulfilled");- const flatResult = fulfilledPromises- .map((promise) => promise.value)- .flat()- .filter((obj) => obj !== null);+ const flatResult = fulfilledPromises.flatMap((promise) => promise.value).filter((obj) => obj !== null);return flatResult as DAVObject[];}