Feat/calendar sync

packages/features/bookings/lib/handleCancelBooking.ts

@@ -162,6 +162,7 @@ async function handler(input: CancelBookingInput, dependencies?: Dependencies) {
     cancelSubsequentBookings,
     internalNote,
     skipCancellationReasonValidation = false,
+    skipCalendarSyncTaskCancellation = false,
   } = bookingCancelInput.parse(body);
   const bookingToDelete = await getBookingToDelete(id, uid);
   const {
@@ -610,36 +611,46 @@ async function handler(input: CancelBookingInput, dependencies?: Dependencies) {
     allRemainingBookings
   );
 
-  try {
-    const bookingToDeleteEventTypeMetadataParsed = eventTypeMetaDataSchemaWithTypedApps.safeParse(
-      bookingToDelete.eventType?.metadata || null
-    );
-
-    if (!bookingToDeleteEventTypeMetadataParsed.success) {
-      log.error(
-        `Error parsing metadata`,
-        safeStringify({ error: bookingToDeleteEventTypeMetadataParsed?.error })
+  // Skip calendar event deletion when cancellation comes from a calendar subscription webhook
+  // to avoid infinite loops (Google/Office365 → Cal.com → Google/Office365 → ...)
+  if (!skipCalendarSyncTaskCancellation) {
+    try {
+      const bookingToDeleteEventTypeMetadataParsed = eventTypeMetaDataSchemaWithTypedApps.safeParse(
+        bookingToDelete.eventType?.metadata || null
       );
-      throw new Error("Error parsing metadata");
-    }
 
-    const bookingToDeleteEventTypeMetadata = bookingToDeleteEventTypeMetadataParsed.data;
+      if (!bookingToDeleteEventTypeMetadataParsed.success) {
+        log.error(
+          `Error parsing metadata`,
+          safeStringify({ error: bookingToDeleteEventTypeMetadataParsed?.error })
+        );
+        throw new Error("Error parsing metadata");
+      }
 
-    const credentials = await getAllCredentialsIncludeServiceAccountKey(bookingToDelete.user, {
-      ...bookingToDelete.eventType,
-      metadata: bookingToDeleteEventTypeMetadata,
-    });
+      const bookingToDeleteEventTypeMetadata = bookingToDeleteEventTypeMetadataParsed.data;
 
-    const eventManager = new EventManager(
-      { ...bookingToDelete.user, credentials },
-      bookingToDeleteEventTypeMetadata?.apps
-    );
+      const credentials = await getAllCredentialsIncludeServiceAccountKey(bookingToDelete.user, {
+        ...bookingToDelete.eventType,
+        metadata: bookingToDeleteEventTypeMetadata,
+      });
+
+      const eventManager = new EventManager(
+        { ...bookingToDelete.user, credentials },
+        bookingToDeleteEventTypeMetadata?.apps
+      );
 
-    await eventManager.cancelEvent(evt, bookingToDelete.references, isBookingInRecurringSeries);
+      await eventManager.cancelEvent(evt, bookingToDelete.references, isBookingInRecurringSeries);
+    } catch (error) {
+      log.error(`Error deleting integrations`, safeStringify({ error }));
+    }
+  }
 
+  // Always mark booking references as deleted for data consistency
+  // (even when skipCalendarSyncTaskCancellation is true, since the external event is already deleted)
+  try {
     await bookingReferenceRepository.updateManyByBookingId(bookingToDelete.id, { deleted: true });
   } catch (error) {
-    log.error(`Error deleting integrations`, safeStringify({ error }));
+    log.error(`Error marking booking references as deleted`, safeStringify({ error }));
   }
 
   try {

packages/features/calendar-subscription/lib/sync/CalendarSyncService.ts

@@ -1,7 +1,10 @@
-import { BookingRepository } from "@calcom/features/bookings/repositories/BookingRepository";
+import handleCancelBooking from "@calcom/features/bookings/lib/handleCancelBooking";
+import type { BookingRepository } from "@calcom/features/bookings/repositories/BookingRepository";
 import type { CalendarSubscriptionEventItem } from "@calcom/features/calendar-subscription/lib/CalendarSubscriptionPort.interface";
 import logger from "@calcom/lib/logger";
+import { safeStringify } from "@calcom/lib/safeStringify";
 import type { SelectedCalendar } from "@calcom/prisma/client";
+import { metrics } from "@sentry/nextjs";
 
 const log = logger.getSubLogger({ prefix: ["CalendarSyncService"] });
 
@@ -31,10 +34,23 @@ export class CalendarSyncService {
       countEvents: calendarSubscriptionEvents.length,
     });
 
+    metrics.count("calendar.sync.handleEvents.calls", 1, {
+      attributes: {
+        integration: selectedCalendar.integration,
+      },
+    });
+
     // only process cal.com calendar events
     const calEvents = calendarSubscriptionEvents.filter((e) =>
       e.iCalUID?.toLowerCase()?.endsWith("@cal.com")
     );
+
+    metrics.distribution("calendar.sync.handleEvents.events_count", calEvents.length, {
+      attributes: {
+        integration: selectedCalendar.integration,
+      },
+    });
+
     if (calEvents.length === 0) {
       log.debug("handleEvents: no calendar events to process");
       return;
@@ -59,40 +75,136 @@ export class CalendarSyncService {
    * @returns
    */
   async cancelBooking(event: CalendarSubscriptionEventItem) {
+    const startTime = performance.now();
     log.debug("cancelBooking", { event });
     const [bookingUid] = event.iCalUID?.split("@") ?? [undefined];
     if (!bookingUid) {
-      log.debug("Unable to sync, booking not found");
+      log.debug("Unable to sync, booking UID not found in iCalUID");
       return;
     }
 
     const booking = await this.deps.bookingRepository.findBookingByUidWithEventType({ bookingUid });
     if (!booking) {
-      log.debug("Unable to sync, booking not found");
+      log.debug("Unable to sync, booking not found in database", { bookingUid });
       return;
     }
 
-    // todo handle cancel booking
+    if (!booking.userId || !booking.userPrimaryEmail) {
+      log.warn("Unable to sync cancellation, booking missing required user data", {
+        bookingUid,
+        hasUserId: !!booking.userId,
+        hasUserPrimaryEmail: !!booking.userPrimaryEmail,
+      });
+      metrics.count("calendar.sync.cancelBooking.calls", 1, {
+        attributes: { status: "skipped", reason: "missing_user_data" },
+      });
+      return;
+    }
+
+    try {
+      await handleCancelBooking({
+        userId: booking.userId,
+        bookingData: {
+          uid: booking.uid,
+          cancellationReason: "Cancelled on user's calendar",
+          cancelledBy: booking.userPrimaryEmail,
+          // Skip calendar event deletion to avoid infinite loops
+          // (Google/Office365 → Cal.com → Google/Office365 → ...)
+          skipCalendarSyncTaskCancellation: true,
+        },
+      });
+      log.info("Successfully cancelled booking from calendar sync", { bookingUid });
+
+      metrics.count("calendar.sync.cancelBooking.calls", 1, {
+        attributes: { status: "success" },
+      });
+      metrics.distribution("calendar.sync.cancelBooking.duration_ms", performance.now() - startTime, {
+        attributes: { status: "success" },
+      });
+    } catch (error) {
+      // Log error but don't block - calendar change should still be reflected
+      log.error("Failed to cancel booking from calendar sync", { bookingUid, error: safeStringify(error) });
+
+      metrics.count("calendar.sync.cancelBooking.calls", 1, {
+        attributes: { status: "error" },
+      });
+      metrics.distribution("calendar.sync.cancelBooking.duration_ms", performance.now() - startTime, {
+        attributes: { status: "error" },
+      });
+    }
   }
 
   /**
    * Reschedule a booking
    * @param event
    */
   async rescheduleBooking(event: CalendarSubscriptionEventItem) {
+    const startTime = performance.now();
     log.debug("rescheduleBooking", { event });
     const [bookingUid] = event.iCalUID?.split("@") ?? [undefined];
     if (!bookingUid) {
-      log.debug("Unable to sync, booking not found");
+      log.debug("Unable to sync, booking UID not found in iCalUID");
       return;
     }
 
     const booking = await this.deps.bookingRepository.findBookingByUidWithEventType({ bookingUid });
     if (!booking) {
-      log.debug("Unable to sync, booking not found");
+      log.debug("Unable to sync, booking not found in database", { bookingUid });
+      return;
+    }
+
+    if (!booking.eventTypeId) {
+      log.warn("Unable to sync reschedule, booking missing eventTypeId", { bookingUid });
+      metrics.count("calendar.sync.rescheduleBooking.calls", 1, {
+        attributes: { status: "skipped", reason: "missing_event_type_id" },
+      });
       return;
     }
 
-    // todo handle update booking
+    try {
+      // Dynamic import to avoid loading the entire booking service chain at module evaluation time
+      // This prevents react-awesome-query-builder from being loaded in server-side contexts
+      const { getRegularBookingService } = await import(
+        "@calcom/features/bookings/di/RegularBookingService.container"
+      );
+      const regularBookingService = getRegularBookingService();
+      await regularBookingService.createBooking({
+        bookingData: {
+          eventTypeId: booking.eventTypeId,
+          start: event.start?.toISOString() ?? booking.startTime.toISOString(),
+          end: event.end?.toISOString() ?? booking.endTime.toISOString(),
+          timeZone: event.timeZone ?? "UTC",
+          language: "en",
+          metadata: {},
+          rescheduleUid: booking.uid,
+        },
+        bookingMeta: {
+          // Skip calendar event creation to avoid infinite loops
+          // (Google/Office365 → Cal.com → Google/Office365 → ...)
+          skipCalendarSyncTaskCreation: true,
+        },
+      });
+      log.info("Successfully rescheduled booking from calendar sync", { bookingUid });
+
+      metrics.count("calendar.sync.rescheduleBooking.calls", 1, {
+        attributes: { status: "success" },
+      });
+      metrics.distribution("calendar.sync.rescheduleBooking.duration_ms", performance.now() - startTime, {
+        attributes: { status: "success" },
+      });
+    } catch (error) {
+      // Log error but don't block - calendar change should still be reflected
+      log.error("Failed to reschedule booking from calendar sync", {
+        bookingUid,
+        error: safeStringify(error),
+      });
+
+      metrics.count("calendar.sync.rescheduleBooking.calls", 1, {
+        attributes: { status: "error" },
+      });
+      metrics.distribution("calendar.sync.rescheduleBooking.duration_ms", performance.now() - startTime, {
+        attributes: { status: "error" },
+      });
+    }
   }
 }