feat: prisma DB multi-tenancy (cal.eu)

.env.example

@@ -28,6 +28,10 @@ CALCOM_PRIVATE_API_ROUTE="https://goblin.cal.com"
 
 # - DATABASE ************************************************************************************************
 DATABASE_URL="postgresql://postgres:@localhost:5450/calendso"
+
+# Optional: for EU data residency, set this to your EU database URL
+DATABASE_URL_EU=
+
 # Needed to run migrations while using a connection pooler like PgBouncer
 # Use the same one as DATABASE_URL if you're not using a connection pooler
 DATABASE_DIRECT_URL="postgresql://postgres:@localhost:5450/calendso"
@@ -70,6 +74,8 @@ PGSSLMODE=
 ALLOWED_HOSTNAMES='"cal.com","cal.dev","cal-staging.com","cal.community","cal.local:3000","localhost:3000"'
 #  Reserved orgs subdomains for our own usage
 RESERVED_SUBDOMAINS='"app","auth","docs","design","console","go","status","api","saml","www","matrix","developer","cal","my","team","support","security","blog","learn","admin"'
+# Tenants that use the EU data residency
+TENANT_DOMAINS_EU=
 
 #   - NEXTAUTH
 # @see: https://github.com/calendso/calendso/issues/263

apps/web/app/(booking-page-wrapper)/[user]/page.tsx

@@ -4,6 +4,7 @@ import { generateMeetingMetadata } from "app/_utils";
 import { headers, cookies } from "next/headers";
 
 import { getOrgFullOrigin } from "@calcom/features/ee/organizations/lib/orgDomains";
+import { withPrismaPage } from "@calcom/prisma/store/withPrismaPage";
 
 import { buildLegacyCtx, decodeParams } from "@lib/buildLegacyCtx";
 
@@ -54,4 +55,4 @@ const ServerPage = async ({ params, searchParams }: PageProps) => {
   return <LegacyPage {...props} />;
 };
 
-export default ServerPage;
+export default withPrismaPage(ServerPage);

apps/web/app/(booking-page-wrapper)/org/[orgSlug]/[user]/[type]/page.tsx

@@ -6,6 +6,7 @@ import { cookies, headers } from "next/headers";
 
 import { getOrgFullOrigin } from "@calcom/features/ee/organizations/lib/orgDomains";
 import { loadTranslations } from "@calcom/lib/server/i18n";
+import { withPrismaPage } from "@calcom/prisma/store/withPrismaPage";
 
 import { buildLegacyCtx, decodeParams } from "@lib/buildLegacyCtx";
 import { getServerSideProps } from "@lib/org/[orgSlug]/[user]/[type]/getServerSideProps";
@@ -93,4 +94,4 @@ const ServerPage = async ({ params, searchParams }: PageProps) => {
   );
 };
 
-export default ServerPage;
+export default withPrismaPage(ServerPage);

apps/web/app/(use-page-wrapper)/(main-nav)/event-types/page.tsx

@@ -8,6 +8,7 @@ import { redirect } from "next/navigation";
 
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
 import { getTeamsFiltersFromQuery } from "@calcom/features/filters/lib/getTeamsFiltersFromQuery";
+import { withPrismaPage } from "@calcom/prisma/store/withPrismaPage";
 import { eventTypesRouter } from "@calcom/trpc/server/routers/viewer/eventTypes/_router";
 import { meRouter } from "@calcom/trpc/server/routers/viewer/me/_router";
 
@@ -81,4 +82,4 @@ const Page = async ({ params, searchParams }: PageProps) => {
   );
 };
 
-export default Page;
+export default withPrismaPage(Page);

apps/web/app/WithAppDirSsr.tsx

@@ -1,7 +1,9 @@
 import type { GetServerSideProps, GetServerSidePropsContext } from "next";
 import { notFound, redirect } from "next/navigation";
 
-export const withAppDirSsr =
+import { withPrismaSsr } from "@calcom/prisma/store/withPrismaSsr";
+
+const _withAppDirSsr =
   <T extends Record<string, any>>(getServerSideProps: GetServerSideProps<T>) =>
   async (context: GetServerSidePropsContext) => {
     const ssrResponse = await getServerSideProps(context);
@@ -19,3 +21,5 @@ export const withAppDirSsr =
       ...props,
     };
   };
