perf: optimize google's getAvailability with caching (calcom#22191)

* refactor: optimize google's getAvailability with caching

Refactored the getAvailability method to improve readability and efficiency by extracting logic into helper methods for cache checking, calendar ID retrieval, and chunked API fetching. Added early cache lookup for selected calendar IDs, improved cache hit logging, and modularized the code for easier maintenance and future enhancements.

* Update CalendarService.test.ts

* Update CalendarService.ts

* Update CalendarService.test.ts

* Update CalendarService.ts

* Update CalendarService.test.ts

* Update CalendarService.ts

* Apply suggestion from @hbjORbj

Co-authored-by: Benny Joo <sldisek783@gmail.com>

---------

Co-authored-by: Benny Joo <sldisek783@gmail.com>

Author: zomars

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

@@ -1,12 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { calendar_v3 } from "@googleapis/calendar";
-import type { Prisma } from "@prisma/client";
 import type { GaxiosResponse } from "googleapis-common";
 import { RRule } from "rrule";
 import { v4 as uuid } from "uuid";
 
 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";
@@ -16,6 +14,7 @@ import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import { SelectedCalendarRepository } from "@calcom/lib/server/repository/selectedCalendar";
 import prisma from "@calcom/prisma";
+import type { Prisma } from "@calcom/prisma/client";
 import type {
   Calendar,
   CalendarServiceEvent,
@@ -232,14 +231,13 @@ export default class GoogleCalendarService implements Calendar {
           eventId: calEvent.existingRecurringEvent.recurringEventId,
         });
         if (recurringEventInstances.data.items) {
-          const calComEventStartTime = dayjs(calEvent.startTime).tz(calEvent.organizer.timeZone).format();
+          // Compare timestamps directly for more reliable and faster matching
+          const calComEventStartTimeMs = new Date(calEvent.startTime).getTime();
           for (let i = 0; i < recurringEventInstances.data.items.length; i++) {
             const instance = recurringEventInstances.data.items[i];
-            const instanceStartTime = dayjs(instance.start?.dateTime)
-              .tz(instance.start?.timeZone == null ? undefined : instance.start?.timeZone)
-              .format();
+            const instanceStartTimeMs = new Date(instance.start?.dateTime || "").getTime();
 
-            if (instanceStartTime === calComEventStartTime) {
+            if (instanceStartTimeMs === calComEventStartTimeMs) {
               event = instance;
               break;
             }
@@ -562,10 +560,6 @@ export default class GoogleCalendarService implements Calendar {
     try {
       const calIdsWithTimeZone = await getCalIdsWithTimeZone();
       const calIds = calIdsWithTimeZone.map((calIdWithTimeZone) => ({ id: calIdWithTimeZone.id }));
-
-      const originalStartDate = dayjs(dateFrom);
-      const originalEndDate = dayjs(dateTo);
-      const diff = originalEndDate.diff(originalStartDate, "days");
       const freeBusyData = await this.getCacheOrFetchAvailability({
         timeMin: dateFrom,
         timeMax: dateTo,
@@ -593,6 +587,148 @@ export default class GoogleCalendarService implements Calendar {
     }
   }
 
+  /**
+   * Converts FreeBusy response data to EventBusyDate array
+   */
+  private convertFreeBusyToEventBusyDates(
+    freeBusyResult: calendar_v3.Schema$FreeBusyResponse
+  ): EventBusyDate[] {
+    if (!freeBusyResult.calendars) return [];
+
+    return Object.values(freeBusyResult.calendars).flatMap(
+      (calendar) =>
+        calendar.busy?.map((busyTime) => ({
+          start: busyTime.start || "",
+          end: busyTime.end || "",
+        })) || []
+    );
+  }
+
+  /**
+   * Attempts to get availability from cache
+   */
+  private async tryGetAvailabilityFromCache(
+    timeMin: string,
+    timeMax: string,
+    calendarIds: string[]
+  ): Promise<EventBusyDate[] | null> {
+    try {
+      const calendarCache = await CalendarCache.init(null);
+      const cached = await calendarCache.getCachedAvailability({
+        credentialId: this.credential.id,
+        userId: this.credential.userId,
+        args: {
+          // Expand the start date to the start of the month to increase cache hits
+          timeMin: getTimeMin(timeMin),
+          // Expand the end date to the end of the month to increase cache hits
+          timeMax: getTimeMax(timeMax),
+          items: calendarIds.map((id) => ({ id })),
+        },
+      });
+
+      if (cached) {
+        this.log.debug(
+          "[Cache Hit] Returning cached availability result",
+          safeStringify({ timeMin, timeMax, calendarIds })
+        );
+        const freeBusyResult = cached.value as unknown as calendar_v3.Schema$FreeBusyResponse;
+        return this.convertFreeBusyToEventBusyDates(freeBusyResult);
+      }
+
+      return null;
+    } catch (error) {
+      this.log.debug("Cache check failed, proceeding with API call", safeStringify(error));
+      return null;
+    }
+  }
+
+  /**
+   * Gets calendar IDs for the request, either from selected calendars or fallback logic
+   */
+  private async getCalendarIds(
+    selectedCalendarIds: string[],
+    fallbackToPrimary?: boolean
+  ): Promise<string[]> {
+    if (selectedCalendarIds.length !== 0) return selectedCalendarIds;
+
+    const calendar = await this.authedCalendar();
+    const cals = await this.getAllCalendars(calendar, ["id", "primary"]);
+    if (!cals.length) return [];
+
+    if (!fallbackToPrimary) {
+      return this.getValidCalendars(cals).map((cal) => cal.id);
+    }
+
+    const primaryCalendar = this.filterPrimaryCalendar(cals);
+    return primaryCalendar ? [primaryCalendar.id] : [];
+  }
+
+  /**
+   * Fetches availability data using the cache-or-fetch pattern
+   */
+  private async fetchAvailabilityData(
+    calendarIds: string[],
+    dateFrom: string,
+    dateTo: string,
+    shouldServeCache?: boolean
+  ): Promise<EventBusyDate[]> {
+    // More efficient date difference calculation using native Date objects
+    // Use Math.floor to match dayjs diff behavior (truncates, doesn't round up)
+    const fromDate = new Date(dateFrom);
+    const toDate = new Date(dateTo);
+    const oneDayMs = 1000 * 60 * 60 * 24;
+    const diff = Math.floor((toDate.getTime() - fromDate.getTime()) / (oneDayMs));
+
+    // Google API only allows a date range of 90 days for /freebusy
+    if (diff <= 90) {
+      const freeBusyData = await this.getCacheOrFetchAvailability(
+        {
+          timeMin: dateFrom,
+          timeMax: dateTo,
+          items: calendarIds.map((id) => ({ id })),
+        },
+        shouldServeCache
+      );
+
+      if (!freeBusyData) throw new Error("No response from google calendar");
+      return freeBusyData.map((freeBusy) => ({ start: freeBusy.start, end: freeBusy.end }));
+    }
+
+    // Handle longer periods by chunking into 90-day periods
+    const busyData: EventBusyDate[] = [];
+    const loopsNumber = Math.ceil(diff / 90);
+    let currentStartTime = fromDate.getTime();
+    const originalEndTime = toDate.getTime();
+    const ninetyDaysMs = 90 * 24 * 60 * 60 * 1000;
+    const oneMinuteMs = 60 * 1000;
+
+    for (let i = 0; i < loopsNumber; i++) {
+      let currentEndTime = currentStartTime + ninetyDaysMs;
+
+      // Don't go beyond the original end date
+      if (currentEndTime > originalEndTime) {
+        currentEndTime = originalEndTime;
+      }
+
+      const chunkData = await this.getCacheOrFetchAvailability(
+        {
+          timeMin: new Date(currentStartTime).toISOString(),
+          timeMax: new Date(currentEndTime).toISOString(),
+          items: calendarIds.map((id) => ({ id })),
+        },
+        shouldServeCache
+      );
+
+      if (chunkData) {
+        busyData.push(...chunkData.map((freeBusy) => ({ start: freeBusy.start, end: freeBusy.end })));
+      }
+
+      currentStartTime = currentEndTime + oneMinuteMs;
+    }
+
+    return busyData;
+  }
+
   async getAvailability(
     dateFrom: string,
     dateTo: string,
@@ -604,71 +740,33 @@ export default class GoogleCalendarService implements Calendar {
     fallbackToPrimary?: boolean
   ): Promise<EventBusyDate[]> {
     this.log.debug("Getting availability", safeStringify({ dateFrom, dateTo, selectedCalendars }));
-    const calendar = await this.authedCalendar();
+
     const selectedCalendarIds = selectedCalendars
       .filter((e) => e.integration === this.integrationName)
       .map((e) => e.externalId);
+
+    // Early return if only other integrations are selected
     if (selectedCalendarIds.length === 0 && selectedCalendars.length > 0) {
-      // Only calendars of other integrations selected
       return [];
     }
-    const getCalIds = async () => {
-      if (selectedCalendarIds.length !== 0) return selectedCalendarIds;
-      const cals = await this.getAllCalendars(calendar, ["id", "primary"]);
-      if (!cals.length) return [];
-      if (!fallbackToPrimary) return this.getValidCalendars(cals).map((cal) => cal.id);
-
-      const primaryCalendar = this.filterPrimaryCalendar(cals);
-      if (!primaryCalendar) return [];
-      return [primaryCalendar.id];
-    };
 
-    try {
-      const calsIds = await getCalIds();
-      const originalStartDate = dayjs(dateFrom);
-      const originalEndDate = dayjs(dateTo);
-      const diff = originalEndDate.diff(originalStartDate, "days");
-
-      // /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 })),
-          },
-          shouldServeCache
-        );
-        if (!freeBusyData) throw new Error("No response from google calendar");
-
-        return freeBusyData.map((freeBusy) => ({ start: freeBusy.start, end: freeBusy.end }));
-      } else {
-        const busyData = [];
-
-        const loopsNumber = Math.ceil(diff / 90);
-
-        let startDate = originalStartDate;
-        let endDate = originalStartDate.add(90, "days");
-
-        for (let i = 0; i < loopsNumber; i++) {
-          if (endDate.isAfter(originalEndDate)) endDate = originalEndDate;
+    // Try cache first when we have selected calendar IDs
+    if (selectedCalendarIds.length > 0 && shouldServeCache !== false) {
+      const cachedResult = await this.tryGetAvailabilityFromCache(dateFrom, dateTo, selectedCalendarIds);
+      if (cachedResult) {
+        return cachedResult;
+      }
+    }
 
-          busyData.push(
-            ...((await this.getCacheOrFetchAvailability(
-              {
-                timeMin: startDate.format(),
-                timeMax: endDate.format(),
-                items: calsIds.map((id) => ({ id })),
-              },
-              shouldServeCache
-            )) || [])
-          );
+    // Cache miss - proceed with API calls
+    this.log.debug(
+      "[Cache Miss] Proceeding with Google API calls",
+      safeStringify({ selectedCalendarIds, fallbackToPrimary })
+    );
 
-          startDate = endDate.add(1, "minutes");
-          endDate = startDate.add(90, "days");
-        }
-        return busyData.map((freeBusy) => ({ start: freeBusy.start, end: freeBusy.end }));
-      }
+    try {
+      const calendarIds = await this.getCalendarIds(selectedCalendarIds, fallbackToPrimary);
+      return await this.fetchAvailabilityData(calendarIds, dateFrom, dateTo, shouldServeCache);
     } catch (error) {
       this.log.error(
         "There was an error getting availability from google calendar: ",