chore: release v5.2.1

* Add whitelistWorkflows to user

* Do not autolock whitelisted users

* Add endpoint to whitelist a user

* Get users data - include whitelistWorkflows

* Whitelist a user on the user admin page

* Fix typo

* Add test

* Use translations

* Add `updateWhitelistWorkflows` to `UserRepository`

* Use i18 for strings

* Rename to whitelistWorkflows

---------

Co-authored-by: Benny Joo <sldisek783@gmail.com>

.github/ISSUE_TEMPLATE/platform.md

@@ -0,0 +1,58 @@
+---
+name: Cal.com/platform request
+about: Suggest a feature or bug report for cal.com/platform
+title: ""
+labels: ["platform", "🚨 needs approval"]
+assignees: ""
+---
+
+### Is your proposal related to a problem?
+
+<!--
+  Provide a clear and concise description of what the problem is.
+  For example, "I'm always frustrated when..."
+-->
+
+(Write your answer here.)
+
+### Describe the solution you'd like
+
+<!--
+  Provide a clear and concise description of what you want to happen.
+-->
+
+(Describe your proposed solution here.)
+
+### Describe alternatives you've considered
+
+<!--
+  Let us know about other solutions you've tried or researched.
+-->
+
+(Write your answer here.)
+
+### Additional context
+
+<!--
+  Is there anything else you can add about the proposal?
+  You might want to link to related issues here, if you haven't already.
+-->
+
+(Write your answer here.)
+
+### Requirement/Document
+
+<!--
+  Is there any type of document that could support that feature?
+-->
+
+(Share it here.)
+
+---
+
+##### House rules
+
+- If this issue has a `🚨 needs approval` label, don't start coding yet. Wait until a core member approves feature request by removing this label, then you can start coding.
+  - For clarity: Non-core member issues automatically get the `🚨 needs approval` label.
+  - Your feature ideas are invaluable to us! However, they undergo review to ensure alignment with the product's direction.
+  - Follow Best Practices lined out in our [Contributor Docs](https://github.com/calcom/cal.com/blob/main/CONTRIBUTING.md)

.github/workflows/cron-scheduleEmailReminders.yml

@@ -1,3 +1,5 @@
+# deprecated - use smtp with tasker instead */
+
 name: Cron - scheduleEmailReminders
 
 on:

.yarn/versions/5939e821.yml

@@ -0,0 +1,2 @@
+undecided:
+  - "@calcom/prisma"

.yarn/versions/7370f650.yml

@@ -0,0 +1,2 @@
+undecided:
+  - "@calcom/prisma"

.yarn/versions/8c9cdea6.yml

@@ -0,0 +1,8 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/app-store-cli"
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
+  - "@calcom/prisma"

CONTRIBUTING.md

@@ -1,43 +1,76 @@
 # Contributing to Cal.com
 
-Contributions are what makes the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
 
-## House rules
+## House Rules (for PRs and Issues)
 
-- Before submitting a new issue or PR, check if it already exists in [issues](https://github.com/calcom/cal.com/issues) or [PRs](https://github.com/calcom/cal.com/pulls).
-- GitHub issues: take note of the `🚨 needs approval` label.
-  - **For Contributors**:
-    - Feature Requests: Wait for a core member to approve and remove the `🚨 needs approval` label before you start coding or submit a PR.
-    - Bugs, Security, Performance, Documentation, etc.: You can start coding immediately, even if the `🚨 needs approval` label is present. This label mainly concerns feature requests.
-  - **Our Process**:
-    - Issues from non-core members automatically receive the `🚨 needs approval` label.
-    - We greatly value new feature ideas. To ensure consistency in the product's direction, they undergo review and approval.
+### 👥 Prevent Work Duplication
+
+Before submitting a new issue or PR, check if it already exists in the [Issues](https://github.com/calcom/cal.com/issues) or [Pull Requests](https://github.com/calcom/cal.com/pulls).
+
+### ✅ Work Only on Approved Issues
+
+For feature requests, please wait for a core team member to approve and remove the `🚨 needs approval` label before you start coding or submitting a PR.
+
+For bugs, security, performance, documentation, etc., you can start coding immediately—even if the `🚨 needs approval` label is present.
+
+We highly value new feature ideas, but to maintain consistency in the product direction, they must go through a review and approval process.
+
+### 🚫 Don’t Just Drop a Link
+
+Avoid posting third-party links (e.g., Slack threads or Linear tickets) without context. A GitHub issue or PR should stand on its own—reviewers shouldn’t have to chase information across multiple tools to understand the context.
+
+### 👀 Think Like a Reviewer
+
+Put yourself in the reviewer’s shoes. What would you want to know if reading this for the first time? Are there key decisions, goals, or constraints that need clarification? Does the PR assume knowledge that isn’t obvious? Are there related issues or previous PRs that should be linked?
+
+### 🧵 Bring in Context from Private Channels
+
+If the task originated from a private conversation (e.g., Slack), take a moment to extract the relevant details and include them in the GitHub issue or PR. Avoid sharing sensitive information, but make sure important reasoning is captured.
+
+> Example:  
+> “A user requested feature X to solve problem Y. I considered approaches A, B, and C, but chose C for the following reasons…”
+
+### 📚 Treat It Like Documentation
+
+GitHub is a shared source of truth. Every issue and PR contributes to the long-term understanding of the codebase. Write clearly enough that someone—possibly you—can revisit it months later and still understand what happened and why.
+
+### ✅ Summarize Your PR at the Top
+
+Even if the code changes are minor or self-explanatory, a short written summary helps reviewers quickly understand the intent. You can use GitHub Copilot’s auto-summarize feature, but make sure to verify it for accuracy and relevance.
+
+### 🔗 Use GitHub Keywords to Auto-Link Issues
+
+Use phrases like “Closes #123” or “Fixes #456” in your PR descriptions. This automatically links your PR to the related issue and closes it once merged—keeping everything traceable and organized.
+
+### 🧪 Mention What Was Tested (and How)
+
+Explain how you validated your changes. It doesn’t need to be exhaustive—just enough to give reviewers confidence that things were tested and work as expected.
+
+> Example:  
+> “Tested locally with mock data and confirmed the flow works on staging.”
+
+### 🧠 Assume Future-You Won’t Remember
+
+Write with the future in mind. If there are trade-offs, edge cases, or temporary workarounds, document them clearly so they don’t get lost or misinterpreted later.
 
 ## Priorities
 
 <table>
   <tr>
-    <td>
-      Type of Issue
-    </td>
-    <td>
-      Priority
-    </td>
+    <td><strong>Type of Issue</strong></td>
+    <td><strong>Priority</strong></td>
   </tr>
   <tr>
-    <td>
-      Minor improvements, non-core feature requests
-    </td>
+    <td>Minor improvements, non-core feature requests</td>
     <td>
       <a href="https://github.com/calcom/cal.com/issues?q=is:issue+is:open+sort:updated-desc+label:%22Low+priority%22">
         <img src="https://img.shields.io/badge/-Low%20Priority-green">
       </a>
     </td>
   </tr>
-   <tr>
-    <td>
-      Confusing UX (... but working)
-    </td>
+  <tr>
+    <td>Confusing UX (but still functional)</td>
     <td>
       <a href="https://github.com/calcom/cal.com/issues?q=is:issue+is:open+sort:updated-desc+label:%22Medium+priority%22">
         <img src="https://img.shields.io/badge/-Medium%20Priority-yellow">
@@ -45,9 +78,7 @@ Contributions are what makes the open source community such an amazing place to
     </td>
   </tr>
   <tr>
-    <td>
-      Core Features (Booking page, availability, timezone calculation)
-    </td>
+    <td>Core Features (Booking page, availability, timezone calculation)</td>
     <td>
       <a href="https://github.com/calcom/cal.com/issues?q=is:issue+is:open+sort:updated-desc+label:%22High+priority%22">
         <img src="https://img.shields.io/badge/-High%20Priority-orange">
@@ -55,9 +86,7 @@ Contributions are what makes the open source community such an amazing place to
     </td>
   </tr>
   <tr>
-    <td>
-      Core Bugs (Login, Booking page, Emails are not working)
-    </td>
+    <td>Core Bugs (Login, Booking page, Emails not working)</td>
     <td>
       <a href="https://github.com/calcom/cal.com/issues?q=is:issue+is:open+sort:updated-desc+label:Urgent">
         <img src="https://img.shields.io/badge/-Urgent-red">
@@ -68,59 +97,7 @@ Contributions are what makes the open source community such an amazing place to
 
 ## Developing
 
-The development branch is `main`. This is the branch that all pull
-requests should be made against. The changes on the `main`
-branch are tagged into a release monthly.
-
-To develop locally:
-
-1. [Fork](https://github.com/calcom/cal.com/fork/) this repository to your
-   own GitHub account and then
-   [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device.
-2. Create a new branch:
-
-   ```sh
-   git checkout -b MY_BRANCH_NAME
-   ```
-
-3. Install yarn:
-
-   ```sh
-   npm install -g yarn
-   ```
-
-4. Install the dependencies with:
-
-   ```sh
-   yarn
-   ```
-
-5. Set up your `.env` file:
-
-   - Duplicate `.env.example` to `.env`.
-   - Use `openssl rand -base64 32` to generate a key and add it under `NEXTAUTH_SECRET` in the `.env` file.
-   - Use `openssl rand -base64 32` to generate a key and add it under `CALENDSO_ENCRYPTION_KEY` in the `.env` file.
-
-6. Setup Node
-   If your Node version does not meet the project's requirements as instructed by the docs, "nvm" (Node Version Manager) allows using Node at the version required by the project:
-
-   ```sh
-   nvm use
-   ```
-
-   You first might need to install the specific version:
-
-   ```sh
-   nvm install
-   ```
-
-   You can install nvm from [here](https://github.com/nvm-sh/nvm).
-
-7. Start developing and watch for code changes:
-
-   ```sh
-   yarn dev
-   ```
+[See README](https://github.com/calcom/cal.com#development)
 
 ## Building
 
@@ -130,23 +107,19 @@ You can build the project with:
 yarn build
 ```
 
-Please be sure that you can make a full production build before pushing code.
+Please ensure that you can make a full production build before pushing code.
 
 ## Testing
 
 More info on how to add new tests coming soon.
 
-### Running tests
+### Running Tests
 
-This will run and test all flows in multiple Chromium windows to verify that no critical flow breaks:
+[See README](https://github.com/calcom/cal.com#e2e-testing)
 
-```sh
-yarn test-e2e
-```
+#### Resolving Issues
 
-#### Resolving issues
-
-##### E2E test browsers not installed
+##### E2E Test Browsers Not Installed
 
 Run `npx playwright install` to download test browsers and resolve the error below when running `yarn test-e2e`:
 
@@ -166,68 +139,8 @@ If you get errors, be sure to fix them before committing.
 
 ## Making a Pull Request
 
-- Be sure to [check the "Allow edits from maintainers" option](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork) while creating your PR.
-- If your PR refers to or fixes an issue, be sure to add `refs #XXX` or `fixes #XXX` to the PR description. Replacing `XXX` with the respective issue number. See more about [Linking a pull request to an issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
-- Be sure to fill the PR Template accordingly.
-- Review [App Contribution Guidelines](./packages/app-store/CONTRIBUTING.md) when building integrations
-
-## Guidelines for committing yarn lockfile
-
-Do not commit your `yarn.lock` unless you've made changes to the `package.json`. If you've already committed `yarn.lock` unintentionally, follow these steps to undo:
-
-If your last commit has the `yarn.lock` file alongside other files and you only wish to uncommit the `yarn.lock`:
-
-```bash
-git checkout HEAD~1 yarn.lock
-git commit -m "Revert yarn.lock changes"
-```
-
-_NB_: You may have to bypass the pre-commit hook with by appending `--no-verify` to the git commit
-If you've pushed the commit with the `yarn.lock`:
-
-1.  Correct the commit locally using the above method.
-2.  Carefully force push:
-
-```bash
-git push origin <your-branch-name> --force
-```
-
-If `yarn.lock` was committed a while ago and there have been several commits since, you can use the following steps to revert just the `yarn.lock` changes without impacting the subsequent changes:
-
-1. **Checkout a Previous Version**:
-
-   - Find the commit hash before the `yarn.lock` was unintentionally committed. You can do this by viewing the Git log:
-
-     ```bash
-     git log yarn.lock
-     ```
-
-   - Once you have identified the commit hash, use it to checkout the previous version of `yarn.lock`:
-
-     ```bash
-     git checkout <commit_hash> yarn.lock
-     ```
-
-2. **Commit the Reverted Version**:
-
-   - After checking out the previous version of the `yarn.lock`, commit this change:
-
-     ```bash
-     git commit -m "Revert yarn.lock to its state before unintended changes"
-     ```
-
-3. **Proceed with Caution**:
-
-   - If you need to push this change, first pull the latest changes from your remote branch to ensure you're not overwriting other recent changes:
-
-     ```bash
-     git pull origin <your-branch-name>
-     ```
-
-   - Then push the updated branch:
-
-     ```bash
-     git push origin <your-branch-name>
-     ```
-
-Lastly, make sure to keep the branches updated (e.g. click the `Update branch` button on GitHub PR).
+- Be sure to [check the "Allow edits from maintainers" option](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork) when creating your PR. (This option isn't available if you're [contributing from a fork belonging to an organization](https://github.com/orgs/community/discussions/5634))
+- If your PR refers to or fixes an issue, add `refs #XXX` or `fixes #XXX` to the PR description. Replace `XXX` with the respective issue number. See more about [linking a pull request to an issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
+- Fill out the PR template accordingly.
+- Review the [App Contribution Guidelines](./packages/app-store/CONTRIBUTING.md) when building integrations.
+- Lastly, make sure to keep your branches updated (e.g., click the `Update branch` button on the GitHub PR page).

apps/api/v1/pages/api/invites/_post.ts

@@ -8,6 +8,7 @@ import { createContext } from "@calcom/trpc/server/createContext";
 import { viewerTeamsRouter } from "@calcom/trpc/server/routers/viewer/teams/_router";
 import type { TInviteMemberInputSchema } from "@calcom/trpc/server/routers/viewer/teams/inviteMember/inviteMember.schema";
 import { ZInviteMemberInputSchema } from "@calcom/trpc/server/routers/viewer/teams/inviteMember/inviteMember.schema";
+import { createCallerFactory } from "@calcom/trpc/server/trpc";
 import type { UserProfile } from "@calcom/types/UserProfile";
 
 import { TRPCError } from "@trpc/server";
@@ -38,7 +39,8 @@ async function postHandler(req: NextApiRequest, res: NextApiResponse) {
 
   const ctx = await createContext({ req, res }, sessionGetter);
   try {
-    const caller = viewerTeamsRouter.createCaller(ctx);
+    const createCaller = createCallerFactory(viewerTeamsRouter);
+    const caller = createCaller(ctx);
     await caller.inviteMember({
       role: data.role,
       language: data.language,

apps/api/v1/pages/api/slots/_get.ts

@@ -3,8 +3,7 @@ import utc from "dayjs/plugin/utc";
 import type { NextApiRequest, NextApiResponse } from "next";
 
 import dayjs from "@calcom/dayjs";
-import { IS_PRODUCTION } from "@calcom/lib/constants";
-import { isSupportedTimeZone } from "@calcom/lib/date-fns";
+import { isSupportedTimeZone } from "@calcom/lib/dayjs";
 import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import { createContext } from "@calcom/trpc/server/createContext";
@@ -18,15 +17,8 @@ import { getHTTPStatusCodeFromError } from "@trpc/server/http";
 dayjs.extend(utc);
 dayjs.extend(timezone);
 
-let isColdStart = true;
-
 async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
-    if (isColdStart && IS_PRODUCTION) {
-      console.log("Cold start of /v1/slots detected");
-      isColdStart = false;
-    }
-
     const { usernameList, isTeamEvent, ...rest } = req.query;
     const parsedIsTeamEvent = String(isTeamEvent).toLowerCase() === "true";
     let slugs = usernameList;

apps/api/v1/pages/api/teams/[teamId]/publish.ts

@@ -6,6 +6,7 @@ import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import { MembershipRole, UserPermissionRole } from "@calcom/prisma/enums";
 import { createContext } from "@calcom/trpc/server/createContext";
 import { viewerTeamsRouter } from "@calcom/trpc/server/routers/viewer/teams/_router";
+import { createCallerFactory } from "@calcom/trpc/server/trpc";
 import type { UserProfile } from "@calcom/types/UserProfile";
 
 import { TRPCError } from "@trpc/server";
@@ -39,7 +40,8 @@ const patchHandler = async (req: NextApiRequest, res: NextApiResponse) => {
   /** @see https://trpc.io/docs/server-side-calls */
   const ctx = await createContext({ req, res }, sessionGetter);
   try {
-    const caller = viewerTeamsRouter.createCaller(ctx);
+    const createCaller = createCallerFactory(viewerTeamsRouter);
+    const caller = createCaller(ctx);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return await caller.publish(req.query as any /* Let tRPC handle this */);
   } catch (cause) {

apps/api/v2/package.json

@@ -38,7 +38,7 @@
     "@axiomhq/winston": "^1.2.0",
     "@calcom/platform-constants": "*",
     "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.171",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.173",
     "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",

apps/api/v2/src/ee/bookings/2024-08-13/controllers/bookings.controller.ts

@@ -256,7 +256,8 @@ export class BookingsController_2024_08_13 {
   @UseGuards(ApiAuthGuard, BookingUidGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
-    summary: "Mark a booking absence - provided authorization header refers to owner of the booking.",
+    summary: "Mark a booking absence",
+    description: "The provided authorization header refers to the owner of the booking.",
   })
   async markNoShow(
     @Param("bookingUid") bookingUid: string,
@@ -277,8 +278,8 @@ export class BookingsController_2024_08_13 {
   @UseGuards(ApiAuthGuard, BookingUidGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
-    summary:
-      "Automatically reassign booking to a new host automatically - provided authorization header refers to person who reassigned the booking.",
+    summary: "Reassign a booking to auto-selected host",
+    description: "The provided authorization header refers to the owner of the booking.",
   })
   async reassignBooking(
     @Param("bookingUid") bookingUid: string,
@@ -298,8 +299,8 @@ export class BookingsController_2024_08_13 {
   @UseGuards(ApiAuthGuard, BookingUidGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
-    summary:
-      "Reassign a booking to a specific user specified by the :userId - provided authorization header refers to person who reassigned the booking.",
+    summary: "Reassign a booking to a specific host",
+    description: "The provided authorization header refers to the owner of the booking.",
   })
   async reassignBookingToUser(
     @Param("bookingUid") bookingUid: string,
@@ -326,8 +327,8 @@ export class BookingsController_2024_08_13 {
   @UseGuards(ApiAuthGuard, BookingUidGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
-    summary:
-      "Confirm booking that requires a confirmation - provided authorization header refers to owner of the booking.",
+    summary: "Confirm a booking",
+    description: "The provided authorization header refers to the owner of the booking.",
   })
   async confirmBooking(
     @Param("bookingUid") bookingUid: string,
@@ -347,8 +348,8 @@ export class BookingsController_2024_08_13 {
   @UseGuards(ApiAuthGuard, BookingUidGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
-    summary:
-      "Decline booking that requires a confirmation - provided authorization header refers to owner of the booking.",
+    summary: "Decline a booking",
+    description: "The provided authorization header refers to the owner of the booking.",
   })
   async declineBooking(
     @Param("bookingUid") bookingUid: string,

apps/api/v2/src/ee/bookings/2024-08-13/services/bookings.service.ts

@@ -146,8 +146,8 @@ export class BookingsService_2024_08_13 {
   }
 
   async hasRequiredBookingFieldsResponses(body: CreateBookingInput, eventType: EventType | null) {
-    const bookingFields = body.bookingFieldsResponses;
-    if (!bookingFields || !eventType || !eventType.bookingFields) {
+    const bookingFields = { ...body.bookingFieldsResponses, attendeePhoneNumber: body.attendee.phoneNumber };
+    if (!eventType?.bookingFields) {
       return true;
     }
 
@@ -156,11 +156,20 @@ export class BookingsService_2024_08_13 {
       .parse(eventType.bookingFields)
       .filter((field) => !field.editable.startsWith("system"));
 
+    if (!eventTypeBookingFields.length) {
+      return true;
+    }
+
     for (const field of eventTypeBookingFields) {
       if (field.required && !(field.name in bookingFields)) {
-        throw new BadRequestException(`
-          Missing required booking field response: ${field.name} - it is required by the event type booking fields, but missing in the bookingFieldsResponses.
-          You can fetch the event type with ID ${eventType.id} to see the required fields.`);
+        if (field.name === "attendeePhoneNumber") {
+          throw new BadRequestException(
+            `Missing attendee phone number - it is required by the event type. Pass it as "attendee.phoneNumber" in the request.`
+          );
+        }
+        throw new BadRequestException(
+          `Missing required booking field response: ${field.name} - it is required by the event type booking fields, but missing in the bookingFieldsResponses. You can fetch the event type with ID ${eventType.id} to see the required fields.`
+        );
       }
     }
 
@@ -185,7 +194,11 @@ export class BookingsService_2024_08_13 {
     return this.outputService.getOutputBooking(databaseBooking);
   }
 
-  async createRecurringBooking(request: Request, body: CreateRecurringBookingInput_2024_08_13, eventType: EventTypeWithOwnerAndTeam) {
+  async createRecurringBooking(
+    request: Request,
+    body: CreateRecurringBookingInput_2024_08_13,
+    eventType: EventTypeWithOwnerAndTeam
+  ) {
     const bookingRequest = await this.inputService.createRecurringBookingRequest(request, body, eventType);
     const bookings = await handleNewRecurringBooking({
       bookingData: bookingRequest.body,
@@ -202,7 +215,11 @@ export class BookingsService_2024_08_13 {
     return this.outputService.getOutputRecurringBookings(ids);
   }
 
-  async createRecurringSeatedBooking(request: Request, body: CreateRecurringBookingInput_2024_08_13, eventType: EventTypeWithOwnerAndTeam) {
+  async createRecurringSeatedBooking(
+    request: Request,
+    body: CreateRecurringBookingInput_2024_08_13,
+    eventType: EventTypeWithOwnerAndTeam
+  ) {
     const bookingRequest = await this.inputService.createRecurringBookingRequest(request, body, eventType);
     const bookings = await handleNewRecurringBooking({
       bookingData: bookingRequest.body,
@@ -219,7 +236,11 @@ export class BookingsService_2024_08_13 {
     );
   }
 
-  async createRegularBooking(request: Request, body: CreateBookingInput_2024_08_13,  eventType: EventTypeWithOwnerAndTeam) {
+  async createRegularBooking(
+    request: Request,
+    body: CreateBookingInput_2024_08_13,
+    eventType: EventTypeWithOwnerAndTeam
+  ) {
     const bookingRequest = await this.inputService.createBookingRequest(request, body, eventType);
     const booking = await handleNewBooking({
       bookingData: bookingRequest.body,
@@ -244,7 +265,11 @@ export class BookingsService_2024_08_13 {
     return this.outputService.getOutputBooking(databaseBooking);
   }
 
-  async createSeatedBooking(request: Request, body: CreateBookingInput_2024_08_13, eventType: EventTypeWithOwnerAndTeam) {
+  async createSeatedBooking(
+    request: Request,
+    body: CreateBookingInput_2024_08_13,
+    eventType: EventTypeWithOwnerAndTeam
+  ) {
     const bookingRequest = await this.inputService.createBookingRequest(request, body, eventType);
     const booking = await handleNewBooking({
       bookingData: bookingRequest.body,

apps/api/v2/src/ee/calendars/controllers/calendars.controller.e2e-spec.ts

@@ -129,7 +129,7 @@ describe("Platform Calendars Endpoints", () => {
 
   it(`/GET/v2/calendars/${GOOGLE_CALENDAR}/connect: it should redirect to auth-url for google calendar OAuth with valid access token `, async () => {
     const response = await request(app.getHttpServer())
-      .get(`/v2/calendars/${GOOGLE_CALENDAR}/connect`)
+      .get(`/v2/calendars/${GOOGLE_CALENDAR}/connect?redir=https://cal.com&isDryRun=false`)
       .set("Authorization", `Bearer ${accessTokenSecret}`)
       .set("Origin", CLIENT_REDIRECT_URI)
       .expect(200);

apps/api/v2/src/ee/calendars/controllers/calendars.controller.ts

@@ -34,6 +34,7 @@ import {
   BadRequestException,
   Post,
   Body,
+  ParseBoolPipe,
 } from "@nestjs/common";
 import { ApiHeader, ApiOperation, ApiParam, ApiQuery, ApiTags as DocsTags } from "@nestjs/swagger";
 import { User } from "@prisma/client";
@@ -148,13 +149,14 @@ export class CalendarsController {
     @Req() req: Request,
     @Headers("Authorization") authorization: string,
     @Param("calendar") calendar: string,
-    @Query("redir") redir?: string | null
+    @Query("redir") redir?: string | null,
+    @Query("isDryRun", ParseBoolPipe) isDryRun?: boolean
   ): Promise<ApiResponse<{ authUrl: string }>> {
     switch (calendar) {
       case OFFICE_365_CALENDAR:
-        return await this.outlookService.connect(authorization, req, redir ?? "");
+        return await this.outlookService.connect(authorization, req, redir ?? "", isDryRun);
       case GOOGLE_CALENDAR:
-        return await this.googleCalendarService.connect(authorization, req, redir ?? "");
+        return await this.googleCalendarService.connect(authorization, req, redir ?? "", isDryRun);
       default:
         throw new BadRequestException(
           "Invalid calendar type, available calendars are: ",
@@ -179,18 +181,30 @@ export class CalendarsController {
   ): Promise<{ url: string }> {
     // state params contains our user access token
     const stateParams = new URLSearchParams(state);
-    const { accessToken, origin, redir } = z
-      .object({ accessToken: z.string(), origin: z.string(), redir: z.string().nullish().optional() })
+    const { accessToken, origin, redir, isDryRun } = z
+      .object({
+        accessToken: z.string(),
+        origin: z.string(),
+        redir: z.string().nullish().optional(),
+        isDryRun: z.string().nullish().optional(),
+      })
       .parse({
         accessToken: stateParams.get("accessToken"),
         origin: stateParams.get("origin"),
         redir: stateParams.get("redir"),
+        isDryRun: stateParams.get("isDryRun"),
       });
     switch (calendar) {
       case OFFICE_365_CALENDAR:
-        return await this.outlookService.save(code, accessToken, origin, redir ?? "");
+        return await this.outlookService.save(code, accessToken, origin, redir ?? "", isDryRun === "true");
       case GOOGLE_CALENDAR:
-        return await this.googleCalendarService.save(code, accessToken, origin, redir ?? "");
+        return await this.googleCalendarService.save(
+          code,
+          accessToken,
+          origin,
+          redir ?? "",
+          isDryRun === "true"
+        );
       default:
         throw new BadRequestException(
           "Invalid calendar type, available calendars are: ",

apps/api/v2/src/ee/calendars/services/gcal.service.ts

@@ -39,31 +39,38 @@ export class GoogleCalendarService implements OAuthCalendarApp {
   async connect(
     authorization: string,
     req: Request,
-    redir?: string
+    redir?: string,
+    isDryRun?: boolean
   ): Promise<{ status: typeof SUCCESS_STATUS; data: { authUrl: string } }> {
     const accessToken = authorization.replace("Bearer ", "");
     const origin = req.get("origin") ?? req.get("host");
-    const redirectUrl = await this.getCalendarRedirectUrl(accessToken, origin ?? "", redir);
+    const redirectUrl = await this.getCalendarRedirectUrl(accessToken, origin ?? "", redir, isDryRun);
 
     return { status: SUCCESS_STATUS, data: { authUrl: redirectUrl } };
   }
 
-  async save(code: string, accessToken: string, origin: string, redir?: string): Promise<{ url: string }> {
-    return await this.saveCalendarCredentialsAndRedirect(code, accessToken, origin, redir);
+  async save(
+    code: string,
+    accessToken: string,
+    origin: string,
+    redir?: string,
+    isDryRun?: boolean
+  ): Promise<{ url: string }> {
+    return await this.saveCalendarCredentialsAndRedirect(code, accessToken, origin, redir, isDryRun);
   }
 
   async check(userId: number): Promise<{ status: typeof SUCCESS_STATUS }> {
     return await this.checkIfCalendarConnected(userId);
   }
 
-  async getCalendarRedirectUrl(accessToken: string, origin: string, redir?: string) {
+  async getCalendarRedirectUrl(accessToken: string, origin: string, redir?: string, isDryRun?: boolean) {
     const oAuth2Client = await this.getOAuthClient(this.redirectUri);
 
     const authUrl = oAuth2Client.generateAuthUrl({
       access_type: "offline",
       scope: CALENDAR_SCOPES,
       prompt: "consent",
-      state: `accessToken=${accessToken}&origin=${origin}&redir=${redir ?? ""}`,
+      state: `accessToken=${accessToken}&origin=${origin}&redir=${redir ?? ""}&isDryRun=${isDryRun}`,
     });
 
     return authUrl;
@@ -115,7 +122,8 @@ export class GoogleCalendarService implements OAuthCalendarApp {
     code: string,
     accessToken: string,
     origin: string,
-    redir?: string
+    redir?: string,
+    isDryRun?: boolean
   ) {
     // User chose not to authorize your app or didn't authorize your app
     // redirect directly without oauth code
@@ -123,6 +131,11 @@ export class GoogleCalendarService implements OAuthCalendarApp {
       return { url: redir || origin };
     }
 
+    // if isDryRun is true we know its a dry run so we just redirect straight away
+    if (isDryRun) {
+      return { url: redir || origin };
+    }
+
     const parsedCode = z.string().parse(code);
 
     const ownerId = await this.tokensRepository.getAccessTokenOwnerId(accessToken);

apps/api/v2/src/ee/calendars/services/outlook.service.ts

@@ -33,24 +33,31 @@ export class OutlookService implements OAuthCalendarApp {
   async connect(
     authorization: string,
     req: Request,
-    redir?: string
+    redir?: string,
+    isDryRun?: boolean
   ): Promise<{ status: typeof SUCCESS_STATUS; data: { authUrl: string } }> {
     const accessToken = authorization.replace("Bearer ", "");
     const origin = req.get("origin") ?? req.get("host");
-    const redirectUrl = await await this.getCalendarRedirectUrl(accessToken, origin ?? "", redir);
+    const redirectUrl = await this.getCalendarRedirectUrl(accessToken, origin ?? "", redir, isDryRun);
 
     return { status: SUCCESS_STATUS, data: { authUrl: redirectUrl } };
   }
 
-  async save(code: string, accessToken: string, origin: string, redir?: string): Promise<{ url: string }> {
-    return await this.saveCalendarCredentialsAndRedirect(code, accessToken, origin, redir);
+  async save(
+    code: string,
+    accessToken: string,
+    origin: string,
+    redir?: string,
+    isDryRun?: boolean
+  ): Promise<{ url: string }> {
+    return await this.saveCalendarCredentialsAndRedirect(code, accessToken, origin, redir, isDryRun);
   }
 
   async check(userId: number): Promise<{ status: typeof SUCCESS_STATUS }> {
     return await this.checkIfCalendarConnected(userId);
   }
 
-  async getCalendarRedirectUrl(accessToken: string, origin: string, redir?: string) {
+  async getCalendarRedirectUrl(accessToken: string, origin: string, redir?: string, isDryRun?: boolean) {
     const { client_id } = await this.calendarsService.getAppKeys(OFFICE_365_CALENDAR_ID);
 
     const scopes = ["User.Read", "Calendars.Read", "Calendars.ReadWrite", "offline_access"];
@@ -60,7 +67,7 @@ export class OutlookService implements OAuthCalendarApp {
       client_id,
       prompt: "select_account",
       redirect_uri: this.redirectUri,
-      state: `accessToken=${accessToken}&origin=${origin}&redir=${redir ?? ""}`,
+      state: `accessToken=${accessToken}&origin=${origin}&redir=${redir ?? ""}&isDryRun=${isDryRun}`,
     };
 
     const query = stringify(params);
@@ -148,13 +155,19 @@ export class OutlookService implements OAuthCalendarApp {
     code: string,
     accessToken: string,
     origin: string,
-    redir?: string
+    redir?: string,
+    isDryRun?: boolean
   ) {
     // if code is not defined, user denied to authorize office 365 app, just redirect straight away
     if (!code || code === "undefined") {
       return { url: redir || origin };
     }
 
+    // if isDryRun is true we know its a dry run so we just redirect straight away
+    if (isDryRun) {
+      return { url: redir || origin };
+    }
+
     const parsedCode = z.string().parse(code);
 
     const ownerId = await this.tokensRepository.getAccessTokenOwnerId(accessToken);

apps/api/v2/src/ee/platform-endpoints-module.ts

@@ -8,6 +8,7 @@ import { MeModule } from "@/ee/me/me.module";
 import { ProviderModule } from "@/ee/provider/provider.module";
 import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
 import { SchedulesModule_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.module";
+import { RoutingFormsModule } from "@/modules/routing-forms/routing-forms.module";
 import { SlotsModule_2024_04_15 } from "@/modules/slots/slots-2024-04-15/slots.module";
 import { SlotsModule_2024_09_04 } from "@/modules/slots/slots-2024-09-04/slots.module";
 import { TeamsEventTypesModule } from "@/modules/teams/event-types/teams-event-types.module";
@@ -33,6 +34,7 @@ import { Module } from "@nestjs/common";
     SlotsModule_2024_04_15,
     SlotsModule_2024_09_04,
     TeamsModule,
+    RoutingFormsModule,
   ],
 })
 export class PlatformEndpointsModule implements NestModule {

apps/api/v2/src/lib/throttler-guard.ts

@@ -54,12 +54,13 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
     const { context } = requestProps;
 
     const request = context.switchToHttp().getRequest<Request>();
+    const IP = request?.headers?.["cf-connecting-ip"] ?? request?.headers?.["CF-Connecting-IP"] ?? request.ip;
     const response = context.switchToHttp().getResponse<Response>();
     const tracker = await this.getTracker(request);
     this.logger.verbose(
       `Tracker "${tracker}" generated based on: Bearer token "${request.get(
         "Authorization"
-      )}", OAuth client ID "${request.get(X_CAL_CLIENT_ID)}" and IP "${request.ip}"`
+      )}", OAuth client ID "${request.get(X_CAL_CLIENT_ID)}" and IP "${IP}"`
     );
 
     if (tracker.startsWith("api_key_")) {
@@ -209,6 +210,7 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
 
   protected async getTracker(request: Request): Promise<string> {
     const authorizationHeader = request.get("Authorization")?.replace("Bearer ", "");
+    const IP = request?.headers?.["cf-connecting-ip"] ?? request?.headers?.["CF-Connecting-IP"] ?? request.ip;
 
     if (authorizationHeader) {
       const apiKeyPrefix = getEnv("API_KEY_PREFIX", "cal_");
@@ -223,8 +225,8 @@ export class CustomThrottlerGuard extends ThrottlerGuard {
       return `oauth_client_${oauthClientId}`;
     }
 
-    if (request.ip) {
-      return `ip_${request.ip}`;
+    if (IP) {
+      return `ip_${IP}`;
     }
 
     this.logger.verbose(`no tracker found: ${request.url}`);

apps/api/v2/src/modules/atoms/atoms.module.ts

@@ -2,6 +2,7 @@ import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_0
 import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { AtomsRepository } from "@/modules/atoms/atoms.repository";
 import { AtomsController } from "@/modules/atoms/controllers/atoms.controller";
+import { AttributesAtomsService } from "@/modules/atoms/services/attributes-atom.service";
 import { ConferencingAtomsService } from "@/modules/atoms/services/conferencing-atom.service";
 import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
@@ -19,6 +20,7 @@ import { Module } from "@nestjs/common";
   providers: [
     EventTypesAtomService,
     ConferencingAtomsService,
+    AttributesAtomsService,
     MembershipsRepository,
     CredentialsRepository,
     UsersRepository,

apps/api/v2/src/modules/atoms/controllers/atoms.controller.ts

@@ -3,6 +3,8 @@ import {
   BulkUpdateEventTypeToDefaultLocationDto,
   EventTypesAppInput,
 } from "@/modules/atoms/inputs/event-types-app.input";
+import { FindTeamMembersMatchingAttributeQueryDto } from "@/modules/atoms/inputs/find-team-members-matching-attribute.input";
+import { AttributesAtomsService } from "@/modules/atoms/services/attributes-atom.service";
 import { ConferencingAtomsService } from "@/modules/atoms/services/conferencing-atom.service";
 import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
@@ -34,6 +36,8 @@ import { ConnectedApps } from "@calcom/platform-libraries/app-store";
 import type { UpdateEventTypeReturn } from "@calcom/platform-libraries/event-types";
 import { ApiResponse } from "@calcom/platform-types";
 
+import { FindTeamMembersMatchingAttributeResponseDto } from "../outputs/find-team-members-matching-attribute.output";
+
 /*
 
 Endpoints used only by platform atoms, reusing code from other modules, data is already formatted and ready to be used by frontend atoms
@@ -50,7 +54,8 @@ these endpoints should not be recommended for use by third party and are exclude
 export class AtomsController {
   constructor(
     private readonly eventTypesService: EventTypesAtomService,
-    private readonly conferencingService: ConferencingAtomsService
+    private readonly conferencingService: ConferencingAtomsService,
+    private readonly attributesService: AttributesAtomsService
   ) {}
 
   @Get("event-types/:eventTypeId")
@@ -222,4 +227,25 @@ export class AtomsController {
       data: conferencingApps,
     };
   }
+  @Get("/organizations/:orgId/teams/:teamId/members-matching-attribute")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async findTeamMembersMatchingAttributes(
+    @GetUser() user: UserWithProfile,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Query() query: FindTeamMembersMatchingAttributeQueryDto
+  ): Promise<FindTeamMembersMatchingAttributeResponseDto> {
+    const result = await this.attributesService.findTeamMembersMatchingAttribute(teamId, orgId, {
+      attributesQueryValue: query.attributesQueryValue,
+      isPreview: query.isPreview,
+      enablePerf: query.enablePerf,
+      concurrency: query.concurrency,
+    });
+
+    return {
+      status: SUCCESS_STATUS,
+      data: result,
+    };
+  }
 }

apps/api/v2/src/modules/atoms/inputs/find-team-members-matching-attribute.input.ts

@@ -0,0 +1,25 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+
+import type { TFindTeamMembersMatchingAttributeLogicInputSchema } from "@calcom/platform-libraries";
+
+export class FindTeamMembersMatchingAttributeQueryDto {
+  @ApiPropertyOptional({
+    nullable: true,
+  })
+  attributesQueryValue: TFindTeamMembersMatchingAttributeLogicInputSchema["attributesQueryValue"];
+
+  @ApiPropertyOptional({
+    type: Boolean,
+  })
+  isPreview?: boolean;
+
+  @ApiPropertyOptional({
+    type: Boolean,
+  })
+  enablePerf?: boolean;
+
+  @ApiPropertyOptional({
+    type: Number,
+  })
+  concurrency?: number;
+}

apps/api/v2/src/modules/atoms/outputs/find-team-members-matching-attribute.output.ts

@@ -0,0 +1,19 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsString, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { FindTeamMembersMatchingAttributeOutputDto } from "@calcom/platform-types";
+
+export class FindTeamMembersMatchingAttributeResponseDto {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsString()
+  @Expose()
+  readonly status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ValidateNested()
+  @Type(() => FindTeamMembersMatchingAttributeOutputDto)
+  @Expose()
+  @ApiProperty({ type: FindTeamMembersMatchingAttributeOutputDto })
+  readonly data!: FindTeamMembersMatchingAttributeOutputDto;
+}

apps/api/v2/src/modules/atoms/services/attributes-atom.service.ts

@@ -0,0 +1,64 @@
+import { UsersRepository } from "@/modules/users/users.repository";
+import { Logger } from "@nestjs/common";
+import { Injectable } from "@nestjs/common";
+
+import { findTeamMembersMatchingAttributeLogic } from "@calcom/platform-libraries";
+
+import { FindTeamMembersMatchingAttributeQueryDto } from "../inputs/find-team-members-matching-attribute.input";
+
+@Injectable()
+export class AttributesAtomsService {
+  private logger = new Logger("AttributesAtomService");
+
+  constructor(private readonly usersRepository: UsersRepository) {}
+
+  async findTeamMembersMatchingAttribute(
+    teamId: number,
+    orgId: number,
+    input: FindTeamMembersMatchingAttributeQueryDto
+  ) {
+    const {
+      teamMembersMatchingAttributeLogic: matchingTeamMembersWithResult,
+      mainAttributeLogicBuildingWarnings: mainWarnings,
+      fallbackAttributeLogicBuildingWarnings: fallbackWarnings,
+      troubleshooter,
+    } = await findTeamMembersMatchingAttributeLogic(
+      {
+        teamId,
+        orgId,
+        attributesQueryValue: input.attributesQueryValue,
+      },
+      {
+        enablePerf: input.enablePerf,
+        concurrency: input.concurrency,
+        enableTroubleshooter: input.enablePerf,
+      }
+    );
+
+    if (!matchingTeamMembersWithResult) {
+      return {
+        troubleshooter,
+        mainWarnings,
+        fallbackWarnings,
+        result: null,
+      };
+    }
+
+    const matchingTeamMembersIds = matchingTeamMembersWithResult.map(
+      (member: { userId: number }) => member.userId
+    );
+
+    const matchingTeamMembers = await this.usersRepository.findByIds(matchingTeamMembersIds);
+
+    return {
+      mainWarnings,
+      fallbackWarnings,
+      troubleshooter: troubleshooter,
+      result: matchingTeamMembers.map((user) => ({
+        id: user.id,
+        name: user.name,
+        email: user.email,
+      })),
+    };
+  }
+}

apps/api/v2/src/modules/endpoints.module.ts

@@ -5,6 +5,7 @@ import { ConferencingModule } from "@/modules/conferencing/conferencing.module";
 import { DestinationCalendarsModule } from "@/modules/destination-calendars/destination-calendars.module";
 import { OAuthClientModule } from "@/modules/oauth-clients/oauth-client.module";
 import { OrganizationsBookingsModule } from "@/modules/organizations/bookings/organizations.bookings.module";
+import { OrganizationsRoutingFormsModule } from "@/modules/organizations/routing-forms/organizations-routing-forms.module";
 import { OrganizationsTeamsBookingsModule } from "@/modules/organizations/teams/bookings/organizations-teams-bookings.module";
 import { OrganizationsUsersBookingsModule } from "@/modules/organizations/users/bookings/organizations-users-bookings.module";
 import { RouterModule } from "@/modules/router/router.module";
@@ -31,6 +32,7 @@ import { WebhooksModule } from "./webhooks/webhooks.module";
     OrganizationsTeamsBookingsModule,
     OrganizationsUsersBookingsModule,
     OrganizationsBookingsModule,
+    OrganizationsRoutingFormsModule,
     RouterModule,
   ],
 })

apps/api/v2/src/modules/oauth-clients/controllers/oauth-client-users/oauth-client-users.controller.e2e-spec.ts

@@ -305,8 +305,6 @@ describe("OAuth Client Users Endpoints", () => {
       expect(responseBody.data.user.timeFormat).toEqual(requestBody.timeFormat);
       expect(responseBody.data.user.locale).toEqual(requestBody.locale);
       expect(responseBody.data.user.avatarUrl).toEqual(requestBody.avatarUrl);
-      expect(responseBody.data.user.bio).toEqual(requestBody.bio);
-      expect(responseBody.data.user.metadata).toEqual(requestBody.metadata);
 
       const { accessToken, refreshToken, accessTokenExpiresAt, refreshTokenExpiresAt } = response.body.data;
       expect(accessToken).toBeDefined();
@@ -372,8 +370,6 @@ describe("OAuth Client Users Endpoints", () => {
       expect(responseBody.data.user.timeFormat).toEqual(requestBody.timeFormat);
       expect(responseBody.data.user.locale).toEqual(requestBody.locale);
       expect(responseBody.data.user.avatarUrl).toEqual(requestBody.avatarUrl);
-      expect(responseBody.data.user.bio).toEqual(requestBody.bio);
-      expect(responseBody.data.user.metadata).toEqual(requestBody.metadata);
 
       const { accessToken, refreshToken, accessTokenExpiresAt, refreshTokenExpiresAt } = response.body.data;
       expect(accessToken).toBeDefined();

apps/api/v2/src/modules/oauth-clients/controllers/oauth-client-users/oauth-client-users.controller.ts

@@ -98,7 +98,10 @@ export class OAuthClientUsersController {
       status: SUCCESS_STATUS,
       data: {
         user: this.oAuthClientUsersOutputService.getResponseUser(user),
-        ...tokens,
+        accessToken: tokens.accessToken,
+        accessTokenExpiresAt: tokens.accessTokenExpiresAt.valueOf(),
+        refreshToken: tokens.refreshToken,
+        refreshTokenExpiresAt: tokens.refreshTokenExpiresAt.valueOf(),
       },
     };
   }
@@ -162,7 +165,7 @@ export class OAuthClientUsersController {
   @HttpCode(HttpStatus.OK)
   @ApiOperation({
     summary: "Force refresh tokens",
-    description: `If you have lost managed user access or refresh token or the refresh token has expired, then you can get new ones by using OAuth credentials. ${TOKENS_DOCS}`,
+    description: `If you have lost managed user access or refresh token, then you can get new ones by using OAuth credentials. ${TOKENS_DOCS}`,
   })
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
   async forceRefresh(
@@ -171,16 +174,19 @@ export class OAuthClientUsersController {
   ): Promise<KeysResponseDto> {
     this.logger.log(`Forcing new access tokens for managed user with ID ${userId}`);
 
-    await this.validateManagedUserOwnership(oAuthClientId, userId);
+    const { id } = await this.validateManagedUserOwnership(oAuthClientId, userId);
 
-    const { accessToken, refreshToken } = await this.tokensRepository.refreshOAuthTokens(
-      userId,
-      oAuthClientId
-    );
+    const { accessToken, refreshToken, accessTokenExpiresAt, refreshTokenExpiresAt } =
+      await this.tokensRepository.createOAuthTokens(oAuthClientId, id, true);
 
     return {
       status: SUCCESS_STATUS,
-      data: this.oAuthClientUsersService.getResponseOAuthTokens(accessToken, refreshToken),
+      data: {
+        accessToken,
+        refreshToken,
+        accessTokenExpiresAt: accessTokenExpiresAt.valueOf(),
+        refreshTokenExpiresAt: refreshTokenExpiresAt.valueOf(),
+      },
     };
   }
 

apps/api/v2/src/modules/oauth-clients/controllers/oauth-flow/oauth-flow.controller.e2e-spec.ts

@@ -18,6 +18,7 @@ import * as request from "supertest";
 import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
 import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
 import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
 import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
 import { randomString } from "test/utils/randomString";
 import { withNextAuth } from "test/utils/withNextAuth";
@@ -204,12 +205,14 @@ describe("OAuthFlow Endpoints", () => {
 
         expect(decodedAccessToken.clientId).toBe(oAuthClient.id);
         expect(decodedAccessToken.ownerId).toBe(user.id);
+        expect(decodedAccessToken.userId).toBe(user.id);
         expect(decodedAccessToken.type).toBe("access_token");
         expect(decodedAccessToken.expiresAt).toBe(new Date(accessTokenExpiresAt).valueOf());
         expect(decodedAccessToken.iat).toBeGreaterThan(0);
 
         expect(decodedRefreshToken.clientId).toBe(oAuthClient.id);
         expect(decodedRefreshToken.ownerId).toBe(user.id);
+        expect(decodedRefreshToken.userId).toBe(user.id);
         expect(decodedRefreshToken.type).toBe("refresh_token");
         expect(decodedRefreshToken.expiresAt).toBe(new Date(refreshTokenExpiresAt).valueOf());
         expect(decodedRefreshToken.iat).toBeGreaterThan(0);

apps/api/v2/src/modules/oauth-clients/controllers/oauth-flow/oauth-flow.controller.ts

@@ -33,8 +33,7 @@ import { Response as ExpressResponse } from "express";
 import { SUCCESS_STATUS, X_CAL_SECRET_KEY } from "@calcom/platform-constants";
 
 export const TOKENS_DOCS = `Access token is valid for 60 minutes and refresh token for 1 year. Make sure to store them in your database, for example, in your User database model \`calAccessToken\` and \`calRefreshToken\` fields.
-Response also contains \`accessTokenExpiresAt\` and \`refreshTokenExpiresAt\` fields, but if you decode the jwt token the payload will contain \`clientId\` (OAuth client ID), \`ownerId\` (user to whom token belongs ID), \`iat\` (issued at time) and \`expiresAt\` (when does the token expire) fields.
-To learn about managing refresh tokens expiring after 1 year follow [this guide](https://cal.com/docs/platform/quickstart#5-managing-refresh-token-expiry)`;
+Response also contains \`accessTokenExpiresAt\` and \`refreshTokenExpiresAt\` fields, but if you decode the jwt token the payload will contain \`clientId\` (OAuth client ID), \`ownerId\` (user to whom token belongs ID), \`iat\` (issued at time) and \`expiresAt\` (when does the token expire) fields.`;
 
 @Controller({
   path: "/v2/oauth/:clientId",
@@ -95,7 +94,7 @@ export class OAuthFlowController {
       throw new BadRequestException("Missing 'Bearer' Authorization header.");
     }
 
-    const tokens = await this.oAuthFlowService.exchangeOAuthClientAuthorizationToken(
+    const tokens = await this.oAuthFlowService.exchangeAuthorizationToken(
       authorizeEndpointCode,
       clientId,
       body.clientSecret
@@ -126,7 +125,7 @@ export class OAuthFlowController {
     @Headers(X_CAL_SECRET_KEY) secretKey: string,
     @Body() body: RefreshTokenInput
   ): Promise<KeysResponseDto> {
-    const tokens = await this.oAuthFlowService.refreshUserTokens(clientId, secretKey, body.refreshToken);
+    const tokens = await this.oAuthFlowService.refreshToken(clientId, secretKey, body.refreshToken);
 
     return {
       status: SUCCESS_STATUS,

apps/api/v2/src/modules/oauth-clients/services/oauth-clients-users.service.ts

@@ -3,13 +3,12 @@ import { EventTypesService_2024_04_15 } from "@/ee/event-types/event-types_2024_
 import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
 import { Locales } from "@/lib/enums/locales";
 import { GetManagedUsersInput } from "@/modules/oauth-clients/controllers/oauth-client-users/inputs/get-managed-users.input";
-import { KeysDto } from "@/modules/oauth-clients/controllers/oauth-flow/responses/KeysResponse.dto";
 import { TokensRepository } from "@/modules/tokens/tokens.repository";
 import { CreateManagedUserInput } from "@/modules/users/inputs/create-managed-user.input";
 import { UpdateManagedUserInput } from "@/modules/users/inputs/update-managed-user.input";
 import { UsersRepository } from "@/modules/users/users.repository";
 import { BadRequestException, ConflictException, Injectable, Logger } from "@nestjs/common";
-import { User, CreationSource, PlatformOAuthClient, AccessToken, RefreshToken } from "@prisma/client";
+import { User, CreationSource, PlatformOAuthClient } from "@prisma/client";
 
 import { createNewUsersConnectToOrgIfExists, slugify } from "@calcom/platform-libraries";
 
@@ -79,10 +78,8 @@ export class OAuthClientUsersService {
       });
     }
 
-    const { accessToken, refreshToken } = await this.tokensRepository.createOAuthTokens(
-      user.id,
-      oAuthClientId
-    );
+    const { accessToken, refreshToken, accessTokenExpiresAt, refreshTokenExpiresAt } =
+      await this.tokensRepository.createOAuthTokens(oAuthClientId, user.id);
 
     if (oAuthClient.areDefaultEventTypesEnabled) {
       await this.eventTypesService.createUserDefaultEventTypes(user.id);
@@ -102,16 +99,12 @@ export class OAuthClientUsersService {
 
     return {
       user,
-      tokens: this.getResponseOAuthTokens(accessToken, refreshToken),
-    };
-  }
-
-  getResponseOAuthTokens(accessToken: AccessToken, refreshToken: RefreshToken): KeysDto {
-    return {
-      accessToken: accessToken.secret,
-      refreshToken: refreshToken.secret,
-      accessTokenExpiresAt: accessToken.expiresAt.valueOf(),
-      refreshTokenExpiresAt: refreshToken.expiresAt.valueOf(),
+      tokens: {
+        accessToken,
+        accessTokenExpiresAt,
+        refreshToken,
+        refreshTokenExpiresAt,
+      },
     };
   }
 

apps/api/v2/src/modules/oauth-clients/services/oauth-flow.service.ts

@@ -1,5 +1,8 @@
 import { TokenExpiredException } from "@/modules/auth/guards/api-auth/token-expired.exception";
-import { KeysDto } from "@/modules/oauth-clients/controllers/oauth-flow/responses/KeysResponse.dto";
+import {
+  KeysDto,
+  KeysResponseDto,
+} from "@/modules/oauth-clients/controllers/oauth-flow/responses/KeysResponse.dto";
 import { OAuthClientRepository } from "@/modules/oauth-clients/oauth-client.repository";
 import { RedisService } from "@/modules/redis/redis.service";
 import { TokensRepository } from "@/modules/tokens/tokens.repository";
@@ -7,7 +10,6 @@ import { BadRequestException, Injectable, Logger, UnauthorizedException } from "
 import { DateTime } from "luxon";
 
 import { INVALID_ACCESS_TOKEN } from "@calcom/platform-constants";
-import { AccessToken, RefreshToken } from "@calcom/prisma/client";
 
 @Injectable()
 export class OAuthFlowService {
@@ -57,8 +59,8 @@ export class OAuthFlowService {
 
     if (!ownerIdFromDb) throw new Error("Invalid Access Token, not present in Redis or DB");
 
-    // await in case of race conditions
-    await this.redisService.redis.setex(cacheKey, 3600, ownerIdFromDb); // expires in 1 hour
+    // await in case of race conditions, but void it's return since cache writes shouldn't halt execution.
+    void (await this.redisService.redis.setex(cacheKey, 3600, ownerIdFromDb)); // expires in 1 hour
 
     return ownerIdFromDb;
   }
@@ -83,8 +85,9 @@ export class OAuthFlowService {
     }
 
     // we can't use a Promise#all or similar here because we care about execution order
-    await this.redisService.redis.hmset(cacheKey, { expiresAt: tokenExpiresAt.toJSON() });
-    await this.redisService.redis.expireat(cacheKey, Math.floor(tokenExpiresAt.getTime() / 1000));
+    // however we can't allow caches to fail a validation hence the results are voided.
+    void (await this.redisService.redis.hmset(cacheKey, { expiresAt: tokenExpiresAt.toJSON() }));
+    void (await this.redisService.redis.expireat(cacheKey, Math.floor(tokenExpiresAt.getTime() / 1000)));
 
     return true;
   }
@@ -100,7 +103,7 @@ export class OAuthFlowService {
     return { status: "CACHE_MISS", cacheKey };
   }
 
-  async exchangeOAuthClientAuthorizationToken(
+  async exchangeAuthorizationToken(
     tokenId: string,
     clientId: string,
     clientSecret: string
@@ -121,50 +124,46 @@ export class OAuthFlowService {
       throw new BadRequestException("Invalid Authorization Token.");
     }
 
-    const { accessToken, refreshToken } = await this.tokensRepository.createOAuthTokens(
-      authorizationToken.owner.id,
-      clientId
-    );
+    const { accessToken, refreshToken, accessTokenExpiresAt, refreshTokenExpiresAt } =
+      await this.tokensRepository.createOAuthTokens(clientId, authorizationToken.owner.id);
     await this.tokensRepository.invalidateAuthorizationToken(authorizationToken.id);
-    await this.propagateAccessToken(accessToken.secret);
+    void this.propagateAccessToken(accessToken); // void result, ignored.
 
-    return this.getResponseOAuthTokens(accessToken, refreshToken);
+    return {
+      accessToken,
+      accessTokenExpiresAt: accessTokenExpiresAt.valueOf(),
+      refreshToken,
+      refreshTokenExpiresAt: refreshTokenExpiresAt.valueOf(),
+    };
   }
 
-  async refreshUserTokens(
-    clientId: string,
-    clientSecret: string,
-    userRefreshTokenSecret: string
-  ): Promise<KeysDto> {
+  async refreshToken(clientId: string, clientSecret: string, tokenSecret: string): Promise<KeysDto> {
     const oauthClient = await this.oAuthClientRepository.getOAuthClientWithRefreshSecret(
       clientId,
       clientSecret,
-      userRefreshTokenSecret
+      tokenSecret
     );
 
     if (!oauthClient) {
       throw new BadRequestException("Invalid OAuthClient credentials.");
     }
 
-    const currentUserRefreshToken = oauthClient.refreshToken[0];
+    const currentRefreshToken = oauthClient.refreshToken[0];
 
-    if (!currentUserRefreshToken) {
-      throw new BadRequestException("Invalid managed user refresh token");
+    if (!currentRefreshToken) {
+      throw new BadRequestException("Invalid refresh token");
     }
 
     const { accessToken, refreshToken } = await this.tokensRepository.refreshOAuthTokens(
-      currentUserRefreshToken.userId,
-      clientId
+      clientId,
+      currentRefreshToken.secret,
+      currentRefreshToken.userId
     );
 
-    return this.getResponseOAuthTokens(accessToken, refreshToken);
-  }
-
-  getResponseOAuthTokens(accessToken: AccessToken, refreshToken: RefreshToken): KeysDto {
     return {
       accessToken: accessToken.secret,
-      refreshToken: refreshToken.secret,
       accessTokenExpiresAt: accessToken.expiresAt.valueOf(),
+      refreshToken: refreshToken.secret,
       refreshTokenExpiresAt: refreshToken.expiresAt.valueOf(),
     };
   }

apps/api/v2/src/modules/organizations/bookings/organizations-bookings.controller.ts

@@ -1,5 +1,11 @@
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import {
+  OPTIONAL_X_CAL_CLIENT_ID_HEADER,
+  OPTIONAL_X_CAL_SECRET_KEY_HEADER,
+  OPTIONAL_API_KEY_HEADER,
+  OPTIONAL_API_KEY_OR_ACCESS_TOKEN_HEADER,
+} from "@/lib/docs/headers";
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
@@ -8,15 +14,12 @@ import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.g
 import { IsAdminAPIEnabledGuard } from "@/modules/auth/guards/organizations/is-admin-api-enabled.guard";
 import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
 import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
-import { OrganizationsUsersService } from "@/modules/organizations/users/index/services/organizations-users-service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Controller, UseGuards, Get, Param, ParseIntPipe, Query, HttpStatus, HttpCode } from "@nestjs/common";
-import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiHeader, ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
-import { GetBookingsOutput_2024_08_13 } from "@calcom/platform-types";
-
-import { GetOrganizationsBookingsInput } from "./inputs/get-org-bookings.input";
+import { GetBookingsOutput_2024_08_13, GetOrganizationsBookingsInput } from "@calcom/platform-types";
 
 @Controller({
   path: "/v2/organizations/:orgId/bookings",
@@ -24,11 +27,11 @@ import { GetOrganizationsBookingsInput } from "./inputs/get-org-bookings.input";
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
 @DocsTags("Orgs / Bookings")
+@ApiHeader(OPTIONAL_X_CAL_CLIENT_ID_HEADER)
+@ApiHeader(OPTIONAL_X_CAL_SECRET_KEY_HEADER)
+@ApiHeader(OPTIONAL_API_KEY_OR_ACCESS_TOKEN_HEADER)
 export class OrganizationsBookingsController {
-  constructor(
-    private readonly bookingsService: BookingsService_2024_08_13,
-    private readonly orgUsersService: OrganizationsUsersService
-  ) {}
+  constructor(private readonly bookingsService: BookingsService_2024_08_13) {}
 
   @Get("/")
   @ApiOperation({ summary: "Get Organization Bookings" })

apps/api/v2/src/modules/organizations/conferencing/organizations-conferencing.controller.ts

@@ -56,7 +56,7 @@ export type OAuthCallbackState = {
   path: "/v2/organizations/:orgId",
   version: API_VERSIONS_VALUES,
 })
-@DocsTags("Organizations/Teams Conferencing")
+@DocsTags("Orgs / Teams / Conferencing")
 export class OrganizationsConferencingController {
   constructor(
     private readonly conferencingService: ConferencingService,

apps/api/v2/src/modules/organizations/event-types/organizations-event-types.controller.ts

@@ -152,7 +152,7 @@ export class OrganizationsEventTypesController {
 
   @UseGuards(IsOrgGuard, IsTeamInOrg, IsAdminAPIEnabledGuard)
   @Get("/teams/:teamId/event-types")
-  @ApiOperation({ summary: "Get a team event type" })
+  @ApiOperation({ summary: "Get team event types" })
   async getTeamEventTypes(
     @Param("teamId", ParseIntPipe) teamId: number,
     @Query() queryParams: GetTeamEventTypesQuery_2024_06_14

apps/api/v2/src/modules/organizations/organizations.module.ts

@@ -37,7 +37,7 @@ import { OrganizationsTeamsService } from "@/modules/organizations/teams/index/s
 import { OrganizationsTeamsMembershipsController } from "@/modules/organizations/teams/memberships/organizations-teams-memberships.controller";
 import { OrganizationsTeamsMembershipsRepository } from "@/modules/organizations/teams/memberships/organizations-teams-memberships.repository";
 import { OrganizationsTeamsMembershipsService } from "@/modules/organizations/teams/memberships/services/organizations-teams-memberships.service";
-import { OrganizationsTeamsRoutingFormsModule } from "@/modules/organizations/teams/routing-forms/organizations-teams-routing-forms-responses.module";
+import { OrganizationsTeamsRoutingFormsModule } from "@/modules/organizations/teams/routing-forms/organizations-teams-routing-forms.module";
 import { OrganizationsTeamsSchedulesController } from "@/modules/organizations/teams/schedules/organizations-teams-schedules.controller";
 import { OrganizationsUsersController } from "@/modules/organizations/users/index/controllers/organizations-users.controller";
 import { OrganizationsUsersRepository } from "@/modules/organizations/users/index/organizations-users.repository";

apps/api/v2/src/modules/organizations/organizations/organizations-organizations.controller.ts

@@ -40,7 +40,7 @@ const SCALE = "SCALE";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-@DocsTags("Orgs / Orgs")
+@DocsTags("Managed Orgs")
 @ApiHeader(X_CAL_CLIENT_ID_HEADER)
 @ApiHeader(X_CAL_SECRET_KEY_HEADER)
 export class OrganizationsOrganizationsController {

apps/api/v2/src/modules/organizations/routing-forms/controllers/organizations-routing-forms-responses.controller.e2e-spec.ts

@@ -0,0 +1,264 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { App_RoutingForms_Form, App_RoutingForms_FormResponse, Team, User } from "@prisma/client";
+import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { randomString } from "test/utils/randomString";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+describe("OrganizationsRoutingFormsResponsesController", () => {
+  let app: INestApplication;
+  let prismaWriteService: PrismaWriteService;
+  let org: Team;
+  let team: Team;
+  let apiKeyString: string;
+  let routingForm: App_RoutingForms_Form;
+  let routingFormResponse: App_RoutingForms_FormResponse;
+  let routingFormResponse2: App_RoutingForms_FormResponse;
+
+  let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let userRepositoryFixture: UserRepositoryFixture;
+  let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+
+  let user: User;
+  const userEmail = `OrganizationsRoutingFormsResponsesController-key-bookings-2024-08-13-user-${randomString()}@api.com`;
+  let profileRepositoryFixture: ProfileRepositoryFixture;
+
+  let membershipsRepositoryFixture: MembershipRepositoryFixture;
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [AppModule, PrismaModule, UsersModule, TokensModule],
+    }).compile();
+
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+
+    prismaWriteService = moduleRef.get<PrismaWriteService>(PrismaWriteService);
+    apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
+    profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+    organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+
+    membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+    org = await organizationsRepositoryFixture.create({
+      name: `OrganizationsRoutingFormsResponsesController-teams-memberships-organization-${randomString()}`,
+      isOrganization: true,
+    });
+
+    team = await teamRepositoryFixture.create({
+      name: "OrganizationsRoutingFormsResponsesController orgs booking 1",
+      isOrganization: false,
+      parent: { connect: { id: org.id } },
+    });
+
+    user = await userRepositoryFixture.create({
+      email: userEmail,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "OWNER",
+      user: { connect: { id: user.id } },
+      team: { connect: { id: org.id } },
+    });
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${user.id}`,
+      username: userEmail,
+      organization: {
+        connect: {
+          id: org.id,
+        },
+      },
+      user: {
+        connect: {
+          id: user.id,
+        },
+      },
+    });
+    const now = new Date();
+    now.setDate(now.getDate() + 1);
+    const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+    apiKeyString = `${keyString}`;
+
+    routingForm = await prismaWriteService.prisma.app_RoutingForms_Form.create({
+      data: {
+        name: "Test Routing Form",
+        description: "Test Description",
+        disabled: false,
+        routes: JSON.stringify([]),
+        fields: JSON.stringify([]),
+        settings: JSON.stringify({}),
+        teamId: team.id,
+        userId: user.id,
+      },
+    });
+
+    routingFormResponse = await prismaWriteService.prisma.app_RoutingForms_FormResponse.create({
+      data: {
+        formId: routingForm.id,
+        response: JSON.stringify({ question1: "answer1", question2: "answer2" }),
+      },
+    });
+
+    routingFormResponse2 = await prismaWriteService.prisma.app_RoutingForms_FormResponse.create({
+      data: {
+        formId: routingForm.id,
+        response: { question1: "answer1", question2: "answer2" },
+      },
+    });
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await prismaWriteService.prisma.app_RoutingForms_FormResponse.deleteMany({
+      where: {
+        formId: routingForm.id,
+      },
+    });
+    await prismaWriteService.prisma.app_RoutingForms_Form.deleteMany({
+      where: {
+        teamId: org.id,
+      },
+    });
+    await prismaWriteService.prisma.apiKey.deleteMany({
+      where: {
+        teamId: org.id,
+      },
+    });
+    await prismaWriteService.prisma.team.delete({
+      where: {
+        id: team.id,
+      },
+    });
+    await prismaWriteService.prisma.team.delete({
+      where: {
+        id: org.id,
+      },
+    });
+
+    await app.close();
+  });
+
+  describe(`GET /v2/organizations/:orgId/routing-forms/:routingFormId/responses`, () => {
+    it("should not get routing form responses for non existing org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/99999/routing-forms/${routingForm.id}/responses`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(403);
+    });
+
+    it("should not get routing form responses for non existing form", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/routing-forms/non-existent-id/responses`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(404);
+    });
+
+    it("should not get routing form responses without authentication", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/routing-forms/${routingForm.id}/responses`)
+        .expect(401);
+    });
+
+    it("should get routing form responses", async () => {
+      const createdAt = new Date(routingFormResponse.createdAt);
+      createdAt.setHours(createdAt.getHours() - 1);
+      const isoStringCreatedAt = createdAt.toISOString();
+      return request(app.getHttpServer())
+        .get(
+          `/v2/organizations/${org.id}/routing-forms/${routingForm.id}/responses?skip=0&take=2&sortUpdatedAt=asc&sortCreatedAt=desc&afterCreatedAt=${isoStringCreatedAt}`
+        )
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const responses = responseBody.data as App_RoutingForms_FormResponse[];
+          expect(responses).toBeDefined();
+          expect(responses.length).toBeGreaterThan(0);
+          expect(responses.find((response) => response.id === routingFormResponse.id)).toBeDefined();
+          expect(responses.find((response) => response.id === routingFormResponse.id)?.formId).toEqual(
+            routingFormResponse.formId
+          );
+          expect(responses.find((response) => response.id === routingFormResponse2.id)).toBeDefined();
+          expect(responses.find((response) => response.id === routingFormResponse2.id)?.formId).toEqual(
+            routingFormResponse2.formId
+          );
+        });
+    });
+  });
+
+  describe(`PATCH /v2/organizations/:orgId/routing-forms/:routingFormId/responses/:responseId`, () => {
+    it("should not update routing form response for non existing org", async () => {
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/99999/routing-forms/${routingForm.id}/responses/${routingFormResponse.id}`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(403);
+    });
+
+    it("should not update routing form response for non existing form", async () => {
+      return request(app.getHttpServer())
+        .patch(
+          `/v2/organizations/${org.id}/routing-forms/non-existent-id/responses/${routingFormResponse.id}`
+        )
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(404);
+    });
+
+    it("should not update routing form response for non existing response", async () => {
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/routing-forms/${routingForm.id}/responses/99999`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(404);
+    });
+
+    it("should not update routing form response without authentication", async () => {
+      return request(app.getHttpServer())
+        .patch(
+          `/v2/organizations/${org.id}/routing-forms/${routingForm.id}/responses/${routingFormResponse.id}`
+        )
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(401);
+    });
+
+    it("should update routing form response", async () => {
+      const updatedResponse = { question1: "updated_answer1", question2: "updated_answer2" };
+      return request(app.getHttpServer())
+        .patch(
+          `/v2/organizations/${org.id}/routing-forms/${routingForm.id}/responses/${routingFormResponse.id}`
+        )
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: updatedResponse })
+        .expect(200)
+        .then((response) => {
+          const responseBody = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const data = responseBody.data;
+          expect(data).toBeDefined();
+          expect(data.id).toEqual(routingFormResponse.id);
+          expect(data.formId).toEqual(routingFormResponse.formId);
+          expect(data.response).toEqual(updatedResponse);
+        });
+    });
+  });
+});

apps/api/v2/src/modules/organizations/routing-forms/controllers/organizations-routing-forms-responses.controller.ts

@@ -0,0 +1,81 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { API_KEY_HEADER } from "@/lib/docs/headers";
+import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+import { IsAdminAPIEnabledGuard } from "@/modules/auth/guards/organizations/is-admin-api-enabled.guard";
+import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
+import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
+import { GetRoutingFormResponsesOutput } from "@/modules/organizations/routing-forms/outputs/get-routing-form-responses.output";
+import { OrganizationsRoutingFormsResponsesService } from "@/modules/organizations/routing-forms/services/organizations-routing-forms-responses.service";
+import { Body, Controller, Get, Param, Patch, Query, UseGuards, ParseIntPipe } from "@nestjs/common";
+import { ApiHeader, ApiOperation, ApiTags } from "@nestjs/swagger";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+import { GetRoutingFormResponsesParams } from "../inputs/get-routing-form-responses-params.input";
+import { UpdateRoutingFormResponseInput } from "../inputs/update-routing-form-response.input";
+import { UpdateRoutingFormResponseOutput } from "../outputs/update-routing-form-response.output";
+
+@Controller({
+  path: "/v2/organizations/:orgId/routing-forms/:routingFormId/responses",
+  version: API_VERSIONS_VALUES,
+})
+@UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+@ApiTags("Orgs / Routing forms")
+@ApiHeader(API_KEY_HEADER)
+export class OrganizationsRoutingFormsResponsesController {
+  constructor(
+    private readonly organizationsRoutingFormsResponsesService: OrganizationsRoutingFormsResponsesService
+  ) {}
+
+  @Get("/")
+  @ApiOperation({ summary: "Get routing form responses" })
+  @Roles("ORG_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  async getRoutingFormResponses(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("routingFormId") routingFormId: string,
+    @Query() queryParams: GetRoutingFormResponsesParams
+  ): Promise<GetRoutingFormResponsesOutput> {
+    const { skip, take, ...filters } = queryParams;
+
+    const responses =
+      await this.organizationsRoutingFormsResponsesService.getOrganizationRoutingFormResponses(
+        orgId,
+        routingFormId,
+        skip ?? 0,
+        take ?? 250,
+        filters
+      );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: responses,
+    };
+  }
+
+  @Patch("/:responseId")
+  @ApiOperation({ summary: "Update routing form response" })
+  @Roles("ORG_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  async updateRoutingFormResponse(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("routingFormId") routingFormId: string,
+    @Param("responseId", ParseIntPipe) responseId: number,
+    @Body() updateRoutingFormResponseInput: UpdateRoutingFormResponseInput
+  ): Promise<UpdateRoutingFormResponseOutput> {
+    const updatedResponse = await this.organizationsRoutingFormsResponsesService.updateRoutingFormResponse(
+      orgId,
+      routingFormId,
+      responseId,
+      updateRoutingFormResponseInput
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: updatedResponse,
+    };
+  }
+}

apps/api/v2/src/modules/organizations/routing-forms/controllers/organizations-routing-forms.controller.e2e-spec.ts

@@ -0,0 +1,215 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { GetRoutingFormsOutput } from "@/modules/organizations/routing-forms/outputs/get-routing-forms.output";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { App_RoutingForms_Form, App_RoutingForms_FormResponse, Team, User } from "@prisma/client";
+import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { randomString } from "test/utils/randomString";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+describe("OrganizationsRoutingFormController", () => {
+  let app: INestApplication;
+  let prismaWriteService: PrismaWriteService;
+  let org: Team;
+  let team: Team;
+  let apiKeyString: string;
+  let routingForm: App_RoutingForms_Form;
+  let routingFormResponse: App_RoutingForms_FormResponse;
+  let routingFormResponse2: App_RoutingForms_FormResponse;
+
+  let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let userRepositoryFixture: UserRepositoryFixture;
+  let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+
+  let user: User;
+  const userEmail = `OrganizationsRoutingFormsResponsesController-key-bookings-2024-08-13-user-${randomString()}@api.com`;
+  let profileRepositoryFixture: ProfileRepositoryFixture;
+
+  let membershipsRepositoryFixture: MembershipRepositoryFixture;
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [AppModule, PrismaModule, UsersModule, TokensModule],
+    }).compile();
+
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+
+    prismaWriteService = moduleRef.get<PrismaWriteService>(PrismaWriteService);
+    apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
+    profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+    organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+
+    membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+    org = await organizationsRepositoryFixture.create({
+      name: `OrganizationsRoutingFormsResponsesController-teams-memberships-organization-${randomString()}`,
+      isOrganization: true,
+    });
+
+    team = await teamRepositoryFixture.create({
+      name: "OrganizationsRoutingFormsResponsesController orgs booking 1",
+      isOrganization: false,
+      parent: { connect: { id: org.id } },
+    });
+
+    user = await userRepositoryFixture.create({
+      email: userEmail,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "OWNER",
+      user: { connect: { id: user.id } },
+      team: { connect: { id: org.id } },
+    });
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${user.id}`,
+      username: userEmail,
+      organization: {
+        connect: {
+          id: org.id,
+        },
+      },
+      user: {
+        connect: {
+          id: user.id,
+        },
+      },
+    });
+    const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+    apiKeyString = `${keyString}`;
+
+    routingForm = await prismaWriteService.prisma.app_RoutingForms_Form.create({
+      data: {
+        name: "Test Routing Form",
+        description: "Test Description",
+        disabled: false,
+        routes: [{ redirect: "http://google.com" }],
+        fields: [{ territory: "input" }],
+        settings: { test: "true" },
+        teamId: team.id,
+        userId: user.id,
+      },
+    });
+
+    routingFormResponse = await prismaWriteService.prisma.app_RoutingForms_FormResponse.create({
+      data: {
+        formId: routingForm.id,
+        response: JSON.stringify({ question1: "answer1", question2: "answer2" }),
+      },
+    });
+
+    routingFormResponse2 = await prismaWriteService.prisma.app_RoutingForms_FormResponse.create({
+      data: {
+        formId: routingForm.id,
+        response: JSON.stringify({ question1: "answer1", question2: "answer2" }),
+      },
+    });
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await prismaWriteService.prisma.app_RoutingForms_Form.deleteMany({
+      where: {
+        teamId: org.id,
+      },
+    });
+    await prismaWriteService.prisma.apiKey.deleteMany({
+      where: {
+        teamId: org.id,
+      },
+    });
+    await prismaWriteService.prisma.team.delete({
+      where: {
+        id: team.id,
+      },
+    });
+    await prismaWriteService.prisma.team.delete({
+      where: {
+        id: org.id,
+      },
+    });
+    await app.close();
+  });
+
+  describe(`GET /v2/organizations/:orgId/routing-forms`, () => {
+    it("should not get routing forms for non existing org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/99999/routing-forms`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(403);
+    });
+
+    it("should not get routing forms without authentication", async () => {
+      return request(app.getHttpServer()).get(`/v2/organizations/${org.id}/routing-forms`).expect(401);
+    });
+
+    it("should get organization routing forms", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/routing-forms?skip=0&take=1`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody: GetRoutingFormsOutput = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const routingForms = responseBody.data;
+          expect(routingForms).toBeDefined();
+          expect(routingForms.length).toBeGreaterThan(0);
+          expect(routingForms[0].id).toEqual(routingForm.id);
+          expect(routingForms[0].name).toEqual(routingForm.name);
+          expect(routingForms[0].description).toEqual(routingForm.description);
+          expect(routingForms[0].disabled).toEqual(routingForm.disabled);
+        });
+    });
+
+    it("should filter routing forms by name", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/routing-forms?name=Test`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody: GetRoutingFormsOutput = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const routingForms = responseBody.data;
+          expect(routingForms).toBeDefined();
+          expect(routingForms.length).toBeGreaterThan(0);
+          expect(routingForms[0].name).toContain("Test");
+        });
+    });
+
+    it("should filter routing forms by disabled status", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/routing-forms?disabled=false`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody: GetRoutingFormsOutput = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const routingForms = responseBody.data;
+          expect(routingForms).toBeDefined();
+          expect(routingForms.length).toBeGreaterThan(0);
+          expect(routingForms[0].disabled).toEqual(false);
+          expect(routingForms[0].fields?.[0]).toEqual({ territory: "input" });
+          expect(routingForms[0].routes?.[0]).toEqual({ redirect: "http://google.com" });
+          expect(routingForms[0].settings).toEqual({ test: "true" });
+        });
+    });
+  });
+});

apps/api/v2/src/modules/organizations/routing-forms/controllers/organizations-routing-forms.controller.ts

@@ -0,0 +1,54 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { API_KEY_HEADER } from "@/lib/docs/headers";
+import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+import { IsAdminAPIEnabledGuard } from "@/modules/auth/guards/organizations/is-admin-api-enabled.guard";
+import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
+import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
+import { GetRoutingFormsParams } from "@/modules/organizations/routing-forms/inputs/get-routing-form-responses-params.input";
+import {
+  GetRoutingFormsOutput,
+  RoutingFormOutput,
+} from "@/modules/organizations/routing-forms/outputs/get-routing-forms.output";
+import { OrganizationsRoutingFormsService } from "@/modules/organizations/routing-forms/services/organizations-routing-forms.service";
+import { Controller, Get, Param, Query, UseGuards, ParseIntPipe } from "@nestjs/common";
+import { ApiHeader, ApiOperation, ApiTags } from "@nestjs/swagger";
+import { plainToClass } from "class-transformer";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+@Controller({
+  path: "/v2/organizations/:orgId/routing-forms",
+  version: API_VERSIONS_VALUES,
+})
+@UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+@ApiTags("Orgs / Routing forms")
+@ApiHeader(API_KEY_HEADER)
+export class OrganizationsRoutingFormsController {
+  constructor(private readonly organizationsRoutingFormsService: OrganizationsRoutingFormsService) {}
+
+  @Get()
+  @ApiOperation({ summary: "Get organization routing forms" })
+  @Roles("ORG_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  async getOrganizationRoutingForms(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Query() queryParams: GetRoutingFormsParams
+  ): Promise<GetRoutingFormsOutput> {
+    const { skip, take, ...filters } = queryParams;
+
+    const routingForms = await this.organizationsRoutingFormsService.getOrganizationRoutingForms(
+      orgId,
+      skip ?? 0,
+      take ?? 250,
+      filters
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: routingForms.map((form) => plainToClass(RoutingFormOutput, form)),
+    };
+  }
+}

apps/api/v2/src/modules/organizations/routing-forms/inputs/get-routing-form-responses-params.input.ts

@@ -0,0 +1,90 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform } from "class-transformer";
+import { IsOptional, IsString, IsEnum, IsISO8601, IsNumber, IsArray, ArrayMinSize } from "class-validator";
+
+enum SortOrder {
+  ASC = "asc",
+  DESC = "desc",
+}
+
+export class GetRoutingFormResponsesParams {
+  @ApiPropertyOptional({ type: Number, description: "Number of responses to skip" })
+  @Transform(({ value }) => value && parseInt(value))
+  @IsOptional()
+  skip?: number;
+
+  @ApiPropertyOptional({ type: Number, description: "Number of responses to take" })
+  @Transform(({ value }) => value && parseInt(value))
+  @IsOptional()
+  take?: number;
+
+  @ApiPropertyOptional({ enum: SortOrder, description: "Sort by creation time" })
+  @IsOptional()
+  @IsEnum(SortOrder)
+  sortCreatedAt?: "asc" | "desc";
+
+  @ApiPropertyOptional({ enum: SortOrder, description: "Sort by update time" })
+  @IsOptional()
+  @IsEnum(SortOrder)
+  sortUpdatedAt?: "asc" | "desc";
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by responses created after this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  afterCreatedAt?: string;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by responses created before this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  beforeCreatedAt?: string;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by responses created after this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  afterUpdatedAt?: string;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by responses updated before this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  beforeUpdatedAt?: string;
+
+  @ApiPropertyOptional({ type: String, description: "Filter by responses routed to a specific booking" })
+  @IsOptional()
+  @IsString()
+  routedToBookingUid?: string;
+}
+
+export class GetRoutingFormsParams extends GetRoutingFormResponsesParams {
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (typeof value === "string") {
+      return value.split(",").map((teamId: string) => parseInt(teamId));
+    }
+    return value;
+  })
+  @ApiPropertyOptional({
+    type: [Number],
+    description: "Filter by teamIds. Team ids must be separated by a comma.",
+    example: "?teamIds=100,200",
+  })
+  @IsArray()
+  @IsNumber({}, { each: true })
+  @ArrayMinSize(1, { message: "teamIds must contain at least 1 team id" })
+  teamIds?: number[];
+}

apps/api/v2/src/modules/organizations/routing-forms/inputs/get-routing-forms-params.input.ts

@@ -0,0 +1,89 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform } from "class-transformer";
+import { IsOptional, IsBoolean, IsString, IsEnum, IsDate, IsISO8601 } from "class-validator";
+
+enum SortOrder {
+  ASC = "asc",
+  DESC = "desc",
+}
+
+export class GetRoutingFormsParams {
+  @ApiPropertyOptional({ type: Number, description: "Number of routing forms to skip" })
+  @Transform(({ value }) => value && parseInt(value))
+  @IsOptional()
+  skip?: number;
+
+  @ApiPropertyOptional({ type: Number, description: "Number of routing forms to take" })
+  @Transform(({ value }) => value && parseInt(value))
+  @IsOptional()
+  take?: number;
+
+  @ApiPropertyOptional({ enum: SortOrder, description: "Sort by creation time" })
+  @IsOptional()
+  @IsEnum(SortOrder)
+  sortCreatedAt?: "asc" | "desc";
+
+  @ApiPropertyOptional({ enum: SortOrder, description: "Sort by update time" })
+  @IsOptional()
+  @IsEnum(SortOrder)
+  sortUpdatedAt?: "asc" | "desc";
+
+  @ApiPropertyOptional({ type: Boolean, description: "Filter by disabled status" })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    return value;
+  })
+  @IsBoolean()
+  disabled?: boolean;
+
+  @ApiPropertyOptional({ type: String, description: "Filter by name" })
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by forms created after this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  @Transform(({ value }) => value && new Date(value))
+  @IsDate()
+  afterCreatedAt?: Date;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by forms created before this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  @Transform(({ value }) => value && new Date(value))
+  @IsDate()
+  beforeCreatedAt?: Date;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by forms updated after this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  @Transform(({ value }) => value && new Date(value))
+  @IsDate()
+  afterUpdatedAt?: Date;
+
+  @ApiPropertyOptional({
+    type: String,
+    format: "date-time",
+    description: "Filter by forms updated before this date",
+  })
+  @IsOptional()
+  @IsISO8601()
+  @Transform(({ value }) => value && new Date(value))
+  @IsDate()
+  beforeUpdatedAt?: Date;
+}

apps/api/v2/src/modules/organizations/routing-forms/inputs/update-routing-form-response.input.ts

@@ -0,0 +1,8 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsOptional } from "class-validator";
+
+export class UpdateRoutingFormResponseInput {
+  @ApiPropertyOptional({ type: Object, description: "The updated response data" })
+  @IsOptional()
+  response?: Record<string, any>;
+}

apps/api/v2/src/modules/organizations/routing-forms/organizations-routing-forms.module.ts

@@ -0,0 +1,28 @@
+import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
+import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
+import { OrganizationsTeamsRoutingFormsResponsesOutputService } from "@/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms-responses-output.service";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { RedisModule } from "@/modules/redis/redis.module";
+import { RoutingFormsModule } from "@/modules/routing-forms/routing-forms.module";
+import { StripeModule } from "@/modules/stripe/stripe.module";
+import { Module } from "@nestjs/common";
+
+import { OrganizationsRoutingFormsResponsesController } from "./controllers/organizations-routing-forms-responses.controller";
+import { OrganizationsRoutingFormsController } from "./controllers/organizations-routing-forms.controller";
+import { OrganizationsRoutingFormsRepository } from "./organizations-routing-forms.repository";
+import { OrganizationsRoutingFormsResponsesService } from "./services/organizations-routing-forms-responses.service";
+import { OrganizationsRoutingFormsService } from "./services/organizations-routing-forms.service";
+
+@Module({
+  imports: [PrismaModule, StripeModule, RedisModule, RoutingFormsModule],
+  providers: [
+    MembershipsRepository,
+    OrganizationsRepository,
+    OrganizationsRoutingFormsRepository,
+    OrganizationsRoutingFormsService,
+    OrganizationsRoutingFormsResponsesService,
+    OrganizationsTeamsRoutingFormsResponsesOutputService,
+  ],
+  controllers: [OrganizationsRoutingFormsController, OrganizationsRoutingFormsResponsesController],
+})
+export class OrganizationsRoutingFormsModule {}

apps/api/v2/src/modules/organizations/routing-forms/organizations-routing-forms.repository.ts

@@ -0,0 +1,128 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsRoutingFormsRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getOrganizationRoutingForms(
+    orgId: number,
+    skip: number,
+    take: number,
+    options?: {
+      disabled?: boolean;
+      name?: string;
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+      teamIds?: number[];
+    }
+  ) {
+    const {
+      disabled,
+      name,
+      sortCreatedAt,
+      sortUpdatedAt,
+      afterCreatedAt,
+      beforeCreatedAt,
+      afterUpdatedAt,
+      beforeUpdatedAt,
+      teamIds,
+    } = options || {};
+
+    return this.dbRead.prisma.app_RoutingForms_Form.findMany({
+      where: {
+        team: { parentId: orgId, ...(teamIds?.length ? { id: { in: teamIds } } : {}) },
+        ...(disabled !== undefined && { disabled }),
+        ...(name && { name: { contains: name, mode: "insensitive" } }),
+        ...(afterCreatedAt && { createdAt: { gte: afterCreatedAt } }),
+        ...(beforeCreatedAt && { createdAt: { lte: beforeCreatedAt } }),
+        ...(afterUpdatedAt && { updatedAt: { gte: afterUpdatedAt } }),
+        ...(beforeUpdatedAt && { updatedAt: { lte: beforeUpdatedAt } }),
+      },
+      orderBy: [
+        ...(sortCreatedAt ? [{ createdAt: sortCreatedAt }] : []),
+        ...(sortUpdatedAt ? [{ updatedAt: sortUpdatedAt }] : []),
+      ],
+      skip,
+      take,
+    });
+  }
+
+  async getOrganizationRoutingFormResponses(
+    orgId: number,
+    routingFormId: string,
+    skip: number,
+    take: number,
+    options?: {
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+      routedToBookingUid?: string;
+    }
+  ) {
+    const {
+      sortCreatedAt,
+      sortUpdatedAt,
+      afterCreatedAt,
+      beforeCreatedAt,
+      routedToBookingUid,
+      afterUpdatedAt,
+      beforeUpdatedAt,
+    } = options || {};
+    await this.dbRead.prisma.app_RoutingForms_Form.findFirstOrThrow({
+      where: {
+        team: { parentId: orgId },
+        id: routingFormId,
+      },
+    });
+
+    return this.dbRead.prisma.app_RoutingForms_FormResponse.findMany({
+      where: {
+        formId: routingFormId,
+        ...(afterCreatedAt && { createdAt: { gte: afterCreatedAt } }),
+        ...(beforeCreatedAt && { createdAt: { lte: beforeCreatedAt } }),
+        ...(afterUpdatedAt && { updatedAt: { gte: afterUpdatedAt } }),
+        ...(beforeUpdatedAt && { updatedAt: { lte: beforeUpdatedAt } }),
+        ...(routedToBookingUid && { routedToBookingUid }),
+      },
+      orderBy: [
+        ...(sortCreatedAt ? [{ createdAt: sortCreatedAt }] : []),
+        ...(sortUpdatedAt ? [{ updatedAt: sortUpdatedAt }] : []),
+      ],
+      skip,
+      take,
+    });
+  }
+
+  async updateRoutingFormResponse(
+    orgId: number,
+    routingFormId: string,
+    responseId: number,
+    data: {
+      response?: Record<string, any>;
+    }
+  ) {
+    return this.dbWrite.prisma.app_RoutingForms_FormResponse.update({
+      where: {
+        id: responseId,
+        formId: routingFormId,
+        form: {
+          team: {
+            parentId: orgId,
+          },
+        },
+      },
+      data: {
+        ...data,
+      },
+    });
+  }
+}

apps/api/v2/src/modules/organizations/routing-forms/outputs/get-routing-form-responses.output.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsEnum } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { RoutingFormResponseOutput } from "@calcom/platform-types";
+
+export class GetRoutingFormResponsesOutput {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({ type: RoutingFormResponseOutput })
+  @Expose()
+  @Type(() => RoutingFormResponseOutput)
+  data!: RoutingFormResponseOutput[];
+}

apps/api/v2/src/modules/organizations/routing-forms/outputs/get-routing-forms.output.ts

@@ -0,0 +1,62 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsEnum } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+
+export class RoutingFormOutput {
+  @Expose()
+  id!: string;
+
+  @ApiProperty({ example: "My Form" })
+  @Expose()
+  name!: string;
+
+  @ApiProperty({ example: "This is the description." })
+  @Expose()
+  description!: string | null;
+
+  @ApiProperty({ example: 0 })
+  @Expose()
+  position!: number;
+
+  @Expose()
+  routes!: Record<string, unknown> | null;
+
+  @ApiProperty({ example: "2024-03-28T10:00:00.000Z" })
+  @Expose()
+  createdAt!: string;
+
+  @ApiProperty({ example: "2024-03-28T10:00:00.000Z" })
+  @Expose()
+  updatedAt!: string;
+
+  @Expose()
+  fields!: Record<string, unknown> | null;
+
+  @ApiProperty({ example: 2313 })
+  @Expose()
+  userId!: number;
+
+  @ApiProperty({ example: 4214321 })
+  @Expose()
+  teamId!: number | null;
+
+  @ApiProperty({ example: false })
+  @Expose()
+  disabled!: boolean;
+
+  @Expose()
+  settings!: Record<string, unknown> | null;
+}
+
+export class GetRoutingFormsOutput {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({ type: [RoutingFormOutput] })
+  @Expose()
+  @Type(() => RoutingFormOutput)
+  data!: RoutingFormOutput[];
+}

apps/api/v2/src/modules/organizations/routing-forms/outputs/update-routing-form-response.output.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsEnum } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { RoutingFormResponseOutput } from "@calcom/platform-types";
+
+export class UpdateRoutingFormResponseOutput {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({ type: RoutingFormResponseOutput })
+  @Expose()
+  @Type(() => RoutingFormResponseOutput)
+  data!: RoutingFormResponseOutput;
+}

apps/api/v2/src/modules/organizations/routing-forms/services/organizations-routing-forms-responses.service.ts

@@ -0,0 +1,55 @@
+import { OrganizationsRoutingFormsRepository } from "@/modules/organizations/routing-forms/organizations-routing-forms.repository";
+import { OrganizationsTeamsRoutingFormsResponsesOutputService } from "@/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms-responses-output.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsRoutingFormsResponsesService {
+  constructor(
+    private readonly organizationsRoutingFormsRepository: OrganizationsRoutingFormsRepository,
+    private readonly outputService: OrganizationsTeamsRoutingFormsResponsesOutputService
+  ) {}
+
+  async getOrganizationRoutingFormResponses(
+    orgId: number,
+    routingFormId: string,
+    skip: number,
+    take: number,
+    options?: {
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+      routedToBookingUid?: string;
+    }
+  ) {
+    const responses = await this.organizationsRoutingFormsRepository.getOrganizationRoutingFormResponses(
+      orgId,
+      routingFormId,
+      skip,
+      take,
+      options
+    );
+
+    return this.outputService.getRoutingFormResponses(responses);
+  }
+
+  async updateRoutingFormResponse(
+    orgId: number,
+    routingFormId: string,
+    responseId: number,
+    data: {
+      response?: Record<string, any>;
+    }
+  ) {
+    const updatedResponse = await this.organizationsRoutingFormsRepository.updateRoutingFormResponse(
+      orgId,
+      routingFormId,
+      responseId,
+      data
+    );
+
+    return this.outputService.getRoutingFormResponses([updatedResponse])[0];
+  }
+}

apps/api/v2/src/modules/organizations/routing-forms/services/organizations-routing-forms.service.ts

@@ -0,0 +1,26 @@
+import { OrganizationsRoutingFormsRepository } from "@/modules/organizations/routing-forms/organizations-routing-forms.repository";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsRoutingFormsService {
+  constructor(private readonly organizationsRoutingFormsRepository: OrganizationsRoutingFormsRepository) {}
+
+  async getOrganizationRoutingForms(
+    orgId: number,
+    skip: number,
+    take: number,
+    options?: {
+      disabled?: boolean;
+      name?: string;
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+      teamIds?: number[];
+    }
+  ) {
+    return this.organizationsRoutingFormsRepository.getOrganizationRoutingForms(orgId, skip, take, options);
+  }
+}

apps/api/v2/src/modules/organizations/teams/index/organizations-teams.repository.ts

@@ -18,6 +18,18 @@ export class OrganizationsTeamsRepository {
     });
   }
 
+  async findOrgTeamBySlug(organizationId: number, teamSlug: string) {
+    return this.dbRead.prisma.team.findUnique({
+      where: {
+        slug_parentId: {
+          slug: teamSlug,
+          parentId: organizationId,
+        },
+        isOrganization: false,
+      },
+    });
+  }
+
   async findOrgTeams(organizationId: number) {
     return this.dbRead.prisma.team.findMany({
       where: {

apps/api/v2/src/modules/organizations/teams/routing-forms/controllers/organizations-teams-routing-forms-responses.controller.e2e-spec.ts

@@ -35,7 +35,7 @@ describe("Organizations Teams Routing Forms Responses", () => {
 
   let org: Team;
   let orgTeam: Team;
-
+  let routingFormResponseId: string;
   const authEmail = `organizations-teams-routing-forms-responses-user-${randomString()}@api.com`;
   let user: User;
   let apiKeyString: string;
@@ -173,7 +173,9 @@ describe("Organizations Teams Routing Forms Responses", () => {
 
   it("should get routing form responses", async () => {
     return request(app.getHttpServer())
-      .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/routing-forms/${routingFormId}/responses`)
+      .get(
+        `/v2/organizations/${org.id}/teams/${orgTeam.id}/routing-forms/${routingFormId}/responses?skip=0&take=1`
+      )
       .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
       .expect(200)
       .then((response) => {
@@ -186,9 +188,65 @@ describe("Organizations Teams Routing Forms Responses", () => {
         expect(responseData[0].response).toEqual(routingFormResponses[0].response);
         expect(responseData[0].formFillerId).toEqual(routingFormResponses[0].formFillerId);
         expect(responseData[0].createdAt).toEqual(routingFormResponses[0].createdAt.toISOString());
+        routingFormResponseId = responseData[0].id;
       });
   });
 
+  describe(`PATCH /v2/organizations/:orgId/routing-forms/:routingFormId/responses/:responseId`, () => {
+    it("should not update routing form response for non existing org", async () => {
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/99999/routing-forms/${routingFormId}/responses/${routingFormResponseId}`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(403);
+    });
+
+    it("should not update routing form response for non existing form", async () => {
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/routing-forms/non-existent-id/responses/${routingFormResponseId}`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(404);
+    });
+
+    it("should not update routing form response for non existing response", async () => {
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/routing-forms/${routingFormId}/responses/99999`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(404);
+    });
+
+    it("should not update routing form response without authentication", async () => {
+      return request(app.getHttpServer())
+        .patch(
+          `/v2/organizations/${org.id}/routing-forms/${routingFormId}/responses/${routingFormResponseId}`
+        )
+        .send({ response: JSON.stringify({ question1: "updated_answer1" }) })
+        .expect(401);
+    });
+
+    it("should update routing form response", async () => {
+      const updatedResponse = { question1: "updated_answer1", question2: "updated_answer2" };
+      return request(app.getHttpServer())
+        .patch(
+          `/v2/organizations/${org.id}/routing-forms/${routingFormId}/responses/${routingFormResponseId}`
+        )
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .send({ response: updatedResponse })
+        .expect(200)
+        .then((response) => {
+          const responseBody = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const data = responseBody.data;
+          expect(data).toBeDefined();
+          expect(data.id).toEqual(routingFormResponseId);
+          expect(data.formId).toEqual(routingFormId);
+          expect(data.response).toEqual(updatedResponse);
+        });
+    });
+  });
+
   afterAll(async () => {
     await userRepositoryFixture.deleteByEmail(user.email);
     await organizationsRepositoryFixture.delete(org.id);

apps/api/v2/src/modules/organizations/teams/routing-forms/controllers/organizations-teams-routing-forms-responses.controller.ts

@@ -8,14 +8,16 @@ import { IsAdminAPIEnabledGuard } from "@/modules/auth/guards/organizations/is-a
 import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
 import { IsRoutingFormInTeam } from "@/modules/auth/guards/routing-forms/is-routing-form-in-team.guard";
 import { IsTeamInOrg } from "@/modules/auth/guards/teams/is-team-in-org.guard";
-import { Controller, Get, Param, UseGuards } from "@nestjs/common";
+import { GetRoutingFormResponsesParams } from "@/modules/organizations/routing-forms/inputs/get-routing-form-responses-params.input";
+import { UpdateRoutingFormResponseInput } from "@/modules/organizations/routing-forms/inputs/update-routing-form-response.input";
+import { UpdateRoutingFormResponseOutput } from "@/modules/organizations/routing-forms/outputs/update-routing-form-response.output";
+import { GetRoutingFormResponsesOutput } from "@/modules/organizations/teams/routing-forms/outputs/get-routing-form-responses.output";
+import { OrganizationsTeamsRoutingFormsResponsesService } from "@/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms-responses.service";
+import { Controller, Get, Patch, Param, ParseIntPipe, Query, UseGuards, Body } from "@nestjs/common";
 import { ApiHeader, ApiOperation, ApiTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 
-import { RoutingFormsResponsesService } from "../../../../routing-forms-responses/services/routing-forms-responses.service";
-import { GetRoutingFormResponsesOutput } from "../outputs/get-routing-form-responses.output";
-
 @Controller({
   path: "/v2/organizations/:orgId/teams/:teamId/routing-forms/:routingFormId/responses",
   version: API_VERSIONS_VALUES,
@@ -31,22 +33,58 @@ import { GetRoutingFormResponsesOutput } from "../outputs/get-routing-form-respo
 )
 @ApiHeader(API_KEY_HEADER)
 export class OrganizationsTeamsRoutingFormsResponsesController {
-  constructor(private readonly routingFormsResponsesService: RoutingFormsResponsesService) {}
+  constructor(
+    private readonly organizationsTeamsRoutingFormsResponsesService: OrganizationsTeamsRoutingFormsResponsesService
+  ) {}
 
-  @Get()
-  @ApiOperation({ summary: "Get routing form responses" })
-  @Roles("ORG_ADMIN")
+  @Get("/")
+  @ApiOperation({ summary: "Get organization team routing form responses" })
+  @Roles("TEAM_ADMIN")
   @PlatformPlan("ESSENTIALS")
   async getRoutingFormResponses(
-    @Param("routingFormId") routingFormId: string
+    @Param("routingFormId") routingFormId: string,
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Query() queryParams: GetRoutingFormResponsesParams
   ): Promise<GetRoutingFormResponsesOutput> {
-    const routingFormResponses = await this.routingFormsResponsesService.getRoutingFormResponses(
-      routingFormId
-    );
+    const { skip, take, ...filters } = queryParams;
+
+    const routingFormResponses =
+      await this.organizationsTeamsRoutingFormsResponsesService.getTeamRoutingFormResponses(
+        teamId,
+        routingFormId,
+        skip ?? 0,
+        take ?? 250,
+        { ...(filters ?? {}) }
+      );
 
     return {
       status: SUCCESS_STATUS,
       data: routingFormResponses,
     };
   }
+
+  @Patch("/:responseId")
+  @ApiOperation({ summary: "Update routing form response" })
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  async updateRoutingFormResponse(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("routingFormId") routingFormId: string,
+    @Param("responseId", ParseIntPipe) responseId: number,
+    @Body() updateRoutingFormResponseInput: UpdateRoutingFormResponseInput
+  ): Promise<UpdateRoutingFormResponseOutput> {
+    const updatedResponse =
+      await this.organizationsTeamsRoutingFormsResponsesService.updateTeamRoutingFormResponse(
+        teamId,
+        routingFormId,
+        responseId,
+        updateRoutingFormResponseInput
+      );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: updatedResponse,
+    };
+  }
 }

apps/api/v2/src/modules/organizations/teams/routing-forms/controllers/organizations-teams-routing-forms.controller.e2e-spec.ts

@@ -0,0 +1,206 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { GetRoutingFormsOutput } from "@/modules/organizations/routing-forms/outputs/get-routing-forms.output";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { App_RoutingForms_Form, Team, User } from "@prisma/client";
+import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { randomString } from "test/utils/randomString";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+describe("OrganizationsRoutingFormsResponsesController", () => {
+  let app: INestApplication;
+  let prismaWriteService: PrismaWriteService;
+  let org: Team;
+  let team: Team;
+  let apiKeyString: string;
+  let routingForm: App_RoutingForms_Form;
+
+  let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let userRepositoryFixture: UserRepositoryFixture;
+  let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+
+  let user: User;
+  const userEmail = `OrganizationsRoutingFormsResponsesController-key-bookings-2024-08-13-user-${randomString()}@api.com`;
+  let profileRepositoryFixture: ProfileRepositoryFixture;
+
+  let membershipsRepositoryFixture: MembershipRepositoryFixture;
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [AppModule, PrismaModule, UsersModule, TokensModule],
+    }).compile();
+
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+
+    prismaWriteService = moduleRef.get<PrismaWriteService>(PrismaWriteService);
+    apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
+    profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+    organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+
+    membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+    org = await organizationsRepositoryFixture.create({
+      name: `OrganizationsRoutingFormsResponsesController-teams-memberships-organization-${randomString()}`,
+      isOrganization: true,
+    });
+
+    team = await teamRepositoryFixture.create({
+      name: "OrganizationsRoutingFormsResponsesController orgs booking 1",
+      isOrganization: false,
+      parent: { connect: { id: org.id } },
+    });
+
+    user = await userRepositoryFixture.create({
+      email: userEmail,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "OWNER",
+      user: { connect: { id: user.id } },
+      team: { connect: { id: org.id } },
+    });
+
+    await profileRepositoryFixture.create({
+      uid: `usr-${user.id}`,
+      username: userEmail,
+      organization: {
+        connect: {
+          id: org.id,
+        },
+      },
+      user: {
+        connect: {
+          id: user.id,
+        },
+      },
+    });
+    const now = new Date();
+    now.setDate(now.getDate() + 1);
+    const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+    apiKeyString = `${keyString}`;
+
+    routingForm = await prismaWriteService.prisma.app_RoutingForms_Form.create({
+      data: {
+        name: "Test Routing Form",
+        description: "Test Description",
+        disabled: false,
+        routes: JSON.stringify([]),
+        fields: JSON.stringify([]),
+        settings: JSON.stringify({}),
+        teamId: team.id,
+        userId: user.id,
+      },
+    });
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+  afterAll(async () => {
+    await prismaWriteService.prisma.app_RoutingForms_Form.deleteMany({
+      where: {
+        teamId: team.id,
+      },
+    });
+    await prismaWriteService.prisma.apiKey.deleteMany({
+      where: {
+        teamId: org.id,
+      },
+    });
+    await prismaWriteService.prisma.team.delete({
+      where: {
+        id: team.id,
+      },
+    });
+    await prismaWriteService.prisma.team.delete({
+      where: {
+        id: org.id,
+      },
+    });
+    await app.close();
+  });
+
+  describe(`GET /v2/organizations/:orgId/teams/:teamId/routing-forms`, () => {
+    it("should not get team routing forms for non existing org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/99999/teams/${team.id}/routing-forms`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(403);
+    });
+
+    it("should not get team routing forms for non existing team", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/99999/routing-forms`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(404);
+    });
+
+    it("should not get team routing forms without authentication", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/routing-forms`)
+        .expect(401);
+    });
+
+    it("should get team routing forms", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/routing-forms`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody: GetRoutingFormsOutput = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const routingForms = responseBody.data;
+          expect(routingForms).toBeDefined();
+          expect(routingForms.length).toBeGreaterThan(0);
+          expect(routingForms[0].id).toEqual(routingForm.id);
+          expect(routingForms[0].name).toEqual(routingForm.name);
+          expect(routingForms[0].description).toEqual(routingForm.description);
+          expect(routingForms[0].disabled).toEqual(routingForm.disabled);
+        });
+    });
+
+    it("should filter team routing forms by name", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/routing-forms?name=Team`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody: GetRoutingFormsOutput = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const routingForms = responseBody.data;
+          expect(routingForms).toBeDefined();
+          expect(routingForms.length).toBeGreaterThan(0);
+          expect(routingForms[0].name).toContain("Test Routing Form");
+        });
+    });
+
+    it("should filter team routing forms by disabled status", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/routing-forms?disabled=false`)
+        .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+        .expect(200)
+        .then((response) => {
+          const responseBody: GetRoutingFormsOutput = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const routingForms = responseBody.data;
+          expect(routingForms).toBeDefined();
+          expect(routingForms.length).toBeGreaterThan(0);
+          expect(routingForms[0].disabled).toEqual(false);
+        });
+    });
+  });
+});

apps/api/v2/src/modules/organizations/teams/routing-forms/controllers/organizations-teams-routing-forms.controller.ts

@@ -0,0 +1,58 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { API_KEY_HEADER } from "@/lib/docs/headers";
+import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+import { IsAdminAPIEnabledGuard } from "@/modules/auth/guards/organizations/is-admin-api-enabled.guard";
+import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
+import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
+import { IsTeamInOrg } from "@/modules/auth/guards/teams/is-team-in-org.guard";
+import { GetRoutingFormResponsesParams } from "@/modules/organizations/routing-forms/inputs/get-routing-form-responses-params.input";
+import {
+  GetRoutingFormsOutput,
+  RoutingFormOutput,
+} from "@/modules/organizations/routing-forms/outputs/get-routing-forms.output";
+import { OrganizationsTeamsRoutingFormsService } from "@/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms.service";
+import { Controller, Get, Param, Query, UseGuards, ParseIntPipe } from "@nestjs/common";
+import { ApiHeader, ApiOperation, ApiTags } from "@nestjs/swagger";
+import { plainToClass } from "class-transformer";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+@Controller({
+  path: "/v2/organizations/:orgId/teams/:teamId/routing-forms",
+  version: API_VERSIONS_VALUES,
+})
+@UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+@ApiTags("Orgs / Teams / Routing forms")
+@ApiHeader(API_KEY_HEADER)
+export class OrganizationsTeamsRoutingFormsController {
+  constructor(
+    private readonly organizationsTeamsRoutingFormsService: OrganizationsTeamsRoutingFormsService
+  ) {}
+
+  @Get()
+  @ApiOperation({ summary: "Get team routing forms" })
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  async getTeamRoutingForms(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Query() queryParams: GetRoutingFormResponsesParams
+  ): Promise<GetRoutingFormsOutput> {
+    const { skip, take, ...filters } = queryParams;
+
+    const routingForms = await this.organizationsTeamsRoutingFormsService.getTeamRoutingForms(
+      teamId,
+      skip ?? 0,
+      take ?? 250,
+      { ...(filters ?? {}) }
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: routingForms.map((form) => plainToClass(RoutingFormOutput, form)),
+    };
+  }
+}

apps/api/v2/src/modules/organizations/teams/routing-forms/organizations-teams-routing-forms-responses.module.ts

@@ -1,17 +0,0 @@
-import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
-import { OrganizationsTeamsRepository } from "@/modules/organizations/teams/index/organizations-teams.repository";
-import { PrismaModule } from "@/modules/prisma/prisma.module";
-import { RedisModule } from "@/modules/redis/redis.module";
-import { RoutingFormsResponsesModule } from "@/modules/routing-forms-responses/routing-forms-responses.module";
-import { RoutingFormsModule } from "@/modules/routing-forms/routing-forms.module";
-import { StripeModule } from "@/modules/stripe/stripe.module";
-import { Module } from "@nestjs/common";
-
-import { OrganizationsTeamsRoutingFormsResponsesController } from "./controllers/organizations-teams-routing-forms-responses.controller";
-
-@Module({
-  imports: [PrismaModule, StripeModule, RedisModule, RoutingFormsResponsesModule, RoutingFormsModule],
-  providers: [OrganizationsRepository, OrganizationsTeamsRepository],
-  controllers: [OrganizationsTeamsRoutingFormsResponsesController],
-})
-export class OrganizationsTeamsRoutingFormsModule {}

apps/api/v2/src/modules/organizations/teams/routing-forms/organizations-teams-routing-forms.module.ts

@@ -0,0 +1,36 @@
+import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
+import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
+import { OrganizationsRoutingFormsRepository } from "@/modules/organizations/routing-forms/organizations-routing-forms.repository";
+import { OrganizationsRoutingFormsResponsesService } from "@/modules/organizations/routing-forms/services/organizations-routing-forms-responses.service";
+import { OrganizationsTeamsRepository } from "@/modules/organizations/teams/index/organizations-teams.repository";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { RedisModule } from "@/modules/redis/redis.module";
+import { RoutingFormsModule } from "@/modules/routing-forms/routing-forms.module";
+import { StripeModule } from "@/modules/stripe/stripe.module";
+import { Module } from "@nestjs/common";
+
+import { OrganizationsTeamsRoutingFormsResponsesController } from "./controllers/organizations-teams-routing-forms-responses.controller";
+import { OrganizationsTeamsRoutingFormsController } from "./controllers/organizations-teams-routing-forms.controller";
+import { OrganizationsTeamsRoutingFormsResponsesRepository } from "./repositories/organizations-teams-routing-forms-responses.repository";
+import { OrganizationsTeamsRoutingFormsRepository } from "./repositories/organizations-teams-routing-forms.repository";
+import { OrganizationsTeamsRoutingFormsResponsesOutputService } from "./services/organizations-teams-routing-forms-responses-output.service";
+import { OrganizationsTeamsRoutingFormsResponsesService } from "./services/organizations-teams-routing-forms-responses.service";
+import { OrganizationsTeamsRoutingFormsService } from "./services/organizations-teams-routing-forms.service";
+
+@Module({
+  imports: [PrismaModule, StripeModule, RedisModule, RoutingFormsModule],
+  providers: [
+    OrganizationsTeamsRoutingFormsService,
+    OrganizationsTeamsRoutingFormsResponsesService,
+    OrganizationsTeamsRoutingFormsResponsesOutputService,
+    OrganizationsTeamsRoutingFormsResponsesRepository,
+    OrganizationsTeamsRoutingFormsRepository,
+    OrganizationsRepository,
+    OrganizationsTeamsRepository,
+    MembershipsRepository,
+    OrganizationsRoutingFormsResponsesService,
+    OrganizationsRoutingFormsRepository,
+  ],
+  controllers: [OrganizationsTeamsRoutingFormsResponsesController, OrganizationsTeamsRoutingFormsController],
+})
+export class OrganizationsTeamsRoutingFormsModule {}

apps/api/v2/src/modules/organizations/teams/routing-forms/repositories/organizations-teams-routing-forms-responses.repository.ts

@@ -0,0 +1,60 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsTeamsRoutingFormsResponsesRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getTeamRoutingFormResponses(
+    teamId: number,
+    routingFormId: string,
+    skip: number,
+    take: number,
+    options?: {
+      sortCreatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      routedToBookingUid?: string;
+    }
+  ) {
+    const { sortCreatedAt, afterCreatedAt, beforeCreatedAt, routedToBookingUid } = options || {};
+
+    return this.dbRead.prisma.app_RoutingForms_FormResponse.findMany({
+      where: {
+        formId: routingFormId,
+        form: {
+          teamId,
+        },
+        ...(afterCreatedAt && { createdAt: { gte: afterCreatedAt } }),
+        ...(beforeCreatedAt && { createdAt: { lte: beforeCreatedAt } }),
+        ...(routedToBookingUid && { routedToBookingUid }),
+      },
+      orderBy: [...(sortCreatedAt ? [{ createdAt: sortCreatedAt }] : [])],
+      skip,
+      take,
+    });
+  }
+
+  async updateTeamRoutingFormResponse(
+    teamId: number,
+    routingFormId: string,
+    responseId: number,
+    data: {
+      response?: Record<string, any>;
+    }
+  ) {
+    return this.dbWrite.prisma.app_RoutingForms_FormResponse.update({
+      where: {
+        id: responseId,
+        formId: routingFormId,
+        form: {
+          teamId,
+        },
+      },
+      data: {
+        ...data,
+      },
+    });
+  }
+}

apps/api/v2/src/modules/organizations/teams/routing-forms/repositories/organizations-teams-routing-forms.repository.ts

@@ -0,0 +1,53 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsTeamsRoutingFormsRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getTeamRoutingForms(
+    teamId: number,
+    skip: number,
+    take: number,
+    options?: {
+      disabled?: boolean;
+      name?: string;
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+    }
+  ) {
+    const {
+      disabled,
+      name,
+      sortCreatedAt,
+      sortUpdatedAt,
+      afterCreatedAt,
+      beforeCreatedAt,
+      afterUpdatedAt,
+      beforeUpdatedAt,
+    } = options || {};
+
+    return this.dbRead.prisma.app_RoutingForms_Form.findMany({
+      where: {
+        teamId,
+        ...(disabled !== undefined && { disabled }),
+        ...(name && { name: { contains: name, mode: "insensitive" } }),
+        ...(afterCreatedAt && { createdAt: { gte: afterCreatedAt } }),
+        ...(beforeCreatedAt && { createdAt: { lte: beforeCreatedAt } }),
+        ...(afterUpdatedAt && { updatedAt: { gte: afterUpdatedAt } }),
+        ...(beforeUpdatedAt && { updatedAt: { lte: beforeUpdatedAt } }),
+      },
+      orderBy: [
+        ...(sortCreatedAt ? [{ createdAt: sortCreatedAt }] : []),
+        ...(sortUpdatedAt ? [{ updatedAt: sortUpdatedAt }] : []),
+      ],
+      skip,
+      take,
+    });
+  }
+}

apps/api/v2/src/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms-responses-output.service.ts

@@ -5,7 +5,7 @@ import { RoutingFormResponseOutput, RoutingFormResponseResponseOutput } from "@c
 import { App_RoutingForms_FormResponse } from "@calcom/prisma/client";
 
 @Injectable()
-export class RoutingFormsResponsesOutputService {
+export class OrganizationsTeamsRoutingFormsResponsesOutputService {
   getRoutingFormResponses(
     dbRoutingFormResponses: App_RoutingForms_FormResponse[]
   ): RoutingFormResponseOutput[] {

apps/api/v2/src/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms-responses.service.ts

@@ -0,0 +1,56 @@
+import { OrganizationsTeamsRoutingFormsResponsesOutputService } from "@/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms-responses-output.service";
+import { Injectable } from "@nestjs/common";
+
+import { OrganizationsTeamsRoutingFormsResponsesRepository } from "../repositories/organizations-teams-routing-forms-responses.repository";
+
+@Injectable()
+export class OrganizationsTeamsRoutingFormsResponsesService {
+  constructor(
+    private readonly routingFormsRepository: OrganizationsTeamsRoutingFormsResponsesRepository,
+    private readonly routingFormsResponsesOutputService: OrganizationsTeamsRoutingFormsResponsesOutputService
+  ) {}
+
+  async getTeamRoutingFormResponses(
+    teamId: number,
+    routingFormId: string,
+    skip: number,
+    take: number,
+    options?: {
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+      routedToBookingUid?: string;
+    }
+  ) {
+    const responses = await this.routingFormsRepository.getTeamRoutingFormResponses(
+      teamId,
+      routingFormId,
+      skip,
+      take,
+      options
+    );
+
+    return this.routingFormsResponsesOutputService.getRoutingFormResponses(responses);
+  }
+
+  async updateTeamRoutingFormResponse(
+    teamId: number,
+    routingFormId: string,
+    responseId: number,
+    data: {
+      response?: Record<string, any>;
+    }
+  ) {
+    const updatedResponse = await this.routingFormsRepository.updateTeamRoutingFormResponse(
+      teamId,
+      routingFormId,
+      responseId,
+      data
+    );
+
+    return this.routingFormsResponsesOutputService.getRoutingFormResponses([updatedResponse])[0];
+  }
+}

apps/api/v2/src/modules/organizations/teams/routing-forms/services/organizations-teams-routing-forms.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from "@nestjs/common";
+
+import { OrganizationsTeamsRoutingFormsRepository } from "../repositories/organizations-teams-routing-forms.repository";
+
+@Injectable()
+export class OrganizationsTeamsRoutingFormsService {
+  constructor(private readonly routingFormsRepository: OrganizationsTeamsRoutingFormsRepository) {}
+
+  async getTeamRoutingForms(
+    teamId: number,
+    skip: number,
+    take: number,
+    options?: {
+      disabled?: boolean;
+      name?: string;
+      sortCreatedAt?: "asc" | "desc";
+      sortUpdatedAt?: "asc" | "desc";
+      afterCreatedAt?: string;
+      beforeCreatedAt?: string;
+      afterUpdatedAt?: string;
+      beforeUpdatedAt?: string;
+    }
+  ) {
+    return this.routingFormsRepository.getTeamRoutingForms(teamId, skip, take, options);
+  }
+}

apps/api/v2/src/modules/organizations/users/bookings/controllers/organizations-users-bookings-controller.ts

@@ -1,6 +1,10 @@
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import {
+  OPTIONAL_X_CAL_CLIENT_ID_HEADER,
+  OPTIONAL_X_CAL_SECRET_KEY_HEADER,
+  OPTIONAL_API_KEY_OR_ACCESS_TOKEN_HEADER,
+} from "@/lib/docs/headers";
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
-import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
 import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
@@ -10,11 +14,10 @@ import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
 import { IsUserInOrg } from "@/modules/auth/guards/users/is-user-in-org.guard";
 import { OrganizationUsersBookingsService } from "@/modules/organizations/users/bookings/services/organization-users-bookings.service";
 import { Controller, UseGuards, Get, Query, ParseIntPipe, Param } from "@nestjs/common";
-import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiHeader, ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import { GetBookingsInput_2024_08_13, GetBookingsOutput_2024_08_13 } from "@calcom/platform-types";
-import { User } from "@calcom/prisma/client";
 
 @Controller({
   path: "/v2/organizations/:orgId/users/:userId/bookings",
@@ -22,6 +25,9 @@ import { User } from "@calcom/prisma/client";
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsUserInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
 @DocsTags("Orgs / Users / Bookings")
+@ApiHeader(OPTIONAL_X_CAL_CLIENT_ID_HEADER)
+@ApiHeader(OPTIONAL_X_CAL_SECRET_KEY_HEADER)
+@ApiHeader(OPTIONAL_API_KEY_OR_ACCESS_TOKEN_HEADER)
 export class OrganizationsUsersBookingsController {
   constructor(private readonly organizationUsersBookingsService: OrganizationUsersBookingsService) {}
 
@@ -30,13 +36,13 @@ export class OrganizationsUsersBookingsController {
   @PlatformPlan("ESSENTIALS")
   @ApiOperation({ summary: "Get all bookings of an organization user" })
   async getOrganizationUserBookings(
-    @GetUser() user: User,
     @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("userId", ParseIntPipe) userId: number,
     @Query() query: GetBookingsInput_2024_08_13
   ): Promise<GetBookingsOutput_2024_08_13> {
     const bookings = await this.organizationUsersBookingsService.getOrganizationUserBookings(
       orgId,
-      user,
+      userId,
       query
     );
 

apps/api/v2/src/modules/organizations/users/bookings/services/organization-users-bookings.service.ts

@@ -1,18 +1,21 @@
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
-import { Injectable } from "@nestjs/common";
+import { UsersRepository } from "@/modules/users/users.repository";
+import { Injectable, NotFoundException } from "@nestjs/common";
 
 import { GetBookingsInput_2024_08_13 } from "@calcom/platform-types";
-import { User } from "@calcom/prisma/client";
 
 @Injectable()
 export class OrganizationUsersBookingsService {
-  constructor(private readonly bookingsService: BookingsService_2024_08_13) {}
+  constructor(
+    private readonly bookingsService: BookingsService_2024_08_13,
+    private readonly usersRepository: UsersRepository
+  ) {}
 
-  async getOrganizationUserBookings(
-    orgId: number,
-    user: Pick<User, "id" | "email">,
-    queryParams: GetBookingsInput_2024_08_13
-  ) {
+  async getOrganizationUserBookings(orgId: number, userId: number, queryParams: GetBookingsInput_2024_08_13) {
+    const user = await this.usersRepository.findById(userId);
+    if (!user) {
+      throw new NotFoundException(`getOrganizationUserBookings - User ${userId} not found`);
+    }
     return await this.bookingsService.getBookings(queryParams, { orgId, id: user.id, email: user.email });
   }
 }

apps/api/v2/src/modules/routing-forms-responses/routing-forms-responses.module.ts

@@ -1,20 +0,0 @@
-import { PrismaModule } from "@/modules/prisma/prisma.module";
-import { RoutingFormsResponsesRepository } from "@/modules/routing-forms-responses/routing-forms-responses.repository";
-import { RoutingFormsResponsesOutputService } from "@/modules/routing-forms-responses/services/routing-forms-responses-output.service";
-import { RoutingFormsResponsesService } from "@/modules/routing-forms-responses/services/routing-forms-responses.service";
-import { Module } from "@nestjs/common";
-
-@Module({
-  imports: [PrismaModule],
-  providers: [
-    RoutingFormsResponsesService,
-    RoutingFormsResponsesRepository,
-    RoutingFormsResponsesOutputService,
-  ],
-  exports: [
-    RoutingFormsResponsesService,
-    RoutingFormsResponsesRepository,
-    RoutingFormsResponsesOutputService,
-  ],
-})
-export class RoutingFormsResponsesModule {}

apps/api/v2/src/modules/routing-forms-responses/routing-forms-responses.repository.ts

@@ -1,18 +0,0 @@
-import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
-import { Injectable } from "@nestjs/common";
-
-@Injectable()
-export class RoutingFormsResponsesRepository {
-  constructor(private readonly dbRead: PrismaReadService) {}
-
-  async getRoutingFormResponses(routingFormId: string) {
-    return this.dbRead.prisma.app_RoutingForms_FormResponse.findMany({
-      where: {
-        formId: routingFormId,
-      },
-      orderBy: {
-        createdAt: "desc",
-      },
-    });
-  }
-}

apps/api/v2/src/modules/routing-forms-responses/services/routing-forms-responses.service.ts

@@ -1,17 +0,0 @@
-import { RoutingFormsResponsesOutputService } from "@/modules/routing-forms-responses/services/routing-forms-responses-output.service";
-import { Injectable } from "@nestjs/common";
-
-import { RoutingFormsResponsesRepository } from "../routing-forms-responses.repository";
-
-@Injectable()
-export class RoutingFormsResponsesService {
-  constructor(
-    private readonly routingFormsRepository: RoutingFormsResponsesRepository,
-    private readonly routingFormsResponsesOutputService: RoutingFormsResponsesOutputService
-  ) {}
-
-  async getRoutingFormResponses(routingFormId: string) {
-    const responses = await this.routingFormsRepository.getRoutingFormResponses(routingFormId);
-    return this.routingFormsResponsesOutputService.getRoutingFormResponses(responses);
-  }
-}

apps/api/v2/src/modules/routing-forms/controllers/routing-forms.controller.ts

@@ -0,0 +1,44 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { API_KEY_HEADER } from "@/lib/docs/headers";
+import { ResponseSlotsOutput } from "@/modules/routing-forms/outputs/response-slots.output";
+import { RoutingFormsService } from "@/modules/routing-forms/services/routing-forms.service";
+import { Controller, HttpCode, HttpStatus, Param, Post, Query, Req } from "@nestjs/common";
+import { ApiHeader, ApiOperation, ApiTags } from "@nestjs/swagger";
+import { Request } from "express";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { GetAvailableSlotsInput_2024_09_04 } from "@calcom/platform-types";
+
+@Controller({
+  path: "/v2/routing-forms/:routingFormId",
+  version: API_VERSIONS_VALUES,
+})
+@ApiTags("Routing forms")
+@ApiHeader(API_KEY_HEADER)
+export class RoutingFormsController {
+  constructor(private readonly routingFormsService: RoutingFormsService) {}
+
+  @Post("/calculate-slots")
+  @ApiOperation({
+    summary: "Calculate slots based on routing form response",
+    description:
+      "It will not actually save the response just return the routed event type and slots when it can be booked.",
+  })
+  @HttpCode(HttpStatus.OK)
+  async calculateSlotsBasedOnRoutingFormResponse(
+    @Req() request: Request,
+    @Query() query: GetAvailableSlotsInput_2024_09_04,
+    @Param("routingFormId") routingFormId: string
+  ): Promise<ResponseSlotsOutput> {
+    const responseSlots = await this.routingFormsService.calculateSlotsBasedOnRoutingFormResponse(
+      request,
+      routingFormId,
+      query
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: responseSlots,
+    };
+  }
+}

apps/api/v2/src/modules/routing-forms/controllers/routing-forms.e2e-spec.ts

@@ -0,0 +1,355 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { SchedulesModule_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.module";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import {
+  ResponseSlotsOutput,
+  ResponseSlotsOutputData,
+} from "@/modules/routing-forms/outputs/response-slots.output";
+import { SlotsModule_2024_09_04 } from "@/modules/slots/slots-2024-09-04/slots.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { App_RoutingForms_Form, EventType, User } from "@prisma/client";
+import * as request from "supertest";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { RoutingFormsRepositoryFixture } from "test/fixtures/repository/routing-forms.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { randomString } from "test/utils/randomString";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { Team } from "@calcom/prisma/client";
+
+describe("Routing forms endpoints", () => {
+  let app: INestApplication;
+
+  let userRepositoryFixture: UserRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+  let membershipsRepositoryFixture: MembershipRepositoryFixture;
+  let routingFormsRepositoryFixture: RoutingFormsRepositoryFixture;
+
+  const teammateEmailTwo = `routing-forms-teammate-1-${randomString()}`;
+  const teammateEmailOne = `routing-forms-teammate-2-${randomString()}`;
+
+  let team: Team;
+  let teammateOne: User;
+  let teammateTwo: User;
+  let collectiveEventTypeFootball: EventType;
+  let collectiveEventTypeBasketball: EventType;
+
+  let routingForm: App_RoutingForms_Form;
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        AppModule,
+        PrismaModule,
+        UsersModule,
+        TokensModule,
+        SchedulesModule_2024_06_11,
+        SlotsModule_2024_09_04,
+      ],
+    })
+      .overrideGuard(PermissionsGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+      .compile();
+
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+    membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+    routingFormsRepositoryFixture = new RoutingFormsRepositoryFixture(moduleRef);
+
+    teammateOne = await userRepositoryFixture.create({
+      email: teammateEmailOne,
+      name: teammateEmailOne,
+      username: teammateEmailOne,
+    });
+
+    teammateTwo = await userRepositoryFixture.create({
+      email: teammateEmailTwo,
+      name: teammateEmailTwo,
+      username: teammateEmailTwo,
+    });
+
+    const teamSlug = `routing-forms-team-${randomString()}`;
+    team = await teamRepositoryFixture.create({
+      name: teamSlug,
+      slug: teamSlug,
+      isOrganization: false,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "MEMBER",
+      user: { connect: { id: teammateOne.id } },
+      team: { connect: { id: team.id } },
+      accepted: true,
+    });
+
+    await membershipsRepositoryFixture.create({
+      role: "MEMBER",
+      user: { connect: { id: teammateTwo.id } },
+      team: { connect: { id: team.id } },
+      accepted: true,
+    });
+
+    const collectiveEventTypeFootballSlug = `routing-forms-collective-event-type-football-${randomString()}`;
+    collectiveEventTypeFootball = await eventTypesRepositoryFixture.createTeamEventType({
+      schedulingType: "COLLECTIVE",
+      team: {
+        connect: { id: team.id },
+      },
+      title: "Collective Event Type Football",
+      slug: collectiveEventTypeFootballSlug,
+      length: 60,
+      assignAllTeamMembers: true,
+      bookingFields: [],
+      locations: [],
+      schedule: {
+        create: {
+          name: "football",
+          timeZone: "Europe/London",
+          user: { connect: { id: teammateOne.id } },
+          availability: {
+            create: {
+              days: [1],
+              startTime: new Date("1970-01-01T09:00:00Z"),
+              endTime: new Date("1970-01-01T11:00:00Z"),
+            },
+          },
+        },
+      },
+      users: {
+        connect: [{ id: teammateOne.id }, { id: teammateTwo.id }],
+      },
+      hosts: {
+        create: [
+          {
+            userId: teammateOne.id,
+            isFixed: true,
+          },
+          {
+            userId: teammateTwo.id,
+            isFixed: true,
+          },
+        ],
+      },
+    });
+
+    const collectiveEventTypeBasketballSlug = `routing-forms-collective-event-type-basketball-${randomString()}`;
+    collectiveEventTypeBasketball = await eventTypesRepositoryFixture.createTeamEventType({
+      schedulingType: "COLLECTIVE",
+      team: {
+        connect: { id: team.id },
+      },
+      title: "Collective Event Type Basketball",
+      slug: collectiveEventTypeBasketballSlug,
+      length: 60,
+      assignAllTeamMembers: true,
+      bookingFields: [],
+      locations: [],
+      schedule: {
+        create: {
+          name: "basketball",
+          timeZone: "Europe/London",
+          user: { connect: { id: teammateTwo.id } },
+          availability: {
+            create: {
+              days: [2],
+              startTime: new Date("1970-01-01T11:00:00Z"),
+              endTime: new Date("1970-01-01T13:00:00Z"),
+            },
+          },
+        },
+      },
+      users: {
+        connect: [{ id: teammateOne.id }, { id: teammateTwo.id }],
+      },
+      hosts: {
+        create: [
+          {
+            userId: teammateOne.id,
+            isFixed: true,
+          },
+          {
+            userId: teammateTwo.id,
+            isFixed: true,
+          },
+        ],
+      },
+    });
+
+    routingForm = await routingFormsRepositoryFixture.create({
+      name: "football or basketball",
+      description: "Do you want to play football or basketball?",
+      routes: [
+        {
+          id: "baba89aa-4567-489a-bcde-f1961b1ae10c",
+          action: {
+            type: "eventTypeRedirectUrl",
+            value: `team/${team.slug}/${collectiveEventTypeFootballSlug}`,
+            eventTypeId: collectiveEventTypeFootball.id,
+          },
+          queryValue: {
+            id: "a8a8b9aa-0123-4456-b89a-b1961b1ae10c",
+            type: "group",
+            children1: {
+              "99ab8aaa-4567-489a-bcde-f1961b1ae5cd": {
+                type: "rule",
+                properties: {
+                  field: "dcd8b978-fa11-47be-801a-5ca2cd4ec16e",
+                  value: ["755c11d1-fa46-4d03-8e15-d2c4ab3407d7"],
+                  operator: "select_equals",
+                  valueSrc: ["value"],
+                  valueType: ["select"],
+                  valueError: [null],
+                },
+              },
+            },
+          },
+          attributesQueryValue: { id: "b8998aab-cdef-4012-b456-71961b1ae10c", type: "group" },
+          attributeRoutingConfig: {},
+          fallbackAttributesQueryValue: { id: "ab98888a-89ab-4cde-b012-31961b1ae10c", type: "group" },
+        },
+        {
+          id: "88a98b98-0123-4456-b89a-b1961b1b1a04",
+          action: {
+            type: "eventTypeRedirectUrl",
+            value: `team/${team.slug}/${collectiveEventTypeBasketballSlug}`,
+            eventTypeId: collectiveEventTypeBasketball.id,
+          },
+          queryValue: {
+            id: "bab8b9a8-cdef-4012-b456-71961b1b1a04",
+            type: "group",
+            children1: {
+              "9988a98a-0123-4456-b89a-b1961b1b1f8b": {
+                type: "rule",
+                properties: {
+                  field: "dcd8b978-fa11-47be-801a-5ca2cd4ec16e",
+                  value: ["4cbb1537-0ab9-4286-b4bf-08b08ff23372"],
+                  operator: "select_equals",
+                  valueSrc: ["value"],
+                  valueType: ["select"],
+                  valueError: [null],
+                },
+              },
+            },
+          },
+          attributesQueryValue: { id: "99a89a9b-89ab-4cde-b012-31961b1b1a04", type: "group" },
+          attributeRoutingConfig: {},
+          fallbackAttributesQueryValue: { id: "88989a98-4567-489a-bcde-f1961b1b1a04", type: "group" },
+        },
+        {
+          id: "9b9ab9bb-cdef-4012-b456-71961b1a8b78",
+          action: {
+            type: "customPageMessage",
+            value: "Thank you for your interest! We will be in touch soon.",
+          },
+          isFallback: true,
+          queryValue: { id: "9b9ab9bb-cdef-4012-b456-71961b1a8b78", type: "group" },
+          attributesQueryValue: { id: "88b988ab-cdef-4012-b456-71961b1ad81a", type: "group" },
+          fallbackAttributesQueryValue: { id: "a8b89a9a-89ab-4cde-b012-31961b1ad81a", type: "group" },
+        },
+      ],
+      createdAt: new Date("2025-04-09T15:10:46.651Z"),
+      updatedAt: new Date("2025-04-09T15:11:37.696Z"),
+      fields: [
+        {
+          id: "dcd8b978-fa11-47be-801a-5ca2cd4ec16e",
+          type: "select",
+          label: "sport",
+          options: [
+            { id: "755c11d1-fa46-4d03-8e15-d2c4ab3407d7", label: "football" },
+            { id: "4cbb1537-0ab9-4286-b4bf-08b08ff23372", label: "basketball" },
+          ],
+          required: true,
+        },
+      ],
+      user: {
+        connect: { id: teammateOne.id },
+      },
+      disabled: false,
+      settings: { emailOwnerOnSubmission: true },
+      team: {
+        connect: { id: team.id },
+      },
+      position: 0,
+    });
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    await app.init();
+  });
+
+  describe("Calculate slots", () => {
+    const slotsQuery = "start=2060-01-12&end=2060-01-16";
+
+    it("should return correct slots for option 1", async () => {
+      const body = {
+        sport: "football",
+      };
+
+      const reserveResponse = await request(app.getHttpServer())
+        .post(`/v2/routing-forms/${routingForm.id}/calculate-slots?${slotsQuery}`)
+        .send(body)
+        .expect(200);
+
+      const responseBody: ResponseSlotsOutput = reserveResponse.body;
+      expect(responseBody.status).toEqual(SUCCESS_STATUS);
+      const responseBodyData: ResponseSlotsOutputData = responseBody.data;
+      expect(responseBodyData.eventTypeId).toEqual(collectiveEventTypeFootball.id);
+      expect(responseBodyData.slots).toEqual({
+        "2060-01-12": [
+          {
+            start: "2060-01-12T09:00:00.000Z",
+          },
+          {
+            start: "2060-01-12T10:00:00.000Z",
+          },
+        ],
+      });
+    });
+
+    it("should return correct slots for option 2", async () => {
+      const body = {
+        sport: "basketball",
+      };
+
+      const reserveResponse = await request(app.getHttpServer())
+        .post(`/v2/routing-forms/${routingForm.id}/calculate-slots?${slotsQuery}`)
+        .send(body)
+        .expect(200);
+
+      const responseBody: ResponseSlotsOutput = reserveResponse.body;
+      expect(responseBody.status).toEqual(SUCCESS_STATUS);
+      const responseBodyData: ResponseSlotsOutputData = responseBody.data;
+      expect(responseBodyData.eventTypeId).toEqual(collectiveEventTypeBasketball.id);
+      expect(responseBodyData.slots).toEqual({
+        "2060-01-13": [
+          {
+            start: "2060-01-13T11:00:00.000Z",
+          },
+          {
+            start: "2060-01-13T12:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+
+  afterAll(async () => {
+    await userRepositoryFixture.deleteByEmail(teammateOne.email);
+    await userRepositoryFixture.deleteByEmail(teammateTwo.email);
+    await teamRepositoryFixture.delete(team.id);
+    await app.close();
+  });
+});

apps/api/v2/src/modules/routing-forms/outputs/response-slots.output.ts

@@ -0,0 +1,32 @@
+import { ApiExtraModels, ApiProperty, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsNumber, ValidateNested } from "class-validator";
+
+import { ApiResponseWithoutData, SlotsOutput_2024_09_04 } from "@calcom/platform-types";
+import { RangeSlotsOutput_2024_09_04 } from "@calcom/platform-types";
+
+@ApiExtraModels(SlotsOutput_2024_09_04, RangeSlotsOutput_2024_09_04)
+export class ResponseSlotsOutputData {
+  @IsNumber()
+  @ApiProperty()
+  eventTypeId!: number;
+
+  @ValidateNested()
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(SlotsOutput_2024_09_04) },
+      { $ref: getSchemaPath(RangeSlotsOutput_2024_09_04) },
+    ],
+  })
+  @Type(() => Object)
+  slots!: SlotsOutput_2024_09_04 | RangeSlotsOutput_2024_09_04;
+}
+
+export class ResponseSlotsOutput extends ApiResponseWithoutData {
+  @ValidateNested()
+  @ApiProperty({
+    type: ResponseSlotsOutputData,
+  })
+  @Type(() => ResponseSlotsOutputData)
+  data!: ResponseSlotsOutputData;
+}

apps/api/v2/src/modules/routing-forms/routing-forms.module.ts

@@ -1,10 +1,17 @@
+import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { RoutingFormsController } from "@/modules/routing-forms/controllers/routing-forms.controller";
 import { RoutingFormsRepository } from "@/modules/routing-forms/routing-forms.repository";
+import { RoutingFormsService } from "@/modules/routing-forms/services/routing-forms.service";
+import { SlotsModule_2024_09_04 } from "@/modules/slots/slots-2024-09-04/slots.module";
+import { StripeModule } from "@/modules/stripe/stripe.module";
+import { TeamsEventTypesModule } from "@/modules/teams/event-types/teams-event-types.module";
 import { Module } from "@nestjs/common";
 
 @Module({
-  imports: [PrismaModule],
-  providers: [RoutingFormsRepository],
+  imports: [PrismaModule, TeamsEventTypesModule, SlotsModule_2024_09_04, StripeModule],
+  providers: [RoutingFormsRepository, RoutingFormsService, OrganizationsRepository],
+  controllers: [RoutingFormsController],
   exports: [RoutingFormsRepository],
 })
 export class RoutingFormsModule {}

apps/api/v2/src/modules/routing-forms/services/routing-forms.service.ts

@@ -0,0 +1,96 @@
+import { SlotsService_2024_09_04 } from "@/modules/slots/slots-2024-09-04/services/slots.service";
+import { TeamsEventTypesRepository } from "@/modules/teams/event-types/teams-event-types.repository";
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { Request } from "express";
+
+import { getRoutedUrl } from "@calcom/platform-libraries";
+import { ById_2024_09_04_type, GetAvailableSlotsInput_2024_09_04 } from "@calcom/platform-types";
+
+@Injectable()
+export class RoutingFormsService {
+  constructor(
+    private readonly teamsEventTypesRepository: TeamsEventTypesRepository,
+    private readonly slotsService: SlotsService_2024_09_04
+  ) {}
+
+  async calculateSlotsBasedOnRoutingFormResponse(
+    request: Request,
+    formId: string,
+    slotsQuery: GetAvailableSlotsInput_2024_09_04
+  ) {
+    const eventTypeId = await this.getRoutedEventTypeId(request, formId);
+
+    if (!eventTypeId) {
+      throw new NotFoundException("Event type not found.");
+    }
+
+    const slots = await this.slotsService.getAvailableSlots({
+      type: ById_2024_09_04_type,
+      eventTypeId,
+      ...slotsQuery,
+    });
+
+    return {
+      eventTypeId,
+      slots,
+    };
+  }
+
+  private async getRoutedEventTypeId(request: Request, formId: string) {
+    const routingUrl = await this.getRoutingUrl(request, formId);
+    if (!this.isEventTypeRedirectUrl(routingUrl)) {
+      throw new NotFoundException("Routed to a non cal.com event type URL.");
+    }
+
+    const { teamId, eventTypeSlug } = this.extractTeamIdAndEventTypeSlugFromRedirectUrl(routingUrl);
+
+    const eventType = await this.teamsEventTypesRepository.getEventTypeByTeamIdAndSlug(teamId, eventTypeSlug);
+    return eventType?.id;
+  }
+
+  private async getRoutingUrl(request: Request, formId: string) {
+    const params = Object.fromEntries(new URLSearchParams(request.body));
+    const routedUrlData = await getRoutedUrl({
+      req: request,
+      query: { ...params, "cal.isBookingDryRun": "true", form: formId },
+    });
+
+    const destination = routedUrlData?.redirect?.destination;
+
+    if (!destination) {
+      throw new NotFoundException("Route to which the form response should be redirected not found.");
+    }
+
+    return new URL(destination);
+  }
+
+  private extractTeamIdAndEventTypeSlugFromRedirectUrl(routingUrl: URL) {
+    const eventTypeSlug = this.extractEventTypeFromRoutedUrl(routingUrl);
+    const teamId = this.extractTeamIdFromRoutedUrl(routingUrl);
+
+    if (!teamId) {
+      throw new NotFoundException("Team ID not found in the routed URL.");
+    }
+
+    if (!eventTypeSlug) {
+      throw new NotFoundException("Event type slug not found in the routed URL.");
+    }
+
+    return { teamId, eventTypeSlug };
+  }
+
+  private isEventTypeRedirectUrl(routingUrl: URL) {
+    const routingSearchParams = routingUrl.searchParams;
+    return routingSearchParams.get("cal.action") === "eventTypeRedirectUrl";
+  }
+
+  private extractTeamIdFromRoutedUrl(routingUrl: URL) {
+    const routingSearchParams = routingUrl.searchParams;
+    return Number(routingSearchParams.get("cal.teamId"));
+  }
+
+  private extractEventTypeFromRoutedUrl(routingUrl: URL) {
+    const pathNameParams = routingUrl.pathname.split("/");
+    return pathNameParams[pathNameParams.length - 1];
+  }
+}

apps/api/v2/src/modules/slots/slots-2024-09-04/controllers/e2e/org-team-event-type-slots.controller.e2e-spec.ts

@@ -49,11 +49,14 @@ describe("Slots 2024-09-04 Endpoints", () => {
 
     const nonOrgUserEmailOne = `slots-2024-09-04-non-org-user-one-${randomString()}@api.com`;
 
+    const orgSlug = `slots-2024-09-04-organization-${randomString()}`;
     let organization: Team;
+    const teamSlug = `slots-2024-09-04-organization-team-${randomString()}`;
     let team: Team;
     let orgUserOne: User;
     let orgUserTwo: User;
     let collectiveEventTypeId: number;
+    let collectiveEventTypeSlug: string;
     let roundRobinEventTypeId: number;
     let collectiveBookingId: number;
     let roundRobinBookingId: number;
@@ -91,7 +94,6 @@ describe("Slots 2024-09-04 Endpoints", () => {
       membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
       bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
 
-      const orgSlug = `slots-2024-09-04-organization-${randomString()}`;
       organization = await organizationsRepositoryFixture.create({
         name: orgSlug,
         isOrganization: true,
@@ -143,7 +145,8 @@ describe("Slots 2024-09-04 Endpoints", () => {
       });
 
       team = await teamRepositoryFixture.create({
-        name: `slots-2024-09-04-team-${randomString()}`,
+        name: teamSlug,
+        slug: teamSlug,
         isOrganization: false,
         parent: { connect: { id: organization.id } },
       });
@@ -178,6 +181,7 @@ describe("Slots 2024-09-04 Endpoints", () => {
         },
       });
       collectiveEventTypeId = collectiveEventType.id;
+      collectiveEventTypeSlug = collectiveEventType.slug;
 
       const roundRobinEventType = await eventTypesRepositoryFixture.createTeamEventType({
         schedulingType: "ROUND_ROBIN",
@@ -282,6 +286,34 @@ describe("Slots 2024-09-04 Endpoints", () => {
         });
     });
 
+    it("should get collective team event slots in UTC using teamSlug, eventTypeSlug and organizationSlug", async () => {
+      return request(app.getHttpServer())
+        .get(
+          `/v2/slots?organizationSlug=${orgSlug}&teamSlug=${teamSlug}&eventTypeSlug=${collectiveEventTypeSlug}&start=2050-09-05&end=2050-09-09`
+        )
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_09_04)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: GetSlotsOutput_2024_09_04 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const slots = responseBody.data;
+
+          expect(slots).toBeDefined();
+          const days = Object.keys(slots);
+          expect(days.length).toEqual(5);
+          expect(slots).toEqual(expectedSlotsUTC);
+        });
+    });
+
+    it("should not get collective team event slots in UTC using teamSlug, eventTypeSlug if organizationSlug is missing", async () => {
+      return request(app.getHttpServer())
+        .get(
+          `/v2/slots?teamSlug=${teamSlug}&eventTypeSlug=${collectiveEventTypeSlug}&start=2050-09-05&end=2050-09-09`
+        )
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_09_04)
+        .expect(404);
+    });
+
     it("should get round robin team event slots in UTC", async () => {
       return request(app.getHttpServer())
         .get(`/v2/slots?eventTypeId=${roundRobinEventTypeId}&start=2050-09-05&end=2050-09-09`)

apps/api/v2/src/modules/slots/slots-2024-09-04/controllers/e2e/team-event-type-slots.controller.e2e-spec.ts

@@ -54,10 +54,12 @@ describe("Slots 2024-09-04 Endpoints", () => {
     let outsider: User;
     let outsiderApiKeyString: string;
 
+    const teamSlug = `slots-2024-09-04-team-${randomString()}`;
     let team: Team;
     let teammateOne: User;
     let teammateTwo: User;
     let collectiveEventTypeId: number;
+    let collectiveEventTypeSlug: string;
     let collectiveEventTypeWithoutHostsId: number;
     let roundRobinEventTypeId: number;
     let collectiveBookingId: number;
@@ -121,7 +123,8 @@ describe("Slots 2024-09-04 Endpoints", () => {
       outsiderApiKeyString = unrelatedUserKeyString;
 
       team = await teamRepositoryFixture.create({
-        name: `slots-2024-09-04-team-${randomString()}`,
+        name: teamSlug,
+        slug: teamSlug,
         isOrganization: false,
       });
 
@@ -167,6 +170,7 @@ describe("Slots 2024-09-04 Endpoints", () => {
         },
       });
       collectiveEventTypeId = collectiveEventType.id;
+      collectiveEventTypeSlug = collectiveEventType.slug;
 
       const collectiveEventTypeWithoutHosts = await eventTypesRepositoryFixture.createTeamEventType({
         schedulingType: "COLLECTIVE",
@@ -246,6 +250,25 @@ describe("Slots 2024-09-04 Endpoints", () => {
         });
     });
 
+    it("should get collective team event slots in UTC using teamSlug and eventTypeSlug", async () => {
+      return request(app.getHttpServer())
+        .get(
+          `/v2/slots?teamSlug=${teamSlug}&eventTypeSlug=${collectiveEventTypeSlug}&start=2050-09-05&end=2050-09-09`
+        )
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_09_04)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: GetSlotsOutput_2024_09_04 = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          const slots = responseBody.data;
+
+          expect(slots).toBeDefined();
+          const days = Object.keys(slots);
+          expect(days.length).toEqual(5);
+          expect(slots).toEqual(expectedSlotsUTC);
+        });
+    });
+
     it("should get round robin team event slots in UTC", async () => {
       return request(app.getHttpServer())
         .get(`/v2/slots?eventTypeId=${roundRobinEventTypeId}&start=2050-09-05&end=2050-09-09`)

apps/api/v2/src/modules/slots/slots-2024-09-04/controllers/slots.controller.ts

@@ -60,7 +60,7 @@ export class SlotsController_2024_09_04 {
   @ApiOperation({
     summary: "Find out when is an event type ready to be booked.",
     description: `
-      There are 4 ways to get available slots:
+      There are 4 ways to get available slots for event type of an individual user:
       
       1. By event type id. Event type id can be of user and team event types. Example '/v2/slots?eventTypeId=10&start=2050-09-05&end=2050-09-06&timeZone=Europe/Rome'
 
@@ -70,6 +70,14 @@ export class SlotsController_2024_09_04 {
 
       4. By usernames only (used for dynamic event type - there is no specific event but you want to know when 2 or more people are available). Example '/v2/slots?usernames=alice,bob&username=bob&organizationSlug=org-slug&start=2050-09-05&end=2050-09-06'. As you see you also need to provide the slug of the organization to which each user in the 'usernames' array belongs.
 
+      And 3 ways to get available slots for team event type:
+
+      1. By team event type id. Example '/v2/slots?teamEventTypeId=10&start=2050-09-05&end=2050-09-06&timeZone=Europe/Rome'
+
+      2. By team event type slug + team slug. Example '/v2/slots?eventTypeSlug=intro&teamSlug=team-slug&start=2050-09-05&end=2050-09-06'
+
+      3. By team event type slug + team slug + organization slug when searching within an organization. Example '/v2/slots?organizationSlug=org-slug&eventTypeSlug=intro&teamSlug=team-slug&start=2050-09-05&end=2050-09-06'
+
       All of them require "start" and "end" query parameters which define the time range for which available slots should be checked.
       Optional parameters are:
       - timeZone: Time zone in which the available slots should be returned. Defaults to UTC.
@@ -117,19 +125,28 @@ export class SlotsController_2024_09_04 {
     name: "eventTypeSlug",
     required: false,
     description:
-      "The slug of the event type for which available slots should be checked. If slug is provided then username must be provided too and if relevant organizationSlug too.",
+      "The slug of the event type for which available slots should be checked. If slug is provided then username or teamSlug must be provided too and if relevant organizationSlug too.",
     example: "event-type-slug",
   })
   @ApiQuery({
     name: "username",
     required: false,
-    description: "The username of the user to get event types for.",
+    description:
+      "The username of the user who owns event type with eventTypeSlug - used when slots are checked for individual user event type.",
     example: "bob",
   })
+  @ApiQuery({
+    name: "teamSlug",
+    required: false,
+    description:
+      "The slug of the team who owns event type with eventTypeSlug - used when slots are checked for team event type.",
+    example: "team-slug",
+  })
   @ApiQuery({
     name: "organizationSlug",
     required: false,
-    description: "The slug of the organization to which user with username belongs.",
+    description:
+      "The slug of the organization to which user with username belongs or team with teamSlug belongs.",
     example: "org-slug",
   })
   @ApiQuery({

apps/api/v2/src/modules/slots/slots-2024-09-04/services/slots-input.service.ts

@@ -1,12 +1,23 @@
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
+import { OrganizationsTeamsRepository } from "@/modules/organizations/teams/index/organizations-teams.repository";
 import { OrganizationsUsersRepository } from "@/modules/organizations/users/index/organizations-users.repository";
+import { TeamsEventTypesRepository } from "@/modules/teams/event-types/teams-event-types.repository";
+import { TeamsRepository } from "@/modules/teams/teams/teams.repository";
 import { UsersRepository } from "@/modules/users/users.repository";
 import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
 import { DateTime } from "luxon";
 
 import { dynamicEvent } from "@calcom/platform-libraries";
-import { GetSlotsInput_2024_09_04 } from "@calcom/platform-types";
+import {
+  ById_2024_09_04,
+  ByUsernameAndEventTypeSlug_2024_09_04,
+  ByTeamSlugAndEventTypeSlug_2024_09_04,
+  GetSlotsInput_2024_09_04,
+  ById_2024_09_04_type,
+  ByUsernameAndEventTypeSlug_2024_09_04_type,
+  ByTeamSlugAndEventTypeSlug_2024_09_04_type,
+} from "@calcom/platform-types";
 
 @Injectable()
 export class SlotsInputService_2024_09_04 {
@@ -14,7 +25,10 @@ export class SlotsInputService_2024_09_04 {
     private readonly eventTypeRepository: EventTypesRepository_2024_06_14,
     private readonly usersRepository: UsersRepository,
     private readonly organizationsUsersRepository: OrganizationsUsersRepository,
-    private readonly organizationsRepository: OrganizationsRepository
+    private readonly organizationsTeamsRepository: OrganizationsTeamsRepository,
+    private readonly organizationsRepository: OrganizationsRepository,
+    private readonly teamsRepository: TeamsRepository,
+    private readonly teamsEventTypesRepository: TeamsEventTypesRepository
   ) {}
 
   async transformGetSlotsQuery(query: GetSlotsInput_2024_09_04) {
@@ -47,11 +61,11 @@ export class SlotsInputService_2024_09_04 {
   }
 
   private async getEventType(input: GetSlotsInput_2024_09_04) {
-    if ("eventTypeId" in input) {
+    if (input.type === ById_2024_09_04_type) {
       return this.eventTypeRepository.getEventTypeById(input.eventTypeId);
     }
 
-    if ("eventTypeSlug" in input) {
+    if (input.type === ByUsernameAndEventTypeSlug_2024_09_04_type) {
       const user = await this.getEventTypeUser(input);
       if (!user) {
         throw new NotFoundException(`User with username ${input.username} not found`);
@@ -59,27 +73,48 @@ export class SlotsInputService_2024_09_04 {
       return this.eventTypeRepository.getUserEventTypeBySlug(user.id, input.eventTypeSlug);
     }
 
+    if (input.type === ByTeamSlugAndEventTypeSlug_2024_09_04_type) {
+      const team = await this.getEventTypeTeam(input);
+      if (!team) {
+        throw new NotFoundException(`Team with slug ${input.teamSlug} not found`);
+      }
+      return this.teamsEventTypesRepository.getEventTypeByTeamIdAndSlug(team.id, input.eventTypeSlug);
+    }
+
     return input.duration ? { ...dynamicEvent, length: input.duration } : dynamicEvent;
   }
 
-  private async getEventTypeUser(input: GetSlotsInput_2024_09_04) {
-    if ("eventTypeSlug" in input) {
-      if ("organizationSlug" in input && input.organizationSlug) {
-        const organization = await this.organizationsRepository.findOrgBySlug(input.organizationSlug);
-        if (!organization) {
-          throw new NotFoundException(
-            `slots-input.service.ts: Organization with slug ${input.organizationSlug} not found`
-          );
-        }
-
-        return await this.organizationsUsersRepository.getOrganizationUserByUsername(
-          organization.id,
-          input.username
-        );
-      }
-
+  private async getEventTypeUser(input: ByUsernameAndEventTypeSlug_2024_09_04) {
+    if (!input.organizationSlug) {
       return await this.usersRepository.findByUsername(input.username);
     }
+
+    const organization = await this.organizationsRepository.findOrgBySlug(input.organizationSlug);
+    if (!organization) {
+      throw new NotFoundException(
+        `slots-input.service.ts: Organization with slug ${input.organizationSlug} not found`
+      );
+    }
+
+    return await this.organizationsUsersRepository.getOrganizationUserByUsername(
+      organization.id,
+      input.username
+    );
+  }
+
+  private async getEventTypeTeam(input: ByTeamSlugAndEventTypeSlug_2024_09_04) {
+    if (!input.organizationSlug) {
+      return await this.teamsRepository.findTeamBySlug(input.teamSlug);
+    }
+
+    const organization = await this.organizationsRepository.findOrgBySlug(input.organizationSlug);
+    if (!organization) {
+      throw new NotFoundException(
+        `slots-input.service.ts: Organization with slug ${input.organizationSlug} not found`
+      );
+    }
+
+    return await this.organizationsTeamsRepository.findOrgTeamBySlug(organization.id, input.teamSlug);
   }
 
   private adjustStartTime(startTime: string) {

apps/api/v2/src/modules/slots/slots-2024-09-04/slots.module.ts

@@ -1,6 +1,7 @@
 import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
 import { MembershipsModule } from "@/modules/memberships/memberships.module";
 import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
+import { OrganizationsTeamsRepository } from "@/modules/organizations/teams/index/organizations-teams.repository";
 import { OrganizationsUsersRepository } from "@/modules/organizations/users/index/organizations-users.repository";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { SlotsController_2024_09_04 } from "@/modules/slots/slots-2024-09-04/controllers/slots.controller";
@@ -9,12 +10,20 @@ import { SlotsOutputService_2024_09_04 } from "@/modules/slots/slots-2024-09-04/
 import { SlotsService_2024_09_04 } from "@/modules/slots/slots-2024-09-04/services/slots.service";
 import { SlotsRepository_2024_09_04 } from "@/modules/slots/slots-2024-09-04/slots.repository";
 import { StripeModule } from "@/modules/stripe/stripe.module";
+import { TeamsEventTypesModule } from "@/modules/teams/event-types/teams-event-types.module";
 import { TeamsModule } from "@/modules/teams/teams/teams.module";
 import { UsersRepository } from "@/modules/users/users.repository";
 import { Module } from "@nestjs/common";
 
 @Module({
-  imports: [PrismaModule, EventTypesModule_2024_06_14, StripeModule, TeamsModule, MembershipsModule],
+  imports: [
+    PrismaModule,
+    EventTypesModule_2024_06_14,
+    StripeModule,
+    TeamsModule,
+    MembershipsModule,
+    TeamsEventTypesModule,
+  ],
   providers: [
     SlotsRepository_2024_09_04,
     SlotsService_2024_09_04,
@@ -23,6 +32,7 @@ import { Module } from "@nestjs/common";
     SlotsOutputService_2024_09_04,
     OrganizationsUsersRepository,
     OrganizationsRepository,
+    OrganizationsTeamsRepository,
   ],
   controllers: [SlotsController_2024_09_04],
   exports: [SlotsService_2024_09_04],

apps/api/v2/src/modules/teams/teams/teams.repository.ts

@@ -110,4 +110,14 @@ export class TeamsRepository {
       where: { id: teamId },
     });
   }
+
+  async findTeamBySlug(slug: string) {
+    return this.dbRead.prisma.team.findFirst({
+      where: {
+        slug,
+        isOrganization: false,
+        parentId: null,
+      },
+    });
+  }
 }

apps/api/v2/src/modules/tokens/tokens.repository.ts

@@ -50,6 +50,54 @@ export class TokensRepository {
     });
   }
 
+  async createOAuthTokens(clientId: string, ownerId: number, deleteOld?: boolean) {
+    if (deleteOld) {
+      try {
+        await this.dbWrite.prisma.$transaction([
+          this.dbWrite.prisma.accessToken.deleteMany({
+            where: { client: { id: clientId }, userId: ownerId },
+          }),
+          this.dbWrite.prisma.refreshToken.deleteMany({
+            where: {
+              client: { id: clientId },
+              userId: ownerId,
+            },
+          }),
+        ]);
+      } catch (err) {
+        this.logger.error("createOAuthTokens - Failed to delete old tokens", err);
+      }
+    }
+
+    const accessExpiry = DateTime.now().plus({ minute: 60 }).startOf("minute").toJSDate();
+    const refreshExpiry = DateTime.now().plus({ year: 1 }).startOf("day").toJSDate();
+    const [accessToken, refreshToken] = await this.dbWrite.prisma.$transaction([
+      this.dbWrite.prisma.accessToken.create({
+        data: {
+          secret: this.jwtService.signAccessToken({ clientId, ownerId, expiresAt: accessExpiry.valueOf() }),
+          expiresAt: accessExpiry,
+          client: { connect: { id: clientId } },
+          owner: { connect: { id: ownerId } },
+        },
+      }),
+      this.dbWrite.prisma.refreshToken.create({
+        data: {
+          secret: this.jwtService.signRefreshToken({ clientId, ownerId, expiresAt: refreshExpiry.valueOf() }),
+          expiresAt: refreshExpiry,
+          client: { connect: { id: clientId } },
+          owner: { connect: { id: ownerId } },
+        },
+      }),
+    ]);
+
+    return {
+      accessToken: accessToken.secret,
+      accessTokenExpiresAt: accessToken.expiresAt,
+      refreshToken: refreshToken.secret,
+      refreshTokenExpiresAt: refreshToken.expiresAt,
+    };
+  }
+
   async getAccessTokenExpiryDate(accessTokenSecret: string) {
     const accessToken = await this.dbRead.prisma.accessToken.findFirst({
       where: {
@@ -75,57 +123,46 @@ export class TokensRepository {
     return accessToken?.userId;
   }
 
-  async refreshOAuthTokens(ownerId: number, clientId: string) {
-    try {
-      await this.deleteOAuthTokens(ownerId, clientId);
-    } catch (err) {
-      this.logger.error("refreshOAuthTokens - Failed to delete old tokens", err);
-    }
-
-    return await this.createOAuthTokens(ownerId, clientId);
-  }
-
-  private async deleteOAuthTokens(ownerId: number, clientId: string) {
-    await this.dbWrite.prisma.$transaction([
-      this.dbWrite.prisma.accessToken.deleteMany({
-        where: { client: { id: clientId }, userId: ownerId },
-      }),
-      this.dbWrite.prisma.refreshToken.deleteMany({
-        where: {
-          client: { id: clientId },
-          userId: ownerId,
-        },
-      }),
-    ]);
-  }
-
-  async createOAuthTokens(ownerId: number, clientId: string) {
+  async refreshOAuthTokens(clientId: string, refreshTokenSecret: string, tokenUserId: number) {
     const accessExpiry = DateTime.now().plus({ minute: 60 }).startOf("minute").toJSDate();
     const refreshExpiry = DateTime.now().plus({ year: 1 }).startOf("day").toJSDate();
 
-    const [accessToken, refreshToken] = await this.dbWrite.prisma.$transaction([
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, _refresh, accessToken, refreshToken] = await this.dbWrite.prisma.$transaction([
+      this.dbWrite.prisma.accessToken.deleteMany({
+        where: { client: { id: clientId }, expiresAt: { lte: new Date() } },
+      }),
+      this.dbWrite.prisma.refreshToken.delete({ where: { secret: refreshTokenSecret } }),
       this.dbWrite.prisma.accessToken.create({
         data: {
-          secret: this.jwtService.signAccessToken({ clientId, ownerId, expiresAt: accessExpiry.valueOf() }),
+          secret: this.jwtService.signAccessToken({
+            clientId,
+            ownerId: tokenUserId,
+            expiresAt: accessExpiry.valueOf(),
+            userId: tokenUserId,
+          }),
           expiresAt: accessExpiry,
           client: { connect: { id: clientId } },
-          owner: { connect: { id: ownerId } },
+          owner: { connect: { id: tokenUserId } },
         },
       }),
       this.dbWrite.prisma.refreshToken.create({
         data: {
-          secret: this.jwtService.signRefreshToken({ clientId, ownerId, expiresAt: refreshExpiry.valueOf() }),
+          // note(Lauris): I am leaving userId because it was before adding ownerId to standardize payload like in the createOAuthTokens function for
+          // backwards compatability.
+          secret: this.jwtService.signRefreshToken({
+            clientId,
+            ownerId: tokenUserId,
+            expiresAt: refreshExpiry.valueOf(),
+            userId: tokenUserId,
+          }),
           expiresAt: refreshExpiry,
           client: { connect: { id: clientId } },
-          owner: { connect: { id: ownerId } },
+          owner: { connect: { id: tokenUserId } },
         },
       }),
     ]);
-
-    return {
-      accessToken,
-      refreshToken,
-    };
+    return { accessToken, refreshToken };
   }
 
   async getAccessTokenClient(accessToken: string) {

apps/web/app/(booking-page-wrapper)/layout.tsx

@@ -7,8 +7,10 @@ export default async function BookingPageWrapperLayout({ children }: { children:
   const nonce = h.get("x-nonce") ?? undefined;
 
   return (
-    <PageWrapper isBookingPage={true} requiresLicense={false} nonce={nonce}>
-      {children}
-    </PageWrapper>
+    <>
+      <PageWrapper isBookingPage={true} requiresLicense={false} nonce={nonce}>
+        {children}
+      </PageWrapper>
+    </>
   );
 }

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

@@ -1,10 +1,13 @@
 import { ShellMainAppDir } from "app/(use-page-wrapper)/(main-nav)/ShellMainAppDir";
+import { createRouterCaller } from "app/_trpc/context";
 import type { PageProps } from "app/_types";
 import { _generateMetadata, getTranslate } from "app/_utils";
 import { cookies, headers } from "next/headers";
 import { redirect } from "next/navigation";
 
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
+import { getTeamsFiltersFromQuery } from "@calcom/features/filters/lib/getTeamsFiltersFromQuery";
+import { eventTypesRouter } from "@calcom/trpc/server/routers/viewer/eventTypes/_router";
 
 import { buildLegacyCtx } from "@lib/buildLegacyCtx";
 
@@ -17,7 +20,8 @@ export const generateMetadata = async () =>
   );
 
 const Page = async ({ params, searchParams }: PageProps) => {
-  const context = buildLegacyCtx(await headers(), await cookies(), await params, await searchParams);
+  const _searchParams = await searchParams;
+  const context = buildLegacyCtx(await headers(), await cookies(), await params, _searchParams);
   const session = await getServerSession({ req: context.req });
 
   if (!session?.user?.id) {
@@ -26,12 +30,16 @@ const Page = async ({ params, searchParams }: PageProps) => {
 
   const t = await getTranslate();
 
+  const caller = await createRouterCaller(eventTypesRouter);
+  const filters = getTeamsFiltersFromQuery(_searchParams);
+  const initialData = await caller.getUserEventGroups({ filters });
+
   return (
     <ShellMainAppDir
       heading={t("event_types_page_title")}
       subtitle={t("event_types_page_subtitle")}
-      CTA={<EventTypesCTA />}>
-      <EventTypes />
+      CTA={<EventTypesCTA initialData={initialData} filters={filters} />}>
+      <EventTypes initialData={initialData} filters={filters} />
     </ShellMainAppDir>
   );
 };

apps/web/app/(use-page-wrapper)/layout.tsx

@@ -21,19 +21,21 @@ export default async function PageWrapperLayout({ children }: { children: React.
   ].filter((script): script is { id: string; script: string } => !!script.script);
 
   return (
-    <PageWrapper requiresLicense={false} nonce={nonce}>
-      {children}
-      {scripts.map((script) => (
-        <Script
-          key={script.id}
-          nonce={nonce}
-          id={script.id}
-          // eslint-disable-next-line react/no-danger
-          dangerouslySetInnerHTML={{
-            __html: script.script,
-          }}
-        />
-      ))}
-    </PageWrapper>
+    <>
+      <PageWrapper requiresLicense={false} nonce={nonce}>
+        {children}
+        {scripts.map((script) => (
+          <Script
+            key={script.id}
+            nonce={nonce}
+            id={script.id}
+            // eslint-disable-next-line react/no-danger
+            dangerouslySetInnerHTML={{
+              __html: script.script,
+            }}
+          />
+        ))}
+      </PageWrapper>
+    </>
   );
 }

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/SettingsLayoutAppDirClient.tsx

@@ -199,9 +199,7 @@ const useTabs = ({ isDelegationCredentialEnabled }: { isDelegationCredentialEnab
           (child) => isOrgAdminOrOwner || !organizationAdminKeys.includes(child.name)
         );
 
-        // TODO: figure out feature flag as it doesnt cause a re-render of the component when loaded.
-        // You have to refresh the page to see the changes.
-        if (true) {
+        if (isOrgAdminOrOwner) {
           newArray.splice(4, 0, {
             name: "attributes",
             href: "/settings/organizations/attributes",
@@ -316,27 +314,41 @@ const TeamListCollapsible = () => {
                 className="cursor-pointer"
                 key={team.id}
                 open={teamMenuState[index].teamMenuOpen}
-                onOpenChange={() =>
-                  setTeamMenuState([
-                    ...teamMenuState,
-                    (teamMenuState[index] = {
-                      ...teamMenuState[index],
-                      teamMenuOpen: !teamMenuState[index].teamMenuOpen,
-                    }),
-                  ])
-                }>
+                onOpenChange={(open) => {
+                  const newTeamMenuState = [...teamMenuState];
+                  newTeamMenuState[index] = {
+                    ...newTeamMenuState[index],
+                    teamMenuOpen: open,
+                  };
+                  setTeamMenuState(newTeamMenuState);
+                }}>
                 <CollapsibleTrigger asChild>
-                  <div
+                  <button
                     className="hover:bg-subtle [&[aria-current='page']]:bg-emphasis [&[aria-current='page']]:text-emphasis text-default flex h-9 w-full flex-row items-center rounded-md px-2 py-[10px] text-left text-sm font-medium leading-none transition"
-                    onClick={() =>
-                      setTeamMenuState([
-                        ...teamMenuState,
-                        (teamMenuState[index] = {
-                          ...teamMenuState[index],
+                    aria-controls={`team-content-${team.id}`}
+                    aria-expanded={teamMenuState[index].teamMenuOpen}
+                    onClick={() => {
+                      const newTeamMenuState = [...teamMenuState];
+                      newTeamMenuState[index] = {
+                        ...newTeamMenuState[index],
+                        teamMenuOpen: !teamMenuState[index].teamMenuOpen,
+                      };
+                      setTeamMenuState(newTeamMenuState);
+                    }}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter" || e.key === " ") {
+                        e.preventDefault();
+                        const newTeamMenuState = [...teamMenuState];
+                        newTeamMenuState[index] = {
+                          ...newTeamMenuState[index],
                           teamMenuOpen: !teamMenuState[index].teamMenuOpen,
-                        }),
-                      ])
-                    }>
+                        };
+                        setTeamMenuState(newTeamMenuState);
+                      }
+                    }}
+                    aria-label={`${team.name} ${
+                      teamMenuState[index].teamMenuOpen ? t("collapse_menu") : t("expand_menu")
+                    }`}>
                     <div className="me-3">
                       {teamMenuState[index].teamMenuOpen ? (
                         <Icon name="chevron-down" className="h-4 w-4" />
@@ -357,9 +369,9 @@ const TeamListCollapsible = () => {
                         Inv.
                       </Badge>
                     )}
-                  </div>
+                  </button>
                 </CollapsibleTrigger>
-                <CollapsibleContent className="space-y-0.5">
+                <CollapsibleContent className="space-y-0.5" id={`team-content-${team.id}`}>
                   {team.accepted && (
                     <VerticalTabItem
                       name={t("profile")}
@@ -486,7 +498,7 @@ const SettingsSidebarContainer = ({
           ? "translate-x-0 opacity-100"
           : "-translate-x-full opacity-0 lg:translate-x-0 lg:opacity-100"
       )}
-      aria-label="Tabs">
+      aria-label={t("settings_navigation")}>
       <>
         <BackButtonInSidebar name={t("back")} />
         {tabsWithPermissions.map((tab) => {
@@ -602,27 +614,43 @@ const SettingsSidebarContainer = ({
                               className="cursor-pointer"
                               key={otherTeam.id}
                               open={otherTeamMenuState[index].teamMenuOpen}
-                              onOpenChange={() =>
-                                setOtherTeamMenuState([
-                                  ...otherTeamMenuState,
-                                  (otherTeamMenuState[index] = {
-                                    ...otherTeamMenuState[index],
-                                    teamMenuOpen: !otherTeamMenuState[index].teamMenuOpen,
-                                  }),
-                                ])
-                              }>
+                              onOpenChange={(open) => {
+                                const newOtherTeamMenuState = [...otherTeamMenuState];
+                                newOtherTeamMenuState[index] = {
+                                  ...newOtherTeamMenuState[index],
+                                  teamMenuOpen: open,
+                                };
+                                setOtherTeamMenuState(newOtherTeamMenuState);
+                              }}>
                               <CollapsibleTrigger asChild>
-                                <div
+                                <button
                                   className="hover:bg-subtle [&[aria-current='page']]:bg-emphasis [&[aria-current='page']]:text-emphasis text-default flex h-9 w-full flex-row items-center rounded-md px-2 py-[10px] text-left text-sm font-medium leading-none transition"
-                                  onClick={() =>
-                                    setOtherTeamMenuState([
-                                      ...otherTeamMenuState,
-                                      (otherTeamMenuState[index] = {
-                                        ...otherTeamMenuState[index],
+                                  aria-controls={`other-team-content-${otherTeam.id}`}
+                                  aria-expanded={otherTeamMenuState[index].teamMenuOpen}
+                                  onClick={() => {
+                                    const newOtherTeamMenuState = [...otherTeamMenuState];
+                                    newOtherTeamMenuState[index] = {
+                                      ...newOtherTeamMenuState[index],
+                                      teamMenuOpen: !otherTeamMenuState[index].teamMenuOpen,
+                                    };
+                                    setOtherTeamMenuState(newOtherTeamMenuState);
+                                  }}
+                                  onKeyDown={(e) => {
+                                    if (e.key === "Enter" || e.key === " ") {
+                                      e.preventDefault();
+                                      const newOtherTeamMenuState = [...otherTeamMenuState];
+                                      newOtherTeamMenuState[index] = {
+                                        ...newOtherTeamMenuState[index],
                                         teamMenuOpen: !otherTeamMenuState[index].teamMenuOpen,
-                                      }),
-                                    ])
-                                  }>
+                                      };
+                                      setOtherTeamMenuState(newOtherTeamMenuState);
+                                    }
+                                  }}
+                                  aria-label={`${otherTeam.name} ${
+                                    otherTeamMenuState[index].teamMenuOpen
+                                      ? t("collapse_menu")
+                                      : t("expand_menu")
+                                  }`}>
                                   <div className="me-3">
                                     {otherTeamMenuState[index].teamMenuOpen ? (
                                       <Icon name="chevron-down" className="h-4 w-4" />
@@ -638,9 +666,11 @@ const SettingsSidebarContainer = ({
                                     />
                                   )}
                                   <p className="w-1/2 truncate leading-normal">{otherTeam.name}</p>
-                                </div>
+                                </button>
                               </CollapsibleTrigger>
-                              <CollapsibleContent className="space-y-0.5">
+                              <CollapsibleContent
+                                className="space-y-0.5"
+                                id={`other-team-content-${otherTeam.id}`}>
                                 <VerticalTabItem
                                   name={t("profile")}
                                   href={`/settings/organizations/teams/other/${otherTeam.id}/profile`}

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/developer/webhooks/(with-loader)/actions.ts

@@ -0,0 +1,7 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+
+export async function revalidateWebhooksList() {
+  revalidatePath("/settings/developer/webhooks");
+}

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/developer/webhooks/(with-loader)/loading.tsx

@@ -0,0 +1,5 @@
+import { SkeletonLoader } from "@calcom/features/webhooks/pages/webhooks-skeleton";
+
+export default function Loading() {
+  return <SkeletonLoader />;
+}

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/developer/webhooks/(with-loader)/page.tsx

@@ -0,0 +1,33 @@
+import { createRouterCaller } from "app/_trpc/context";
+import { _generateMetadata } from "app/_utils";
+import { cookies, headers } from "next/headers";
+import { redirect } from "next/navigation";
+
+import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
+import WebhooksView from "@calcom/features/webhooks/pages/webhooks-view";
+import { APP_NAME } from "@calcom/lib/constants";
+import { UserPermissionRole } from "@calcom/prisma/enums";
+import { webhookRouter } from "@calcom/trpc/server/routers/viewer/webhook/_router";
+
+import { buildLegacyRequest } from "@lib/buildLegacyCtx";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("webhooks"),
+    (t) => t("add_webhook_description", { appName: APP_NAME })
+  );
+
+const WebhooksViewServerWrapper = async () => {
+  const session = await getServerSession({ req: buildLegacyRequest(await headers(), await cookies()) });
+  if (!session?.user?.id) {
+    redirect("/auth/login");
+  }
+
+  const isAdmin = session.user.role === UserPermissionRole.ADMIN;
+  const caller = await createRouterCaller(webhookRouter);
+  const data = await caller.getByViewer();
+
+  return <WebhooksView data={data} isAdmin={isAdmin} />;
+};
+
+export default WebhooksViewServerWrapper;

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/developer/webhooks/new/loading.tsx

@@ -0,0 +1,5 @@
+import { SkeletonLoader } from "@calcom/features/webhooks/pages/webhook-new-skeleton";
+
+export default function Loading() {
+  return <SkeletonLoader />;
+}

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/developer/webhooks/new/page.tsx

@@ -1,10 +1,10 @@
-import { getTranslate, _generateMetadata } from "app/_utils";
-import { Suspense } from "react";
+import { createRouterCaller } from "app/_trpc/context";
+import { _generateMetadata } from "app/_utils";
 
-import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
 import { NewWebhookView } from "@calcom/features/webhooks/pages/webhook-new-view";
 import { APP_NAME } from "@calcom/lib/constants";
-import { SkeletonText, SkeletonContainer } from "@calcom/ui/components/skeleton";
+import { appsRouter } from "@calcom/trpc/server/routers/viewer/apps/_router";
+import { webhookRouter } from "@calcom/trpc/server/routers/viewer/webhook/_router";
 
 export const generateMetadata = async () =>
   await _generateMetadata(
@@ -12,31 +12,18 @@ export const generateMetadata = async () =>
     (t) => t("add_webhook_description", { appName: APP_NAME })
   );
 
-const SkeletonLoader = () => {
-  return (
-    <SkeletonContainer>
-      <div className="divide-subtle border-subtle space-y-6 rounded-b-lg border border-t-0 px-6 py-4">
-        <SkeletonText className="h-8 w-full" />
-        <SkeletonText className="h-8 w-full" />
-      </div>
-    </SkeletonContainer>
-  );
-};
-
 const Page = async () => {
-  const t = await getTranslate();
+  const [appsCaller, webhookCaller] = await Promise.all([
+    createRouterCaller(appsRouter),
+    createRouterCaller(webhookRouter),
+  ]);
 
-  return (
-    <SettingsHeader
-      title={t("add_webhook")}
-      description={t("add_webhook_description", { appName: APP_NAME })}
-      borderInShellHeader={true}
-      backButton>
-      <Suspense fallback={<SkeletonLoader />}>
-        <NewWebhookView />
-      </Suspense>
-    </SettingsHeader>
-  );
+  const [installedApps, webhooks] = await Promise.all([
+    appsCaller.integrations({ variant: "other", onlyInstalled: true }),
+    webhookCaller.list(),
+  ]);
+
+  return <NewWebhookView webhooks={webhooks} installedApps={installedApps} />;
 };
 
 export default Page;

apps/web/app/(use-page-wrapper)/settings/(settings-layout)/developer/webhooks/page.tsx

@@ -1,16 +0,0 @@
-import { _generateMetadata } from "app/_utils";
-
-import WebhooksView from "@calcom/features/webhooks/pages/webhooks-view";
-import { APP_NAME } from "@calcom/lib/constants";
-
-export const generateMetadata = async () =>
-  await _generateMetadata(
-    (t) => t("webhooks"),
-    (t) => t("add_webhook_description", { appName: APP_NAME })
-  );
-
-const WebhooksViewServerWrapper = async () => {
-  return <WebhooksView />;
-};
-
-export default WebhooksViewServerWrapper;

apps/web/app/AppRouterI18nProvider.tsx

@@ -0,0 +1,33 @@
+"use client";
+
+import { createContext, useMemo } from "react";
+import type { ReactNode } from "react";
+
+type AppRouterI18nContextType = {
+  translations: Record<string, string>;
+  ns: string;
+  locale: string;
+};
+
+export const AppRouterI18nContext = createContext<AppRouterI18nContextType | null>(null);
+
+export function AppRouterI18nProvider({
+  children,
+  translations,
+  locale,
+  ns,
+}: AppRouterI18nContextType & {
+  children: ReactNode;
+}) {
+  // Memoize the value to prevent re-renders unless the data changes
+  const value = useMemo(
+    () => ({
+      translations,
+      locale,
+      ns,
+    }),
+    [locale, ns]
+  );
+
+  return <AppRouterI18nContext.Provider value={value}>{children}</AppRouterI18nContext.Provider>;
+}

apps/web/app/api/avatar/[uuid]/route.ts

@@ -5,6 +5,7 @@ import { NextResponse } from "next/server";
 import { z } from "zod";
 
 import { AVATAR_FALLBACK, WEBAPP_URL } from "@calcom/lib/constants";
+import { convertSvgToPng } from "@calcom/lib/server/imageUtils";
 import prisma from "@calcom/prisma";
 
 const querySchema = z.object({
@@ -44,7 +45,19 @@ async function handler(req: NextRequest, { params }: { params: Promise<Params> }
         data: true,
       },
     });
-    img = data;
+
+    // Convert SVG to PNG if needed and update the database
+    if (data.startsWith("data:image/svg+xml;base64,")) {
+      const pngData = await convertSvgToPng(data);
+
+      await prisma.avatar.update({
+        where: { objectKey },
+        data: { data: pngData },
+      });
+      img = pngData;
+    } else {
+      img = data;
+    }
   } catch (e) {
     // If anything goes wrong or avatar is not found, use default avatar
     const url = new URL(AVATAR_FALLBACK, WEBAPP_URL).toString();

apps/web/app/api/link/route.ts

@@ -9,6 +9,7 @@ import prisma from "@calcom/prisma";
 import { UserPermissionRole } from "@calcom/prisma/enums";
 import { createContext } from "@calcom/trpc/server/createContext";
 import { bookingsRouter } from "@calcom/trpc/server/routers/viewer/bookings/_router";
+import { createCallerFactory } from "@calcom/trpc/server/trpc";
 import type { UserProfile } from "@calcom/types/UserProfile";
 
 import { buildLegacyRequest } from "@lib/buildLegacyCtx";
@@ -83,7 +84,8 @@ async function handler(request: NextRequest) {
     const res = {} as any; // Response is still mocked as it's not used in this context
 
     const ctx = await createContext({ req: legacyReq, res }, sessionGetter);
-    const caller = bookingsRouter.createCaller({
+    const createCaller = createCallerFactory(bookingsRouter);
+    const caller = createCaller({
       ...ctx,
       req: legacyReq,
       res,

apps/web/app/api/me/route.ts

@@ -7,8 +7,6 @@ import { performance } from "@calcom/lib/server/perfObserver";
 
 import { buildLegacyRequest } from "@lib/buildLegacyCtx";
 
-let isCold = true;
-
 async function getHandler() {
   const prePrismaDate = performance.now();
   const prisma = (await import("@calcom/prisma")).default;
@@ -30,7 +28,6 @@ async function getHandler() {
 
   const lastUpdate = performance.now();
 
-  // Create response with headers
   const response = NextResponse.json({
     message: `Hello ${user.name}`,
     prePrismaDate,
@@ -40,13 +37,8 @@ async function getHandler() {
     preUserDate,
     userDuration: `User took ${lastUpdate - preUserDate}ms`,
     lastUpdate,
-    wasCold: isCold,
   });
 
-  // Set custom header
-  response.headers.set("x-is-cold", isCold.toString());
-  isCold = false;
-
   return response;
 }
 

apps/web/app/error.tsx

@@ -17,7 +17,7 @@ export type ErrorProps = {
   reset?: () => void;
 };
 
-export default function Error({ error }: ErrorProps) {
+export default function Error({ error, reset }: ErrorProps) {
   React.useEffect(() => {
     log.error(error);
 
@@ -51,6 +51,7 @@ export default function Error({ error }: ErrorProps) {
 
   return (
     <ErrorPage
+      reset={reset}
       statusCode={processedError.statusCode}
       error={processedError}
       message={processedError.message}

apps/web/app/layout.tsx

@@ -5,10 +5,12 @@ import { headers, cookies } from "next/headers";
 import React from "react";
 
 import { getLocale } from "@calcom/features/auth/lib/getLocale";
+import { loadTranslations } from "@calcom/lib/server/i18n";
 import { IconSprites } from "@calcom/ui/components/icon";
 import { NotificationSoundHandler } from "@calcom/web/components/notification-sound-handler";
 
 import "../styles/globals.css";
+import { AppRouterI18nProvider } from "./AppRouterI18nProvider";
 import { SpeculationRules } from "./SpeculationRules";
 import { Providers } from "./providers";
 
@@ -83,10 +85,15 @@ const getInitialProps = async (url: string) => {
   const embedColorScheme = searchParams?.get("ui.color-scheme");
 
   const req = { headers: await headers(), cookies: await cookies() };
-  const newLocale = await getLocale(req);
+  const newLocale = (await getLocale(req)) ?? "en";
   const direction = dir(newLocale);
 
-  return { isEmbed, embedColorScheme, locale: newLocale, direction };
+  return {
+    isEmbed,
+    embedColorScheme,
+    locale: newLocale,
+    direction,
+  };
 };
 
 const getFallbackProps = () => ({
@@ -107,6 +114,8 @@ export default async function RootLayout({ children }: { children: React.ReactNo
   const { locale, direction, isEmbed, embedColorScheme } = isSSG
     ? getFallbackProps()
     : await getInitialProps(fullUrl);
+  const ns = "common";
+  const translations = await loadTranslations(locale, ns);
 
   return (
     <html
@@ -153,7 +162,12 @@ export default async function RootLayout({ children }: { children: React.ReactNo
             "/insights",
           ]}
         />
-        <Providers>{children}</Providers>
+
+        <Providers>
+          <AppRouterI18nProvider translations={translations} locale={locale} ns={ns}>
+            {children}
+          </AppRouterI18nProvider>
+        </Providers>
         {!isEmbed && <NotificationSoundHandler />}
         <NotificationSoundHandler />
       </body>

apps/web/components/PageWrapperAppDir.tsx

@@ -1,7 +1,5 @@
 "use client";
 
-import type { SSRConfig } from "next-i18next/dist/types/types";
-// import I18nLanguageHandler from "@components/I18nLanguageHandler";
 import { usePathname } from "next/navigation";
 import Script from "next/script";
 
@@ -11,12 +9,10 @@ import LicenseRequired from "@calcom/features/ee/common/components/LicenseRequir
 import AppProviders from "@lib/app-providers-app-dir";
 
 export type PageWrapperProps = Readonly<{
-  getLayout?: ((page: React.ReactElement) => React.ReactNode) | null;
   children: React.ReactNode;
   requiresLicense: boolean;
   nonce: string | undefined;
   isBookingPage?: boolean;
-  i18n?: SSRConfig;
 }>;
 
 function PageWrapper(props: PageWrapperProps) {
@@ -41,25 +37,26 @@ function PageWrapper(props: PageWrapperProps) {
     nonce,
   };
 
-  const getLayout: (page: React.ReactElement) => React.ReactNode = props.getLayout ?? ((page) => page);
-
   return (
-    <AppProviders {...providerProps}>
-      {/* <I18nLanguageHandler locales={props.router.locales || []} /> */}
-      <>
-        <Script
-          nonce={nonce}
-          id="page-status"
-          // It is strictly not necessary to disable, but in a future update of react/no-danger this will error.
-          // And we don't want it to error here anyways
-          // eslint-disable-next-line react/no-danger
-          dangerouslySetInnerHTML={{ __html: `window.CalComPageStatus = '${pageStatus}'` }}
-        />
-        {getLayout(
-          props.requiresLicense ? <LicenseRequired>{props.children}</LicenseRequired> : <>{props.children}</>
-        )}
-      </>
-    </AppProviders>
+    <>
+      <AppProviders {...providerProps}>
+        <>
+          <Script
+            nonce={nonce}
+            id="page-status"
+            // It is strictly not necessary to disable, but in a future update of react/no-danger this will error.
+            // And we don't want it to error here anyways
+            // eslint-disable-next-line react/no-danger
+            dangerouslySetInnerHTML={{ __html: `window.CalComPageStatus = '${pageStatus}'` }}
+          />
+          {props.requiresLicense ? (
+            <LicenseRequired>{props.children}</LicenseRequired>
+          ) : (
+            <>{props.children}</>
+          )}
+        </>
+      </AppProviders>
+    </>
   );
 }