feat: Populate gCal calendar cache via webhooks

apps/web/app/api/calendar-cache/cron/route.ts

@@ -0,0 +1,7 @@
+export { GET } from "@calcom/features/calendar-cache/api/cron";
+
+/**
+ * This runs each minute and we need fresh data each time
+ * @see https://nextjs.org/docs/app/building-your-application/caching#opting-out-2
+ **/
+export const revalidate = 0;

apps/web/app/settings/(admin-layout)/admin/calendar-cache/page.tsx

@@ -0,0 +1,11 @@
+import { _generateMetadata } from "app/_utils";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("admin"),
+    () => ""
+  );
+
+const Page = () => <h1>Calendar cache index</h1>;
+
+export default Page;

apps/web/cron-tester.ts

@@ -1,9 +1,12 @@
 import { CronJob } from "cron";
+import dotEnv from "dotenv";
+
+dotEnv.config({ path: "../../.env" });
 
 async function fetchCron(endpoint: string) {
   const apiKey = process.env.CRON_API_KEY;
 
-  const res = await fetch(`http://localhost:3000/api${endpoint}?${apiKey}`, {
+  const res = await fetch(`http://localhost:3000/api${endpoint}?apiKey=${apiKey}`, {
     headers: {
       "Content-Type": "application/json",
       authorization: `Bearer ${process.env.CRON_SECRET}`,
@@ -20,7 +23,7 @@ try {
     "*/5 * * * * *",
     async function () {
       await Promise.allSettled([
-        fetchCron("/tasks/cron"),
+        fetchCron("/calendar-cache/cron"),
         // fetchCron("/cron/calVideoNoShowWebhookTriggers"),
         //
         // fetchCron("/tasks/cleanup"),

apps/web/pages/api/availability/calendar.ts

@@ -3,22 +3,26 @@ import { z } from "zod";
 
 import { getCalendarCredentials, getConnectedCalendars } from "@calcom/core/CalendarManager";
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
+import { CalendarCache } from "@calcom/features/calendar-cache/calendar-cache";
+import { HttpError } from "@calcom/lib/http-error";
 import notEmpty from "@calcom/lib/notEmpty";
+import { defaultHandler, defaultResponder } from "@calcom/lib/server";
+import { SelectedCalendarRepository } from "@calcom/lib/server/repository/selectedCalendar";
 import prisma from "@calcom/prisma";
 import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";
 
 const selectedCalendarSelectSchema = z.object({
   integration: z.string(),
   externalId: z.string(),
-  credentialId: z.number().optional(),
+  credentialId: z.coerce.number(),
 });
 
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  const session = await getServerSession({ req, res });
+/** Shared authentication middleware for GET, DELETE and POST requests */
+async function authMiddleware(req: CustomNextApiRequest) {
+  const session = await getServerSession({ req });
 
   if (!session?.user?.id) {
-    res.status(401).json({ message: "Not authenticated" });
-    return;
+    throw new HttpError({ statusCode: 401, message: "Not authenticated" });
   }
 
   const userWithCredentials = await prisma.user.findUnique({
@@ -35,66 +39,76 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     },
   });
   if (!userWithCredentials) {
-    res.status(401).json({ message: "Not authenticated" });
-    return;
+    throw new HttpError({ statusCode: 401, message: "Not authenticated" });
   }
-  const { credentials, ...user } = userWithCredentials;
+  req.userWithCredentials = userWithCredentials;
+  return userWithCredentials;
+}
 
-  if (req.method === "POST") {
-    const { integration, externalId, credentialId } = selectedCalendarSelectSchema.parse(req.body);
-    await prisma.selectedCalendar.upsert({
-      where: {
-        userId_integration_externalId: {
-          userId: user.id,
-          integration,
-          externalId,
-        },
-      },
-      create: {
-        userId: user.id,
-        integration,
-        externalId,
-        credentialId,
-      },
-      // already exists
-      update: {},
-    });
-    res.status(200).json({ message: "Calendar Selection Saved" });
-  }
+type CustomNextApiRequest = NextApiRequest & {
+  userWithCredentials?: Awaited<ReturnType<typeof authMiddleware>>;
+};
 
-  if (req.method === "DELETE") {
-    const { integration, externalId } = selectedCalendarSelectSchema.parse(req.query);
-    await prisma.selectedCalendar.delete({
-      where: {
-        userId_integration_externalId: {
-          userId: user.id,
-          externalId,
-          integration,
-        },
-      },
-    });
+async function postHandler(req: CustomNextApiRequest) {
+  if (!req.userWithCredentials) throw new HttpError({ statusCode: 401, message: "Not authenticated" });
+  const user = req.userWithCredentials;
+  const { integration, externalId, credentialId } = selectedCalendarSelectSchema.parse(req.body);
+  await SelectedCalendarRepository.upsert({
+    userId: user.id,
+    integration,
+    externalId,
+    credentialId,
+  });
 
-    res.status(200).json({ message: "Calendar Selection Saved" });
-  }
+  return { message: "Calendar Selection Saved" };
+}
 
-  if (req.method === "GET") {
-    const selectedCalendarIds = await prisma.selectedCalendar.findMany({
-      where: {
+async function deleteHandler(req: CustomNextApiRequest) {
+  if (!req.userWithCredentials) throw new HttpError({ statusCode: 401, message: "Not authenticated" });
+  const user = req.userWithCredentials;
+  const { integration, externalId, credentialId } = selectedCalendarSelectSchema.parse(req.query);
+  const calendarCacheRepository = await CalendarCache.initFromCredentialId(credentialId);
+  await calendarCacheRepository.unwatchCalendar({ calendarId: externalId });
+  await prisma.selectedCalendar.delete({
+    where: {
+      userId_integration_externalId: {
         userId: user.id,
+        externalId,
+        integration,
       },
-      select: {
-        externalId: true,
-      },
-    });
+    },
+  });
 
-    // get user's credentials + their connected integrations
-    const calendarCredentials = getCalendarCredentials(credentials);
-    // get all the connected integrations' calendars (from third party)
-    const { connectedCalendars } = await getConnectedCalendars(calendarCredentials, user.selectedCalendars);
-    const calendars = connectedCalendars.flatMap((c) => c.calendars).filter(notEmpty);
-    const selectableCalendars = calendars.map((cal) => {
-      return { selected: selectedCalendarIds.findIndex((s) => s.externalId === cal.externalId) > -1, ...cal };
-    });
-    res.status(200).json(selectableCalendars);
-  }
+  return { message: "Calendar Selection Saved" };
+}
+
+async function getHandler(req: CustomNextApiRequest) {
+  if (!req.userWithCredentials) throw new HttpError({ statusCode: 401, message: "Not authenticated" });
+  const user = req.userWithCredentials;
+  const selectedCalendarIds = await prisma.selectedCalendar.findMany({
+    where: {
+      userId: user.id,
+    },
+    select: {
+      externalId: true,
+    },
+  });
+  // get user's credentials + their connected integrations
+  const calendarCredentials = getCalendarCredentials(user.credentials);
+  // get all the connected integrations' calendars (from third party)
+  const { connectedCalendars } = await getConnectedCalendars(calendarCredentials, user.selectedCalendars);
+  const calendars = connectedCalendars.flatMap((c) => c.calendars).filter(notEmpty);
+  const selectableCalendars = calendars.map((cal) => {
+    return { selected: selectedCalendarIds.findIndex((s) => s.externalId === cal.externalId) > -1, ...cal };
+  });
+  return selectableCalendars;
 }
+
+export default defaultResponder(async (req: NextApiRequest, res: NextApiResponse) => {
+  await authMiddleware(req);
+  return defaultHandler({
+    GET: Promise.resolve({ default: defaultResponder(getHandler) }),
+    POST: Promise.resolve({ default: defaultResponder(postHandler) }),
+    DELETE: Promise.resolve({ default: defaultResponder(deleteHandler) }),
+  })(req, res);
+});

apps/web/pages/api/cron/calendar-cache-cleanup.ts

@@ -3,6 +3,12 @@ import type { NextApiRequest, NextApiResponse } from "next";
 import prisma from "@calcom/prisma";
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+  if (![process.env.CRON_API_KEY, `Bearer ${process.env.CRON_SECRET}`].includes(`${apiKey}`)) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+
   const deleted = await prisma.calendarCache.deleteMany({
     where: {
       // Delete all cache entries that expired before now

apps/web/vercel.json

@@ -8,6 +8,10 @@
       "path": "/api/tasks/cron",
       "schedule": "* * * * *"
     },
+    {
+      "path": "/api/calendar-cache/cron",
+      "schedule": "* * * * *"
+    },
     {
       "path": "/api/tasks/cleanup",
       "schedule": "0 0 * * *"

packages/app-store/googlecalendar/api/callback.ts

@@ -105,7 +105,7 @@ async function getHandler(req: NextApiRequest, res: NextApiResponse) {
     // Wrapping in a try/catch to reduce chance of race conditions-
     // also this improves performance for most of the happy-paths.
     try {
-      await GoogleRepository.createSelectedCalendar({
+      await GoogleRepository.upsertSelectedCalendar({
         credentialId: gcalCredential.id,
         externalId: selectedCalendarWhereUnique.externalId,
         userId: selectedCalendarWhereUnique.userId,

packages/app-store/googlecalendar/api/index.ts

@@ -1,2 +1,3 @@
 export { default as add } from "./add";
 export { default as callback } from "./callback";
+export { default as webhook } from "./webhook";

packages/app-store/googlecalendar/api/webhook.ts

@@ -0,0 +1,47 @@
+import type { NextApiRequest } from "next";
+
+import { HttpError } from "@calcom/lib/http-error";
+import { defaultHandler, defaultResponder } from "@calcom/lib/server";
+import prisma from "@calcom/prisma";
+import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";
+
+import { getCalendar } from "../../_utils/getCalendar";
+
+async function postHandler(req: NextApiRequest) {
+  // 1. validate request
+  if (req.headers["x-goog-channel-token"] !== process.env.CRON_API_KEY) {
+    throw new HttpError({ statusCode: 403, message: "Invalid API key" });
+  }
+  if (typeof req.headers["x-goog-channel-id"] !== "string") {
+    throw new HttpError({ statusCode: 403, message: "Missing Channel ID" });
+  }
+
+  const selectedCalendar = await prisma.selectedCalendar.findUnique({
+    where: {
+      googleChannelId: req.headers["x-goog-channel-id"],
+    },
+    select: {
+      credential: {
+        select: {
+          ...credentialForCalendarServiceSelect,
+          selectedCalendars: {
+            orderBy: {
+              externalId: "asc",
+            },
+          },
+        },
+      },
+    },
+  });
+  if (!selectedCalendar) throw new HttpError({ statusCode: 404, message: "No calendar found" });
+  const { credential } = selectedCalendar;
+  if (!credential) throw new HttpError({ statusCode: 404, message: "No credential found" });
+  const { selectedCalendars } = credential;
+  const calendar = await getCalendar(credential);
+  await calendar?.fetchAvailabilityAndSetCache?.(selectedCalendars);
+  return { message: "ok" };
+}
+
+export default defaultHandler({
+  POST: Promise.resolve({ default: defaultResponder(postHandler) }),
+});