feat: take into account guest availability when host reschedules

apps/web/modules/schedules/hooks/useEvent.ts

@@ -1,11 +1,10 @@
-import { shallow } from "zustand/shallow";
-
 import { useBookerStoreContext } from "@calcom/features/bookings/Booker/BookerStoreProvider";
-import { useSchedule } from "@calcom/web/modules/schedules/hooks/useSchedule";
+import { useBookerTime } from "@calcom/features/bookings/Booker/hooks/useBookerTime";
+import { useStableTimezone } from "@calcom/features/bookings/Booker/hooks/useStableTimezone";
 import { useCompatSearchParams } from "@calcom/lib/hooks/useCompatSearchParams";
 import { trpc } from "@calcom/trpc/react";
-
-import { useBookerTime } from "@calcom/features/bookings/Booker/hooks/useBookerTime";
+import { useSchedule } from "@calcom/web/modules/schedules/hooks/useSchedule";
+import { shallow } from "zustand/shallow";
 
 export type useEventReturnType = ReturnType<typeof useEvent>;
 export type useScheduleForEventReturnType = ReturnType<typeof useScheduleForEvent>;
@@ -71,6 +70,7 @@ export const useScheduleForEvent = ({
   isTeamEvent,
   useApiV2 = true,
   bookerLayout,
+  restrictionSchedule,
 }: {
   username?: string | null;
   eventSlug?: string | null;
@@ -92,24 +92,34 @@ export const useScheduleForEvent = ({
     extraDays: number;
     columnViewExtraDays: { current: number };
   };
+  restrictionSchedule?: { id: number | null; useBookerTimezone: boolean };
 }) => {
-  const { timezone } = useBookerTime();
+  const { timezone: rawTimezone } = useBookerTime();
   const [usernameFromStore, eventSlugFromStore, monthFromStore, durationFromStore] = useBookerStoreContext(
     (state) => [state.username, state.eventSlug, state.month, state.selectedDuration],
     shallow
   );
 
+  const effectiveTimezone = useStableTimezone(rawTimezone, restrictionSchedule);
+
   const searchParams = useCompatSearchParams();
   const rescheduleUid = searchParams?.get("rescheduleUid");
+  const rawRescheduledBy = searchParams?.get("rescheduledBy");
+  // Lightweight client-side normalization: the server validates rescheduledBy
+  // as a non-empty email, so drop obviously malformed URL values (empty string,
+  // missing "@") to null before the query fires.
+  const rescheduledBy =
+    rawRescheduledBy && rawRescheduledBy.includes("@") ? rawRescheduledBy : null;
 
   const schedule = useSchedule({
     username: usernameFromStore ?? username,
     eventSlug: eventSlugFromStore ?? eventSlug,
     eventId,
-    timezone,
+    timezone: effectiveTimezone,
     selectedDate,
     dayCount,
     rescheduleUid,
+    rescheduledBy,
     month: monthFromStore ?? month,
     duration: durationFromStore ?? duration,
     isTeamEvent,

apps/web/modules/schedules/hooks/useSchedule.ts

@@ -20,6 +20,7 @@ export type UseScheduleWithCacheArgs = {
   duration?: number | null;
   dayCount?: number | null;
   rescheduleUid?: string | null;
+  rescheduledBy?: string | null;
   isTeamEvent?: boolean;
   orgSlug?: string;
   teamMemberEmail?: string | null;
@@ -58,6 +59,7 @@ export const useSchedule = ({
   duration,
   dayCount,
   rescheduleUid,
+  rescheduledBy,
   isTeamEvent,
   orgSlug,
   teamMemberEmail,
@@ -102,6 +104,7 @@ export const useSchedule = ({
     timeZone: timezone ?? "PLACEHOLDER_TIMEZONE",
     duration: duration ? `${duration}` : undefined,
     rescheduleUid,
+    rescheduledBy,
     orgSlug,
     teamMemberEmail,
     routedTeamMemberIds,
@@ -135,7 +138,14 @@ export const useSchedule = ({
       enabledProp,
   };
 
-  const isCallingApiV2Slots = useApiV2 && Boolean(isTeamEvent) && options.enabled;
+  // Fall back to V1 when rescheduledBy is set: the V2 available-slots DTO does not
+  // carry rescheduledBy, so host/attendee initiator gating in guest busy-time lookup
+  // would be lost if we routed the reschedule through V2.
+  // TODO: extend the V2 available-slots DTO to accept rescheduledBy and drop this
+  // fallback. Requires propagating the param through the slots service and adding
+  // host-initiated reschedule test coverage.
+  const isCallingApiV2Slots =
+    useApiV2 && Boolean(isTeamEvent) && options.enabled && !(rescheduleUid && rescheduledBy);
 
   // API V2 query for team events
   const teamScheduleV2 = useApiV2AvailableSlots({

packages/features/availability/lib/getUserAvailability.ts

@@ -160,6 +160,7 @@ export type GetUserAvailabilityInitialData = {
     bookingLimits?: unknown;
     includeManagedEventsInLimits: boolean;
   } | null;
+  guestBusyTimes?: { start: Date; end: Date }[];
 };
 
 export type GetAvailabilityUser = GetUserAvailabilityInitialData["user"];
@@ -617,6 +618,13 @@ export class UserAvailabilityService {
       };
     }
 
+    const guestBusyTimesFormatted: EventBusyDetails[] = (initialData?.guestBusyTimes ?? []).map((t) => ({
+      start: t.start.toISOString(),
+      end: t.end.toISOString(),
+      title: "Guest busy",
+      source: "guest-availability",
+    }));
+
     const detailedBusyTimesWithSource: EventBusyDetails[] = [
       ...busyTimes.map((a) => ({
         ...a,
@@ -627,6 +635,7 @@ export class UserAvailabilityService {
       })),
       ...busyTimesFromLimits,
       ...busyTimesFromTeamLimits,
+      ...guestBusyTimesFormatted,
     ];
 
     const detailedBusyTimes: UserAvailabilityBusyDetails[] = withSource

packages/features/bookings/repositories/BookingRepository.test.ts

@@ -1,18 +1,27 @@
 import type { PrismaClient } from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { BookingRepository } from "./BookingRepository";
 
 describe("BookingRepository", () => {
   let repository: BookingRepository;
   let mockPrismaClient: {
     $queryRaw: ReturnType<typeof vi.fn>;
+    booking: {
+      findUnique: ReturnType<typeof vi.fn>;
+      findMany: ReturnType<typeof vi.fn>;
+    };
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
 
     mockPrismaClient = {
       $queryRaw: vi.fn(),
+      booking: {
+        findUnique: vi.fn(),
+        findMany: vi.fn(),
+      },
     };
 
     repository = new BookingRepository(mockPrismaClient as unknown as PrismaClient);
@@ -58,4 +67,223 @@ describe("BookingRepository", () => {
       expect(mockPrismaClient.$queryRaw).toHaveBeenCalledTimes(1);
     });
   });
+
+  describe("findByUidIncludeAttendeeEmails", () => {
+    it("should query booking by uid with attendee emails and host user email", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        attendees: [{ email: "guest@example.com" }],
+        user: { email: "host@example.com" },
+      };
+      mockPrismaClient.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const result = await repository.findByUidIncludeAttendeeEmails({ uid: "test-uid" });
+
+      expect(result).toEqual(mockBooking);
+      expect(mockPrismaClient.booking.findUnique).toHaveBeenCalledWith({
+        where: { uid: "test-uid" },
+        select: {
+          id: true,
+          uid: true,
+          attendees: { select: { email: true } },
+          user: { select: { email: true } },
+        },
+      });
+    });
+
+    it("should return null when booking does not exist", async () => {
+      mockPrismaClient.booking.findUnique.mockResolvedValue(null);
+
+      const result = await repository.findByUidIncludeAttendeeEmails({ uid: "nonexistent" });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("findByUserIdsAndDateRange", () => {
+    const dateFrom = new Date("2026-04-01T00:00:00Z");
+    const dateTo = new Date("2026-04-30T23:59:59Z");
+
+    it("should return empty array when both userIds and userEmails are empty", async () => {
+      const result = await repository.findByUserIdsAndDateRange({
+        userIds: [],
+        userEmails: [],
+        dateFrom,
+        dateTo,
+      });
+
+      expect(result).toEqual([]);
+      expect(mockPrismaClient.booking.findMany).not.toHaveBeenCalled();
+    });
+
+    it("should query bookings by userId when userIds are provided", async () => {
+      const mockBookings = [
+        {
+          uid: "booking-1",
+          startTime: new Date("2026-04-10T09:00:00Z"),
+          endTime: new Date("2026-04-10T10:00:00Z"),
+          title: "Meeting",
+          userId: 10,
+          status: BookingStatus.ACCEPTED,
+        },
+      ];
+      mockPrismaClient.booking.findMany.mockResolvedValue(mockBookings);
+
+      const result = await repository.findByUserIdsAndDateRange({
+        userIds: [10],
+        userEmails: [],
+        dateFrom,
+        dateTo,
+      });
+
+      expect(result).toEqual(mockBookings);
+      expect(mockPrismaClient.booking.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            status: { in: [BookingStatus.ACCEPTED, BookingStatus.PENDING] },
+            AND: [{ startTime: { lt: dateTo } }, { endTime: { gt: dateFrom } }],
+          }),
+        })
+      );
+    });
+
+    it("should query bookings by email when userEmails are provided", async () => {
+      mockPrismaClient.booking.findMany.mockResolvedValue([]);
+
+      await repository.findByUserIdsAndDateRange({
+        userIds: [],
+        userEmails: ["guest@example.com"],
+        dateFrom,
+        dateTo,
+      });
+
+      expect(mockPrismaClient.booking.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            OR: expect.arrayContaining([
+              {
+                attendees: {
+                  some: { email: { in: ["guest@example.com"], mode: "insensitive" } },
+                },
+              },
+            ]),
+          }),
+        })
+      );
+    });
+
+    it("should combine userId and email conditions in OR clause", async () => {
+      mockPrismaClient.booking.findMany.mockResolvedValue([]);
+
+      await repository.findByUserIdsAndDateRange({
+        userIds: [10, 20],
+        userEmails: ["guest@example.com"],
+        dateFrom,
+        dateTo,
+      });
+
+      const callArgs = mockPrismaClient.booking.findMany.mock.calls[0][0];
+      expect(callArgs.where.OR).toHaveLength(2);
+      expect(callArgs.where.OR).toEqual(
+        expect.arrayContaining([
+          { userId: { in: [10, 20] } },
+          {
+            attendees: {
+              some: { email: { in: ["guest@example.com"], mode: "insensitive" } },
+            },
+          },
+        ])
+      );
+    });
+
+    it("should select the correct fields", async () => {
+      mockPrismaClient.booking.findMany.mockResolvedValue([]);
+
+      await repository.findByUserIdsAndDateRange({
+        userIds: [10],
+        userEmails: [],
+        dateFrom,
+        dateTo,
+      });
+
+      expect(mockPrismaClient.booking.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: {
+            uid: true,
+            startTime: true,
+            endTime: true,
+            title: true,
+            userId: true,
+            status: true,
+          },
+        })
+      );
+    });
+
+    it("should include excludeUid in query when provided", async () => {
+      const repo = new BookingRepository(mockPrismaClient as unknown as PrismaClient);
+      await repo.findByUserIdsAndDateRange({
+        userIds: [1],
+        userEmails: [],
+        dateFrom,
+        dateTo,
+        excludeUid: "booking-to-exclude",
+      });
+
+      expect(mockPrismaClient.booking.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            uid: { not: "booking-to-exclude" },
+          }),
+        })
+      );
+    });
+
+    it("should skip excludeUid filter when empty string is passed", async () => {
+      mockPrismaClient.booking.findMany.mockResolvedValue([]);
+
+      await repository.findByUserIdsAndDateRange({
+        userIds: [1],
+        userEmails: [],
+        dateFrom,
+        dateTo,
+        excludeUid: "",
+      });
+
+      const callArgs = mockPrismaClient.booking.findMany.mock.calls[0][0];
+      expect(callArgs.where).not.toHaveProperty("uid");
+    });
+
+    it("should dedupe by uid when OR branches surface the same booking twice", async () => {
+      mockPrismaClient.booking.findMany.mockResolvedValue([
+        {
+          uid: "booking-a",
+          startTime: new Date("2026-04-10T09:00:00Z"),
+          endTime: new Date("2026-04-10T10:00:00Z"),
+          title: "Team sync",
+          userId: 10,
+          status: "ACCEPTED",
+        },
+        {
+          uid: "booking-a",
+          startTime: new Date("2026-04-10T09:00:00Z"),
+          endTime: new Date("2026-04-10T10:00:00Z"),
+          title: "Team sync",
+          userId: 10,
+          status: "ACCEPTED",
+        },
+      ]);
+
+      const result = await repository.findByUserIdsAndDateRange({
+        userIds: [10],
+        userEmails: ["guest@example.com"],
+        dateFrom,
+        dateTo,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].uid).toBe("booking-a");
+    });
+  });
 });