Uncodedtech
diff --git a/‎packages/app-store/_utils/__tests__/getCalendar.test.ts‎
Lines changed: 408 additions & 0 deletions b/‎packages/app-store/_utils/__tests__/getCalendar.test.ts‎
Lines changed: 408 additions & 0 deletions
diff --git a/‎packages/app-store/_utils/getCalendar.ts‎
Lines changed: 36 additions & 14 deletions b/‎packages/app-store/_utils/getCalendar.ts‎
Lines changed: 36 additions & 14 deletions
diff --git a/‎packages/app-store/googlecalendar/lib/CalendarService.ts‎
Lines changed: 14 additions & 73 deletions b/‎packages/app-store/googlecalendar/lib/CalendarService.ts‎
Lines changed: 14 additions & 73 deletions
@@ -1,3 +1,5 @@
+import { CalendarBatchService } from "@calcom/features/calendar-batch/lib/CalendarBatchService";
+import { CalendarBatchWrapper } from "@calcom/features/calendar-batch/lib/CalendarBatchWrapper";
 import { CalendarSubscriptionService } from "@calcom/features/calendar-subscription/lib/CalendarSubscriptionService";
 import { CalendarCacheEventRepository } from "@calcom/features/calendar-subscription/lib/cache/CalendarCacheEventRepository";
 import { CalendarCacheEventService } from "@calcom/features/calendar-subscription/lib/cache/CalendarCacheEventService";
@@ -42,6 +44,20 @@ export const getCalendar = async (
     log.warn(`calendar of type ${calendarType} is not implemented`);
     return null;
   }
