feat: allows forcing/skipping calendar cache serving

packages/app-store/googlecalendar/lib/CalendarService.ts

@@ -10,6 +10,7 @@ import { MeetLocationType } from "@calcom/app-store/locations";
 import dayjs from "@calcom/dayjs";
 import { CalendarCache } from "@calcom/features/calendar-cache/calendar-cache";
 import type { FreeBusyArgs } from "@calcom/features/calendar-cache/calendar-cache.repository.interface";
+import { getTimeMax, getTimeMin } from "@calcom/features/calendar-cache/lib/datesForCache";
 import { getLocation, getRichDescription } from "@calcom/lib/CalEventParser";
 import type CalendarService from "@calcom/lib/CalendarService";
 import {
@@ -510,16 +511,22 @@ export default class GoogleCalendarService implements Calendar {
     return apiResponse.json;
   }
 
-  async getCacheOrFetchAvailability(args: FreeBusyArgs): Promise<EventBusyDate[] | null> {
-    const { timeMin, timeMax, items } = args;
-    let freeBusyResult: calendar_v3.Schema$FreeBusyResponse = {};
+  async getFreeBusyResult(
+    args: FreeBusyArgs,
+    shouldServeCache?: boolean
+  ): Promise<calendar_v3.Schema$FreeBusyResponse> {
+    if (shouldServeCache === false) return await this.fetchAvailability(args);
     const calendarCache = await CalendarCache.init(null);
     const cached = await calendarCache.getCachedAvailability(this.credential.id, args);
-    if (cached) {
-      freeBusyResult = cached.value as unknown as calendar_v3.Schema$FreeBusyResponse;
-    } else {
-      freeBusyResult = await this.fetchAvailability({ timeMin, timeMax, items });
-    }
+    if (cached) return cached.value as unknown as calendar_v3.Schema$FreeBusyResponse;
+    return await this.fetchAvailability(args);
+  }
+
+  async getCacheOrFetchAvailability(
+    args: FreeBusyArgs,
+    shouldServeCache?: boolean
+  ): Promise<EventBusyDate[] | null> {
+    const freeBusyResult = await this.getFreeBusyResult(args, shouldServeCache);
     if (!freeBusyResult.calendars) return null;
 
     const result = Object.values(freeBusyResult.calendars).reduce((c, i) => {
@@ -537,7 +544,8 @@ export default class GoogleCalendarService implements Calendar {
   async getAvailability(
     dateFrom: string,
     dateTo: string,
-    selectedCalendars: IntegrationCalendar[]
+    selectedCalendars: IntegrationCalendar[],
+    shouldServeCache?: boolean
   ): Promise<EventBusyDate[]> {
     this.log.debug("Getting availability", safeStringify({ dateFrom, dateTo, selectedCalendars }));
     const calendar = await this.authedCalendar();
@@ -563,11 +571,14 @@ export default class GoogleCalendarService implements Calendar {
 
       // /freebusy from google api only allows a date range of 90 days
       if (diff <= 90) {
-        const freeBusyData = await this.getCacheOrFetchAvailability({
-          timeMin: dateFrom,
-          timeMax: dateTo,
-          items: calsIds.map((id) => ({ id })),
-        });
+        const freeBusyData = await this.getCacheOrFetchAvailability(
+          {
+            timeMin: dateFrom,
+            timeMax: dateTo,
+            items: calsIds.map((id) => ({ id })),
+          },
+          shouldServeCache
+        );
         if (!freeBusyData) throw new Error("No response from google calendar");
 
         return freeBusyData;
@@ -583,11 +594,14 @@ export default class GoogleCalendarService implements Calendar {
           if (endDate.isAfter(originalEndDate)) endDate = originalEndDate;
 
           busyData.push(
-            ...((await this.getCacheOrFetchAvailability({
-              timeMin: startDate.format(),
-              timeMax: endDate.format(),
-              items: calsIds.map((id) => ({ id })),
-            })) || [])
+            ...((await this.getCacheOrFetchAvailability(
+              {
+                timeMin: startDate.format(),
+                timeMax: endDate.format(),
+                items: calsIds.map((id) => ({ id })),
+              },
+              shouldServeCache
+            )) || [])
           );
 
           startDate = endDate.add(1, "minutes");
@@ -672,12 +686,7 @@ export default class GoogleCalendarService implements Calendar {
   }
   async unwatchCalendar({ calendarId }: { calendarId: string }) {
     const credentialId = this.credential.id;
-    const sc = await prisma.selectedCalendar.findFirst({
-      where: {
-        credentialId,
-        externalId: calendarId,
-      },
-    });
+    const sc = await SelectedCalendarRepository.findByExternalId(credentialId, calendarId);
     // Delete the calendar cache to force a fresh cache
     await prisma.calendarCache.deleteMany({ where: { credentialId } });
     const calendar = await this.authedCalendar();
@@ -699,6 +708,12 @@ export default class GoogleCalendarService implements Calendar {
       googleChannelResourceUri: null,
       googleChannelExpiration: null,
     });
+    // Populate the cache back for the remaining calendars, if any
+    const remainingCalendars =
+      sc?.credential?.selectedCalendars.filter((sc) => sc.externalId !== calendarId) || [];
+    if (remainingCalendars.length > 0) {
+      await this.fetchAvailabilityAndSetCache(remainingCalendars);
+    }
   }
 
   async setAvailabilityInCache(args: FreeBusyArgs, data: calendar_v3.Schema$FreeBusyResponse): Promise<void> {
@@ -707,12 +722,11 @@ export default class GoogleCalendarService implements Calendar {
   }
 
   async fetchAvailabilityAndSetCache(selectedCalendars: IntegrationCalendar[]) {
-    const date = new Date();
     const parsedArgs = {
       /** Expand the start date to the start of the month */
-      timeMin: new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0).toISOString(),
+      timeMin: getTimeMax(),
       /** Expand the end date to the end of the month */
-      timeMax: new Date(date.getFullYear(), date.getMonth() + 1, 0, 0, 0, 0, 0).toISOString(),
+      timeMax: getTimeMin(),
       items: selectedCalendars.map((sc) => ({ id: sc.externalId })),
     };
     const data = await this.fetchAvailability(parsedArgs);

packages/core/CalendarManager.ts

@@ -8,7 +8,6 @@ import { getUid } from "@calcom/lib/CalEventParser";
 import logger from "@calcom/lib/logger";
 import { getPiiFreeCalendarEvent, getPiiFreeCredential } from "@calcom/lib/piiFreeData";
 import { safeStringify } from "@calcom/lib/safeStringify";
-import { performance } from "@calcom/lib/server/perfObserver";
 import type {
   CalendarEvent,
   EventBusyDate,
@@ -136,51 +135,6 @@ const cleanIntegrationKeys = (
   return rest;
 };
 
-// here I will fetch the page json file.
-export const getCachedResults = async (
-  withCredentials: CredentialPayload[],
-  dateFrom: string,
-  dateTo: string,
-  selectedCalendars: SelectedCalendar[]
-): Promise<EventBusyDate[][]> => {
-  const calendarCredentials = withCredentials.filter((credential) => credential.type.endsWith("_calendar"));
-  const calendars = await Promise.all(calendarCredentials.map((credential) => getCalendar(credential)));
-  performance.mark("getBusyCalendarTimesStart");
-  const results = calendars.map(async (c, i) => {
-    /** Filter out nulls */
-    if (!c) return [];
-    /** We rely on the index so we can match credentials with calendars */
-    const { type, appId } = calendarCredentials[i];
-    /** We just pass the calendars that matched the credential type,
-     * TODO: Migrate credential type or appId
-     */
-    const passedSelectedCalendars = selectedCalendars.filter((sc) => sc.integration === type);
-    if (!passedSelectedCalendars.length) return [];
-    /** We extract external Ids so we don't cache too much */
-    const selectedCalendarIds = passedSelectedCalendars.map((sc) => sc.externalId);
-    /** If we don't then we actually fetch external calendars (which can be very slow) */
-    performance.mark("eventBusyDatesStart");
-    const eventBusyDates = await c.getAvailability(dateFrom, dateTo, passedSelectedCalendars);
-    performance.mark("eventBusyDatesEnd");
-    performance.measure(
-      `[getAvailability for ${selectedCalendarIds.join(", ")}][$1]'`,
-      "eventBusyDatesStart",
-      "eventBusyDatesEnd"
-    );
-
-    return eventBusyDates.map((a: object) => ({ ...a, source: `${appId}` }));
-  });
-  const awaitedResults = await Promise.all(results);
-  performance.mark("getBusyCalendarTimesEnd");
-  performance.measure(
-    `getBusyCalendarTimes took $1 for creds ${calendarCredentials.map((cred) => cred.id)}`,
-    "getBusyCalendarTimesStart",
-    "getBusyCalendarTimesEnd"
-  );
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return awaitedResults as any;
-};
-
 /**
  * Get months between given dates
  * @returns ["2023-04", "2024-05"]
@@ -203,7 +157,8 @@ export const getBusyCalendarTimes = async (
   withCredentials: CredentialPayload[],
   dateFrom: string,
   dateTo: string,
-  selectedCalendars: SelectedCalendar[]
+  selectedCalendars: SelectedCalendar[],
+  shouldServeCache?: boolean
 ) => {
   let results: EventBusyDate[][] = [];
   // const months = getMonths(dateFrom, dateTo);
@@ -212,7 +167,13 @@ export const getBusyCalendarTimes = async (
     const startDate = dayjs(dateFrom).subtract(11, "hours").format();
     // Add 14 hours from the start date to avoid problems in UTC+ time zones.
     const endDate = dayjs(dateTo).endOf("month").add(14, "hours").format();
-    results = await getCalendarsEvents(withCredentials, startDate, endDate, selectedCalendars);
+    results = await getCalendarsEvents(
+      withCredentials,
+      startDate,
+      endDate,
+      selectedCalendars,
+      shouldServeCache
+    );
   } catch (e) {
     log.warn(safeStringify(e));
   }

packages/core/getBusyTimes.ts

@@ -44,6 +44,7 @@ export async function getBusyTimes(params: {
       })[]
     | null;
   bypassBusyCalendarTimes: boolean;
+  shouldServeCache?: boolean;
 }) {
   const {
     credentials,
@@ -60,6 +61,7 @@ export async function getBusyTimes(params: {
     rescheduleUid,
     duration,
     bypassBusyCalendarTimes = false,
+    shouldServeCache,
   } = params;
 
   logger.silly(
@@ -243,7 +245,8 @@ export async function getBusyTimes(params: {
       credentials,
       startTime,
       endTime,
-      selectedCalendars
+      selectedCalendars,
+      shouldServeCache
     );
     const endConnectedCalendarsGet = performance.now();
     logger.debug(

packages/core/getCalendarsEvents.test.ts

@@ -127,7 +127,12 @@ describe("getCalendarsEvents", () => {
       [selectedCalendar]
     );
 
-    expect(getAvailabilitySpy).toHaveBeenCalledWith("2010-12-01", "2010-12-04", [selectedCalendar]);
+    expect(getAvailabilitySpy).toHaveBeenCalledWith(
+      "2010-12-01",
+      "2010-12-04",
+      [selectedCalendar],
+      undefined
+    );
     expect(result).toEqual([
       availability.map((av) => ({
         ...av,
@@ -190,12 +195,18 @@ describe("getCalendarsEvents", () => {
       [selectedGoogleCalendar, selectedOfficeCalendar]
     );
 
-    expect(getGoogleAvailabilitySpy).toHaveBeenCalledWith("2010-12-01", "2010-12-04", [
-      selectedGoogleCalendar,
-    ]);
-    expect(getOfficeAvailabilitySpy).toHaveBeenCalledWith("2010-12-01", "2010-12-04", [
-      selectedOfficeCalendar,
-    ]);
+    expect(getGoogleAvailabilitySpy).toHaveBeenCalledWith(
+      "2010-12-01",
+      "2010-12-04",
+      [selectedGoogleCalendar],
+      undefined
+    );
+    expect(getOfficeAvailabilitySpy).toHaveBeenCalledWith(
+      "2010-12-01",
+      "2010-12-04",
+      [selectedOfficeCalendar],
+      undefined
+    );
     expect(result).toEqual([
       googleAvailability.map((av) => ({
         ...av,

packages/core/getCalendarsEvents.ts

@@ -11,7 +11,8 @@ const getCalendarsEvents = async (
   withCredentials: CredentialPayload[],
   dateFrom: string,
   dateTo: string,
-  selectedCalendars: SelectedCalendar[]
+  selectedCalendars: SelectedCalendar[],
+  shouldServeCache?: boolean
 ): Promise<EventBusyDate[][]> => {
   const calendarCredentials = withCredentials
     .filter((credential) => credential.type.endsWith("_calendar"))
@@ -45,7 +46,12 @@ const getCalendarsEvents = async (
         selectedCalendars: passedSelectedCalendars.map(getPiiFreeSelectedCalendar),
       })
     );
-    const eventBusyDates = await c.getAvailability(dateFrom, dateTo, passedSelectedCalendars);
+    const eventBusyDates = await c.getAvailability(
+      dateFrom,
+      dateTo,
+      passedSelectedCalendars,
+      shouldServeCache
+    );
     performance.mark("eventBusyDatesEnd");
     performance.measure(
       `[getAvailability for ${selectedCalendarIds.join(", ")}][$1]'`,

packages/core/getUserAvailability.ts

@@ -45,6 +45,7 @@ const availabilitySchema = z
     withSource: z.boolean().optional(),
     returnDateOverrides: z.boolean(),
     bypassBusyCalendarTimes: z.boolean().optional(),
+    shouldServeCache: z.boolean().optional(),
   })
   .refine((data) => !!data.username || !!data.userId, "Either username or userId should be filled in.");
 
@@ -245,6 +246,7 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
     duration?: number;
     returnDateOverrides: boolean;
     bypassBusyCalendarTimes: boolean;
+    shouldServeCache?: boolean;
   },
   initialData?: {
     user?: GetUser;
@@ -279,6 +281,7 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
     duration,
     returnDateOverrides,
     bypassBusyCalendarTimes = false,
+    shouldServeCache,
   } = availabilitySchema.parse(query);
 
   if (!dateFrom.isValid() || !dateTo.isValid()) {
@@ -393,6 +396,7 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
     duration,
     currentBookings: initialData?.currentBookings,
     bypassBusyCalendarTimes,
+    shouldServeCache,
   });
 
   const detailedBusyTimes: EventBusyDetails[] = [

packages/features/calendar-cache/calendar-cache.repository.ts

@@ -6,6 +6,7 @@ import type { Calendar } from "@calcom/types/Calendar";
 
 import type { ICalendarCacheRepository } from "./calendar-cache.repository.interface";
 import { watchCalendarSchema } from "./calendar-cache.repository.schema";
+import { getTimeMax, getTimeMin } from "./lib/datesForCache";
 
 const log = logger.getSubLogger({ prefix: ["CalendarCacheRepository"] });
 
@@ -15,18 +16,6 @@ const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const ONE_MONTH_IN_MS = 30 * MS_PER_DAY;
 const CACHING_TIME = ONE_MONTH_IN_MS;
 
-/** Expand the start date to the start of the month */
-function getTimeMin(timeMin: string) {
-  const dateMin = new Date(timeMin);
-  return new Date(dateMin.getFullYear(), dateMin.getMonth(), 1, 0, 0, 0, 0).toISOString();
-}
-
-/** Expand the end date to the end of the month */
-function getTimeMax(timeMax: string) {
-  const dateMax = new Date(timeMax);
-  return new Date(dateMax.getFullYear(), dateMax.getMonth() + 1, 0, 0, 0, 0, 0).toISOString();
-}
-
 export function parseKeyForCache(args: FreeBusyArgs): string {
   const { timeMin: _timeMin, timeMax: _timeMax, items } = args;
   const { timeMin, timeMax } = handleMinMax(_timeMin, _timeMax);

packages/features/calendar-cache/lib/datesForCache.ts

@@ -0,0 +1,16 @@
+/** Expand the start date to the beginning of the current month */
+export const getTimeMin = (timeMin?: string) => {
+  const date = timeMin ? new Date(timeMin) : new Date();
+  date.setDate(1);
+  date.setHours(0, 0, 0, 0);
+  return date.toISOString();
+};
+
+/** Expand the end date to the end of the next month */
+export function getTimeMax(timeMax?: string) {
+  const date = timeMax ? new Date(timeMax) : new Date();
+  date.setMonth(date.getMonth() + 2);
+  date.setDate(0);
+  date.setHours(0, 0, 0, 0);
+  return date.toISOString();
+}

packages/features/flags/config.ts

@@ -4,6 +4,7 @@
  **/
 export type AppFlags = {
   "calendar-cache": boolean;
+  "calendar-cache-serve": boolean;
   emails: boolean;
   insights: boolean;
   teams: boolean;

packages/features/flags/features.repository.interface.ts

@@ -3,4 +3,5 @@ import type { AppFlags } from "./config";
 export interface IFeaturesRepository {
   checkIfFeatureIsEnabledGlobally(slug: keyof AppFlags): Promise<boolean>;
   checkIfUserHasFeature(userId: number, slug: string): Promise<boolean>;
+  checkIfTeamHasFeature(teamId: number, slug: keyof AppFlags): Promise<boolean>;
 }