fix: Conditional fetch cache (calcom#24816)

* Fix cache to fetch only when it's available

* Non hierarchical feature check

* Fix tests: Add missing mock method and comprehensive CalendarCacheWrapper tests

- Add checkIfUserHasFeatureNonHierarchical to features.repository mock to fix failing GoogleCalendar tests
- Add comprehensive unit tests for CalendarCacheWrapper covering:
  - Calendars with sync only (cache-only path)
  - Calendars without sync only (original calendar path)
  - Mixed calendars (both cache and original)
  - Timezone handling with UTC defaults
  - Edge cases (empty arrays, undefined methods, null ids)
- Use proper types instead of 'as any' to satisfy lint rules

Co-Authored-By: Volnei Munhoz <volnei.munhoz@gmail.com>

* Fix: Sanitize logging to avoid exposing PII

- Replace logging full selectedCalendars objects with only calendar IDs and count
- Prevents exposure of email fields and other sensitive information in logs
- Addresses AI code reviewer feedback

Co-Authored-By: Volnei Munhoz <volnei.munhoz@gmail.com>

* Apply suggestion from @volnei

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: volnei

packages/app-store/_utils/getCalendar.ts

@@ -50,7 +50,7 @@ export const getCalendar = async (
         featuresRepository.checkIfFeatureIsEnabledGlobally(
           CalendarSubscriptionService.CALENDAR_SUBSCRIPTION_CACHE_FEATURE
         ),
-        featuresRepository.checkIfUserHasFeature(
+        featuresRepository.checkIfUserHasFeatureNonHierarchical(
           credential.userId as number,
           CalendarSubscriptionService.CALENDAR_SUBSCRIPTION_CACHE_FEATURE
         ),

packages/app-store/googlecalendar/lib/__mocks__/features.repository.ts

@@ -4,6 +4,7 @@ const featuresRepositoryModuleMock = {
   FeaturesRepository: vi.fn().mockImplementation(() => ({
     checkIfFeatureIsEnabledGlobally: vi.fn().mockResolvedValue(true),
     checkIfUserHasFeature: vi.fn().mockResolvedValue(true),
+    checkIfUserHasFeatureNonHierarchical: vi.fn().mockResolvedValue(true),
   })),
 };
 

packages/features/calendar-subscription/lib/cache/CalendarCacheWrapper.ts

@@ -50,54 +50,115 @@ export class CalendarCacheWrapper implements Calendar {
   }
 
   /**
-   * Override this method to use cache
+   * Retrieves availability combining cache and live sources.
    *
-   * @param dateFrom
-   * @param dateTo
-   * @param selectedCalendars
-   * @param shouldServeCache
+   * - Calendars **with** both `syncToken` and `syncSubscribedAt` → fetched from cache.
+   * - Calendars **without** one of them → fetched directly from the original calendar.
+   * - Results are merged into a single array.
+   *
+   * @param dateFrom - Start date (ISO string)
+   * @param dateTo - End date (ISO string)
+   * @param selectedCalendars - List of calendars to retrieve availability from
+   * @returns Combined array of busy date ranges
    */
   async getAvailability(
     dateFrom: string,
     dateTo: string,
     selectedCalendars: IntegrationCalendar[]
-    // _shouldServeCache?: boolean
-    // _fallbackToPrimary?: boolean
   ): Promise<EventBusyDate[]> {
-    log.debug("getAvailability from cache", { dateFrom, dateTo, selectedCalendars });
-    const selectedCalendarIds = selectedCalendars.map((e) => e.id).filter((id): id is string => Boolean(id));
-    if (!selectedCalendarIds.length) {
-      return Promise.resolve([]);
+    log.debug("getAvailability (mixed cache + original)", {
+      dateFrom,
+      dateTo,
+      calendarIds: selectedCalendars.map((c) => c.id),
+      calendarCount: selectedCalendars.length,
+    });
+
+    if (!selectedCalendars?.length) return [];
+
+    const withSync = selectedCalendars.filter((c) => c.syncToken && c.syncSubscribedAt);
+    const withoutSync = selectedCalendars.filter((c) => !c.syncToken || !c.syncSubscribedAt);
+
+    const results: EventBusyDate[] = [];
+
+    // Fetch from cache for synced calendars
+    if (withSync.length) {
+      const ids = withSync.map((c) => c.id).filter((id): id is string => Boolean(id));
+      const cached = await this.deps.calendarCacheEventRepository.findAllBySelectedCalendarIdsBetween(
+        ids,
+        new Date(dateFrom),
+        new Date(dateTo)
+      );
+      results.push(...cached);
     }
-    return this.deps.calendarCacheEventRepository.findAllBySelectedCalendarIdsBetween(
-      selectedCalendarIds,
-      new Date(dateFrom),
-      new Date(dateTo)
-    );
+
+    // Fetch from original calendar for unsynced ones
+    if (withoutSync.length) {
+      const original = await this.deps.originalCalendar.getAvailability(dateFrom, dateTo, withoutSync);
+      results.push(...original);
+    }
+
+    return results;
   }
 
   /**
-   * Override this method to use cache
+   * Retrieves availability with time zones, combining cache and live data.
+   *
+   * - Calendars **with** both `syncToken` and `syncSubscribedAt` → fetched from cache.
+   * - Calendars **without** one of them → fetched directly from the original calendar.
+   * - Results are merged into a single array with `{ start, end, timeZone }` format.
    *
-   * @param dateFrom
-   * @param dateTo
-   * @param selectedCalendars
-   * @returns
+   * @param dateFrom - Start date (ISO string)
+   * @param dateTo - End date (ISO string)
+   * @param selectedCalendars - List of calendars to retrieve availability from
+   * @returns Combined array of time-zone-aware availability ranges
    */
-  async getAvailabilityWithTimeZones?(
+  async getAvailabilityWithTimeZones(
     dateFrom: string,
     dateTo: string,
     selectedCalendars: IntegrationCalendar[]
-    // _fallbackToPrimary?: boolean
   ): Promise<{ start: Date | string; end: Date | string; timeZone: string }[]> {
-    log.debug("getAvailabilityWithTimeZones from cache", { dateFrom, dateTo, selectedCalendars });
-    const selectedCalendarIds = selectedCalendars.map((e) => e.id).filter((id): id is string => Boolean(id));
-    const result = await this.deps.calendarCacheEventRepository.findAllBySelectedCalendarIdsBetween(
-      selectedCalendarIds,
-      new Date(dateFrom),
-      new Date(dateTo)
-    );
-    return result.map(({ start, end, timeZone }) => ({ start, end, timeZone: timeZone || "UTC" }));
+    log.debug("getAvailabilityWithTimeZones (mixed cache + original)", {
+      dateFrom,
+      dateTo,
+      calendarIds: selectedCalendars.map((c) => c.id),
+      calendarCount: selectedCalendars.length,
+    });
+
+    if (!selectedCalendars?.length) return [];
+
+    const withSync = selectedCalendars.filter((c) => c.syncToken && c.syncSubscribedAt);
+    const withoutSync = selectedCalendars.filter((c) => !c.syncToken || !c.syncSubscribedAt);
+
+    const results: { start: Date | string; end: Date | string; timeZone: string }[] = [];
+
+    // Fetch from cache for synced calendars
+    if (withSync.length) {
+      const ids = withSync.map((c) => c.id).filter((id): id is string => Boolean(id));
+      const cached = await this.deps.calendarCacheEventRepository.findAllBySelectedCalendarIdsBetween(
+        ids,
+        new Date(dateFrom),
+        new Date(dateTo)
+      );
+      results.push(
+        ...cached.map(({ start, end, timeZone }) => ({
+          start,
+          end,
+          timeZone: timeZone || "UTC",
+        }))
+      );
+    }
+
+    // Fetch from original calendar for unsynced ones
+    if (withoutSync.length) {
+      const original = await this.deps.originalCalendar.getAvailabilityWithTimeZones?.(
+        dateFrom,
+        dateTo,
+        withoutSync
+      );
+      if (original?.length) results.push(...original);
+    }
+
+    return results;
   }
 
   fetchAvailabilityAndSetCache?(selectedCalendars: IntegrationCalendar[]): Promise<unknown> {