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

apps/api/v2/src/modules/prisma/tenant-aware-prisma.service.ts

@@ -0,0 +1,33 @@
+import { Injectable, Scope } from "@nestjs/common";
+import { Inject } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { REQUEST } from "@nestjs/core";
+import { PrismaClient } from "@prisma/client";
+
+import { getTenantFromHost } from "@calcom/prisma/store/tenants";
+
+@Injectable({ scope: Scope.REQUEST })
+export class TenantAwarePrismaService {
+  public prisma: PrismaClient;
+
+  constructor(
+    @Inject(REQUEST) private readonly request: Request,
+    private readonly configService: ConfigService
+  ) {
+    const host = this.request.headers["host"] || "";
+    const tenant = getTenantFromHost(host);
+
+    let dbUrl = this.configService.get("db.url", { infer: true });
+    if (tenant === "eu") {
+      dbUrl = this.configService.get("db.euUrl", { infer: true });
+    }
+
+    this.prisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: dbUrl,
+        },
+      },
+    });
+  }
+}

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";
 
@@ -273,4 +274,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/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/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;

packages/features/auth/lib/getServerSession.ts

@@ -9,6 +9,8 @@ import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
 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"] });
 /**
@@ -28,7 +30,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;
 }) {
@@ -130,3 +132,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";

packages/features/calendar-cache/api/cron.ts

@@ -1,19 +1,19 @@
-import type { NextApiRequest } from "next";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
 
 import { HttpError } from "@calcom/lib/http-error";
 import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
-import { defaultHandler } from "@calcom/lib/server/defaultHandler";
-import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import { SelectedCalendarRepository } from "@calcom/lib/server/repository/selectedCalendar";
 import type { SelectedCalendarEventTypeIds } from "@calcom/types/Calendar";
 
 import { CalendarCache } from "../calendar-cache";
 
 const log = logger.getSubLogger({ prefix: ["CalendarCacheCron"] });
 
-const validateRequest = (req: NextApiRequest) => {
-  const apiKey = req.headers.authorization || req.query.apiKey;
+const validateRequest = (req: NextRequest) => {
+  const url = new URL(req.url);
+  const apiKey = req.headers.get("authorization") || url.searchParams.get("apiKey");
   if (![process.env.CRON_API_KEY, `Bearer ${process.env.CRON_SECRET}`].includes(`${apiKey}`)) {
     throw new HttpError({ statusCode: 401, message: "Unauthorized" });
   }
@@ -144,16 +144,12 @@ const handleCalendarsToWatch = async () => {
 };
 
 // This cron is used to activate and renew calendar subscriptions
-const handler = defaultResponder(async (request: NextApiRequest) => {
+export const handler = async (request: NextRequest) => {
   validateRequest(request);
   await Promise.allSettled([handleCalendarsToWatch(), handleCalendarsToUnwatch()]);
 
   // TODO: Credentials can be installed on a whole team, check for selected calendars on the team
-  return {
+  return NextResponse.json({
     executedAt: new Date().toISOString(),
-  };
-});
-
-export default defaultHandler({
-  GET: Promise.resolve({ default: defaultResponder(handler) }),
-});
+  });
+};

packages/prisma/index.ts

@@ -1,21 +1,11 @@
 import type { Prisma } from "@prisma/client";
-import { PrismaClient as PrismaClientWithoutExtension } from "@prisma/client";
-import { withAccelerate } from "@prisma/extension-accelerate";
 
-import { bookingIdempotencyKeyExtension } from "./extensions/booking-idempotency-key";
-import { disallowUndefinedDeleteUpdateManyExtension } from "./extensions/disallow-undefined-delete-update-many";
-import { excludeLockedUsersExtension } from "./extensions/exclude-locked-users";
-import { excludePendingPaymentsExtension } from "./extensions/exclude-pending-payment-teams";
-import { usageTrackingExtention } from "./extensions/usage-tracking";
-import { bookingReferenceMiddleware } from "./middleware";
+import type { PrismaClientWithExtensions } from "./store/prismaStore";
+import { getPrisma, getTenantAwarePrisma } from "./store/prismaStore";
+import { Tenant } from "./store/tenants";
 
 const prismaOptions: Prisma.PrismaClientOptions = {};
 
-const globalForPrisma = global as unknown as {
-  prismaWithoutClientExtensions: PrismaClientWithoutExtension;
-  prismaWithClientExtensions: PrismaClientWithExtensions;
-};
-
 const loggerLevel = parseInt(process.env.NEXT_PUBLIC_LOGGER_LEVEL ?? "", 10);
 
 if (!isNaN(loggerLevel)) {
@@ -37,49 +27,33 @@ if (!isNaN(loggerLevel)) {
   }
 }
 
-// Prevents flooding with idle connections
-const prismaWithoutClientExtensions =
-  globalForPrisma.prismaWithoutClientExtensions || new PrismaClientWithoutExtension(prismaOptions);
-
-export const customPrisma = (options?: Prisma.PrismaClientOptions) =>
-  new PrismaClientWithoutExtension({ ...prismaOptions, ...options })
-    .$extends(usageTrackingExtention())
-    .$extends(excludeLockedUsersExtension())
-    .$extends(excludePendingPaymentsExtension())
-    .$extends(bookingIdempotencyKeyExtension())
-    .$extends(disallowUndefinedDeleteUpdateManyExtension())
-    .$extends(withAccelerate());
-
 // If any changed on middleware server restart is required
 // TODO: Migrate it to $extends
-bookingReferenceMiddleware(prismaWithoutClientExtensions);
 
-// FIXME: Due to some reason, there are types failing in certain places due to the $extends. Fix it and then enable it
-// Specifically we get errors like `Type 'string | Date | null | undefined' is not assignable to type 'Exact<string | Date | null | undefined, string | Date | null | undefined>'`
-const prismaWithClientExtensions = prismaWithoutClientExtensions
-  .$extends(usageTrackingExtention())
-  .$extends(excludeLockedUsersExtension())
-  .$extends(excludePendingPaymentsExtension())
-  .$extends(bookingIdempotencyKeyExtension())
-  .$extends(disallowUndefinedDeleteUpdateManyExtension())
-  .$extends(withAccelerate());
-
-export const prisma = globalForPrisma.prismaWithClientExtensions || prismaWithClientExtensions;
+export const prisma = new Proxy({} as PrismaClientWithExtensions, {
+  get(target, prop) {
+    if (process.env.NODE_ENV === "test") {
+      const defaultPrisma = getPrisma(Tenant.US, prismaOptions);
+      return Reflect.get(defaultPrisma, prop);
+    }
+
+    try {
+      const tenantPrisma = getTenantAwarePrisma(prismaOptions);
+      return Reflect.get(tenantPrisma, prop);
+    } catch (error) {
+      throw new Error(
+        "Prisma was called outside of runWithTenants. Please wrap your code with runWithTenants or use a tenant-aware approach."
+      );
+    }
+  },
+});
 
 // This prisma instance is meant to be used only for READ operations.
 // If self hosting, feel free to leave INSIGHTS_DATABASE_URL as empty and `readonlyPrisma` will default to `prisma`.
 export const readonlyPrisma = process.env.INSIGHTS_DATABASE_URL
-  ? customPrisma({
-      datasources: { db: { url: process.env.INSIGHTS_DATABASE_URL } },
-    })
+  ? getPrisma(Tenant.INSIGHTS, prismaOptions)
   : prisma;
 
-if (process.env.NODE_ENV !== "production") {
-  globalForPrisma.prismaWithoutClientExtensions = prismaWithoutClientExtensions;
-  globalForPrisma.prismaWithClientExtensions = prisma;
-}
-
-type PrismaClientWithExtensions = typeof prismaWithClientExtensions;
 export type PrismaClient = PrismaClientWithExtensions;
 
 type OmitPrismaClient = Omit<