+
+  // eslint-disable-next-line
+  const originalCalendar = new CalendarService(credential as any);
+  return resolveCalendarServeStrategy(originalCalendar, credential, shouldServeCache);
+};
+
+/**
+ * Resolve best calendar strategy for current calendar and credential
+ */
+const resolveCalendarServeStrategy = async (
+  originalCalendar: Calendar,
+  credential: CredentialForCalendarService,
+  shouldServeCache?: boolean
+): Promise<Calendar> => {
   // if shouldServeCache is not supplied, determine on the fly.
   if (typeof shouldServeCache === "undefined") {
     const featuresRepository = new FeaturesRepository(prisma);
@@ -58,20 +74,26 @@ export const getCalendar = async (
     );
     shouldServeCache = isCalendarSubscriptionCacheEnabled && isCalendarSubscriptionCacheEnabledForUser;
   }
-  if (CalendarCacheEventService.isCalendarTypeSupported(calendarType) && shouldServeCache) {
-    log.info(`Calendar Cache is enabled, using CalendarCacheService for credential ${credential.id}`);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const originalCalendar = new CalendarService(credential as any);
-    if (originalCalendar) {
-      // return cacheable calendar
-      const calendarCacheEventRepository = new CalendarCacheEventRepository(prisma);
-      return new CalendarCacheWrapper({
-        originalCalendar,
-        calendarCacheEventRepository,
-      });
-    }
+  if (CalendarCacheEventService.isCalendarTypeSupported(credential.type) && shouldServeCache) {
+    log.info("Calendar Cache is enabled, using CalendarCacheService for credential", {
+      credentialId: credential.id,
+    });
+    const calendarCacheEventRepository = new CalendarCacheEventRepository(prisma);
+    return new CalendarCacheWrapper({
+      originalCalendar: originalCalendar as unknown as Calendar,
+      calendarCacheEventRepository,
+    });
+  } else if (CalendarBatchService.isSupported(credential)) {
+    // If calendar cache isn't supported, we try calendar batch as the second layer of optimization
+    log.info("Calendar Batch is supported, using CalendarBatchService for credential", {
+      credentialId: credential.id,
+    });
+    return new CalendarBatchWrapper({ originalCalendar: originalCalendar as unknown as Calendar });
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return new CalendarService(credential as any);
+  // Ended up returning unoptimized original calendar
+  log.info("Calendar Cache and Batch aren't supported, serving regular calendar for credential", {
+    credentialId: credential.id,
+  });
+  return originalCalendar;
 };
@@ -2,11 +2,9 @@
 import type { calendar_v3 } from "@googleapis/calendar";
 import type { GaxiosResponse } from "googleapis-common";
 import { RRule } from "rrule";
-import { v4 as uuid } from "uuid";
 
 import { MeetLocationType } from "@calcom/app-store/constants";
 import { getLocation, getRichDescription } from "@calcom/lib/CalEventParser";
-import { uniqueBy } from "@calcom/lib/array";
 import { ORGANIZER_EMAIL_EXEMPT_DOMAINS } from "@calcom/lib/constants";
 import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
@@ -34,12 +32,6 @@ interface GoogleCalError extends Error {
   code?: number;
 }
 
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-const ONE_MONTH_IN_MS = 30 * MS_PER_DAY;
- 
-const GOOGLE_WEBHOOK_URL_BASE = process.env.GOOGLE_WEBHOOK_URL || process.env.NEXT_PUBLIC_WEBAPP_URL;
-const GOOGLE_WEBHOOK_URL = `${GOOGLE_WEBHOOK_URL_BASE}/api/integrations/googlecalendar/webhook`;
-
 const isGaxiosResponse = (error: unknown): error is GaxiosResponse<calendar_v3.Schema$Event> =>
   typeof error === "object" && !!error && Object.prototype.hasOwnProperty.call(error, "config");
 
@@ -120,50 +112,6 @@ export default class GoogleCalendarService implements Calendar {
     return attendees;
   };
 
-  private async stopWatchingCalendarsInGoogle(
-    channels: { googleChannelResourceId: string | null; googleChannelId: string | null }[]
-  ) {
-    const calendar = await this.authedCalendar();
-    logger.debug(`Unsubscribing from calendars ${channels.map((c) => c.googleChannelId).join(", ")}`);
-    const uniqueChannels = uniqueBy(channels, ["googleChannelId", "googleChannelResourceId"]);
-    await Promise.allSettled(
-      uniqueChannels.map(({ googleChannelResourceId, googleChannelId }) =>
-        calendar.channels
-          .stop({
-            requestBody: {
-              resourceId: googleChannelResourceId,
-              id: googleChannelId,
-            },
-          })
-          .catch((err) => {
-            console.warn(JSON.stringify(err));
-          })
-      )
-    );
-  }
-
-  private async startWatchingCalendarsInGoogle({ calendarId }: { calendarId: string }) {
-    const calendar = await this.authedCalendar();
-    logger.debug(`Subscribing to calendar ${calendarId}`, safeStringify({ GOOGLE_WEBHOOK_URL }));
-
-    const res = await calendar.events.watch({
-      // Calendar identifier. To retrieve calendar IDs call the calendarList.list method. If you want to access the primary calendar of the currently logged in user, use the "primary" keyword.
-      calendarId,
-      requestBody: {
-        // A UUID or similar unique string that identifies this channel.
-        id: uuid(),
-        type: "web_hook",
-        address: GOOGLE_WEBHOOK_URL,
-        token: process.env.GOOGLE_WEBHOOK_TOKEN,
-        params: {
-          // The time-to-live in seconds for the notification channel. Default is 604800 seconds.
-          ttl: `${Math.round(ONE_MONTH_IN_MS / 1000)}`,
-        },
-      },
-    });
-    return res.data;
-  }
-
   async createEvent(
     calEvent: CalendarServiceEvent,
     credentialId: number,
@@ -452,9 +400,7 @@ export default class GoogleCalendarService implements Calendar {
     return apiResponse.json;
   }
 
-  async getFreeBusyResult(
-    args: FreeBusyArgs,
-  ): Promise<calendar_v3.Schema$FreeBusyResponse> {
+  async getFreeBusyResult(args: FreeBusyArgs): Promise<calendar_v3.Schema$FreeBusyResponse> {
     return await this.fetchAvailability(args);
   }
 
@@ -471,9 +417,7 @@ export default class GoogleCalendarService implements Calendar {
     return validCals[0];
   }
 
-  async getFreeBusyData(
-    args: FreeBusyArgs,
-  ): Promise<(EventBusyDate & { id: string })[] | null> {
+  async getFreeBusyData(args: FreeBusyArgs): Promise<(EventBusyDate & { id: string })[] | null> {
     const freeBusyResult = await this.getFreeBusyResult(args);
     if (!freeBusyResult.calendars) return null;
 
@@ -604,11 +548,12 @@ export default class GoogleCalendarService implements Calendar {
 
   /**
    * Fetches availability data using the cache-or-fetch pattern
+   *
    */
   private async fetchAvailabilityData(
     calendarIds: string[],
     dateFrom: string,
-    dateTo: string,
+    dateTo: string
   ): Promise<EventBusyDate[]> {
     // More efficient date difference calculation using native Date objects
     // Use Math.floor to match dayjs diff behavior (truncates, doesn't round up)
@@ -619,13 +564,11 @@ export default class GoogleCalendarService implements Calendar {
 
     // Google API only allows a date range of 90 days for /freebusy
     if (diff <= 90) {
-      const freeBusyData = await this.getFreeBusyData(
-        {
-          timeMin: dateFrom,
-          timeMax: dateTo,
-          items: calendarIds.map((id) => ({ id })),
-        }
-      );
+      const freeBusyData = await this.getFreeBusyData({
+        timeMin: dateFrom,
+        timeMax: dateTo,
+        items: calendarIds.map((id) => ({ id })),
+      });
 
       if (!freeBusyData) throw new Error("No response from google calendar");
       return freeBusyData.map((freeBusy) => ({ start: freeBusy.start, end: freeBusy.end }));
@@ -647,13 +590,11 @@ export default class GoogleCalendarService implements Calendar {
         currentEndTime = originalEndTime;
       }
 
-      const chunkData = await this.getFreeBusyData(
-        {
-          timeMin: new Date(currentStartTime).toISOString(),
-          timeMax: new Date(currentEndTime).toISOString(),
-          items: calendarIds.map((id) => ({ id })),
-        }
-      );
+      const chunkData = await this.getFreeBusyData({
+        timeMin: new Date(currentStartTime).toISOString(),
+        timeMax: new Date(currentEndTime).toISOString(),
+        items: calendarIds.map((id) => ({ id })),
+      });
 
       if (chunkData) {
         busyData.push(...chunkData.map((freeBusy) => ({ start: freeBusy.start, end: freeBusy.end })));