+
+export const withAppDirSsr = withPrismaSsr(_withAppDirSsr);

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

@@ -0,0 +1,6 @@
+import { handler } from "@calcom/features/calendar-cache/api/cron";
+import { withMultiTenantPrisma } from "@calcom/prisma/store/withMultiTenantPrisma";
+
+import { defaultResponderForAppDir } from "../../defaultResponderForAppDir";
+
+export const GET = withMultiTenantPrisma(defaultResponderForAppDir(handler));

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

@@ -3,6 +3,7 @@ import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
 
 import prisma from "@calcom/prisma";
+import { withMultiTenantPrisma } from "@calcom/prisma/store/withMultiTenantPrisma";
 
 async function postHandler(request: NextRequest) {
   const apiKey = request.headers.get("authorization") || request.nextUrl.searchParams.get("apiKey");
@@ -23,4 +24,4 @@ async function postHandler(request: NextRequest) {
   return NextResponse.json({ ok: true, count: deleted.count });
 }
 
-export const POST = defaultResponderForAppDir(postHandler);
+export const POST = withMultiTenantPrisma(defaultResponderForAppDir(postHandler));

apps/web/app/api/cron/credentials/route.ts

@@ -11,6 +11,7 @@ import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import { CredentialRepository } from "@calcom/lib/server/repository/credential";
 import { DelegationCredentialRepository } from "@calcom/lib/server/repository/delegationCredential";
+import { withMultiTenantPrisma } from "@calcom/prisma/store/withMultiTenantPrisma";
 
 import { defaultResponderForAppDir } from "../../defaultResponderForAppDir";
 
@@ -167,4 +168,4 @@ const handler = async (request: NextRequest) => {
   return NextResponse.json(response);
 };
 
-export const GET = defaultResponderForAppDir(handler);
+export const GET = withMultiTenantPrisma(defaultResponderForAppDir(handler));

apps/web/app/api/cron/selected-calendars/route.ts

@@ -14,6 +14,7 @@ import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import { CredentialRepository } from "@calcom/lib/server/repository/credential";
 import { SelectedCalendarRepository } from "@calcom/lib/server/repository/selectedCalendar";
+import { withMultiTenantPrisma } from "@calcom/prisma/store/withMultiTenantPrisma";
 import type { CredentialForCalendarServiceWithEmail } from "@calcom/types/Credential";
 import type { Ensure } from "@calcom/types/utils";
 
@@ -312,4 +313,4 @@ const handler = async (request: NextRequest) => {
   return NextResponse.json(await handleCreateSelectedCalendars());
 };
 
-export const GET = defaultResponderForAppDir(handler);
+export const GET = withMultiTenantPrisma(defaultResponderForAppDir(handler));

apps/web/app/api/defaultResponderForAppDir.ts

@@ -7,64 +7,67 @@ import { NextResponse } from "next/server";
 
 import { getServerErrorFromUnknown } from "@calcom/lib/server/getServerErrorFromUnknown";
 import { performance } from "@calcom/lib/server/perfObserver";
+import { withPrismaRoute } from "@calcom/prisma/store/withPrismaRoute";
 
 type Handler<T extends NextResponse | Response = NextResponse> = (
   req: NextRequest,
-  { params }: { params: Promise<Params> }
+  options?: { params: Promise<Params> }
 ) => Promise<T>;
 
 export const defaultResponderForAppDir = <T extends NextResponse | Response = NextResponse>(
   handler: Handler<T>,
   endpointRoute?: string
 ) => {
-  return async (req: NextRequest, { params }: { params: Promise<Params> }) => {
-    let ok = false;
-    try {
-      performance.mark("Start");
+  return withPrismaRoute(
+    async (req: NextRequest, { params }: { params: Promise<Params> } = { params: Promise.resolve({}) }) => {
+      let ok = false;
+      try {
+        performance.mark("Start");
 
-      const result = endpointRoute
-        ? await wrapApiHandlerWithSentry(async () => await handler(req, { params }), endpointRoute)()
-        : await handler(req, { params });
+        const result = endpointRoute
+          ? await wrapApiHandlerWithSentry(async () => await handler(req, { params }), endpointRoute)()
+          : await handler(req, { params });
 
-      ok = true;
-      if (result) {
-        return result;
-      }
-
-      return NextResponse.json({});
-    } catch (error) {
-      let serverError;
+        ok = true;
+        if (result) {
+          return result;
+        }
 
-      if (error instanceof ApiError) {
-        serverError = {
-          message: error.message,
-          statusCode: error.statusCode,
-          url: req.url,
-          method: req.method,
-        };
-      } else {
-        serverError = getServerErrorFromUnknown(error);
-      }
+        return NextResponse.json({});
+      } catch (error) {
+        let serverError;
 
-      // Don't report 400-499 errors to Sentry/console
-      if (!(serverError.statusCode >= 400 && serverError.statusCode < 500)) {
-        console.error(serverError);
-        captureException(error);
-      }
+        if (error instanceof ApiError) {
+          serverError = {
+            message: error.message,
+            statusCode: error.statusCode,
+            url: req.url,
+            method: req.method,
+          };
+        } else {
+          serverError = getServerErrorFromUnknown(error);
+        }
 
-      return NextResponse.json(
-        {
-          message: serverError.message,
-          url: serverError.url,
-          method: serverError.method,
-        },
-        {
-          status: serverError.statusCode,
+        // Don't report 400-499 errors to Sentry/console
+        if (!(serverError.statusCode >= 400 && serverError.statusCode < 500)) {
+          console.error(serverError);
+          captureException(error);
         }
-      );
-    } finally {
-      performance.mark("End");
-      performance.measure(`[${ok ? "OK" : "ERROR"}][${req.method}] '${req.url}'`, "Start", "End");
+
+        return NextResponse.json(
+          {
+            message: serverError.message,
+            url: serverError.url,
+            method: serverError.method,
+          },
+          {
+            status: serverError.statusCode,
+          }
+        );
+      } finally {
+        performance.mark("End");
+        performance.measure(`[${ok ? "OK" : "ERROR"}][${req.method}] '${req.url}'`, "Start", "End");
+      }
     }
-  };
+  );
 };

apps/web/app/api/tasks/cleanup/route.ts

@@ -1,5 +1,6 @@
 import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
 
 import { GET as handler } from "@calcom/features/tasker/api/cleanup";
+import { withMultiTenantPrisma } from "@calcom/prisma/store/withMultiTenantPrisma";
 
-export const GET = defaultResponderForAppDir(handler);
+export const GET = withMultiTenantPrisma(defaultResponderForAppDir(handler));

apps/web/app/api/tasks/cron/route.ts

@@ -1,8 +1,9 @@
 import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
 
 import { GET as handler } from "@calcom/features/tasker/api/cron";
+import { withMultiTenantPrisma } from "@calcom/prisma/store/withMultiTenantPrisma";
 
-export const GET = defaultResponderForAppDir(handler);
+export const GET = withMultiTenantPrisma(defaultResponderForAppDir(handler));
 
 /**
  * This runs each minute and we need fresh data each time

apps/web/app/api/tenant-aware-example/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+
+import { prisma } from "@calcom/prisma";
+import { withPrismaRoute } from "@calcom/prisma/store/withPrismaRoute";
+
+async function handler(req: Request) {
+  const users = await prisma.user.findMany({
+    select: { id: true, name: true, email: true },
+    take: 5,
+  });
+
+  return NextResponse.json({
+    tenant: req.headers.get("host") || "unknown",
+    users,
+  });
+}
+
+export const GET = withPrismaRoute(handler);

apps/web/app/layout.tsx

@@ -6,6 +6,7 @@ import React from "react";
 
 import { getLocale } from "@calcom/features/auth/lib/getLocale";
 import { loadTranslations } from "@calcom/lib/server/i18n";
+import { withPrismaPage } from "@calcom/prisma/store/withPrismaPage";
 import { IconSprites } from "@calcom/ui/components/icon";
 
 import { buildLegacyRequest } from "@lib/buildLegacyCtx";
@@ -94,7 +95,7 @@ const getInitialProps = async () => {
   };
 };
 
-export default async function RootLayout({ children }: { children: React.ReactNode }) {
+async function RootLayout({ children }: { children: React.ReactNode }) {
   const h = await headers();
   const nonce = h.get("x-csp") ?? "";
 
@@ -160,3 +161,5 @@ export default async function RootLayout({ children }: { children: React.ReactNo
     </html>
   );
 }
+
+export default withPrismaPage(RootLayout);

apps/web/app/prisma-test/api/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+
+import { prisma } from "@calcom/prisma";
+import { withPrismaRoute } from "@calcom/prisma/store/withPrismaRoute";
+
+export const GET = withPrismaRoute(async (req) => {
+  const user = await prisma.user.findFirst({ where: { id: 1 }, select: { id: true, name: true } });
+  return NextResponse.json({ user });
+});

apps/web/app/prisma-test/page/page.tsx

@@ -0,0 +1,29 @@
+import type { PrismaClient } from "@prisma/client";
+
+import { withPrismaPage } from "@calcom/prisma/store/withPrismaPage";
+
+interface HomePageProps {
+  prisma: PrismaClient;
+  host: string; // host can be used if needed, e.g. for display
+}
+
+// This is the actual page component logic, now cleaner.
+async function HomePageContent({ prisma, host }: HomePageProps) {
+  const users = await prisma.user.findMany({ where: { id: 1 }, select: { id: true, name: true } });
+
+  return (
+    <div>
+      <h1>Users for tenant ({host})</h1>
+      <ul>
+        {users.map((user) => (
+          <li key={user.id}>{user.name}</li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+
+// Wrap the page content component with the HOC
+const Home = withPrismaPage(HomePageContent);
+
+export default Home;

apps/web/pages/api/auth/[...nextauth].ts

@@ -2,9 +2,10 @@ import type { NextApiRequest, NextApiResponse } from "next";
 import NextAuth from "next-auth";
 
 import { getOptions } from "@calcom/features/auth/lib/next-auth-options";
+import { withPrismaApiHandler } from "@calcom/prisma/store/withPrismaApiHandler";
 
 // pass req to NextAuth: https://github.com/nextauthjs/next-auth/discussions/469
 const handler = (req: NextApiRequest, res: NextApiResponse) =>
   NextAuth(req, res, getOptions({ getDubId: () => req.cookies.dub_id || req.cookies.dclid }));
 
-export default handler;
+export default withPrismaApiHandler(handler);

packages/features/auth/lib/getServerSession.ts

@@ -10,6 +10,8 @@ import { safeStringify } from "@calcom/lib/safeStringify";
 import { DeploymentRepository } from "@calcom/lib/server/repository/deployment";
 import { UserRepository } from "@calcom/lib/server/repository/user";
 import prisma from "@calcom/prisma";
+import { runWithTenants } from "@calcom/prisma/store/prismaStore";
+import { getTenantFromHost } from "@calcom/prisma/store/tenants";
 
 const log = logger.getSubLogger({ prefix: ["getServerSession"] });
 /**
@@ -29,7 +31,7 @@ const CACHE = new LRUCache<string, Session>({ max: 1000 });
  * token has expired (30 days). This should be fine as we call `/auth/session`
  * frequently enough on the client-side to keep the session alive.
  */
-export async function getServerSession(options: {
+async function _getServerSession(options: {
   req: NextApiRequest | GetServerSidePropsContext["req"];
   authOptions?: AuthOptions;
 }) {
@@ -132,3 +134,10 @@ export async function getServerSession(options: {
   log.debug("Returned session", safeStringify(session));
   return session;
 }
+
+export async function getServerSession(options: {
+  req: NextApiRequest | GetServerSidePropsContext["req"];
+  authOptions?: AuthOptions;
+}) {
+  return runWithTenants(getTenantFromHost(options.req.headers.host || ""), () => _getServerSession(options));
+}

packages/features/bookings/Booker/components/hooks/useInitialFormValues.ts

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { z } from "zod";
+import type { z } from "zod";
 
 import { useBookerStore } from "@calcom/features/bookings/Booker/store";
 import type getBookingResponsesSchema from "@calcom/features/bookings/lib/getBookingResponsesSchema";