The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
CalDAV refactor (#20180)
neo7734dd08097ceda
diff --git a/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/imap-smtp-caldav-connection.module.ts b/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/imap-smtp-caldav-connection.module.tsindex 297fd3bc04d..51159a902bd 100644--- a/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/imap-smtp-caldav-connection.module.ts+++ b/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/imap-smtp-caldav-connection.module.ts@@ -8,6 +8,7 @@ import { MessageQueueModule } from 'src/engine/core-modules/message-queue/messagimport { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';+import { CalDavDriverModule } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/caldav-driver.module';import { ConnectedAccountModule } from 'src/modules/connected-account/connected-account.module';import { IMAPAPIsModule } from 'src/modules/connected-account/imap-api/imap-apis.module';import { MessagingIMAPDriverModule } from 'src/modules/messaging/message-import-manager/drivers/imap/messaging-imap-driver.module';@@ -30,6 +31,7 @@ import { ImapSmtpCaldavService } from './services/imap-smtp-caldav-connection.seImapSmtpCaldavValidatorModule,PermissionsModule,SecureHttpClientModule,+ CalDavDriverModule,],providers: [ImapSmtpCaldavResolver, ImapSmtpCaldavService],exports: [ImapSmtpCaldavService],diff --git a/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/__tests__/imap-smtp-caldav-connection.service.spec.ts b/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/__tests__/imap-smtp-caldav-connection.service.spec.tsindex dbd7e492355..e23d911d3c3 100644--- a/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/__tests__/imap-smtp-caldav-connection.service.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/__tests__/imap-smtp-caldav-connection.service.spec.ts@@ -1,55 +1,49 @@import { Test, type TestingModule } from '@nestjs/testing';import { getRepositoryToken } from '@nestjs/typeorm';-import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';+import { type DAVClient } from 'tsdav';+import { ImapSmtpCaldavService } from 'src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection.service';import { type ConnectionParameters } from 'src/engine/core-modules/imap-smtp-caldav-connection/types/imap-smtp-caldav-connection.type';+import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';--jest.mock(- 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client',- () => ({- CalDAVClient: jest.fn().mockImplementation(() => ({- listCalendars: jest.fn().mockResolvedValue([]),- validateSyncCollectionSupport: jest.fn().mockResolvedValue(undefined),- })),- }),-);--import { CalDAVClient } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client';--const MockCalDAVClient = jest.mocked(CalDAVClient);+import { CalDavClientService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service';+import { CalDavFetchEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service';describe('ImapSmtpCaldavService', () => {let service: ImapSmtpCaldavService;- const mockSsrfSafeFetch = jest.fn();+ const mockClient = {} as DAVClient;++ const mockCalDavClientService = {+ getClient: jest.fn(),+ };- const mockSecureHttpClientService = {- createSsrfSafeFetch: jest.fn().mockReturnValue(mockSsrfSafeFetch),+ const mockCalDavFetchEventsService = {+ listEventCalendars: jest.fn(),};beforeEach(async () => {jest.clearAllMocks();- mockSecureHttpClientService.createSsrfSafeFetch.mockReturnValue(- mockSsrfSafeFetch,- );+ mockCalDavClientService.getClient.mockResolvedValue(mockClient);+ mockCalDavFetchEventsService.listEventCalendars.mockResolvedValue([+ { url: 'https://caldav.example.com/calendars/user/default/' },+ ]);const module: TestingModule = await Test.createTestingModule({providers: [ImapSmtpCaldavService,+ { provide: GlobalWorkspaceOrmManager, useValue: {} },+ { provide: getRepositoryToken(ConnectedAccountEntity), useValue: {} },+ { provide: SecureHttpClientService, useValue: {} },{- provide: GlobalWorkspaceOrmManager,- useValue: {},- },- {- provide: getRepositoryToken(ConnectedAccountEntity),- useValue: {},+ provide: CalDavClientService,+ useValue: mockCalDavClientService,},{- provide: SecureHttpClientService,- useValue: mockSecureHttpClientService,+ provide: CalDavFetchEventsService,+ useValue: mockCalDavFetchEventsService,},],}).compile();@@ -58,22 +52,43 @@ describe('ImapSmtpCaldavService', () => {});describe('testCaldavConnection', () => {- it('should pass SSRF-safe fetch to CalDAVClient', async () => {- const params: ConnectionParameters = {- host: 'https://caldav.example.com',- port: 443,- username: '[email protected]',- password: 'password123',- };+ const params: ConnectionParameters = {+ host: 'https://caldav.example.com',+ port: 443,+ username: '[email protected]',+ password: 'password123',+ };+ it('builds a CalDAV client and lists its event calendars', async () => {await service.testCaldavConnection('[email protected]', params);+ expect(mockCalDavClientService.getClient).toHaveBeenCalledWith({+ serverUrl: 'https://caldav.example.com',+ username: '[email protected]',+ password: 'password123',+ });expect(- mockSecureHttpClientService.createSsrfSafeFetch,- ).toHaveBeenCalledTimes(1);- expect(MockCalDAVClient).toHaveBeenCalledWith(- expect.objectContaining({ fetch: mockSsrfSafeFetch }),+ mockCalDavFetchEventsService.listEventCalendars,+ ).toHaveBeenCalledWith(mockClient);+ });++ it('falls back to the handle when CALDAV.username is missing', async () => {+ await service.testCaldavConnection('[email protected]', {+ ...params,+ username: undefined,+ });++ expect(mockCalDavClientService.getClient).toHaveBeenCalledWith(+ expect.objectContaining({ username: '[email protected]' }),);});++ it('throws when no event calendars are found', async () => {+ mockCalDavFetchEventsService.listEventCalendars.mockResolvedValue([]);++ await expect(+ service.testCaldavConnection('[email protected]', params),+ ).rejects.toThrow('No calendar with event support found');+ });});});diff --git a/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection.service.ts b/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection.service.tsindex e9396ef7b48..5408778f972 100644--- a/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection.service.ts+++ b/packages/twenty-server/src/engine/core-modules/imap-smtp-caldav-connection/services/imap-smtp-caldav-connection.service.ts@@ -16,7 +16,8 @@ import {} from 'src/engine/core-modules/imap-smtp-caldav-connection/types/imap-smtp-caldav-connection.type';import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';-import { CalDAVClient } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client';+import { CalDavClientService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service';+import { CalDavFetchEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service';@Injectable()export class ImapSmtpCaldavService {@@ -27,6 +28,8 @@ export class ImapSmtpCaldavService {@InjectRepository(ConnectedAccountEntity)private readonly connectedAccountRepository: Repository<ConnectedAccountEntity>,private readonly secureHttpClientService: SecureHttpClientService,+ private readonly caldavClientService: CalDavClientService,+ private readonly caldavFetchEventsService: CalDavFetchEventsService,) {}async testImapConnection(@@ -132,29 +135,31 @@ export class ImapSmtpCaldavService {handle: string,params: ConnectionParameters,): Promise<boolean> {- const ssrfSafeFetch = this.secureHttpClientService.createSsrfSafeFetch();- const client = new CalDAVClient({- serverUrl: params.host,- username: params.username ?? handle,- password: params.password,- fetch: ssrfSafeFetch,- });-try {- await client.listCalendars();- await client.validateSyncCollectionSupport();+ const client = await this.caldavClientService.getClient({+ serverUrl: params.host,+ username: params.username ?? handle,+ password: params.password,+ });++ const calendars =+ await this.caldavFetchEventsService.listEventCalendars(client);++ if (calendars.length === 0) {+ throw new UserInputError('No calendar with event support found', {+ userFriendlyMessage: msg`We couldn't find any calendars on your CalDAV server. Please make sure your account has at least one calendar.`,+ });+ }} catch (error) {+ if (error instanceof UserInputError) {+ throw error;+ }+this.logger.error(`CALDAV connection failed: ${error.message}`,error.stack,);- if (error.message?.includes('CALDAV_SYNC_COLLECTION_NOT_SUPPORTED')) {- throw new UserInputError(`CALDAV connection failed: ${error.message}`, {- userFriendlyMessage: msg`Your CalDAV server does not support incremental sync (RFC 6578). Please use a compatible provider such as Nextcloud, iCloud, or Fastmail.`,- });- }-if (error.code === 'FailedToOpenSocket') {throw new UserInputError(`CALDAV connection failed: ${error.message}`, {userFriendlyMessage: msg`We couldn't connect to your CalDAV server. Please check your server settings and try again.`,diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/caldav-driver.module.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/caldav-driver.module.tsindex 6478ccd6809..1b1cb1f1f7d 100644--- a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/caldav-driver.module.ts+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/caldav-driver.module.ts@@ -2,12 +2,21 @@ import { Module } from '@nestjs/common';import { SecureHttpClientModule } from 'src/engine/core-modules/secure-http-client/secure-http-client.module';import { TwentyConfigModule } from 'src/engine/core-modules/twenty-config/twenty-config.module';-import { CalDavClientProvider } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/caldav.provider';+import { CalDavClientService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service';+import { CalDavFetchEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service';import { CalDavGetEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-get-events.service';@Module({imports: [SecureHttpClientModule, TwentyConfigModule],- providers: [CalDavClientProvider, CalDavGetEventsService],- exports: [CalDavGetEventsService],+ providers: [+ CalDavClientService,+ CalDavFetchEventsService,+ CalDavGetEventsService,+ ],+ exports: [+ CalDavClientService,+ CalDavFetchEventsService,+ CalDavGetEventsService,+ ],})export class CalDavDriverModule {}diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client.tsdeleted file mode 100644index 1e1aca1c2c7..00000000000--- a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client.ts+++ /dev/null@@ -1,530 +0,0 @@-import { Injectable, Logger } from '@nestjs/common';--import * as ical from 'node-ical';-import {- calendarMultiGet,- createAccount,- type DAVAccount,- type DAVCalendar,- DAVNamespaceShort,- type DAVObject,- fetchCalendars,- syncCollection,-} from 'tsdav';--import { createBasicDigestAuthFetch } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/auth/create-basic-digest-auth-fetch';-import { icalDataExtractPropertyValue } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/utils/icalDataExtractPropertyValue';-import { CalDavGetEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-get-events.service';-import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';-import {- type FetchedCalendarEvent,- type FetchedCalendarEventParticipant,-} from 'src/modules/calendar/common/types/fetched-calendar-event';--const DEFAULT_CALENDAR_TYPE = 'caldav';--type CalendarCredentials = {- username: string;- password: string;- serverUrl: string;- fetch?: typeof globalThis.fetch;-};--type SimpleCalendar = {- id: string;- name: string;- url: string;- isPrimary?: boolean;- syncToken?: string | number;-};--type FetchEventsOptions = {- startDate: Date;- endDate: Date;- syncCursor?: CalDAVSyncCursor;-};--type CalDAVSyncResult = {- events: FetchedCalendarEvent[];- newSyncToken?: string;-};--type CalDAVSyncCursor = {- syncTokens: Record<string, string>;-};--type CalDAVGetEventsResponse = {- events: FetchedCalendarEvent[];- syncCursor: CalDAVSyncCursor;-};--@Injectable()-export class CalDAVClient {- private credentials: CalendarCredentials;- private logger: Logger;- private fetchOverride: typeof fetch;-- constructor(credentials: CalendarCredentials) {- this.credentials = credentials;- this.logger = new Logger(CalDAVClient.name);- this.fetchOverride = createBasicDigestAuthFetch(- credentials.username,- credentials.password,- credentials.fetch ?? globalThis.fetch,- );- }-- private hasFileExtension(url: string): boolean {- const fileName = url.substring(url.lastIndexOf('/') + 1);-- return (- fileName.includes('.') &&- !fileName.substring(fileName.lastIndexOf('.')).includes('/')- );- }-- private getFileExtension(url: string): string {- if (!this.hasFileExtension(url)) return 'ics';- const fileName = url.substring(url.lastIndexOf('/') + 1);-- return fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase();- }-- private isValidFormat(url: string): boolean {- const allowedExtensions = ['eml', 'ics'];-- return allowedExtensions.includes(this.getFileExtension(url));- }-- private async getAccount(): Promise<DAVAccount> {- return createAccount({- account: {- serverUrl: this.credentials.serverUrl,- accountType: DEFAULT_CALENDAR_TYPE,- credentials: {- username: this.credentials.username,- password: this.credentials.password,- },- },- fetch: this.fetchOverride,- });- }-- async listCalendars(): Promise<SimpleCalendar[]> {- try {- const account = await this.getAccount();-- const calendars = (await fetchCalendars({- account,- fetch: this.fetchOverride,- })) as (Omit<DAVCalendar, 'displayName'> & {- displayName?: string | Record<string, unknown>;- })[];-- return calendars.reduce<SimpleCalendar[]>((result, calendar) => {- if (!calendar.components?.includes('VEVENT')) return result;-- result.push({- id: calendar.url,- url: calendar.url,- name:- typeof calendar.displayName === 'string'- ? calendar.displayName- : 'Unnamed Calendar',- isPrimary: false,- });-- return result;- }, []);- } catch (error) {- this.logger.error(- `Error in ${CalDavGetEventsService.name} - getCalendarEvents`,- error.code,- error,- );-- throw error;- }- }-- async validateSyncCollectionSupport(): Promise<void> {- const account = await this.getAccount();-- const calendars = await fetchCalendars({- account,- fetch: this.fetchOverride,- });-- const eventCalendar = calendars.find((calendar) =>- calendar.components?.includes('VEVENT'),- );-- if (!eventCalendar) {- throw new Error('No calendar with event support found');- }-- const supportsSyncCollection =- eventCalendar.reports?.includes('syncCollection') ?? false;-- if (!supportsSyncCollection) {- throw new Error(- 'CALDAV_SYNC_COLLECTION_NOT_SUPPORTED: Your CalDAV server does not support incremental sync (RFC 6578)',- );- }- }-- /**- * Determines if an event is a full-day event by checking the raw iCal data.- * Full-day events use VALUE=DATE parameter in DTSTART/DTEND properties.- * Since node-ical converts all dates to JavaScript Date objects, we must check the raw data.- * @see https://tools.ietf.org/html/rfc5545#section-3.3.4 (DATE Value Type)- * @see https://tools.ietf.org/html/rfc5545#section-3.3.5 (DATE-TIME Value Type)- * @see https://tools.ietf.org/html/rfc5545#section-3.2.20 (VALUE Parameter)- */- private isFullDayEvent(rawICalData: string): boolean {- const lines = rawICalData.split(/\r?\n/);-- for (const line of lines) {- const trimmedLine = line.trim();-- if (- trimmedLine.startsWith('DTSTART') &&- trimmedLine.includes('VALUE=DATE')- ) {- return true;- }- }-- return false;- }-- private extractOrganizerFromEvent(- event: ical.VEvent,- ): FetchedCalendarEventParticipant | null {- if (!event.organizer) {- return null;- }-- const organizerEmail =- // @ts-expect-error - limitation of node-ical typing- event.organizer.val?.replace(/^mailto:/i, '') || '';-- return {- displayName:- // @ts-expect-error - limitation of node-ical typing- event.organizer.params?.CN || organizerEmail || 'Unknown',- responseStatus: CalendarEventParticipantResponseStatus.ACCEPTED,- handle: organizerEmail,- isOrganizer: true,- };- }-- private mapPartStatToResponseStatus(- partStat: ical.AttendeePartStat,- ): CalendarEventParticipantResponseStatus {- switch (partStat) {- case 'ACCEPTED':- return CalendarEventParticipantResponseStatus.ACCEPTED;- case 'DECLINED':- return CalendarEventParticipantResponseStatus.DECLINED;- case 'TENTATIVE':- return CalendarEventParticipantResponseStatus.TENTATIVE;- case 'NEEDS-ACTION':- default:- return CalendarEventParticipantResponseStatus.NEEDS_ACTION;- }- }-- private extractAttendeesFromEvent(- event: ical.VEvent,- ): FetchedCalendarEventParticipant[] {- if (!event.attendee) {- return [];- }-- const attendees = Array.isArray(event.attendee)- ? event.attendee- : [event.attendee];-- return attendees.map((attendee: ical.Attendee) => {- // @ts-expect-error - limitation of node-ical typing- const handle = attendee.val?.replace(/^mailto:/i, '') || '';- // @ts-expect-error - limitation of node-ical typing- const displayName = attendee.params?.CN || handle || 'Unknown';- // @ts-expect-error - limitation of node-ical typing- const partStat = attendee.params?.PARTSTAT || 'NEEDS_ACTION';-- return {- displayName,- responseStatus: this.mapPartStatToResponseStatus(partStat),- handle,- isOrganizer: false,- };- });- }-- private extractParticipantsFromEvent(- event: ical.VEvent,- ): FetchedCalendarEventParticipant[] {- const participants: FetchedCalendarEventParticipant[] = [];-- const organizer = this.extractOrganizerFromEvent(event);-- if (organizer) {- participants.push(organizer);- }-- const attendees = this.extractAttendeesFromEvent(event);-- participants.push(...attendees);-- return participants;- }-- private parseICalData(- rawData: string,- objectUrl: string,- ): FetchedCalendarEvent | null {- try {- const parsed = ical.parseICS(rawData);- const events = Object.values(parsed).filter(- (item) => item.type === 'VEVENT',- );-- if (events.length === 0) {- return null;- }-- const event = events[0] as ical.VEvent;- const participants = this.extractParticipantsFromEvent(event);-- const title = icalDataExtractPropertyValue(- event.summary,- 'Untitled Event',- );- const description = icalDataExtractPropertyValue(event.description);- const location = icalDataExtractPropertyValue(event.location);- const conferenceLinkUrl = icalDataExtractPropertyValue(event.url);-- return {- id: objectUrl,- title,- iCalUid: event.uid || '',- description,- startsAt: event.start.toISOString(),- endsAt: event.end.toISOString(),- location,- isFullDay: this.isFullDayEvent(rawData),- isCanceled: event.status === 'CANCELLED',- conferenceLinkLabel: '',- conferenceLinkUrl,- externalCreatedAt:- event.created?.toISOString() || new Date().toISOString(),- externalUpdatedAt:- event.lastmodified?.toISOString() ||- event.created?.toISOString() ||- new Date().toISOString(),- conferenceSolution: '',- recurringEventExternalId: event.recurrenceid- ? String(event.recurrenceid)- : undefined,- participants,- status: event.status || 'CONFIRMED',- };- } catch (error) {- this.logger.error(- `Error in ${CalDavGetEventsService.name} - parseICalData`,- error,- );-- return null;- }- }-- async getEvents(- options: FetchEventsOptions,- ): Promise<CalDAVGetEventsResponse> {- const calendars = await this.listCalendars();- const results = new Map<string, CalDAVSyncResult>();-- const syncPromises = calendars.map(async (calendar) => {- try {- const syncToken =- options.syncCursor?.syncTokens[calendar.url] ||- calendar.syncToken?.toString();-- const syncResult = await syncCollection({- url: calendar.url,- props: {- [`${DAVNamespaceShort.DAV}:getetag`]: {},- [`${DAVNamespaceShort.CALDAV}:calendar-data`]: {},- },- syncLevel: 1,- ...(syncToken ? { syncToken } : {}),- fetch: this.fetchOverride,- });-- const allEvents: FetchedCalendarEvent[] = [];-- const objectUrls = syncResult- .map((event) => event.href)- .filter((href): href is string => !!href && this.isValidFormat(href));-- if (objectUrls.length > 0) {- try {- const calendarObjects = await calendarMultiGet({- url: calendar.url,- props: {- [`${DAVNamespaceShort.DAV}:getetag`]: {},- [`${DAVNamespaceShort.CALDAV}:calendar-data`]: {},- },- objectUrls: objectUrls,- depth: '1',- fetch: this.fetchOverride,- });-- for (const calendarObject of calendarObjects) {- if (calendarObject.props?.calendarData) {- const iCalData = this.extractICalData(- calendarObject.props?.calendarData,- );-- if (!iCalData) {- continue;- }-- const event = this.parseICalData(- iCalData,- calendarObject.href || '',- );-- if (- event &&- this.isEventInTimeRange(- {- url: calendarObject.href || '',- data: calendarObject.props.calendarData,- etag: calendarObject.props.getetag,- },- options.startDate,- options.endDate,- )- ) {- allEvents.push(event);- }- }- }- } catch (fetchError) {- this.logger.error(- `Error in ${CalDavGetEventsService.name} - getEvents`,- fetchError,- );- }- }-- let newSyncToken = syncToken;-- try {- const account = await this.getAccount();- const updatedCalendars = await fetchCalendars({- account,- fetch: this.fetchOverride,- });- const updatedCalendar = updatedCalendars.find(- (cal) => cal.url === calendar.url,- );-- if (updatedCalendar?.syncToken) {- newSyncToken = updatedCalendar.syncToken.toString();- }- } catch (syncTokenError) {- this.logger.error(- `Error in ${CalDavGetEventsService.name} - getEvents`,- syncTokenError,- );- }-- results.set(calendar.url, {- events: allEvents,- newSyncToken,- });- } catch {- results.set(calendar.url, {- events: [],- newSyncToken: options.syncCursor?.syncTokens[calendar.url],- });- }- });-- await Promise.all(syncPromises);-- const allEvents = Array.from(results.values())- .map((result) => result.events)- .flat();-- const syncTokens: Record<string, string> = {};-- for (const [calendarUrl, result] of results) {- if (result.newSyncToken) {- syncTokens[calendarUrl] = result.newSyncToken;- }- }-- return {- events: allEvents,- syncCursor: { syncTokens },- };- }-- /**- * Extracts iCal data from various CalDAV server response formats.- * Some servers return data directly as a string, others nest it under _cdata or some other properties.- */- private extractICalData(- calendarData: string | Record<string, unknown>,- ): string | null {- if (!calendarData) return null;-- if (- typeof calendarData === 'string' &&- calendarData.includes('VCALENDAR')- ) {- return calendarData;- }-- if (typeof calendarData === 'object' && calendarData !== null) {- for (const key in calendarData) {- const result = this.extractICalData(- calendarData[key] as string | Record<string, unknown>,- );-- if (result) return result;- }- }-- return null;- }-- private isEventInTimeRange(- davObject: DAVObject,- startDate: Date,- endDate: Date,- ): boolean {- try {- if (!davObject.data) return false;-- const parsed = ical.parseICS(davObject.data);- const events = Object.values(parsed).filter(- (item) => item.type === 'VEVENT',- );-- if (events.length === 0) return false;-- const event = events[0] as ical.VEvent;-- return event.start < endDate && event.end > startDate;- } catch {- return true;- }- }-}diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/__tests__/caldav.provider.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/__tests__/caldav.provider.spec.tsdeleted file mode 100644index 83edb322fb1..00000000000--- a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/__tests__/caldav.provider.spec.ts+++ /dev/null@@ -1,52 +0,0 @@-import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';-import { CalDavClientProvider } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/caldav.provider';-import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';--jest.mock(- 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client',- () => ({- CalDAVClient: jest.fn().mockImplementation((creds) => creds),- }),-);--import { CalDAVClient } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client';--const MockCalDAVClient = jest.mocked(CalDAVClient);--describe('CalDavClientProvider', () => {- describe('getCalDavCalendarClient', () => {- it('should pass SSRF-safe fetch to CalDAVClient', async () => {- const fakeFetch = jest.fn();- const mockSecureHttpClientService = {- createSsrfSafeFetch: jest.fn().mockReturnValue(fakeFetch),- } as unknown as SecureHttpClientService;-- const provider = new CalDavClientProvider(mockSecureHttpClientService);-- const connectedAccount = {- id: 'account-1',- provider: 'IMAP_SMTP_CALDAV',- handle: '[email protected]',- connectionParameters: {- CALDAV: {- host: 'https://caldav.example.com',- password: 'secret',- username: 'caldav-user',- },- },- } as unknown as Pick<- ConnectedAccountEntity,- 'id' | 'provider' | 'connectionParameters' | 'handle'- >;-- await provider.getCalDavCalendarClient(connectedAccount);-- expect(- mockSecureHttpClientService.createSsrfSafeFetch,- ).toHaveBeenCalledTimes(1);- expect(MockCalDAVClient).toHaveBeenCalledWith(- expect.objectContaining({ fetch: fakeFetch }),- );- });- });-});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/caldav.provider.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/caldav.provider.tsdeleted file mode 100644index c455bc88f04..00000000000--- a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/caldav.provider.ts+++ /dev/null@@ -1,41 +0,0 @@-import { Injectable } from '@nestjs/common';--import { isDefined } from 'twenty-shared/utils';--import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';-import { CalDAVClient } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/caldav.client';-import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';--@Injectable()-export class CalDavClientProvider {- constructor(- private readonly secureHttpClientService: SecureHttpClientService,- ) {}-- public async getCalDavCalendarClient(- connectedAccount: Pick<- ConnectedAccountEntity,- 'id' | 'provider' | 'connectionParameters' | 'handle'- >,- ): Promise<CalDAVClient> {- if (- !connectedAccount.connectionParameters?.CALDAV?.password ||- !connectedAccount.connectionParameters?.CALDAV?.host ||- !isDefined(connectedAccount.handle)- ) {- throw new Error('Missing required CalDAV connection parameters');- }-- const serverUrl = connectedAccount.connectionParameters.CALDAV.host;- const ssrfSafeFetch = this.secureHttpClientService.createSsrfSafeFetch();-- return new CalDAVClient({- username:- connectedAccount.connectionParameters.CALDAV.username ??- connectedAccount.handle,- password: connectedAccount.connectionParameters.CALDAV.password,- serverUrl,- fetch: ssrfSafeFetch,- });- }-}diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service.tsnew file mode 100644index 00000000000..6ad0503145b--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service.ts@@ -0,0 +1,42 @@+import { Injectable } from '@nestjs/common';++import { DAVClient } from 'tsdav';++import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';+import { createBasicDigestAuthFetch } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/auth/create-basic-digest-auth-fetch';++type CalDavConnectionParams = {+ serverUrl: string;+ username: string;+ password: string;+};++@Injectable()+export class CalDavClientService {+ constructor(+ private readonly secureHttpClientService: SecureHttpClientService,+ ) {}++ async getClient(input: CalDavConnectionParams): Promise<DAVClient> {+ const ssrfSafeFetch = this.secureHttpClientService.createSsrfSafeFetch();+ const fetch = createBasicDigestAuthFetch(+ input.username,+ input.password,+ ssrfSafeFetch,+ );++ const client = new DAVClient({+ serverUrl: input.serverUrl,+ credentials: { username: input.username, password: input.password },+ authMethod: 'Custom',+ // our fetch handles Basic+Digest itself; no-op authFunction so tsdav doesn't add its own header on top+ authFunction: async () => ({}),+ defaultAccountType: 'caldav',+ fetch,+ });++ await client.login();++ return client;+ }+}diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service.spec.tsnew file mode 100644index 00000000000..ae515ccd686--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service.spec.ts@@ -0,0 +1,336 @@+import { type DAVClient } from 'tsdav';++import { CalDavFetchEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service';++const PRIMARY_URL = 'https://caldav.example.com/calendars/user/primary/';+const PERSONAL_URL = 'https://caldav.example.com/calendars/user/personal/';+const HREF_A = `${PRIMARY_URL}event-a.ics`;+const HREF_B = `${PRIMARY_URL}event-b.ics`;++const buildICal = (uid: string) =>+ [+ 'BEGIN:VCALENDAR',+ 'VERSION:2.0',+ 'BEGIN:VEVENT',+ `UID:${uid}`,+ `SUMMARY:${uid}`,+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ 'STATUS:CONFIRMED',+ 'END:VEVENT',+ 'END:VCALENDAR',+ ].join('\r\n');++const inWindow = {+ startDate: new Date('2026-01-01'),+ endDate: new Date('2027-01-01'),+};++const buildClient = () => {+ const fetchCalendars = jest.fn();+ const syncCollection = jest.fn();+ const calendarMultiGet = jest.fn();+ const propfind = jest.fn();++ return {+ client: {+ fetchCalendars,+ syncCollection,+ calendarMultiGet,+ propfind,+ } as unknown as DAVClient,+ fetchCalendars,+ syncCollection,+ calendarMultiGet,+ propfind,+ };+};++describe('CalDavFetchEventsService', () => {+ let service: CalDavFetchEventsService;++ beforeEach(() => {+ service = new CalDavFetchEventsService();+ });++ describe('per-calendar tier dispatch', () => {+ it('runs Tier-1 on calendars advertising sync-collection and Tier-2/3 on the rest, in parallel', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: ['syncCollection'],+ },+ { url: PERSONAL_URL, components: ['VEVENT'], reports: [], ctag: 'c-1' },+ ]);++ c.syncCollection.mockResolvedValue([+ { href: HREF_A, status: 207, statusText: 'OK', ok: true, props: {} },+ ]);++ c.propfind.mockResolvedValue([+ {+ href: HREF_B,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { getetag: '"etag-b"' },+ },+ ]);++ c.calendarMultiGet+ .mockResolvedValueOnce([+ {+ href: HREF_A,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { calendarData: buildICal('uid-a') },+ },+ ])+ .mockResolvedValueOnce([+ {+ href: HREF_B,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { calendarData: buildICal('uid-b') },+ },+ ]);++ const result = await service.fetchEvents(c.client, inWindow);++ expect(result.events.map((event) => event.iCalUid).sort()).toEqual([+ 'uid-a',+ 'uid-b',+ ]);+ expect(c.syncCollection).toHaveBeenCalledTimes(1);+ expect(c.propfind).toHaveBeenCalledTimes(1);+ });+ });++ describe('Tier-2/3 ctag short-circuit', () => {+ it('skips network entirely when the server CTag matches the stored CTag', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: [],+ ctag: 'unchanged',+ },+ ]);++ const storedEtags = { [HREF_A]: '"etag-a"' };++ const result = await service.fetchEvents(c.client, {+ ...inWindow,+ syncCursor: {+ syncTokens: {},+ ctags: { [PRIMARY_URL]: 'unchanged' },+ etags: { [PRIMARY_URL]: storedEtags },+ },+ });++ expect(result.events).toEqual([]);+ expect(c.propfind).not.toHaveBeenCalled();+ expect(c.calendarMultiGet).not.toHaveBeenCalled();+ expect(result.syncCursor.etags).toEqual({ [PRIMARY_URL]: storedEtags });+ });+ });++ describe('Tier-2/3 etag diff', () => {+ it('fetches only changed hrefs and emits cancelled stubs for hrefs vanished from the server', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: [],+ ctag: 'new-ctag',+ },+ ]);++ c.propfind.mockResolvedValue([+ {+ href: HREF_A,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { getetag: '"etag-a-updated"' },+ },+ ]);++ c.calendarMultiGet.mockResolvedValue([+ {+ href: HREF_A,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { calendarData: buildICal('uid-a') },+ },+ ]);++ const result = await service.fetchEvents(c.client, {+ ...inWindow,+ syncCursor: {+ syncTokens: {},+ ctags: { [PRIMARY_URL]: 'old-ctag' },+ etags: {+ [PRIMARY_URL]: { [HREF_A]: '"etag-a"', [HREF_B]: '"etag-b"' },+ },+ },+ });++ expect(c.calendarMultiGet).toHaveBeenCalledWith(+ expect.objectContaining({ objectUrls: [HREF_A] }),+ );++ const live = result.events.filter((event) => !event.isCanceled);+ const cancelled = result.events.filter((event) => event.isCanceled);++ expect(live.map((event) => event.iCalUid)).toEqual(['uid-a']);+ expect(cancelled.map((event) => event.id)).toEqual([HREF_B]);+ });+ });++ describe('per-calendar error isolation', () => {+ it('preserves the prior cursor entry (token + ctag + etags) for the failing calendar without aborting siblings', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: ['syncCollection'],+ },+ {+ url: PERSONAL_URL,+ components: ['VEVENT'],+ reports: [],+ ctag: 'c-new',+ },+ ]);++ c.syncCollection.mockRejectedValue(new Error('network blip'));+ c.propfind.mockRejectedValue(new Error('propfind blip'));++ const priorEtags = { [HREF_A]: '"etag-a"' };++ const result = await service.fetchEvents(c.client, {+ ...inWindow,+ syncCursor: {+ syncTokens: { [PRIMARY_URL]: 'token-prior' },+ ctags: { [PERSONAL_URL]: 'c-prior' },+ etags: { [PERSONAL_URL]: priorEtags },+ },+ });++ expect(result.events).toEqual([]);+ expect(result.syncCursor.syncTokens[PRIMARY_URL]).toBe('token-prior');+ expect(result.syncCursor.ctags?.[PERSONAL_URL]).toBe('c-prior');+ expect(result.syncCursor.etags?.[PERSONAL_URL]).toEqual(priorEtags);+ });+ });++ describe('cursor shape', () => {+ it('omits ctags and etags entirely when only sync-collection calendars exist', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: ['syncCollection'],+ },+ ]);+ c.syncCollection.mockResolvedValue([+ {+ status: 207,+ statusText: 'OK',+ ok: true,+ raw: { multistatus: { syncToken: 'token-fresh' } },+ },+ ]);+ c.calendarMultiGet.mockResolvedValue([]);++ const result = await service.fetchEvents(c.client, inWindow);++ expect(result.syncCursor).toEqual({+ syncTokens: { [PRIMARY_URL]: 'token-fresh' },+ });+ });+ });++ describe('initial sync (no stored cursor)', () => {+ it('omits the sync-token on the first run so the server returns a full listing (RFC 6578 §3.4)', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: ['syncCollection'],+ syncToken: 'server-current-token',+ },+ ]);+ c.syncCollection.mockResolvedValue([+ { href: HREF_A, status: 207, statusText: 'OK', ok: true, props: {} },+ ]);+ c.calendarMultiGet.mockResolvedValue([+ {+ href: HREF_A,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { calendarData: buildICal('uid-a') },+ },+ ]);++ await service.fetchEvents(c.client, inWindow);++ expect(c.syncCollection).toHaveBeenCalledWith(+ expect.not.objectContaining({ syncToken: expect.anything() }),+ );+ });+ });++ describe('time-window filtering', () => {+ it('drops events that fall outside the requested [startDate, endDate] window', async () => {+ const c = buildClient();++ c.fetchCalendars.mockResolvedValue([+ {+ url: PRIMARY_URL,+ components: ['VEVENT'],+ reports: ['syncCollection'],+ },+ ]);++ c.syncCollection.mockResolvedValue([+ { href: HREF_A, status: 207, statusText: 'OK', ok: true, props: {} },+ ]);++ c.calendarMultiGet.mockResolvedValue([+ {+ href: HREF_A,+ status: 207,+ statusText: 'OK',+ ok: true,+ props: { calendarData: buildICal('uid-a') },+ },+ ]);++ const result = await service.fetchEvents(c.client, {+ startDate: new Date('2030-01-01'),+ endDate: new Date('2030-12-31'),+ });++ expect(result.events).toEqual([]);+ });+ });+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service.tsnew file mode 100644index 00000000000..c8b65458350--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service.ts@@ -0,0 +1,290 @@+import { Injectable, Logger } from '@nestjs/common';++import { isNonEmptyString } from '@sniptt/guards';+import {+ type DAVCalendar,+ type DAVClient,+ type DAVResponse,+ DAVNamespaceShort,+} from 'tsdav';+import { isDefined } from 'twenty-shared/utils';++import { type CalDavSyncCursor } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/types/caldav-sync-cursor';+import { buildCancelledCalDavEvent } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/build-cancelled-event.util';+import { extractICalData } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-ical-data.util';+import { isEventInTimeRange } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-event-in-time-range.util';+import { isInvalidSyncTokenResponse } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-invalid-sync-token-response.util';+import { isValidCalDavHref } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-valid-caldav-href.util';+import { parseICalEvents } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-ical-event.util';+import { type FetchedCalendarEvent } from 'src/modules/calendar/common/types/fetched-calendar-event';++type CalendarSyncResult = {+ calendarUrl: string;+ events: FetchedCalendarEvent[];+ newSyncToken?: string;+ newCtag?: string;+ newEtags?: Record<string, string>;+};++type FetchEventsOptions = {+ startDate: Date;+ endDate: Date;+ syncCursor?: CalDavSyncCursor;+};++@Injectable()+export class CalDavFetchEventsService {+ private readonly logger = new Logger(CalDavFetchEventsService.name);++ async listEventCalendars(client: DAVClient): Promise<DAVCalendar[]> {+ const calendars = await client.fetchCalendars();++ return calendars.filter((calendar) =>+ calendar.components?.includes('VEVENT'),+ );+ }++ async fetchEvents(+ client: DAVClient,+ options: FetchEventsOptions,+ ): Promise<{ events: FetchedCalendarEvent[]; syncCursor: CalDavSyncCursor }> {+ const calendars = await this.listEventCalendars(client);++ const results = await Promise.all(+ calendars.map((calendar) => this.syncCalendar(client, calendar, options)),+ );++ return {+ events: results.flatMap((result) => result.events),+ syncCursor: this.mergeSyncCursor(results),+ };+ }++ private async syncCalendar(+ client: DAVClient,+ calendar: DAVCalendar,+ options: FetchEventsOptions,+ ): Promise<CalendarSyncResult> {+ const supportsSyncCollection =+ calendar.reports?.includes('syncCollection') ?? false;++ try {+ return supportsSyncCollection+ ? await this.fetchEventsViaSyncCollection(client, calendar, options)+ : await this.fetchEventsViaCtagEtag(client, calendar, options);+ } catch (error) {+ this.logger.error(`Per-calendar sync failed for ${calendar.url}`, error);++ return {+ calendarUrl: calendar.url,+ events: [],+ newSyncToken: options.syncCursor?.syncTokens[calendar.url],+ newCtag: options.syncCursor?.ctags?.[calendar.url],+ newEtags: options.syncCursor?.etags?.[calendar.url],+ };+ }+ }++ private async fetchEventsViaSyncCollection(+ client: DAVClient,+ calendar: DAVCalendar,+ options: FetchEventsOptions,+ ): Promise<CalendarSyncResult> {+ const previousSyncToken = options.syncCursor?.syncTokens[calendar.url];++ const syncResult = await this.runSyncCollection(+ client,+ calendar.url,+ previousSyncToken,+ );++ const memberResponses = syncResult.filter(+ (entry): entry is DAVResponse & { href: string } =>+ isNonEmptyString(entry.href) && isValidCalDavHref(entry.href),+ );++ const changedHrefs = memberResponses+ .filter((entry) => entry.status !== 404)+ .map((entry) => entry.href);+ const cancelledHrefs = memberResponses+ .filter((entry) => entry.status === 404)+ .map((entry) => entry.href);++ const fetchedEvents = await this.fetchAndParseEvents(+ client,+ calendar.url,+ changedHrefs,+ options,+ );++ const rawSyncToken = syncResult[0]?.raw?.multistatus?.syncToken;+ const newSyncToken = isNonEmptyString(rawSyncToken)+ ? rawSyncToken+ : previousSyncToken;++ return {+ calendarUrl: calendar.url,+ events: [+ ...fetchedEvents,+ ...cancelledHrefs.map(buildCancelledCalDavEvent),+ ],+ newSyncToken,+ };+ }++ private async runSyncCollection(+ client: DAVClient,+ url: string,+ previousSyncToken: string | undefined,+ ): Promise<DAVResponse[]> {+ const send = (token: string | undefined) =>+ client.syncCollection({+ url,+ props: {+ [`${DAVNamespaceShort.DAV}:getetag`]: {},+ [`${DAVNamespaceShort.CALDAV}:calendar-data`]: {},+ },+ syncLevel: 1,+ ...(isNonEmptyString(token) ? { syncToken: token } : {}),+ });++ const result = await send(previousSyncToken);++ if (+ isNonEmptyString(previousSyncToken) &&+ isInvalidSyncTokenResponse(result)+ ) {+ this.logger.warn(+ `Sync-token invalidated for ${url}; falling back to full re-sync`,+ );++ return send(undefined);+ }++ return result;+ }++ private async fetchEventsViaCtagEtag(+ client: DAVClient,+ calendar: DAVCalendar,+ options: FetchEventsOptions,+ ): Promise<CalendarSyncResult> {+ const storedEtags = options.syncCursor?.etags?.[calendar.url] ?? {};+ const newCtag = isDefined(calendar.ctag)+ ? String(calendar.ctag)+ : undefined;+ const storedCtag = options.syncCursor?.ctags?.[calendar.url];++ if (isDefined(newCtag) && isDefined(storedCtag) && newCtag === storedCtag) {+ return {+ calendarUrl: calendar.url,+ events: [],+ newCtag,+ newEtags: storedEtags,+ };+ }++ const currentEtags = await this.fetchEtagsByHref(client, calendar.url);++ const changedHrefs = Object.keys(currentEtags).filter(+ (href) => storedEtags[href] !== currentEtags[href],+ );+ const cancelledHrefs = Object.keys(storedEtags).filter(+ (href) => !(href in currentEtags),+ );++ const fetchedEvents = await this.fetchAndParseEvents(+ client,+ calendar.url,+ changedHrefs,+ options,+ );++ return {+ calendarUrl: calendar.url,+ events: [+ ...fetchedEvents,+ ...cancelledHrefs.map(buildCancelledCalDavEvent),+ ],+ newCtag,+ newEtags: currentEtags,+ };+ }++ private mergeSyncCursor(results: CalendarSyncResult[]): CalDavSyncCursor {+ const syncTokens: Record<string, string> = {};+ const ctags: Record<string, string> = {};+ const etags: Record<string, Record<string, string>> = {};++ for (const result of results) {+ if (result.newSyncToken)+ syncTokens[result.calendarUrl] = result.newSyncToken;+ if (result.newCtag) ctags[result.calendarUrl] = result.newCtag;+ if (result.newEtags) etags[result.calendarUrl] = result.newEtags;+ }++ return {+ syncTokens,+ ctags: Object.keys(ctags).length > 0 ? ctags : undefined,+ etags: Object.keys(etags).length > 0 ? etags : undefined,+ };+ }++ private async fetchEtagsByHref(+ client: DAVClient,+ calendarUrl: string,+ ): Promise<Record<string, string>> {+ const responses = await client.propfind({+ url: calendarUrl,+ props: { [`${DAVNamespaceShort.DAV}:getetag`]: {} },+ depth: '1',+ });++ return responses.reduce<Record<string, string>>((map, response) => {+ const href = response.href;+ const etag = response.props?.getetag;++ if (+ !isNonEmptyString(href) ||+ !isNonEmptyString(etag) ||+ !isValidCalDavHref(href)+ ) {+ return map;+ }++ map[href] = etag;++ return map;+ }, {});+ }++ private async fetchAndParseEvents(+ client: DAVClient,+ calendarUrl: string,+ objectUrls: string[],+ options: { startDate: Date; endDate: Date },+ ): Promise<FetchedCalendarEvent[]> {+ if (objectUrls.length === 0) return [];++ const calendarObjects = await client.calendarMultiGet({+ url: calendarUrl,+ props: {+ [`${DAVNamespaceShort.DAV}:getetag`]: {},+ [`${DAVNamespaceShort.CALDAV}:calendar-data`]: {},+ },+ objectUrls,+ depth: '1',+ });++ return calendarObjects.flatMap((calendarObject) => {+ const iCalData = extractICalData(calendarObject.props?.calendarData);++ if (!iCalData) return [];++ return parseICalEvents(iCalData, calendarObject.href || '').filter(+ (event) =>+ isEventInTimeRange(event, options.startDate, options.endDate),+ );+ });+ }+}diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-get-events.service.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-get-events.service.tsindex 6a6c0d3e6cc..cb70f369dbc 100644--- a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-get-events.service.ts+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-get-events.service.ts@@ -1,9 +1,14 @@import { Injectable, Logger } from '@nestjs/common';-import { CalDavClientProvider } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/providers/caldav.provider';+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-shared/utils';++import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';+import { CalDavClientService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-client.service';+import { CalDavFetchEventsService } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/services/caldav-fetch-events.service';+import { type CalDavSyncCursor } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/types/caldav-sync-cursor';import { parseCalDAVError } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-caldav-error.util';import { type GetCalendarEventsResponse } from 'src/modules/calendar/calendar-event-import-manager/services/calendar-get-events.service';-import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';@Injectable()export class CalDavGetEventsService {@@ -13,10 +18,11 @@ export class CalDavGetEventsService {private static readonly FUTURE_DAYS_WINDOW = 365;constructor(- private readonly caldavCalendarClientProvider: CalDavClientProvider,+ private readonly clientService: CalDavClientService,+ private readonly fetchEventsService: CalDavFetchEventsService,) {}- public async getCalendarEvents(+ async getCalendarEvents(connectedAccount: Pick<ConnectedAccountEntity,'provider' | 'id' | 'connectionParameters' | 'handle'@@ -26,10 +32,21 @@ export class CalDavGetEventsService {this.logger.debug(`Getting calendar events for ${connectedAccount.handle}`);try {- const caldavCalendarClient =- await this.caldavCalendarClientProvider.getCalDavCalendarClient(- connectedAccount,- );+ const params = connectedAccount.connectionParameters?.CALDAV;++ if (+ !isNonEmptyString(params?.host) ||+ !isNonEmptyString(params?.password) ||+ !isDefined(connectedAccount.handle)+ ) {+ throw new Error('Missing required CalDAV connection parameters');+ }++ const client = await this.clientService.getClient({+ serverUrl: params.host,+ username: params.username ?? connectedAccount.handle,+ password: params.password,+ });const startDate = new Date(Date.now() -@@ -40,10 +57,12 @@ export class CalDavGetEventsService {CalDavGetEventsService.FUTURE_DAYS_WINDOW * 24 * 60 * 60 * 1000,);- const result = await caldavCalendarClient.getEvents({+ const result = await this.fetchEventsService.fetchEvents(client, {startDate,endDate,- syncCursor: syncCursor ? JSON.parse(syncCursor) : undefined,+ syncCursor: syncCursor+ ? (JSON.parse(syncCursor) as CalDavSyncCursor)+ : undefined,});this.logger.debug(@@ -56,17 +75,12 @@ export class CalDavGetEventsService {nextSyncCursor: JSON.stringify(result.syncCursor),};} catch (error) {- this.handleError(error as Error);- throw error;- }- }-- private handleError(error: Error) {- this.logger.error(- `Error in ${CalDavGetEventsService.name} - getCalendarEvents`,- error,- );+ this.logger.error(+ `Error in ${CalDavGetEventsService.name} - getCalendarEvents`,+ error,+ );- throw parseCalDAVError(error);+ throw parseCalDAVError(error as Error);+ }}}diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/types/caldav-sync-cursor.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/types/caldav-sync-cursor.tsnew file mode 100644index 00000000000..70fed76a079--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/types/caldav-sync-cursor.ts@@ -0,0 +1,5 @@+export type CalDavSyncCursor = {+ syncTokens: Record<string, string>;+ ctags?: Record<string, string>;+ etags?: Record<string, Record<string, string>>;+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/extract-ical-data.util.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/extract-ical-data.util.spec.tsnew file mode 100644index 00000000000..480ae88574f--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/extract-ical-data.util.spec.ts@@ -0,0 +1,34 @@+import { extractICalData } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-ical-data.util';++const VCALENDAR_PAYLOAD = 'BEGIN:VCALENDAR\r\nEND:VCALENDAR';++describe('extractICalData', () => {+ it('returns the string as-is when it already contains VCALENDAR', () => {+ expect(extractICalData(VCALENDAR_PAYLOAD)).toBe(VCALENDAR_PAYLOAD);+ });++ it('unwraps nested CDATA-style wrappers', () => {+ expect(extractICalData({ _cdata: VCALENDAR_PAYLOAD })).toBe(+ VCALENDAR_PAYLOAD,+ );+ });++ it('recurses through arbitrarily nested objects', () => {+ expect(+ extractICalData({+ outer: { inner: { deeper: VCALENDAR_PAYLOAD } },+ }),+ ).toBe(VCALENDAR_PAYLOAD);+ });++ it('returns null when no VCALENDAR block is found', () => {+ expect(extractICalData('not a calendar')).toBeNull();+ expect(extractICalData({ random: 'payload' })).toBeNull();+ });++ it.each([null, undefined, ''])('returns null for empty input %s', (value) => {+ expect(+ extractICalData(value as unknown as string | Record<string, unknown>),+ ).toBeNull();+ });+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/is-event-in-time-range.util.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/is-event-in-time-range.util.spec.tsnew file mode 100644index 00000000000..95ea2f65f0b--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/is-event-in-time-range.util.spec.ts@@ -0,0 +1,66 @@+import { isEventInTimeRange } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-event-in-time-range.util';+import { type FetchedCalendarEvent } from 'src/modules/calendar/common/types/fetched-calendar-event';++const event = (startsAt: string, endsAt: string) =>+ ({ startsAt, endsAt }) as unknown as FetchedCalendarEvent;++const WINDOW_START = new Date('2026-01-01');+const WINDOW_END = new Date('2026-12-31');++describe('isEventInTimeRange', () => {+ it('returns false when the event lacks start or end', () => {+ expect(isEventInTimeRange(event('', ''), WINDOW_START, WINDOW_END)).toBe(+ false,+ );+ });++ it('includes events fully inside the window', () => {+ expect(+ isEventInTimeRange(+ event('2026-06-01T10:00:00Z', '2026-06-01T11:00:00Z'),+ WINDOW_START,+ WINDOW_END,+ ),+ ).toBe(true);+ });++ it('excludes events entirely before the window', () => {+ expect(+ isEventInTimeRange(+ event('2025-06-01T10:00:00Z', '2025-06-01T11:00:00Z'),+ WINDOW_START,+ WINDOW_END,+ ),+ ).toBe(false);+ });++ it('excludes events entirely after the window', () => {+ expect(+ isEventInTimeRange(+ event('2027-06-01T10:00:00Z', '2027-06-01T11:00:00Z'),+ WINDOW_START,+ WINDOW_END,+ ),+ ).toBe(false);+ });++ it('includes events that straddle the start boundary', () => {+ expect(+ isEventInTimeRange(+ event('2025-12-31T22:00:00Z', '2026-01-01T02:00:00Z'),+ WINDOW_START,+ WINDOW_END,+ ),+ ).toBe(true);+ });++ it('includes events that straddle the end boundary', () => {+ expect(+ isEventInTimeRange(+ event('2026-12-30T22:00:00Z', '2027-01-01T02:00:00Z'),+ WINDOW_START,+ WINDOW_END,+ ),+ ).toBe(true);+ });+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/is-valid-caldav-href.util.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/is-valid-caldav-href.util.spec.tsnew file mode 100644index 00000000000..d30c12c142d--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/is-valid-caldav-href.util.spec.ts@@ -0,0 +1,30 @@+import { isValidCalDavHref } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-valid-caldav-href.util';++describe('isValidCalDavHref', () => {+ it.each([+ 'https://caldav.example.com/calendars/user/event.ics',+ 'https://caldav.example.com/calendars/user/event.ICS',+ 'https://caldav.example.com/calendars/user/message.eml',+ ])('accepts CalDAV-format href %s', (href) => {+ expect(isValidCalDavHref(href)).toBe(true);+ });++ it.each([+ 'https://caldav.example.com/calendars/user/notes.txt',+ 'https://caldav.example.com/calendars/user/data.json',+ ])('rejects non-CalDAV extension %s', (href) => {+ expect(isValidCalDavHref(href)).toBe(false);+ });++ it('treats hrefs without an extension as ics (some servers omit it)', () => {+ expect(+ isValidCalDavHref('https://caldav.example.com/calendars/user/abc123'),+ ).toBe(true);+ });++ it('treats trailing slash as no-extension', () => {+ expect(+ isValidCalDavHref('https://caldav.example.com/calendars/user/'),+ ).toBe(true);+ });+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/parse-caldav-error.util.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/parse-caldav-error.util.spec.tsnew file mode 100644index 00000000000..2b1d297bf7f--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/parse-caldav-error.util.spec.ts@@ -0,0 +1,47 @@+import {+ CalendarEventImportDriverException,+ CalendarEventImportDriverExceptionCode,+} from 'src/modules/calendar/calendar-event-import-manager/drivers/exceptions/calendar-event-import-driver.exception';+import { parseCalDAVError } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-caldav-error.util';++describe('parseCalDAVError', () => {+ it('maps tsdav auth-failure messages to INSUFFICIENT_PERMISSIONS', () => {+ for (const message of [+ 'no account for fetchCalendars',+ 'Must have account before syncCalendars',+ 'Invalid credentials',+ 'Invalid auth method',+ ]) {+ const result = parseCalDAVError(new Error(message));++ expect(result).toBeInstanceOf(CalendarEventImportDriverException);+ expect(result.code).toBe(+ CalendarEventImportDriverExceptionCode.INSUFFICIENT_PERMISSIONS,+ );+ }+ });++ it('maps tsdav not-found messages to NOT_FOUND', () => {+ for (const message of [+ 'Collection does not exist on server',+ 'cannot find homeUrl',+ 'cannot fetchCalendarObjects for undefined calendar',+ ]) {+ expect(parseCalDAVError(new Error(message)).code).toBe(+ CalendarEventImportDriverExceptionCode.NOT_FOUND,+ );+ }+ });++ it('falls back to UNKNOWN for unrecognised errors', () => {+ expect(parseCalDAVError(new Error('TLS handshake failed')).code).toBe(+ CalendarEventImportDriverExceptionCode.UNKNOWN,+ );+ });++ it('forwards the original error message untouched', () => {+ const result = parseCalDAVError(new Error('Invalid credentials'));++ expect(result.message).toBe('Invalid credentials');+ });+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/parse-ical-event.util.spec.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/parse-ical-event.util.spec.tsnew file mode 100644index 00000000000..38d5aea2640--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/__tests__/parse-ical-event.util.spec.ts@@ -0,0 +1,257 @@+import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';+import { parseICalEvents } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-ical-event.util';++const HREF = 'https://caldav.example.com/calendars/user/event-1.ics';++const buildVCalendar = (vevents: string[][]) =>+ [+ 'BEGIN:VCALENDAR',+ 'VERSION:2.0',+ ...vevents.flatMap((lines) => ['BEGIN:VEVENT', ...lines, 'END:VEVENT']),+ 'END:VCALENDAR',+ ].join('\r\n');++const buildVEvent = (lines: string[]) => buildVCalendar([lines]);++describe('parseICalEvents', () => {+ it('returns an empty array when the payload contains no VEVENT', () => {+ const ics = ['BEGIN:VCALENDAR', 'VERSION:2.0', 'END:VCALENDAR'].join(+ '\r\n',+ );++ expect(parseICalEvents(ics, HREF)).toEqual([]);+ });++ it('extracts the canonical VEVENT fields', () => {+ const ics = buildVEvent([+ 'UID:abc123',+ 'SUMMARY:Quarterly review',+ 'DESCRIPTION:Discuss Q2 numbers',+ 'LOCATION:Room 4',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ ]);++ const [event] = parseICalEvents(ics, HREF);++ expect(event).toMatchObject({+ id: HREF,+ iCalUid: 'abc123',+ title: 'Quarterly review',+ description: 'Discuss Q2 numbers',+ location: 'Room 4',+ startsAt: '2026-06-01T10:00:00.000Z',+ endsAt: '2026-06-01T11:00:00.000Z',+ isCanceled: false,+ status: 'CONFIRMED',+ });+ });++ it('falls back to "Untitled Event" when SUMMARY is missing', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ ]);++ expect(parseICalEvents(ics, HREF)[0].title).toBe('Untitled Event');+ });++ it('flags isFullDay when DTSTART carries VALUE=DATE', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'SUMMARY:Holiday',+ 'DTSTART;VALUE=DATE:20260704',+ 'DTEND;VALUE=DATE:20260705',+ ]);++ expect(parseICalEvents(ics, HREF)[0].isFullDay).toBe(true);+ });++ it('classifies isFullDay per-event when a full-day master has a timed recurrence override', () => {+ const ics = buildVCalendar([+ [+ 'UID:series-fullday',+ 'SUMMARY:Daily standup',+ 'DTSTART;VALUE=DATE:20260601',+ 'DTEND;VALUE=DATE:20260602',+ 'RRULE:FREQ=DAILY',+ ],+ [+ 'UID:series-fullday',+ 'SUMMARY:Daily standup (rescheduled to a meeting)',+ 'DTSTART:20260605T140000Z',+ 'DTEND:20260605T143000Z',+ 'RECURRENCE-ID;VALUE=DATE:20260605',+ ],+ ]);++ const [master, override] = parseICalEvents(ics, HREF);++ expect(master.isFullDay).toBe(true);+ expect(override.isFullDay).toBe(false);+ });++ it('flags isCanceled when STATUS:CANCELLED is present', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'SUMMARY:Off',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ 'STATUS:CANCELLED',+ ]);++ const [event] = parseICalEvents(ics, HREF);++ expect(event.isCanceled).toBe(true);+ expect(event.status).toBe('CANCELLED');+ });++ it('attaches recurringEventExternalId in ISO format when RECURRENCE-ID is present', () => {+ const ics = buildVEvent([+ 'UID:series-1',+ 'SUMMARY:Standup',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T101500Z',+ 'RECURRENCE-ID:20260601T100000Z',+ ]);++ expect(parseICalEvents(ics, HREF)[0].recurringEventExternalId).toBe(+ '2026-06-01T10:00:00.000Z',+ );+ });++ it('returns master + override events as separate entries with unique ids (RFC 5545 §3.8.4.4)', () => {+ const ics = buildVCalendar([+ [+ 'UID:series-1',+ 'SUMMARY:Standup',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T101500Z',+ 'RRULE:FREQ=WEEKLY',+ ],+ [+ 'UID:series-1',+ 'SUMMARY:Standup (rescheduled)',+ 'DTSTART:20260609T110000Z',+ 'DTEND:20260609T111500Z',+ 'RECURRENCE-ID:20260608T100000Z',+ ],+ ]);++ const events = parseICalEvents(ics, HREF);++ expect(events).toHaveLength(2);+ expect(events[0]).toMatchObject({+ id: HREF,+ iCalUid: 'series-1',+ recurringEventExternalId: undefined,+ });+ expect(events[1]).toMatchObject({+ id: `${HREF}#recurrence=2026-06-08T10:00:00.000Z`,+ iCalUid: 'series-1',+ title: 'Standup (rescheduled)',+ recurringEventExternalId: '2026-06-08T10:00:00.000Z',+ });+ });++ it('handles bare ORGANIZER (plain mailto, no CN) — node-ical returns a string', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'SUMMARY:Sync',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ 'ORGANIZER:mailto:[email protected]',+ ]);++ expect(parseICalEvents(ics, HREF)[0].participants[0]).toMatchObject({+ handle: '[email protected]',+ displayName: '[email protected]',+ isOrganizer: true,+ });+ });++ it('handles bare ATTENDEE (plain mailto, no params) — node-ical returns a string', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'SUMMARY:Sync',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ 'ATTENDEE:mailto:[email protected]',+ ]);++ const attendee = parseICalEvents(ics, HREF)[0].participants.find(+ (p) => !p.isOrganizer,+ );++ expect(attendee).toMatchObject({+ handle: '[email protected]',+ displayName: '[email protected]',+ isOrganizer: false,+ });+ });++ it('extracts the organizer with mailto stripped and ACCEPTED status', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'SUMMARY:Sync',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ 'ORGANIZER;CN=Alice Org:mailto:[email protected]',+ ]);++ expect(parseICalEvents(ics, HREF)[0].participants[0]).toMatchObject({+ handle: '[email protected]',+ displayName: 'Alice Org',+ isOrganizer: true,+ responseStatus: CalendarEventParticipantResponseStatus.ACCEPTED,+ });+ });++ it('maps each ATTENDEE PARTSTAT to the matching response status', () => {+ const ics = buildVEvent([+ 'UID:abc',+ 'SUMMARY:Sync',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ 'ATTENDEE;CN=Bob;PARTSTAT=ACCEPTED:mailto:[email protected]',+ 'ATTENDEE;CN=Carol;PARTSTAT=DECLINED:mailto:[email protected]',+ 'ATTENDEE;CN=Dan;PARTSTAT=TENTATIVE:mailto:[email protected]',+ 'ATTENDEE;CN=Eve;PARTSTAT=NEEDS-ACTION:mailto:[email protected]',+ 'ATTENDEE;CN=Frank;PARTSTAT=DELEGATED:mailto:[email protected]',+ ]);++ const [event] = parseICalEvents(ics, HREF);+ const byHandle = Object.fromEntries(+ event.participants.map((p) => [p.handle, p.responseStatus]),+ );++ expect(byHandle).toEqual({+ '[email protected]': CalendarEventParticipantResponseStatus.ACCEPTED,+ '[email protected]': CalendarEventParticipantResponseStatus.DECLINED,+ '[email protected]': CalendarEventParticipantResponseStatus.TENTATIVE,+ '[email protected]': CalendarEventParticipantResponseStatus.NEEDS_ACTION,+ '[email protected]': CalendarEventParticipantResponseStatus.NEEDS_ACTION,+ });+ });++ it('returns an empty array and does not throw when iCal data is malformed', () => {+ expect(parseICalEvents('not a calendar', HREF)).toEqual([]);+ });++ it('skips a VEVENT missing DTSTART without dropping its siblings', () => {+ const ics = buildVCalendar([+ ['UID:no-start', 'SUMMARY:Broken'],+ [+ 'UID:healthy',+ 'SUMMARY:Healthy',+ 'DTSTART:20260601T100000Z',+ 'DTEND:20260601T110000Z',+ ],+ ]);++ const events = parseICalEvents(ics, HREF);++ expect(events.map((event) => event.iCalUid)).toEqual(['healthy']);+ });+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/build-cancelled-event.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/build-cancelled-event.util.tsnew file mode 100644index 00000000000..cd8a7822461--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/build-cancelled-event.util.ts@@ -0,0 +1,22 @@+import { type FetchedCalendarEvent } from 'src/modules/calendar/common/types/fetched-calendar-event';++export const buildCancelledCalDavEvent = (+ href: string,+): FetchedCalendarEvent => ({+ id: href,+ title: '',+ iCalUid: '',+ description: '',+ startsAt: '',+ endsAt: '',+ location: '',+ isFullDay: false,+ isCanceled: true,+ conferenceLinkLabel: '',+ conferenceLinkUrl: '',+ externalCreatedAt: '',+ externalUpdatedAt: '',+ conferenceSolution: '',+ participants: [],+ status: 'CANCELLED',+});diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-attendees-from-event.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-attendees-from-event.util.tsnew file mode 100644index 00000000000..767ff8f9759--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-attendees-from-event.util.ts@@ -0,0 +1,32 @@+import { isString } from '@sniptt/guards';+import type * as ical from 'node-ical';+import { isDefined } from 'twenty-shared/utils';++import { mapPartStatToResponseStatus } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/map-partstat-to-response-status.util';+import { type FetchedCalendarEventParticipant } from 'src/modules/calendar/common/types/fetched-calendar-event';++export const extractAttendeesFromEvent = (+ event: ical.VEvent,+): FetchedCalendarEventParticipant[] => {+ if (!isDefined(event.attendee)) return [];++ const attendees = Array.isArray(event.attendee)+ ? event.attendee+ : [event.attendee];++ return attendees.map((attendee) => {+ const rawValue = isString(attendee) ? attendee : attendee.val;+ const params = isString(attendee) ? undefined : attendee.params;+ const handle = rawValue.replace(/^mailto:/i, '');+ const partStat = params?.PARTSTAT ?? 'NEEDS_ACTION';++ return {+ displayName: params?.CN || handle || 'Unknown',+ responseStatus: mapPartStatToResponseStatus(+ partStat as ical.AttendeePartStat,+ ),+ handle,+ isOrganizer: false,+ };+ });+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-ical-data.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-ical-data.util.tsnew file mode 100644index 00000000000..a771dac9b8d--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-ical-data.util.ts@@ -0,0 +1,24 @@+import { isString } from '@sniptt/guards';+import { isDefined } from 'twenty-shared/utils';++// Some CalDAV servers return calendar-data as a string, others nest it under+// _cdata or other shapes. Recurse until a VCALENDAR block is found.+export const extractICalData = (+ calendarData: string | Record<string, unknown> | null | undefined,+): string | null => {+ if (!isDefined(calendarData)) return null;++ if (isString(calendarData) && calendarData.includes('VCALENDAR')) {+ return calendarData;+ }++ if (typeof calendarData === 'object') {+ for (const value of Object.values(calendarData)) {+ const result = extractICalData(value as string | Record<string, unknown>);++ if (isDefined(result)) return result;+ }+ }++ return null;+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-organizer-from-event.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-organizer-from-event.util.tsnew file mode 100644index 00000000000..ebac7ff8ad6--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-organizer-from-event.util.ts@@ -0,0 +1,25 @@+import { isString } from '@sniptt/guards';+import type * as ical from 'node-ical';+import { isDefined } from 'twenty-shared/utils';++import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';+import { type FetchedCalendarEventParticipant } from 'src/modules/calendar/common/types/fetched-calendar-event';++export const extractOrganizerFromEvent = (+ event: ical.VEvent,+): FetchedCalendarEventParticipant | null => {+ const organizer = event.organizer;++ if (!isDefined(organizer)) return null;++ const rawValue = isString(organizer) ? organizer : organizer.val;+ const commonName = isString(organizer) ? undefined : organizer.params?.CN;+ const handle = rawValue.replace(/^mailto:/i, '');++ return {+ displayName: commonName || handle || 'Unknown',+ responseStatus: CalendarEventParticipantResponseStatus.ACCEPTED,+ handle,+ isOrganizer: true,+ };+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-event-in-time-range.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-event-in-time-range.util.tsnew file mode 100644index 00000000000..411754b5118--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-event-in-time-range.util.ts@@ -0,0 +1,17 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type FetchedCalendarEvent } from 'src/modules/calendar/common/types/fetched-calendar-event';++export const isEventInTimeRange = (+ event: FetchedCalendarEvent,+ windowStart: Date,+ windowEnd: Date,+): boolean => {+ if (!isNonEmptyString(event.startsAt) || !isNonEmptyString(event.endsAt))+ return false;++ const eventStart = new Date(event.startsAt);+ const eventEnd = new Date(event.endsAt);++ return eventStart < windowEnd && eventEnd > windowStart;+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-invalid-sync-token-response.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-invalid-sync-token-response.util.tsnew file mode 100644index 00000000000..665725e5482--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-invalid-sync-token-response.util.ts@@ -0,0 +1,17 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type DAVResponse } from 'tsdav';+import { isDefined } from 'twenty-shared/utils';++export const isInvalidSyncTokenResponse = (+ responses: DAVResponse[],+): boolean => {+ const DAVResponse = responses[0];++ if (!isDefined(DAVResponse) || DAVResponse.status !== 403) return false;++ const body = isNonEmptyString(DAVResponse.raw)+ ? DAVResponse.raw+ : JSON.stringify(DAVResponse.raw ?? {});++ return body.includes('valid-sync-token') || body.includes('validSyncToken');+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-valid-caldav-href.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-valid-caldav-href.util.tsnew file mode 100644index 00000000000..81349f4ba9b--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/is-valid-caldav-href.util.ts@@ -0,0 +1,6 @@+import { extname } from 'node:path';++const ALLOWED_EXTENSIONS = new Set(['', '.ics', '.eml']);++export const isValidCalDavHref = (url: string): boolean =>+ ALLOWED_EXTENSIONS.has(extname(url).toLowerCase());diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/map-partstat-to-response-status.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/map-partstat-to-response-status.util.tsnew file mode 100644index 00000000000..a0fbda2ef98--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/map-partstat-to-response-status.util.ts@@ -0,0 +1,20 @@+import type * as ical from 'node-ical';++import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';++export const mapPartStatToResponseStatus = (+ partStat: ical.AttendeePartStat,+): CalendarEventParticipantResponseStatus => {+ switch (partStat) {+ case 'ACCEPTED':+ return CalendarEventParticipantResponseStatus.ACCEPTED;+ case 'DECLINED':+ return CalendarEventParticipantResponseStatus.DECLINED;+ case 'TENTATIVE':+ return CalendarEventParticipantResponseStatus.TENTATIVE;+ case 'DELEGATED':+ case 'NEEDS-ACTION':+ default:+ return CalendarEventParticipantResponseStatus.NEEDS_ACTION;+ }+};diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-ical-event.util.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-ical-event.util.tsnew file mode 100644index 00000000000..f50c87192a7--- /dev/null+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/parse-ical-event.util.ts@@ -0,0 +1,57 @@+import * as ical from 'node-ical';+import { icalDataExtractPropertyValue } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/lib/utils/icalDataExtractPropertyValue';+import { extractAttendeesFromEvent } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-attendees-from-event.util';+import { extractOrganizerFromEvent } from 'src/modules/calendar/calendar-event-import-manager/drivers/caldav/utils/extract-organizer-from-event.util';+import { type FetchedCalendarEvent } from 'src/modules/calendar/common/types/fetched-calendar-event';++export const parseICalEvents = (+ rawData: string,+ objectUrl: string,+): FetchedCalendarEvent[] => {+ try {+ const events = Object.values(ical.parseICS(rawData))+ .filter(+ (calendarComponent): calendarComponent is ical.VEvent =>+ calendarComponent.type === 'VEVENT',+ )+ .flatMap((event) => [event, ...Object.values(event.recurrences ?? {})])+ .filter(+ (event) => event.start instanceof Date && event.end instanceof Date,+ );++ return events.map((event) => {+ const organizer = extractOrganizerFromEvent(event);+ const attendees = extractAttendeesFromEvent(event);+ const recurrenceIso =+ event.recurrenceid instanceof Date+ ? event.recurrenceid.toISOString()+ : undefined;+ const createdIso =+ event.created?.toISOString() ?? new Date().toISOString();++ return {+ id: recurrenceIso+ ? `${objectUrl}#recurrence=${recurrenceIso}`+ : objectUrl,+ iCalUid: event.uid || '',+ title: icalDataExtractPropertyValue(event.summary, 'Untitled Event'),+ description: icalDataExtractPropertyValue(event.description),+ location: icalDataExtractPropertyValue(event.location),+ startsAt: event.start.toISOString(),+ endsAt: event.end.toISOString(),+ isFullDay: event.datetype === 'date',+ isCanceled: event.status === 'CANCELLED',+ status: event.status || 'CONFIRMED',+ recurringEventExternalId: recurrenceIso,+ conferenceLinkLabel: '',+ conferenceLinkUrl: icalDataExtractPropertyValue(event.url),+ conferenceSolution: '',+ externalCreatedAt: createdIso,+ externalUpdatedAt: event.lastmodified?.toISOString() ?? createdIso,+ participants: organizer ? [organizer, ...attendees] : attendees,+ };+ });+ } catch {+ return [];+ }+};