chore: version packages (#23120)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.eslintrc.js

@@ -1 +1,5 @@
-module.exports = require("./packages/config/eslint-preset");
+// This configuration only applies to the package manager root.
+/** @type {import("eslint").Linter.Config} */
+module.exports = {
+  extends: ["./packages/config/eslint-preset.js"],
+};

.github/workflows/atoms-e2e.yml

@@ -0,0 +1,57 @@
+name: Atoms E2E Tests
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'packages/platform/atoms/**'
+      - 'packages/platform/examples/base/**'
+      - 'apps/api/v2/**'
+      - '.github/workflows/atoms-e2e.yml'
+
+permissions:
+  actions: write
+  contents: read
+
+env:
+  NODE_OPTIONS: --max-old-space-size=8096
+  ATOMS_E2E_OAUTH_CLIENT_ID: ${{ secrets.ATOMS_E2E_OAUTH_CLIENT_ID }}
+  ATOMS_E2E_OAUTH_CLIENT_SECRET: ${{ secrets.ATOMS_E2E_OAUTH_CLIENT_SECRET }}
+  ATOMS_E2E_API_URL: ${{ secrets.ATOMS_E2E_API_URL }}
+  ATOMS_E2E_ORG_ID: ${{ secrets.ATOMS_E2E_ORG_ID }}
+  ATOMS_E2E_OAUTH_CLIENT_ID_BOOKER_EMBED: ${{ secrets.ATOMS_E2E_OAUTH_CLIENT_ID_BOOKER_EMBED }}
+  DATABASE_DIRECT_URL: ${{ secrets.CI_DATABASE_URL }}
+  DATABASE_URL: ${{ secrets.CI_DATABASE_URL }}
+
+jobs:
+  atoms-e2e:
+    timeout-minutes: 15
+    name: Atoms E2E Tests
+    runs-on: buildjet-4vcpu-ubuntu-2204
+    steps:
+      - uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/dangerous-git-checkout
+      - uses: ./.github/actions/yarn-install
+      - uses: ./.github/actions/yarn-playwright-install
+      - name: Run Atoms E2E Tests
+        working-directory: packages/platform/examples/base
+        run: yarn test:e2e
+      - name: Upload Test Results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: atoms-e2e-test-results
+          path: test-results
+          retention-days: 7
+      - name: Upload Playwright Report
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: atoms-e2e-playwright-report
+          path: playwright-report
+          retention-days: 7

.github/workflows/e2e-api-v2.yml

@@ -22,6 +22,7 @@ env:
   STRIPE_API_KEY: ${{ secrets.CI_STRIPE_PRIVATE_KEY }}
   STRIPE_CLIENT_ID: ${{ secrets.CI_STRIPE_CLIENT_ID }}
   STRIPE_WEBHOOK_SECRET: ${{ secrets.CI_STRIPE_WEBHOOK_SECRET }}
+  SLOTS_CACHE_TTL: ${{ secrets.CI_SLOTS_CACHE_TTL }}
 jobs:
   e2e:
     timeout-minutes: 20

.yarn/versions/19a4f764.yml

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

.yarn/versions/1e3ec1e6.yml

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

.yarn/versions/45e15b36.yml

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

.yarn/versions/5cae75a1.yml

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

.yarn/versions/96bd4a2c.yml

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

.yarn/versions/c2cf509a.yml

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

.yarn/versions/dcddf8c9.yml

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

.yarn/versions/f7534fef.yml

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

apps/api/v1/package.json

@@ -33,7 +33,7 @@
     "@sentry/nextjs": "^9.15.0",
     "bcryptjs": "^2.4.3",
     "memory-cache": "^0.2.0",
-    "next": "^15.3.0",
+    "next": "^15.4.5",
     "next-api-middleware": "^1.0.1",
     "next-axiom": "^0.17.0",
     "next-swagger-doc": "^0.3.6",

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

@@ -1,7 +1,7 @@
 import type { NextApiRequest } from "next";
 import { z } from "zod";
 
-import { getUserAvailability } from "@calcom/lib/getUserAvailability";
+import { getUserAvailabilityService } from "@calcom/lib/di/containers/GetUserAvailability";
 import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import prisma from "@calcom/prisma";
@@ -191,8 +191,9 @@ const availabilitySchema = z
 async function handler(req: NextApiRequest) {
   const { isSystemWideAdmin, userId: reqUserId } = req;
   const { username, userId, eventTypeId, dateTo, dateFrom, teamId } = availabilitySchema.parse(req.query);
+  const userAvailabilityService = getUserAvailabilityService();
   if (!teamId)
-    return getUserAvailability({
+    return userAvailabilityService.getUserAvailability({
       username,
       dateFrom,
       dateTo,
@@ -230,7 +231,7 @@ async function handler(req: NextApiRequest) {
   const availabilities = members.map(async (user) => {
     return {
       userId: user.id,
-      availability: await getUserAvailability({
+      availability: await userAvailabilityService.getUserAvailability({
         userId: user.id,
         dateFrom,
         dateTo,

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

@@ -4,7 +4,7 @@ import type { NextApiRequest, NextApiResponse } from "next";
 
 import dayjs from "@calcom/dayjs";
 import { isSupportedTimeZone } from "@calcom/lib/dayjs";
-import { getAvailableSlotsService } from "@calcom/lib/di/containers/available-slots";
+import { getAvailableSlotsService } from "@calcom/lib/di/containers/AvailableSlots";
 import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import { createContext } from "@calcom/trpc/server/createContext";

apps/api/v1/test/lib/bookings/_post.test.ts

@@ -76,11 +76,13 @@ vi.mock("@calcom/features/watchlist/operations/check-if-users-are-blocked.contro
   checkIfUsersAreBlocked: vi.fn().mockResolvedValue(false),
 }));
 
-vi.mock("@calcom/lib/bookings/findQualifiedHostsWithDelegationCredentials", () => ({
-  findQualifiedHostsWithDelegationCredentials: vi.fn().mockResolvedValue({
-    qualifiedRRHosts: [],
-    allFallbackRRHosts: [],
-    fixedHosts: [],
+vi.mock("@calcom/lib/di/containers/QualifiedHosts", () => ({
+  getQualifiedHostsService: vi.fn().mockReturnValue({
+    findQualifiedHostsWithDelegationCredentials: vi.fn().mockResolvedValue({
+      qualifiedRRHosts: [],
+      allFallbackRRHosts: [],
+      fixedHosts: [],
+    }),
   }),
 }));
 

apps/api/v2/README.md

@@ -42,15 +42,17 @@ $ yarn prisma generate
 
 Copy `.env.example` to `.env` and fill values.
 
-## Add license Key to deployments table in DB
+## Add license Key to Deployment table in DB
 
-id, logo theme licenseKey agreedLicenseAt
-1, null, null, 'c4234812-12ab-42s6-a1e3-55bedd4a5bb7', '2023-05-15 21:39:47.611'
+id, logo, theme, licenseKey, agreedLicenseAt:-
+1, null, null, '00000000-0000-0000-0000-000000000000', '2023-05-15 21:39:47.611'
+
+Replace with your actual license key.
 
 your CALCOM_LICENSE_KEY env var need to contain the same value
 
 .env
-CALCOM_LICENSE_KEY=c4234812-12ab-42s6-a1e3-55bedd4a5bb
+CALCOM_LICENSE_KEY=00000000-0000-0000-0000-000000000000
 
 ## Running the app
 

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.276",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.312",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",
     "@calcom/prisma": "*",
@@ -98,6 +98,8 @@
     "@types/luxon": "^3.3.7",
     "@types/passport-jwt": "^3.0.13",
     "@types/supertest": "^2.0.12",
+    "@typescript-eslint/eslint-plugin": "^6",
+    "@typescript-eslint/parser": "^6",
     "jest": "^29.7.0",
     "jest-date-mock": "^1.0.10",
     "node-mocks-http": "^1.16.2",

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

@@ -104,10 +104,11 @@ export class OutputBookingsService_2024_08_13 {
     const rescheduledToInfo = databaseBooking.rescheduled
       ? await this.getRescheduledToInfo(databaseBooking.uid)
       : undefined;
-    
-    const rescheduledToUid = rescheduledToInfo?.uid;
-    const rescheduledByEmail = databaseBooking.rescheduled ? rescheduledToInfo?.rescheduledBy : databaseBooking.rescheduledBy;
 
+    const rescheduledToUid = rescheduledToInfo?.uid;
+    const rescheduledByEmail = databaseBooking.rescheduled
+      ? rescheduledToInfo?.rescheduledBy
+      : databaseBooking.rescheduledBy;
 
     const booking = {
       id: databaseBooking.id,
@@ -157,13 +158,12 @@ export class OutputBookingsService_2024_08_13 {
 
   async getRescheduledToInfo(bookingUid: string): Promise<{ uid?: string; rescheduledBy?: string | null }> {
     const rescheduledTo = await this.bookingsRepository.getByFromReschedule(bookingUid);
-    return { 
-      uid: rescheduledTo?.uid, 
-      rescheduledBy: rescheduledTo?.rescheduledBy 
+    return {
+      uid: rescheduledTo?.uid,
+      rescheduledBy: rescheduledTo?.rescheduledBy,
     };
   }
 
-
   getUserDefinedMetadata(databaseMetadata: DatabaseMetadata) {
     if (databaseMetadata === null) return {};
 
@@ -279,9 +279,11 @@ export class OutputBookingsService_2024_08_13 {
     const rescheduledToInfo = databaseBooking.rescheduled
       ? await this.getRescheduledToInfo(databaseBooking.uid)
       : undefined;
-    
+
     const rescheduledToUid = rescheduledToInfo?.uid;
-    const rescheduledByEmail = databaseBooking.rescheduled ? rescheduledToInfo?.rescheduledBy : databaseBooking.rescheduledBy;
+    const rescheduledByEmail = databaseBooking.rescheduled
+      ? rescheduledToInfo?.rescheduledBy
+      : databaseBooking.rescheduledBy;
 
     const booking = {
       id: databaseBooking.id,

apps/api/v2/src/ee/event-types-private-links/controllers/event-types-private-links.controller.e2e-spec.ts

@@ -0,0 +1,178 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { HttpExceptionFilter } from "@/filters/http-exception.filter";
+import { PrismaExceptionFilter } from "@/filters/prisma-exception.filter";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+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 * as request from "supertest";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { CreatePrivateLinkInput } from "@calcom/platform-types";
+
+import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+import { randomString } from "test/utils/randomString";
+
+describe("Event Types Private Links Endpoints", () => {
+  let app: INestApplication;
+
+  let oAuthClient: any;
+  let organization: any;
+  let userRepositoryFixture: UserRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+  let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+  let user: any;
+  let eventType: any;
+
+  const userEmail = `private-links-user-${randomString()}@api.com`;
+
+  beforeAll(async () => {
+    const moduleRef = await withApiAuth(
+      userEmail,
+      Test.createTestingModule({
+        providers: [PrismaExceptionFilter, HttpExceptionFilter],
+        imports: [AppModule, UsersModule, EventTypesModule_2024_06_14, TokensModule],
+      })
+    )
+      .overrideGuard(PermissionsGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+      .compile();
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+
+    organization = await teamRepositoryFixture.create({
+      name: `private-links-organization-${randomString()}`,
+      slug: `private-links-org-slug-${randomString()}`,
+    });
+    oAuthClient = await createOAuthClient(organization.id);
+    user = await userRepositoryFixture.create({
+      email: userEmail,
+      name: `private-links-user-${randomString()}`,
+      username: `private-links-user-${randomString()}`,
+    });
+
+    // create an event type owned by user
+    eventType = await eventTypesRepositoryFixture.create(
+      {
+        title: `private-links-event-type-${randomString()}`,
+        slug: `private-links-event-type-${randomString()}`,
+        length: 30,
+        locations: [],
+      },
+      user.id
+    );
+
+    await app.init();
+  });
+
+  async function createOAuthClient(organizationId: number) {
+    const data = {
+      logo: "logo-url",
+      name: "name",
+      redirectUris: ["redirect-uri"],
+      permissions: 32,
+    };
+    const secret = "secret";
+
+    const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+    return client;
+  }
+
+  it("POST /v2/event-types/:eventTypeId/private-links - create private link", async () => {
+    const body: CreatePrivateLinkInput = {
+      expiresAt: undefined,
+      maxUsageCount: 5,
+    };
+
+    const response = await request(app.getHttpServer())
+      .post(`/api/v2/event-types/${eventType.id}/private-links`)
+      .set("Authorization", `Bearer whatever`)
+      .send(body)
+      .expect(201);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(response.body.data.linkId).toBeDefined();
+    expect(response.body.data.maxUsageCount).toBe(5);
+    expect(response.body.data.usageCount).toBeDefined();
+  });
+
+  it("GET /v2/event-types/:eventTypeId/private-links - list private links", async () => {
+    const response = await request(app.getHttpServer())
+      .get(`/api/v2/event-types/${eventType.id}/private-links`)
+      .set("Authorization", `Bearer whatever`)
+      .expect(200);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(Array.isArray(response.body.data)).toBe(true);
+    expect(response.body.data.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("PATCH /v2/event-types/:eventTypeId/private-links/:linkId - update private link", async () => {
+    // create a link first
+    const createResp = await request(app.getHttpServer())
+      .post(`/api/v2/event-types/${eventType.id}/private-links`)
+      .set("Authorization", `Bearer whatever`)
+      .send({ maxUsageCount: 3 })
+      .expect(201);
+
+    const linkId = createResp.body.data.linkId;
+
+    const response = await request(app.getHttpServer())
+      .patch(`/api/v2/event-types/${eventType.id}/private-links/${linkId}`)
+      .set("Authorization", `Bearer whatever`)
+      .send({ maxUsageCount: 10 })
+      .expect(200);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(response.body.data.maxUsageCount).toBe(10);
+  });
+
+  it("DELETE /v2/event-types/:eventTypeId/private-links/:linkId - delete private link", async () => {
+    // create a link to delete
+    const createResp = await request(app.getHttpServer())
+      .post(`/api/v2/event-types/${eventType.id}/private-links`)
+      .set("Authorization", `Bearer whatever`)
+      .send({ maxUsageCount: 2 })
+      .expect(201);
+
+    const linkId = createResp.body.data.linkId;
+
+    const response = await request(app.getHttpServer())
+      .delete(`/api/v2/event-types/${eventType.id}/private-links/${linkId}`)
+      .set("Authorization", `Bearer whatever`)
+      .expect(200);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(response.body.data.linkId).toBe(linkId);
+  });
+
+  afterAll(async () => {
+    // cleanup created entities
+    try {
+      if (eventType?.id) {
+        const repo = new EventTypesRepositoryFixture((app as any).select(AppModule));
+        await repo.delete(eventType.id);
+      }
+    } catch {}
+    await app.close();
+  });
+});
+
+

apps/api/v2/src/ee/event-types-private-links/controllers/event-types-private-links.controller.ts

@@ -0,0 +1,102 @@
+import { API_KEY_OR_ACCESS_TOKEN_HEADER } from "@/lib/docs/headers";
+import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
+import { Permissions } from "@/modules/auth/decorators/permissions/permissions.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { EventTypeOwnershipGuard } from "@/modules/event-types/guards/event-type-ownership.guard";
+import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post, UseGuards } from "@nestjs/common";
+import { ApiHeader, ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
+
+import { EVENT_TYPE_READ, EVENT_TYPE_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
+import {
+  CreatePrivateLinkInput,
+  CreatePrivateLinkOutput,
+  DeletePrivateLinkOutput,
+  GetPrivateLinksOutput,
+  UpdatePrivateLinkOutput,
+  UpdatePrivateLinkBody,
+} from "@calcom/platform-types";
+
+import { PrivateLinksService } from "../services/private-links.service";
+
+@Controller({
+  path: "/v2/event-types/:eventTypeId/private-links",
+})
+@UseGuards(PermissionsGuard)
+@DocsTags("Event Types Private Links")
+export class EventTypesPrivateLinksController {
+  constructor(private readonly privateLinksService: PrivateLinksService) {}
+
+  @Post("/")
+  @Permissions([EVENT_TYPE_WRITE])
+  @UseGuards(ApiAuthGuard, EventTypeOwnershipGuard)
+  @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
+  @ApiOperation({ summary: "Create a private link for an event type" })
+  async createPrivateLink(
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Body() body: CreatePrivateLinkInput,
+    @GetUser("id") userId: number
+  ): Promise<CreatePrivateLinkOutput> {
+    const privateLink = await this.privateLinksService.createPrivateLink(eventTypeId, userId, body);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: privateLink,
+    };
+  }
+
+  @Get("/")
+  @Permissions([EVENT_TYPE_READ])
+  @UseGuards(ApiAuthGuard, EventTypeOwnershipGuard)
+  @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
+  @ApiOperation({ summary: "Get all private links for an event type" })
+  async getPrivateLinks(
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number
+  ): Promise<GetPrivateLinksOutput> {
+    const privateLinks = await this.privateLinksService.getPrivateLinks(eventTypeId);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: privateLinks,
+    };
+  }
+
+  @Patch("/:linkId")
+  @Permissions([EVENT_TYPE_WRITE])
+  @UseGuards(ApiAuthGuard, EventTypeOwnershipGuard)
+  @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
+  @ApiOperation({ summary: "Update a private link for an event type" })
+  async updatePrivateLink(
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Param("linkId") linkId: string,
+    @Body() body: UpdatePrivateLinkBody
+  ): Promise<UpdatePrivateLinkOutput> {
+    const updateInput = { ...body, linkId };
+    const privateLink = await this.privateLinksService.updatePrivateLink(eventTypeId, updateInput);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: privateLink,
+    };
+  }
+
+  @Delete("/:linkId")
+  @Permissions([EVENT_TYPE_WRITE])
+  @UseGuards(ApiAuthGuard, EventTypeOwnershipGuard)
+  @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
+  @ApiOperation({ summary: "Delete a private link for an event type" })
+  async deletePrivateLink(
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Param("linkId") linkId: string
+  ): Promise<DeletePrivateLinkOutput> {
+    await this.privateLinksService.deletePrivateLink(eventTypeId, linkId);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: {
+        linkId,
+        message: "Private link deleted successfully",
+      },
+    };
+  }
+}

apps/api/v2/src/ee/event-types-private-links/controllers/organizations-event-types-private-links.controller.ts

@@ -0,0 +1,121 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import {
+  OPTIONAL_API_KEY_HEADER,
+  OPTIONAL_X_CAL_CLIENT_ID_HEADER,
+  OPTIONAL_X_CAL_SECRET_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 { TeamsEventTypesService } from "@/modules/teams/event-types/services/teams-event-types.service";
+import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post, UseGuards } from "@nestjs/common";
+import { ApiHeader, ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import {
+  CreatePrivateLinkInput,
+  CreatePrivateLinkOutput,
+  DeletePrivateLinkOutput,
+  GetPrivateLinksOutput,
+  UpdatePrivateLinkInput,
+  UpdatePrivateLinkOutput,
+} from "@calcom/platform-types";
+
+import { PrivateLinksService } from "../services/private-links.service";
+
+@Controller({
+  path: "/v2/organizations/:orgId/teams/:teamId/event-types/:eventTypeId/private-links",
+  version: API_VERSIONS_VALUES,
+})
+@DocsTags("Orgs / Teams / Event Types / Private Links")
+@ApiHeader(OPTIONAL_X_CAL_CLIENT_ID_HEADER)
+@ApiHeader(OPTIONAL_X_CAL_SECRET_KEY_HEADER)
+@ApiHeader(OPTIONAL_API_KEY_HEADER)
+export class OrganizationsEventTypesPrivateLinksController {
+  constructor(
+    private readonly privateLinksService: PrivateLinksService,
+    private readonly teamsEventTypesService: TeamsEventTypesService
+  ) {}
+
+  @Post("/")
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  @ApiOperation({ summary: "Create a private link for a team event type" })
+  async createPrivateLink(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Body() body: CreatePrivateLinkInput
+  ): Promise<CreatePrivateLinkOutput> {
+    await this.teamsEventTypesService.validateEventTypeExists(teamId, eventTypeId);
+    // Use teamId as the seed for link generation in org/team context
+    const privateLink = await this.privateLinksService.createPrivateLink(eventTypeId, teamId, body);
+    return {
+      status: SUCCESS_STATUS,
+      data: privateLink,
+    };
+  }
+
+  @Get("/")
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  @ApiOperation({ summary: "Get all private links for a team event type" })
+  async getPrivateLinks(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number
+  ): Promise<GetPrivateLinksOutput> {
+    await this.teamsEventTypesService.validateEventTypeExists(teamId, eventTypeId);
+    const privateLinks = await this.privateLinksService.getPrivateLinks(eventTypeId);
+    return {
+      status: SUCCESS_STATUS,
+      data: privateLinks,
+    };
+  }
+
+  @Patch("/:linkId")
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  @ApiOperation({ summary: "Update a private link for a team event type" })
+  async updatePrivateLink(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Param("linkId") linkId: string,
+    @Body() body: Omit<UpdatePrivateLinkInput, "linkId">
+  ): Promise<UpdatePrivateLinkOutput> {
+    await this.teamsEventTypesService.validateEventTypeExists(teamId, eventTypeId);
+    const updateInput: UpdatePrivateLinkInput = { ...body, linkId };
+    const privateLink = await this.privateLinksService.updatePrivateLink(eventTypeId, updateInput);
+    return {
+      status: SUCCESS_STATUS,
+      data: privateLink,
+    };
+  }
+
+  @Delete("/:linkId")
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  @ApiOperation({ summary: "Delete a private link for a team event type" })
+  async deletePrivateLink(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Param("linkId") linkId: string
+  ): Promise<DeletePrivateLinkOutput> {
+    await this.teamsEventTypesService.validateEventTypeExists(teamId, eventTypeId);
+    await this.privateLinksService.deletePrivateLink(eventTypeId, linkId);
+    return {
+      status: SUCCESS_STATUS,
+      data: {
+        linkId,
+        message: "Private link deleted successfully",
+      },
+    };
+  }
+}

apps/api/v2/src/ee/event-types-private-links/event-types-private-links.module.ts

@@ -0,0 +1,26 @@
+import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
+import { EventTypeOwnershipGuard } from "@/modules/event-types/guards/event-type-ownership.guard";
+import { OAuthClientModule } from "@/modules/oauth-clients/oauth-client.module";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { Module } from "@nestjs/common";
+
+import { EventTypesPrivateLinksController } from "./controllers/event-types-private-links.controller";
+import { PrivateLinksRepository } from "./private-links.repository";
+import { PrivateLinksInputService } from "./services/private-links-input.service";
+import { PrivateLinksOutputService } from "./services/private-links-output.service";
+import { PrivateLinksService } from "./services/private-links.service";
+
+@Module({
+  imports: [TokensModule, PrismaModule, EventTypesModule_2024_06_14],
+  controllers: [EventTypesPrivateLinksController],
+  providers: [
+    PrivateLinksService,
+    PrivateLinksInputService,
+    PrivateLinksOutputService,
+    PrivateLinksRepository,
+    EventTypeOwnershipGuard,
+  ],
+  exports: [PrivateLinksService],
+})
+export class EventTypesPrivateLinksModule {}

apps/api/v2/src/ee/event-types-private-links/private-links.repository.ts

@@ -0,0 +1,58 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class PrivateLinksRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async listByEventTypeId(eventTypeId: number) {
+    return this.dbRead.prisma.hashedLink.findMany({
+      where: { eventTypeId },
+      select: { link: true, expiresAt: true, maxUsageCount: true, usageCount: true },
+    });
+  }
+
+  async findWithEventTypeDetails(linkId: string) {
+    return this.dbRead.prisma.hashedLink.findUnique({
+      where: { link: linkId },
+      select: {
+        link: true,
+        expiresAt: true,
+        maxUsageCount: true,
+        usageCount: true,
+      },
+    });
+  }
+
+  async create(
+    eventTypeId: number,
+    link: { link: string; expiresAt: Date | null; maxUsageCount?: number | null }
+  ) {
+    return this.dbWrite.prisma.hashedLink.create({
+      data: {
+        eventTypeId,
+        link: link.link,
+        expiresAt: link.expiresAt,
+        ...(typeof link.maxUsageCount === "number" ? { maxUsageCount: link.maxUsageCount } : {}),
+      },
+    });
+  }
+
+  async update(
+    eventTypeId: number,
+    link: { link: string; expiresAt: Date | null; maxUsageCount?: number | null }
+  ) {
+    return this.dbWrite.prisma.hashedLink.updateMany({
+      where: { eventTypeId, link: link.link },
+      data: {
+        expiresAt: link.expiresAt,
+        ...(typeof link.maxUsageCount === "number" ? { maxUsageCount: link.maxUsageCount } : {}),
+      },
+    });
+  }
+
+  async delete(eventTypeId: number, linkId: string) {
+    return this.dbWrite.prisma.hashedLink.deleteMany({ where: { eventTypeId, link: linkId } });
+  }
+}

apps/api/v2/src/ee/event-types-private-links/services/private-links-input.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from "@nestjs/common";
+
+import { CreatePrivateLinkInput, UpdatePrivateLinkInput } from "@calcom/platform-types";
+
+@Injectable()
+export class PrivateLinksInputService {
+  constructor() {}
+
+  transformCreateInput(input: CreatePrivateLinkInput): CreatePrivateLinkInput {
+    const hasExpires = input.expiresAt !== undefined && input.expiresAt !== null;
+    const hasMaxCount = typeof input.maxUsageCount === "number";
+
+    if (!hasExpires && !hasMaxCount) {
+      throw new Error("Either expiresAt or maxUsageCount must be provided");
+    }
+
+    if (hasExpires && hasMaxCount) {
+      throw new Error("Provide only one of expiresAt or maxUsageCount");
+    }
+
+    return {
+      expiresAt: input.expiresAt,
+      maxUsageCount: input.maxUsageCount ?? (hasMaxCount ? input.maxUsageCount : undefined),
+    };
+  }
+
+  transformUpdateInput(input: UpdatePrivateLinkInput): UpdatePrivateLinkInput {
+    return {
+      linkId: input.linkId,
+      expiresAt: input.expiresAt,
+      maxUsageCount: input.maxUsageCount,
+    };
+  }
+}

apps/api/v2/src/ee/event-types-private-links/services/private-links-output.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from "@nestjs/common";
+import { plainToClass } from "class-transformer";
+
+import {
+  PrivateLinkOutput,
+  TimeBasedPrivateLinkOutput,
+  UsageBasedPrivateLinkOutput,
+} from "@calcom/platform-types";
+
+export type PrivateLinkData = {
+  id: string;
+  eventTypeId: number;
+  isExpired: boolean;
+  bookingUrl: string;
+  expiresAt?: Date | null;
+  maxUsageCount?: number | null;
+  usageCount?: number;
+};
+
+@Injectable()
+export class PrivateLinksOutputService {
+  constructor() {}
+
+  transformToOutput(data: PrivateLinkData): PrivateLinkOutput {
+    const baseData = {
+      linkId: data.id.toString(),
+      eventTypeId: data.eventTypeId,
+      isExpired: data.isExpired,
+      bookingUrl: data.bookingUrl,
+    };
+
+    if (data.expiresAt !== null && data.expiresAt !== undefined) {
+      return plainToClass(TimeBasedPrivateLinkOutput, { ...baseData, expiresAt: data.expiresAt });
+    }
+
+    return plainToClass(UsageBasedPrivateLinkOutput, {
+      ...baseData,
+      maxUsageCount: data.maxUsageCount || 0,
+      usageCount: data.usageCount || 0,
+    });
+  }
+
+  transformArrayToOutput(data: PrivateLinkData[]): PrivateLinkOutput[] {
+    return data.map((item) => this.transformToOutput(item));
+  }
+}

apps/api/v2/src/ee/event-types-private-links/services/private-links.service.ts

@@ -0,0 +1,121 @@
+import { PrivateLinksRepository } from "@/ee/event-types-private-links/private-links.repository";
+import { PrivateLinksInputService } from "@/ee/event-types-private-links/services/private-links-input.service";
+import {
+  PrivateLinksOutputService,
+  type PrivateLinkData,
+} from "@/ee/event-types-private-links/services/private-links-output.service";
+import { Injectable, NotFoundException, BadRequestException } from "@nestjs/common";
+
+import { generateHashedLink, isLinkExpired } from "@calcom/platform-libraries/private-links";
+import { CreatePrivateLinkInput, PrivateLinkOutput, UpdatePrivateLinkInput } from "@calcom/platform-types";
+
+@Injectable()
+export class PrivateLinksService {
+  constructor(
+    private readonly inputService: PrivateLinksInputService,
+    private readonly outputService: PrivateLinksOutputService,
+    private readonly repo: PrivateLinksRepository
+  ) {}
+
+  async createPrivateLink(
+    eventTypeId: number,
+    userId: number,
+    input: CreatePrivateLinkInput
+  ): Promise<PrivateLinkOutput> {
+    try {
+      const transformedInput = this.inputService.transformCreateInput(input);
+      const created = await this.repo.create(eventTypeId, {
+        link: generateHashedLink(userId),
+        expiresAt: transformedInput.expiresAt ?? null,
+        maxUsageCount: transformedInput.maxUsageCount ?? null,
+      });
+      const mapped: PrivateLinkData = {
+        id: created.link,
+        eventTypeId,
+        isExpired: isLinkExpired(created as any),
+        bookingUrl: `${process.env.NEXT_PUBLIC_WEBAPP_URL || "https://cal.com"}/d/${created.link}`,
+        expiresAt: created.expiresAt ?? null,
+        maxUsageCount: (created as any).maxUsageCount ?? null,
+        usageCount: (created as any).usageCount ?? 0,
+      };
+      return this.outputService.transformToOutput(mapped);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new BadRequestException(error.message);
+      }
+      throw new BadRequestException("Failed to create private link");
+    }
+  }
+
+  async getPrivateLinks(eventTypeId: number): Promise<PrivateLinkOutput[]> {
+    try {
+      const links = await this.repo.listByEventTypeId(eventTypeId);
+      const mapped: PrivateLinkData[] = links.map((l) => ({
+        id: l.link,
+        eventTypeId,
+        isExpired: isLinkExpired(l as any),
+        bookingUrl: `${process.env.NEXT_PUBLIC_WEBAPP_URL || "https://cal.com"}/d/${l.link}`,
+        expiresAt: l.expiresAt ?? null,
+        maxUsageCount: l.maxUsageCount ?? null,
+        usageCount: l.usageCount ?? 0,
+      }));
+      return this.outputService.transformArrayToOutput(mapped);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new BadRequestException(error.message);
+      }
+      throw new BadRequestException("Failed to get private links");
+    }
+  }
+
+  async updatePrivateLink(eventTypeId: number, input: UpdatePrivateLinkInput): Promise<PrivateLinkOutput> {
+    try {
+      const transformedInput = this.inputService.transformUpdateInput(input);
+      const updatedResult = await this.repo.update(eventTypeId, {
+        link: transformedInput.linkId,
+        expiresAt: transformedInput.expiresAt ?? null,
+        maxUsageCount: transformedInput.maxUsageCount ?? null,
+      });
+      if (!updatedResult || (updatedResult as any).count === 0) {
+        throw new NotFoundException("Updated link not found");
+      }
+      const updated = await this.repo.findWithEventTypeDetails(transformedInput.linkId);
+      if (!updated) throw new NotFoundException("Updated link not found");
+      const mapped: PrivateLinkData = {
+        id: updated.link,
+        eventTypeId,
+        isExpired: isLinkExpired(updated as any),
+        bookingUrl: `${process.env.NEXT_PUBLIC_WEBAPP_URL || "https://cal.com"}/d/${updated.link}`,
+        expiresAt: updated.expiresAt ?? null,
+        maxUsageCount: updated.maxUsageCount ?? null,
+        usageCount: updated.usageCount ?? 0,
+      };
+      return this.outputService.transformToOutput(mapped);
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("not found")) {
+          throw new NotFoundException(error.message);
+        }
+        throw new BadRequestException(error.message);
+      }
+      throw new BadRequestException("Failed to update private link");
+    }
+  }
+
+  async deletePrivateLink(eventTypeId: number, linkId: string): Promise<void> {
+    try {
+      const { count } = await this.repo.delete(eventTypeId, linkId);
+      if (count === 0) {
+        throw new NotFoundException("Deleted link not found");
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("not found")) {
+          throw new NotFoundException(error.message);
+        }
+        throw new BadRequestException(error.message);
+      }
+      throw new BadRequestException("Failed to delete private link");
+    }
+  }
+}

apps/api/v2/src/ee/event-types/event-types_2024_04_15/controllers/event-types.controller.e2e-spec.ts

@@ -290,7 +290,10 @@ describe("Event types Endpoints", () => {
           expect(responseBookingFields).toBeDefined();
           // note(Lauris): response bookingFields are already existing default bookingFields + the new one
           const responseBookingField = responseBookingFields.find((field) => field.name === bookingFieldName);
-          expect(responseBookingField).toEqual(bookingFields[0]);
+          const fields = responseBookingField
+          //@ts-ignore
+          delete fields.labelAsSafeHtml
+          expect(fields).toEqual(bookingFields[0]);
           eventType.bookingFields = responseBookingFields;
         });
     });

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

@@ -1,6 +1,7 @@
 import { BookingsModule_2024_04_15 } from "@/ee/bookings/2024-04-15/bookings.module";
 import { BookingsModule_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.module";
 import { CalendarsModule } from "@/ee/calendars/calendars.module";
+import { EventTypesPrivateLinksModule } from "@/ee/event-types-private-links/event-types-private-links.module";
 import { EventTypesModule_2024_04_15 } from "@/ee/event-types/event-types_2024_04_15/event-types.module";
 import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
 import { GcalModule } from "@/ee/gcal/gcal.module";
@@ -35,6 +36,7 @@ import { Module } from "@nestjs/common";
     SlotsModule_2024_09_04,
     TeamsModule,
     RoutingFormsModule,
+    EventTypesPrivateLinksModule,
   ],
 })
 export class PlatformEndpointsModule implements NestModule {

apps/api/v2/src/lib/modules/available-slots.module.ts

@@ -1,6 +1,7 @@
 import { PrismaBookingRepository } from "@/lib/repositories/prisma-booking.repository";
 import { PrismaEventTypeRepository } from "@/lib/repositories/prisma-event-type.repository";
 import { PrismaFeaturesRepository } from "@/lib/repositories/prisma-features.repository";
+import { PrismaMembershipRepository } from "@/lib/repositories/prisma-membership.repository";
 import { PrismaOOORepository } from "@/lib/repositories/prisma-ooo.repository";
 import { PrismaRoutingFormResponseRepository } from "@/lib/repositories/prisma-routing-form-response.repository";
 import { PrismaScheduleRepository } from "@/lib/repositories/prisma-schedule.repository";
@@ -8,9 +9,15 @@ import { PrismaSelectedSlotRepository } from "@/lib/repositories/prisma-selected
 import { PrismaTeamRepository } from "@/lib/repositories/prisma-team.repository";
 import { PrismaUserRepository } from "@/lib/repositories/prisma-user.repository";
 import { AvailableSlotsService } from "@/lib/services/available-slots.service";
+import { BusyTimesService } from "@/lib/services/busy-times.service";
 import { CacheService } from "@/lib/services/cache.service";
 import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.service";
+import { FilterHostsService } from "@/lib/services/filter-hosts.service";
+import { NoSlotsNotificationService } from "@/lib/services/no-slots-notification.service";
+import { QualifiedHostsService } from "@/lib/services/qualified-hosts.service";
+import { UserAvailabilityService } from "@/lib/services/user-availability.service";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { RedisService } from "@/modules/redis/redis.service";
 import { Module } from "@nestjs/common";
 
 @Module({
@@ -24,10 +31,17 @@ import { Module } from "@nestjs/common";
     PrismaEventTypeRepository,
     PrismaRoutingFormResponseRepository,
     PrismaTeamRepository,
+    RedisService,
     PrismaFeaturesRepository,
+    PrismaMembershipRepository,
     CheckBookingLimitsService,
     CacheService,
     AvailableSlotsService,
+    UserAvailabilityService,
+    BusyTimesService,
+    FilterHostsService,
+    QualifiedHostsService,
+    NoSlotsNotificationService,
   ],
   exports: [AvailableSlotsService],
 })

apps/api/v2/src/lib/repositories/prisma-membership.repository.ts

@@ -0,0 +1,12 @@
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+import { PrismaMembershipRepository as PrismaMembershipRepositoryLib } from "@calcom/platform-libraries/repositories";
+import { PrismaClient } from "@calcom/prisma";
+
+@Injectable()
+export class PrismaMembershipRepository extends PrismaMembershipRepositoryLib {
+  constructor(private readonly dbWrite: PrismaWriteService) {
+    super(dbWrite.prisma as unknown as PrismaClient);
+  }
+}

apps/api/v2/src/lib/services/available-slots.service.ts

@@ -7,12 +7,18 @@ import { PrismaScheduleRepository } from "@/lib/repositories/prisma-schedule.rep
 import { PrismaSelectedSlotRepository } from "@/lib/repositories/prisma-selected-slot.repository";
 import { PrismaTeamRepository } from "@/lib/repositories/prisma-team.repository";
 import { PrismaUserRepository } from "@/lib/repositories/prisma-user.repository";
+import { BusyTimesService } from "@/lib/services/busy-times.service";
 import { CacheService } from "@/lib/services/cache.service";
 import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.service";
+import { NoSlotsNotificationService } from "@/lib/services/no-slots-notification.service";
+import { QualifiedHostsService } from "@/lib/services/qualified-hosts.service";
+import { RedisService } from "@/modules/redis/redis.service";
 import { Injectable } from "@nestjs/common";
 
 import { AvailableSlotsService as BaseAvailableSlotsService } from "@calcom/platform-libraries/slots";
 
+import { UserAvailabilityService } from "./user-availability.service";
+
 @Injectable()
 export class AvailableSlotsService extends BaseAvailableSlotsService {
   constructor(
@@ -24,7 +30,14 @@ export class AvailableSlotsService extends BaseAvailableSlotsService {
     selectedSlotRepository: PrismaSelectedSlotRepository,
     eventTypeRepository: PrismaEventTypeRepository,
     userRepository: PrismaUserRepository,
-    featuresRepository: PrismaFeaturesRepository
+    redisService: RedisService,
+    featuresRepository: PrismaFeaturesRepository,
+    qualifiedHostsService: QualifiedHostsService,
+    checkBookingLimitsService: CheckBookingLimitsService,
+    cacheService: CacheService,
+    userAvailabilityService: UserAvailabilityService,
+    busyTimesService: BusyTimesService,
+    noSlotsNotificationService: NoSlotsNotificationService
   ) {
     super({
       oooRepo: oooRepoDependency,
@@ -35,8 +48,14 @@ export class AvailableSlotsService extends BaseAvailableSlotsService {
       selectedSlotRepo: selectedSlotRepository,
       eventTypeRepo: eventTypeRepository,
       userRepo: userRepository,
-      checkBookingLimitsService: new CheckBookingLimitsService(bookingRepository) as any,
-      cacheService: new CacheService(featuresRepository),
+      redisClient: redisService,
+      checkBookingLimitsService,
+      cacheService,
+      userAvailabilityService,
+      busyTimesService,
+      qualifiedHostsService,
+      featuresRepo: featuresRepository,
+      noSlotsNotificationService,
     });
   }
 }

apps/api/v2/src/lib/services/busy-times.service.ts

@@ -0,0 +1,13 @@
+import { PrismaBookingRepository } from "@/lib/repositories/prisma-booking.repository";
+import { Injectable } from "@nestjs/common";
+
+import { BusyTimesService as BaseBusyTimesService } from "@calcom/platform-libraries/slots";
+
+@Injectable()
+export class BusyTimesService extends BaseBusyTimesService {
+  constructor(bookingRepository: PrismaBookingRepository) {
+    super({
+      bookingRepo: bookingRepository,
+    });
+  }
+}

apps/api/v2/src/lib/services/filter-hosts.service.ts

@@ -0,0 +1,13 @@
+import { PrismaBookingRepository } from "@/lib/repositories/prisma-booking.repository";
+import { Injectable } from "@nestjs/common";
+
+import { FilterHostsService as BaseFilterHostsService } from "@calcom/platform-libraries/slots";
+
+@Injectable()
+export class FilterHostsService extends BaseFilterHostsService {
+  constructor(bookingRepository: PrismaBookingRepository) {
+    super({
+      bookingRepo: bookingRepository,
+    });
+  }
+}

apps/api/v2/src/lib/services/no-slots-notification.service.ts

@@ -0,0 +1,21 @@
+import { PrismaMembershipRepository } from "@/lib/repositories/prisma-membership.repository";
+import { PrismaTeamRepository } from "@/lib/repositories/prisma-team.repository";
+import { RedisService } from "@/modules/redis/redis.service";
+import { Injectable } from "@nestjs/common";
+
+import { NoSlotsNotificationService as BaseNoSlotsNotificationService } from "@calcom/platform-libraries/slots";
+
+@Injectable()
+export class NoSlotsNotificationService extends BaseNoSlotsNotificationService {
+  constructor(
+    teamRepository: PrismaTeamRepository,
+    membershipRepository: PrismaMembershipRepository,
+    redisService: RedisService
+  ) {
+    super({
+      teamRepo: teamRepository,
+      membershipRepo: membershipRepository,
+      redisClient: redisService,
+    });
+  }
+}

apps/api/v2/src/lib/services/qualified-hosts.service.ts

@@ -0,0 +1,15 @@
+import { PrismaBookingRepository } from "@/lib/repositories/prisma-booking.repository";
+import { FilterHostsService } from "@/lib/services/filter-hosts.service";
+import { Injectable } from "@nestjs/common";
+
+import { QualifiedHostsService as BaseQualifiedHostsService } from "@calcom/platform-libraries/slots";
+
+@Injectable()
+export class QualifiedHostsService extends BaseQualifiedHostsService {
+  constructor(bookingRepository: PrismaBookingRepository, filterHostsService: FilterHostsService) {
+    super({
+      bookingRepo: bookingRepository,
+      filterHostsService,
+    });
+  }
+}

apps/api/v2/src/lib/services/user-availability.service.ts

@@ -0,0 +1,24 @@
+import { PrismaBookingRepository } from "@/lib/repositories/prisma-booking.repository";
+import { PrismaEventTypeRepository } from "@/lib/repositories/prisma-event-type.repository";
+import { PrismaOOORepository } from "@/lib/repositories/prisma-ooo.repository";
+import { RedisService } from "@/modules/redis/redis.service";
+import { Injectable } from "@nestjs/common";
+
+import { UserAvailabilityService as BaseUserAvailabilityService } from "@calcom/platform-libraries/schedules";
+
+@Injectable()
+export class UserAvailabilityService extends BaseUserAvailabilityService {
+  constructor(
+    oooRepoDependency: PrismaOOORepository,
+    bookingRepository: PrismaBookingRepository,
+    eventTypeRepository: PrismaEventTypeRepository,
+    redisService: RedisService
+  ) {
+    super({
+      oooRepo: oooRepoDependency,
+      bookingRepo: bookingRepository,
+      eventTypeRepo: eventTypeRepository,
+      redisClient: redisService,
+    });
+  }
+}

apps/api/v2/src/modules/billing/services/billing.service.ts

@@ -403,6 +403,10 @@ export class BillingService implements OnModuleDestroy {
       fromReschedule?: string | null;
     }
   ) {
+
+    if (this.configService.get("e2e")) {
+      return true;
+    }
     const { uid, startTime, fromReschedule } = booking;
 
     const delay = startTime.getTime() - Date.now();
@@ -427,6 +431,9 @@ export class BillingService implements OnModuleDestroy {
    * Removing an attendee from a booking does not cancel the usage increment job.
    */
   async cancelUsageByBookingUid(bookingUid: string) {
+    if (this.configService.get("e2e")) {
+      return true;
+    }
     const job = await this.billingQueue.getJob(`increment-${bookingUid}`);
     if (job) {
       await job.remove();
@@ -458,6 +465,7 @@ export class BillingService implements OnModuleDestroy {
 
   async onModuleDestroy() {
     try {
+      
       await this.billingQueue.close();
     } catch (err) {
       this.logger.error(err);

apps/api/v2/src/modules/cal-unified-calendars/controllers/cal-unified-calendars.controller.ts

@@ -2,10 +2,21 @@ import { API_VERSIONS_VALUES } from "@/lib/api-versions";
 import { API_KEY_OR_ACCESS_TOKEN_HEADER } from "@/lib/docs/headers";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
 import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
-import { GetUnifiedCalendarEventOutput } from "@/modules/cal-unified-calendars/outputs/get-unified-calendar-event";
+import { UpdateUnifiedCalendarEventInput } from "@/modules/cal-unified-calendars/inputs/update-unified-calendar-event.input";
+import { GetUnifiedCalendarEventOutput } from "@/modules/cal-unified-calendars/outputs/get-unified-calendar-event.output";
 import { GoogleCalendarEventOutputPipe } from "@/modules/cal-unified-calendars/pipes/get-calendar-event-details-output-pipe";
 import { GoogleCalendarService } from "@/modules/cal-unified-calendars/services/google-calendar.service";
-import { Controller, Get, Param, UseGuards, HttpCode, HttpStatus, BadRequestException } from "@nestjs/common";
+import {
+  Controller,
+  Get,
+  Param,
+  UseGuards,
+  HttpCode,
+  HttpStatus,
+  BadRequestException,
+  Patch,
+  Body,
+} from "@nestjs/common";
 import { ApiTags as DocsTags, ApiParam, ApiHeader, ApiOperation } from "@nestjs/swagger";
 
 import { GOOGLE_CALENDAR, SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -30,6 +41,7 @@ export class CalUnifiedCalendarsController {
     type: String,
   })
   @Get("/:calendar/event/:eventUid")
+  @Get("/:calendar/events/:eventUid")
   @HttpCode(HttpStatus.OK)
   @UseGuards(ApiAuthGuard, PermissionsGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
@@ -54,4 +66,42 @@ export class CalUnifiedCalendarsController {
       data: transformedEvent,
     };
   }
+
+  @ApiParam({
+    name: "calendar",
+    enum: [GOOGLE_CALENDAR],
+    type: String,
+  })
+  @ApiParam({
+    name: "eventUid",
+    description:
+      "The Google Calendar event ID. You can retrieve this by getting booking references from the following endpoints:\n\n- For team events: https://cal.com/docs/api-reference/v2/orgs-teams-bookings/get-booking-references-for-a-booking\n\n- For user events: https://cal.com/docs/api-reference/v2/bookings/get-booking-references-for-a-booking",
+    type: String,
+  })
+  @Patch("/:calendar/events/:eventUid")
+  @HttpCode(HttpStatus.OK)
+  @UseGuards(ApiAuthGuard, PermissionsGuard)
+  @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
+  @ApiOperation({
+    summary: "Update meeting details in calendar",
+    description: "Updates event information in the specified calendar provider",
+  })
+  async updateCalendarEvent(
+    @Param("calendar") calendar: string,
+    @Param("eventUid") eventUid: string,
+    @Body() updateData: UpdateUnifiedCalendarEventInput
+  ): Promise<GetUnifiedCalendarEventOutput> {
+    if (calendar !== GOOGLE_CALENDAR) {
+      throw new BadRequestException("Event updates are currently only available for Google Calendar");
+    }
+
+    const updatedEvent = await this.googleCalendarService.updateEventDetails(eventUid, updateData);
+
+    const transformedEvent = new GoogleCalendarEventOutputPipe().transform(updatedEvent);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: transformedEvent,
+    };
+  }
 }

apps/api/v2/src/modules/cal-unified-calendars/inputs/update-unified-calendar-event.input.ts

@@ -0,0 +1,134 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsISO8601, IsOptional, IsString, ValidateNested, IsEnum, IsArray } from "class-validator";
+
+import { CalendarEventStatus, CalendarEventResponseStatus } from "../outputs/get-unified-calendar-event.output";
+
+export class UpdateCalendarEventAttendee {
+  @IsString()
+  @ApiPropertyOptional({
+    type: String,
+    description: "Email address of the attendee",
+  })
+  email!: string;
+
+  @IsString()
+  @IsOptional()
+  @ApiPropertyOptional({
+    type: String,
+    description: "Display name of the attendee",
+  })
+  name?: string;
+
+  @IsEnum(CalendarEventResponseStatus)
+  @IsOptional()
+  @ApiPropertyOptional({
+    enum: CalendarEventResponseStatus,
+    enumName: "CalendarEventResponseStatus",
+    nullable: true,
+    description: "Response status of the attendee",
+  })
+  responseStatus?: CalendarEventResponseStatus | null;
+
+  @IsOptional()
+  @ApiPropertyOptional({
+    nullable: true,
+    description: "Indicates if this attendee is the current user",
+  })
+  self?: boolean;
+
+  @IsOptional()
+  @ApiPropertyOptional({
+    nullable: true,
+    description: "Indicates if this attendee's attendance is optional",
+  })
+  optional?: boolean;
+
+  @IsOptional()
+  @ApiPropertyOptional({
+    nullable: true,
+    description: "Indicates if this attendee is the host",
+  })
+  host?: boolean;
+
+}
+
+export class UpdateDateTimeWithZone {
+  @IsISO8601()
+  @IsOptional()
+  @ApiPropertyOptional({ type: "string", format: "date-time" })
+  time?: string;
+
+  @IsString()
+  @IsOptional()
+  @ApiPropertyOptional()
+  timeZone?: string;
+}
+
+export class UpdateUnifiedCalendarEventInput {
+  @ValidateNested()
+  @Type(() => UpdateDateTimeWithZone)
+  @IsOptional()
+  @ApiPropertyOptional({
+    type: "object",
+    properties: {
+      time: { type: "string", format: "date-time" },
+      timeZone: { type: "string" },
+    },
+    description: "Start date and time of the calendar event with timezone information",
+  })
+  start?: UpdateDateTimeWithZone;
+
+  @ValidateNested()
+  @Type(() => UpdateDateTimeWithZone)
+  @IsOptional()
+  @ApiPropertyOptional({
+    type: "object",
+    properties: {
+      time: { type: "string", format: "date-time" },
+      timeZone: { type: "string" },
+    },
+    description: "End date and time of the calendar event with timezone information",
+  })
+  end?: UpdateDateTimeWithZone;
+
+  @IsString()
+  @IsOptional()
+  @ApiPropertyOptional({
+    type: String,
+    description: "Title of the calendar event",
+  })
+  title?: string;
+
+  @IsString()
+  @IsOptional()
+  @ApiPropertyOptional({
+    type: String,
+    nullable: true,
+    description: "Detailed description of the calendar event",
+  })
+  description?: string | null;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => UpdateCalendarEventAttendee)
+  @ApiPropertyOptional({
+    type: [UpdateCalendarEventAttendee],
+    nullable: true,
+    description:
+      "List of attendees. CAUTION: You must pass the entire array with all updated values. Any attendees not included in this array will be removed from the event.",
+  })
+  attendees?: UpdateCalendarEventAttendee[];
+
+  @IsEnum(CalendarEventStatus)
+  @IsOptional()
+  @ApiPropertyOptional({
+    enum: CalendarEventStatus,
+    enumName: "CalendarEventStatus",
+    nullable: true,
+    description: "Status of the event (accepted, pending, declined, cancelled)",
+    example: CalendarEventStatus.ACCEPTED,
+  })
+  status?: CalendarEventStatus | null;
+}

apps/api/v2/src/modules/cal-unified-calendars/outputs/get-unified-calendar-event.output.ts

@@ -225,6 +225,22 @@ export class CalendarEventHost {
   responseStatus!: CalendarEventResponseStatus | null;
 }
 
+export class calendarEventOwner {
+  @IsString()
+  @ApiProperty({
+    description: "Email address of the event host",
+  })
+  email!: string;
+
+  @IsString()
+  @IsOptional()
+  @ApiPropertyOptional({
+    nullable: true,
+    description: "Display name of the event host",
+  })
+  name?: string;
+}
+
 export class CalendarEventAttendee {
   @IsString()
   @ApiProperty({
@@ -264,6 +280,14 @@ export class CalendarEventAttendee {
     description: "Indicates if this attendee's attendance is optional",
   })
   optional?: boolean;
+
+
+  @IsOptional()
+  @ApiPropertyOptional({
+    nullable: true,
+    description: "Indicates if this attendee is the host",
+  })
+  host?: boolean;
 }
 
 export class DateTimeWithZone {
@@ -384,6 +408,16 @@ export class UnifiedCalendarEventOutput {
   })
   hosts?: CalendarEventHost[];
 
+  @IsOptional()
+  @ValidateNested({ each: true })
+  @Type(() => calendarEventOwner)
+  @ApiPropertyOptional({
+    type: calendarEventOwner,
+    nullable: true,
+    description: "The calendar account that owns this event. This is the primary calendar where the event is stored and cannot be modified without appropriate permissions. Changing this would require moving the event to a different calendar",
+  })
+  calendarEventOwner?: calendarEventOwner;
+
   @IsEnum(CALENDARS)
   @ApiProperty({
     enum: CALENDARS,

apps/api/v2/src/modules/cal-unified-calendars/pipes/__fixtures__/google-calendar-event.fixture.ts

@@ -0,0 +1,103 @@
+import { GoogleCalendarEventResponse } from "../get-calendar-event-details-output-pipe";
+
+export const createGoogleCalendarEventFixture = (
+  overrides: Partial<GoogleCalendarEventResponse> = {}
+): GoogleCalendarEventResponse => {
+  const baseEvent: GoogleCalendarEventResponse = {
+    kind: "calendar#event",
+    etag: "test-etag",
+    id: "test-event-id",
+    status: "confirmed",
+    htmlLink: "https://calendar.google.com/event",
+    created: "2024-01-01T00:00:00Z",
+    updated: "2024-01-01T00:00:00Z",
+    summary: "Test Meeting",
+    description: "Test description",
+    creator: {
+      email: "creator@example.com",
+      displayName: "Creator Name",
+    },
+    organizer: {
+      email: "organizer@example.com",
+      displayName: "Organizer Name",
+    },
+    start: {
+      dateTime: "2024-01-15T10:00:00Z",
+      timeZone: "America/New_York",
+    },
+    end: {
+      dateTime: "2024-01-15T11:00:00Z",
+      timeZone: "America/New_York",
+    },
+    iCalUID: "test-ical-uid",
+    sequence: 0,
+    attendees: [
+      {
+        email: "attendee@example.com",
+        displayName: "Attendee Name",
+        responseStatus: "accepted",
+        organizer: false,
+      },
+      {
+        email: "organizer@example.com",
+        displayName: "Organizer Name",
+        responseStatus: "accepted",
+        organizer: true,
+      },
+    ],
+    conferenceData: {
+      conferenceId: "abc-def-ghi",
+      entryPoints: [
+        {
+          entryPointType: "video",
+          uri: "https://meet.google.com/abc-def-ghi",
+          label: "meet.google.com/abc-def-ghi",
+        },
+      ],
+      conferenceSolution: {
+        key: {
+          type: "hangoutsMeet",
+        },
+        name: "Google Meet",
+        iconUri:
+          "https://fonts.gstatic.com/s/i/productlogos/meet_2020q4/v6/web-512dp/logo_meet_2020q4_color_2x_web_512dp.png",
+      },
+    },
+    hangoutLink: "https://meet.google.com/abc-def-ghi",
+  };
+
+  return { ...baseEvent, ...overrides };
+};
+
+export const googleEventWithConferenceData = createGoogleCalendarEventFixture({
+  conferenceData: {
+    conferenceId: "test-conference-id",
+    entryPoints: [
+      {
+        entryPointType: "video",
+        uri: "https://meet.google.com/abc-def-ghi",
+        label: "Google Meet",
+        pin: "123456",
+        regionCode: "US",
+      },
+      {
+        entryPointType: "phone",
+        uri: "tel:+1-555-123-4567",
+        label: "Phone",
+        pin: "789012",
+      },
+    ],
+  },
+});
+
+export const googleEventWithLocationOnly = createGoogleCalendarEventFixture({
+  location: "123 Main St, City, State",
+  conferenceData: undefined,
+  hangoutLink: undefined,
+});
+
+export const googleEventWithHangoutLink = createGoogleCalendarEventFixture({
+  hangoutLink: "https://hangouts.google.com/call/abc123",
+  conferenceData: undefined,
+  location: undefined,
+});

apps/api/v2/src/modules/cal-unified-calendars/pipes/get-calendar-event-details-output-pipe.spec.ts

@@ -0,0 +1,201 @@
+import {
+  CalendarEventStatus,
+  CalendarEventResponseStatus,
+} from "@/modules/cal-unified-calendars/outputs/get-unified-calendar-event.output";
+
+import {
+  createGoogleCalendarEventFixture,
+  googleEventWithConferenceData,
+  googleEventWithLocationOnly,
+  googleEventWithHangoutLink,
+} from "./__fixtures__/google-calendar-event.fixture";
+import {
+  GoogleCalendarEventOutputPipe,
+  GoogleCalendarEventResponse,
+} from "./get-calendar-event-details-output-pipe";
+
+describe("GoogleCalendarEventOutputPipe", () => {
+  let pipe: GoogleCalendarEventOutputPipe;
+  let sharedGoogleEvent: GoogleCalendarEventResponse;
+
+  beforeAll(() => {
+    sharedGoogleEvent = createGoogleCalendarEventFixture();
+  });
+
+  beforeEach(() => {
+    pipe = new GoogleCalendarEventOutputPipe();
+  });
+
+  describe("transform", () => {
+    it("should transform Google Calendar event to unified format", () => {
+      const result = pipe.transform(sharedGoogleEvent);
+
+      expect(result.id).toBe("test-event-id");
+      expect(result.title).toBe("Test Meeting");
+      expect(result.description).toBe("Test description");
+      expect(result.source).toBe("google");
+      expect(result.status).toBe(CalendarEventStatus.ACCEPTED);
+      expect(result.start.time).toBe("2024-01-15T10:00:00Z");
+      expect(result.start.timeZone).toBe("America/New_York");
+      expect(result.end.time).toBe("2024-01-15T11:00:00Z");
+      expect(result.end.timeZone).toBe("America/New_York");
+      expect(result.attendees).toHaveLength(2);
+    });
+  });
+
+  describe("transformDateTimeWithZone", () => {
+    it("should transform Google date time to unified format", () => {
+      const googleDateTime = {
+        dateTime: "2024-01-15T10:00:00Z",
+        timeZone: "America/New_York",
+      };
+
+      const result = pipe["transformDateTimeWithZone"](googleDateTime);
+
+      expect(result.time).toBe("2024-01-15T10:00:00Z");
+      expect(result.timeZone).toBe("America/New_York");
+    });
+  });
+
+  describe("transformAttendeeResponseStatus", () => {
+    it("should transform accepted status", () => {
+      const result = pipe["transformAttendeeResponseStatus"]("accepted");
+      expect(result).toBe(CalendarEventResponseStatus.ACCEPTED);
+    });
+
+    it("should transform tentative status", () => {
+      const result = pipe["transformAttendeeResponseStatus"]("tentative");
+      expect(result).toBe(CalendarEventResponseStatus.PENDING);
+    });
+
+    it("should transform declined status", () => {
+      const result = pipe["transformAttendeeResponseStatus"]("declined");
+      expect(result).toBe(CalendarEventResponseStatus.DECLINED);
+    });
+
+    it("should transform needsaction status", () => {
+      const result = pipe["transformAttendeeResponseStatus"]("needsaction");
+      expect(result).toBe(CalendarEventResponseStatus.NEEDS_ACTION);
+    });
+
+    it("should handle case insensitive status", () => {
+      const result = pipe["transformAttendeeResponseStatus"]("ACCEPTED");
+      expect(result).toBe(CalendarEventResponseStatus.ACCEPTED);
+    });
+
+    it("should handle unknown status", () => {
+      const result = pipe["transformAttendeeResponseStatus"]("unknown");
+      expect(result).toBeNull();
+    });
+
+    it("should handle null status", () => {
+      const result = pipe["transformAttendeeResponseStatus"](undefined);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("transformEventStatus", () => {
+    it("should transform confirmed status", () => {
+      const result = pipe["transformEventStatus"]("confirmed");
+      expect(result).toBe(CalendarEventStatus.ACCEPTED);
+    });
+
+    it("should transform tentative status", () => {
+      const result = pipe["transformEventStatus"]("tentative");
+      expect(result).toBe(CalendarEventStatus.PENDING);
+    });
+
+    it("should transform cancelled status", () => {
+      const result = pipe["transformEventStatus"]("cancelled");
+      expect(result).toBe(CalendarEventStatus.CANCELLED);
+    });
+
+    it("should handle case insensitive status", () => {
+      const result = pipe["transformEventStatus"]("CONFIRMED");
+      expect(result).toBe(CalendarEventStatus.ACCEPTED);
+    });
+
+    it("should handle unknown status", () => {
+      const result = pipe["transformEventStatus"]("unknown");
+      expect(result).toBeNull();
+    });
+
+    it("should handle null status", () => {
+      const result = pipe["transformEventStatus"](undefined);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("transformOrganizer", () => {
+    it("should return calendarEventOwner organizer exist", () => {
+      const eventWithoutOrganizerAttendees = createGoogleCalendarEventFixture({
+        organizer: { email: "organizer@example.com" },
+        attendees: [
+          {
+            email: "attendee@example.com",
+            displayName: "Regular Attendee",
+            responseStatus: "accepted",
+            organizer: false,
+          },
+        ],
+      });
+
+      const result = pipe.transform(eventWithoutOrganizerAttendees);
+
+      expect(result?.calendarEventOwner?.email).toBe("organizer@example.com");
+    });
+  });
+
+  describe("transformLocations", () => {
+    it("should transform conference data entry points", () => {
+      const result = pipe["transformLocations"](googleEventWithConferenceData);
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({
+        type: "video",
+        url: "https://meet.google.com/abc-def-ghi",
+        label: "Google Meet",
+        pin: "123456",
+        regionCode: "US",
+      });
+      expect(result[1]).toEqual({
+        type: "phone",
+        url: "tel:+1-555-123-4567",
+        label: "Phone",
+        pin: "789012",
+        regionCode: undefined,
+      });
+    });
+
+    it("should fallback to location field", () => {
+      const result = pipe["transformLocations"](googleEventWithLocationOnly);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        type: "video",
+        url: "123 Main St, City, State",
+      });
+    });
+
+    it("should fallback to hangout link", () => {
+      const result = pipe["transformLocations"](googleEventWithHangoutLink);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        type: "video",
+        url: "https://hangouts.google.com/call/abc123",
+      });
+    });
+
+    it("should return empty array when no location data", () => {
+      const eventWithoutLocation = createGoogleCalendarEventFixture({
+        location: undefined,
+        conferenceData: undefined,
+        hangoutLink: undefined,
+      });
+
+      const result = pipe["transformLocations"](eventWithoutLocation);
+      expect(result).toEqual([]);
+    });
+  });
+});

apps/api/v2/src/modules/cal-unified-calendars/pipes/get-calendar-event-details-output-pipe.ts

@@ -3,7 +3,7 @@ import {
   CalendarEventStatus,
   DateTimeWithZone,
   UnifiedCalendarEventOutput,
-} from "@/modules/cal-unified-calendars/outputs/get-unified-calendar-event";
+} from "@/modules/cal-unified-calendars/outputs/get-unified-calendar-event.output";
 import { PipeTransform, Injectable } from "@nestjs/common";
 
 export interface GoogleCalendarEventResponse {
@@ -94,14 +94,12 @@ export class GoogleCalendarEventOutputPipe
     calendarEvent.locations = this.transformLocations(googleEvent);
 
     if (googleEvent.attendees && googleEvent.attendees.length > 0) {
-      calendarEvent.attendees = googleEvent.attendees
-        .filter((attendee) => !attendee.organizer)
-        .map((attendee) => {
+      calendarEvent.attendees = googleEvent.attendees.map((attendee) => {
           return {
             email: attendee.email,
             name: attendee.displayName,
             responseStatus: this.transformAttendeeResponseStatus(attendee.responseStatus),
-            organizer: attendee.organizer,
+            host: attendee.organizer,
             self: attendee.self,
             optional: attendee.optional,
           };
@@ -110,7 +108,8 @@ export class GoogleCalendarEventOutputPipe
 
     calendarEvent.status = this.transformEventStatus(googleEvent.status);
 
-    calendarEvent.hosts = this.transformHosts(googleEvent);
+    calendarEvent.calendarEventOwner = googleEvent.organizer 
+    calendarEvent.hosts = this.transformHosts(googleEvent) 
 
     calendarEvent.source = "google";
 
@@ -196,6 +195,8 @@ export class GoogleCalendarEventOutputPipe
           regionCode: entryPoint.regionCode,
         };
       });
+    } else if (googleEvent.location) {
+      return [{ type: "video", url: googleEvent.location }];
     } else if (googleEvent.hangoutLink) {
       return [{ type: "video", url: googleEvent.hangoutLink }];
     }

apps/api/v2/src/modules/cal-unified-calendars/pipes/google-calendar-event-input-pipe.ts

@@ -0,0 +1,121 @@
+import { GoogleCalendarEventResponse } from "@/modules/cal-unified-calendars/pipes/get-calendar-event-details-output-pipe";
+import { Injectable } from "@nestjs/common";
+
+import {
+  UpdateUnifiedCalendarEventInput,
+  UpdateDateTimeWithZone,
+} from "../inputs/update-unified-calendar-event.input";
+import { CalendarEventResponseStatus, CalendarEventStatus } from "../outputs/get-unified-calendar-event.output";
+
+// Common interfaces for Google Calendar types
+interface GoogleCalendarDateTime {
+  dateTime: string;
+  timeZone: string;
+}
+
+interface GoogleCalendarAttendee {
+  email: string;
+  displayName?: string;
+  responseStatus: string;
+  organizer?: boolean;
+}
+
+interface GoogleCalendarEventInputTransform {
+  transform(
+    updateData: UpdateUnifiedCalendarEventInput,
+    fetchedEvent?: GoogleCalendarEventResponse | null
+  ): any;
+}
+
+@Injectable()
+export class GoogleCalendarEventInputPipe implements GoogleCalendarEventInputTransform {
+  transform(
+    updateData: UpdateUnifiedCalendarEventInput,
+  ): any {
+    const updatePayload: any = {};
+
+    if (updateData.title !== undefined) {
+      updatePayload.summary = updateData.title;
+    }
+
+    if (updateData.description !== undefined) {
+      updatePayload.description = updateData.description;
+    }
+
+    if (updateData.start) {
+      updatePayload.start = this.transformDateTimeWithZone(updateData.start);
+    }
+
+    if (updateData.end) {
+      updatePayload.end = this.transformDateTimeWithZone(updateData.end);
+    }
+
+    if (updateData.attendees !== undefined) {
+      updatePayload.attendees = this.transformAttendees(
+        updateData.attendees,
+      );
+    }
+
+    if (updateData.status !== undefined) {
+      updatePayload.status = this.transformEventStatus(updateData.status);
+    }
+
+    return updatePayload;
+  }
+
+  private transformDateTimeWithZone(dateTime: UpdateDateTimeWithZone): GoogleCalendarDateTime {
+    return {
+      dateTime: dateTime.time || "",
+      timeZone: dateTime.timeZone || "",
+    };
+  }
+
+  private transformAttendees(
+    inputAttendees: NonNullable<UpdateUnifiedCalendarEventInput["attendees"]>,
+  ): GoogleCalendarAttendee[] {
+      return  inputAttendees.map((attendee) => {
+          return {
+            email: attendee.email,
+            displayName: attendee.name,
+            responseStatus: this.transformResponseStatus(attendee.responseStatus),
+            organizer: attendee.host,
+            self: attendee.self,
+            optional: attendee.optional,
+          };
+        });
+  }
+
+  private transformResponseStatus(responseStatus?: CalendarEventResponseStatus | null): string {
+    if (!responseStatus) return "needsAction";
+
+    switch (responseStatus) {
+      case CalendarEventResponseStatus.ACCEPTED:
+        return "accepted";
+      case CalendarEventResponseStatus.PENDING:
+        return "tentative";
+      case CalendarEventResponseStatus.DECLINED:
+        return "declined";
+      case CalendarEventResponseStatus.NEEDS_ACTION:
+        return "needsAction";
+      default:
+        return "needsAction";
+    }
+  }
+
+  private transformEventStatus(status?: CalendarEventStatus | null): string {
+    if (!status) return "confirmed";
+
+    switch (status) {
+      case CalendarEventStatus.ACCEPTED:
+        return "confirmed";
+      case CalendarEventStatus.PENDING:
+        return "tentative";
+      case CalendarEventStatus.CANCELLED:
+        return "cancelled";
+      case CalendarEventStatus.DECLINED:
+        return "cancelled";
+      default:
+        return "confirmed";
+    }
+  }
+}

apps/api/v2/src/modules/cal-unified-calendars/pipes/google-calendar-event-input.pipe.spec.ts

@@ -0,0 +1,222 @@
+import {
+  UpdateUnifiedCalendarEventInput,
+  UpdateDateTimeWithZone,
+} from "../inputs/update-unified-calendar-event.input";
+import { CalendarEventResponseStatus, CalendarEventStatus } from "../outputs/get-unified-calendar-event.output";
+import { GoogleCalendarEventResponse } from "./get-calendar-event-details-output-pipe";
+import { GoogleCalendarEventInputPipe } from "./google-calendar-event-input-pipe";
+
+describe("GoogleCalendarEventInputPipe", () => {
+  let pipe: GoogleCalendarEventInputPipe;
+  let sharedGoogleEvent: GoogleCalendarEventResponse;
+
+  beforeAll(() => {
+    sharedGoogleEvent = {
+      kind: "calendar#event",
+      etag: "test-etag",
+      id: "test-event-id",
+      status: "confirmed",
+      htmlLink: "https://calendar.google.com/event",
+      created: "2024-01-01T00:00:00Z",
+      updated: "2024-01-01T00:00:00Z",
+      summary: "Test Meeting",
+      description: "Test description",
+      start: {
+        dateTime: "2024-01-15T10:00:00Z",
+        timeZone: "America/New_York",
+      },
+      end: {
+        dateTime: "2024-01-15T11:00:00Z",
+        timeZone: "America/New_York",
+      },
+      iCalUID: "test-ical-uid",
+      sequence: 0,
+      attendees: [
+        {
+          email: "attendee1@example.com",
+          displayName: "Attendee One",
+          responseStatus: "accepted",
+          organizer: false,
+        },
+        {
+          email: "attendee2@example.com",
+          displayName: "Attendee Two",
+          responseStatus: "needsAction",
+          organizer: false,
+        },
+        {
+          email: "organizer@example.com",
+          displayName: "Organizer",
+          responseStatus: "accepted",
+          organizer: true,
+        },
+      ],
+      creator: {
+        email: "organizer@example.com",
+        displayName: "Organizer",
+      },
+      organizer: {
+        email: "organizer@example.com",
+        displayName: "Organizer",
+      },
+    };
+  });
+
+  beforeEach(() => {
+    pipe = new GoogleCalendarEventInputPipe();
+  });
+
+  describe("transform", () => {
+    it("should transform basic event fields", () => {
+      const input: UpdateUnifiedCalendarEventInput = {
+        title: "Updated Meeting",
+        description: "Updated description",
+        start: {
+          time: "2024-01-15T10:00:00Z",
+          timeZone: "America/New_York",
+        },
+        end: {
+          time: "2024-01-15T11:00:00Z",
+          timeZone: "America/New_York",
+        },
+        status: CalendarEventStatus.ACCEPTED,
+      };
+
+      const expectedOutput = {
+        summary: "Updated Meeting",
+        description: "Updated description",
+        start: {
+          dateTime: "2024-01-15T10:00:00Z",
+          timeZone: "America/New_York",
+        },
+        end: {
+          dateTime: "2024-01-15T11:00:00Z",
+          timeZone: "America/New_York",
+        },
+        status: "confirmed",
+      };
+
+      const result = pipe.transform(input);
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it("should handle partial updates", () => {
+      const input: UpdateUnifiedCalendarEventInput = {
+        title: "Only Title Update",
+      };
+
+      const expectedOutput = {
+        summary: "Only Title Update",
+      };
+
+      const result = pipe.transform(input);
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it("should handle null description", () => {
+      const input: UpdateUnifiedCalendarEventInput = {
+        description: null,
+      };
+
+      const expectedOutput = {
+        description: null,
+      };
+
+      const result = pipe.transform(input);
+      expect(result).toEqual(expectedOutput);
+    });
+  });
+
+  describe("transformDateTimeWithZone", () => {
+    it("should transform date time with timezone", () => {
+      const input: UpdateDateTimeWithZone = {
+        time: "2024-01-15T10:00:00Z",
+        timeZone: "America/New_York",
+      };
+
+      const expectedOutput = {
+        dateTime: "2024-01-15T10:00:00Z",
+        timeZone: "America/New_York",
+      };
+
+      const result = pipe["transformDateTimeWithZone"](input);
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it("should handle empty time and timezone", () => {
+      const input: UpdateDateTimeWithZone = {};
+
+      const expectedOutput = {
+        dateTime: "",
+        timeZone: "",
+      };
+
+      const result = pipe["transformDateTimeWithZone"](input);
+      expect(result).toEqual(expectedOutput);
+    });
+  });
+
+  describe("transformResponseStatus", () => {
+    it("should transform ACCEPTED status", () => {
+      const result = pipe["transformResponseStatus"](CalendarEventResponseStatus.ACCEPTED);
+      expect(result).toBe("accepted");
+    });
+
+    it("should transform PENDING status", () => {
+      const result = pipe["transformResponseStatus"](CalendarEventResponseStatus.PENDING);
+      expect(result).toBe("tentative");
+    });
+
+    it("should transform DECLINED status", () => {
+      const result = pipe["transformResponseStatus"](CalendarEventResponseStatus.DECLINED);
+      expect(result).toBe("declined");
+    });
+
+    it("should transform NEEDS_ACTION status", () => {
+      const result = pipe["transformResponseStatus"](CalendarEventResponseStatus.NEEDS_ACTION);
+      expect(result).toBe("needsAction");
+    });
+
+    it("should handle null status", () => {
+      const result = pipe["transformResponseStatus"](null);
+      expect(result).toBe("needsAction");
+    });
+
+    it("should handle undefined status", () => {
+      const result = pipe["transformResponseStatus"](undefined);
+      expect(result).toBe("needsAction");
+    });
+  });
+
+  describe("transformEventStatus", () => {
+    it("should transform ACCEPTED status", () => {
+      const result = pipe["transformEventStatus"](CalendarEventStatus.ACCEPTED);
+      expect(result).toBe("confirmed");
+    });
+
+    it("should transform PENDING status", () => {
+      const result = pipe["transformEventStatus"](CalendarEventStatus.PENDING);
+      expect(result).toBe("tentative");
+    });
+
+    it("should transform CANCELLED status", () => {
+      const result = pipe["transformEventStatus"](CalendarEventStatus.CANCELLED);
+      expect(result).toBe("cancelled");
+    });
+
+    it("should transform DECLINED status", () => {
+      const result = pipe["transformEventStatus"](CalendarEventStatus.DECLINED);
+      expect(result).toBe("cancelled");
+    });
+
+    it("should handle null status", () => {
+      const result = pipe["transformEventStatus"](null);
+      expect(result).toBe("confirmed");
+    });
+
+    it("should handle undefined status", () => {
+      const result = pipe["transformEventStatus"](undefined);
+      expect(result).toBe("confirmed");
+    });
+  });
+});

apps/api/v2/src/modules/cal-unified-calendars/services/google-calendar.service.ts

@@ -10,7 +10,8 @@ import { JWT } from "googleapis-common";
 
 import { DelegationCredentialRepository, OAuth2UniversalSchema } from "@calcom/platform-libraries/app-store";
 
-import { UnifiedCalendarEventOutput } from "../outputs/get-unified-calendar-event";
+import { UpdateUnifiedCalendarEventInput } from "../inputs/update-unified-calendar-event.input";
+import { GoogleCalendarEventInputPipe } from "../pipes/google-calendar-event-input-pipe";
 
 @Injectable()
 export class GoogleCalendarService {
@@ -53,6 +54,44 @@ export class GoogleCalendarService {
     }
   }
 
+  async updateEventDetails(
+    eventUid: string,
+    updateData: UpdateUnifiedCalendarEventInput
+  ): Promise<GoogleCalendarEventResponse> {
+    const bookingReference =
+      await this.bookingReferencesRepository.getBookingReferencesIncludeSensitiveCredentials(eventUid);
+
+    if (!bookingReference) {
+      throw new NotFoundException("Booking reference not found");
+    }
+
+    const ownerUserEmail = bookingReference?.booking?.user?.email;
+
+    const calendar = await this.getAuthorizedCalendarInstance(
+      ownerUserEmail,
+      bookingReference.credential?.key,
+      bookingReference.delegationCredential
+    );
+
+
+    const updatePayload = new GoogleCalendarEventInputPipe().transform(updateData);
+
+    try {
+      const event = await calendar.events.patch({
+        calendarId: bookingReference?.externalCalendarId ?? "primary",
+        eventId: bookingReference?.uid,
+        requestBody: updatePayload,
+      });
+
+      if (!event.data) {
+        throw new NotFoundException("Failed to update meeting");
+      }
+      return event.data as GoogleCalendarEventResponse;
+    } catch (error) {
+      throw new NotFoundException("Failed to update meeting details");
+    }
+  }
+
   /**
    * Gets an authorized Google Calendar instance
    * Tries delegation credentials first, falls back to direct OAuth

apps/api/v2/src/modules/event-types/guards/event-type-ownership.guard.ts

@@ -0,0 +1,42 @@
+import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
+import { ApiAuthGuardUser } from "@/modules/auth/strategies/api-auth/api-auth.strategy";
+import {
+  BadRequestException,
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from "@nestjs/common";
+import { Request } from "express";
+
+@Injectable()
+export class EventTypeOwnershipGuard implements CanActivate {
+  constructor(private readonly eventTypesService: EventTypesService_2024_06_14) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request>();
+    const user = request.user as ApiAuthGuardUser | undefined;
+    const eventTypeIdParam = request.params?.eventTypeId;
+
+    if (!user) {
+      throw new ForbiddenException("EventTypeOwnershipGuard - No user associated with the request.");
+    }
+
+    if (!eventTypeIdParam) {
+      throw new BadRequestException("Missing eventTypeId param.");
+    }
+
+    const eventTypeId = Number(eventTypeIdParam);
+    if (!Number.isInteger(eventTypeId) || eventTypeId <= 0) {
+      throw new BadRequestException("Invalid eventTypeId param.");
+    }
+    const eventType = await this.eventTypesService.getUserEventType(user.id, eventTypeId);
+    if (!eventType) {
+      // Mirrors EventTypesService behavior: NotFound when not owned or not present
+      throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
+    }
+
+    return true;
+  }
+}

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

@@ -0,0 +1,551 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { OrganizationsTeamsBookingsModule } from "@/modules/organizations/teams/bookings/organizations-teams-bookings.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { HostsRepositoryFixture } from "test/fixtures/repository/hosts.repository.fixture";
+import { ManagedOrganizationsRepositoryFixture } from "test/fixtures/repository/managed-organizations.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+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 { withApiAuth } from "test/utils/withApiAuth";
+
+import { randomString } from "@calcom/lib/random";
+import {
+  CAL_API_VERSION_HEADER,
+  SUCCESS_STATUS,
+  VERSION_2024_08_13,
+  X_CAL_CLIENT_ID,
+  X_CAL_SECRET_KEY,
+} from "@calcom/platform-constants";
+import {
+  BookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+  GetBookingsOutput_2024_08_13,
+  GetSeatedBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { PlatformOAuthClient, Team } from "@calcom/prisma/client";
+
+describe("Organizations Bookings Endpoints 2024-08-13", () => {
+  describe("Manager and managed organizations bookings", () => {
+    let app: INestApplication;
+    let managerOrganization: Team;
+    let managedOrganization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let oAuthClient: PlatformOAuthClient;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
+    let hostsRepositoryFixture: HostsRepositoryFixture;
+    let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+    let profileRepositoryFixture: ProfileRepositoryFixture;
+    let managedOrganizationsRepositoryFixture: ManagedOrganizationsRepositoryFixture;
+
+    const managerOrgUserEmail = "manager-org-user-1-bookings@api.com";
+    const managerOrgUserEmail2 = "manager-org-user-2-bookings@api.com";
+    const managedOrgUserEmail = "managed-org-user-1-bookings@api.com";
+    const nonOrgUserEmail1 = "non-org-user-1-bookings@api.com";
+    let managerOrgUser1: User;
+    let managerOrgUser2: User;
+    let managedOrgUser: User;
+    let nonOrgUser1: User;
+    let managerOrgTeam1: Team;
+    let managedOrgTeam1: Team;
+
+    let managerOrgEventTypeId: number;
+    let managedOrgEventTypeId: number;
+    let nonOrgEventTypeId: number;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        managerOrgUserEmail,
+        Test.createTestingModule({
+          imports: [AppModule, OrganizationsTeamsBookingsModule],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .overrideGuard(PlatformPlanGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+      profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+      hostsRepositoryFixture = new HostsRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+      managedOrganizationsRepositoryFixture = new ManagedOrganizationsRepositoryFixture(moduleRef);
+
+      await setupManagerOrganization();
+      await setupManagedOrganization();
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    async function setupManagerOrganization() {
+      managerOrganization = await organizationsRepositoryFixture.create({
+        name: "organization bookings",
+        isPlatform: true,
+      });
+      managerOrgTeam1 = await teamRepositoryFixture.create({
+        name: "team orgs booking 1",
+        isOrganization: false,
+        parent: { connect: { id: managerOrganization.id } },
+      });
+      oAuthClient = await createOAuthClient(managerOrganization.id);
+
+      nonOrgUser1 = await userRepositoryFixture.create({
+        email: nonOrgUserEmail1,
+        locale: "it",
+        name: "NonOrgUser1Bookings",
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      managerOrgUser1 = await userRepositoryFixture.create({
+        email: managerOrgUserEmail,
+        locale: "it",
+        name: "orgUser1Bookings",
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      managerOrgUser2 = await userRepositoryFixture.create({
+        email: managerOrgUserEmail2,
+        locale: "it",
+        name: "orgUser2Bookings",
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(managerOrgUser1.id, userSchedule);
+      await schedulesService.createUserSchedule(nonOrgUser1.id, userSchedule);
+      await schedulesService.createUserSchedule(managerOrgUser2.id, userSchedule);
+
+      const orgEventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "COLLECTIVE",
+        team: {
+          connect: { id: managerOrgTeam1.id },
+        },
+        title: "Collective Event Type",
+        slug: "manager-org-bookings-collective-event-type",
+        length: 60,
+        assignAllTeamMembers: true,
+        bookingFields: [],
+        locations: [],
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${managerOrgUser1.id}`,
+        username: managerOrgUserEmail,
+        organization: {
+          connect: {
+            id: managerOrganization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: managerOrgUser1.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${managerOrgUser2.id}`,
+        username: managerOrgUserEmail2,
+        organization: {
+          connect: {
+            id: managerOrganization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: managerOrgUser2.id,
+          },
+        },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "OWNER",
+        user: { connect: { id: managerOrgUser1.id } },
+        team: { connect: { id: managerOrganization.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: managerOrgUser2.id } },
+        team: { connect: { id: managerOrganization.id } },
+        accepted: true,
+      });
+
+      const nonOrgEventType = await eventTypesRepositoryFixture.create(
+        {
+          title: "Non Org Event Type",
+          slug: "non-org-event-type",
+          length: 60,
+          bookingFields: [],
+          locations: [],
+        },
+        nonOrgUser1.id
+      );
+
+      managerOrgEventTypeId = orgEventType.id;
+      nonOrgEventTypeId = nonOrgEventType.id;
+
+      await hostsRepositoryFixture.create({
+        isFixed: true,
+        user: {
+          connect: {
+            id: managerOrgUser2.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: managerOrgEventTypeId,
+          },
+        },
+      });
+
+      await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: managerOrgUser2.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2030, 0, 9, 13, 0, 0)),
+        endTime: new Date(Date.UTC(2030, 0, 9, 14, 0, 0)),
+        title: "Manager Org Collective Booking",
+        uid: `manager-org-collective-${randomString()}`,
+        eventType: {
+          connect: {
+            id: managerOrgEventTypeId,
+          },
+        },
+        location: "https://meet.google.com/abc-def-ghi",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: "alice",
+          email: "alice@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "alice@gmail.com",
+            name: "alice",
+            locale: "es",
+            timeZone: "Europe/Madrid",
+          },
+        },
+      });
+
+      await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: nonOrgUser1.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)),
+        endTime: new Date(Date.UTC(2030, 0, 8, 14, 0, 0)),
+        title: "Non-Org Booking 1",
+        uid: `non-org-booking-1-${randomString()}`,
+        eventType: {
+          connect: {
+            id: nonOrgEventTypeId,
+          },
+        },
+        location: "https://meet.google.com/jkl-mno-pqr",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: managerOrgUser2.name ?? "",
+          email: managerOrgUserEmail2,
+        },
+        attendees: {
+          create: {
+            email: managerOrgUserEmail2,
+            name: managerOrgUser2.name ?? "",
+            locale: "en",
+            timeZone: managerOrgUser2.timeZone ?? "Europe/Madrid",
+          },
+        },
+      });
+    }
+
+    async function setupManagedOrganization() {
+      managedOrganization = await organizationsRepositoryFixture.create({
+        name: "organization bookings",
+        isPlatform: true,
+      });
+      await managedOrganizationsRepositoryFixture.createManagedOrganization(
+        managerOrganization.id,
+        managedOrganization.id
+      );
+
+      managedOrgTeam1 = await teamRepositoryFixture.create({
+        name: "managed org team 1",
+        isOrganization: false,
+        parent: { connect: { id: managedOrganization.id } },
+      });
+
+      managedOrgUser = await userRepositoryFixture.create({
+        email: managedOrgUserEmail,
+        locale: "it",
+        name: "ManagedOrgUser1Bookings",
+        platformOAuthClients: {
+          connect: {
+            id: oAuthClient.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${managedOrgUser.id}`,
+        username: managedOrgUserEmail,
+        organization: {
+          connect: {
+            id: managedOrganization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: managedOrgUser.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${managerOrgUser1.id}`,
+        username: managerOrgUserEmail,
+        organization: {
+          connect: {
+            id: managedOrganization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: managerOrgUser1.id,
+          },
+        },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: managedOrgUser.id } },
+        team: { connect: { id: managedOrganization.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "OWNER",
+        user: { connect: { id: managerOrgUser1.id } },
+        team: { connect: { id: managedOrganization.id } },
+        accepted: true,
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(managedOrgUser.id, userSchedule);
+
+      const managedOrgEventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "COLLECTIVE",
+        team: {
+          connect: { id: managedOrgTeam1.id },
+        },
+        title: "Collective Event Type",
+        slug: "managed-org-bookings-collective-event-type",
+        length: 60,
+        assignAllTeamMembers: true,
+        bookingFields: [],
+        locations: [],
+      });
+
+      managedOrgEventTypeId = managedOrgEventType.id;
+
+      await hostsRepositoryFixture.create({
+        isFixed: true,
+        user: {
+          connect: {
+            id: managedOrgUser.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: managedOrgEventType.id,
+          },
+        },
+      });
+
+      await bookingsRepositoryFixture.create({
+        user: {
+          connect: {
+            id: managedOrgUser.id,
+          },
+        },
+        startTime: new Date(Date.UTC(2030, 0, 11, 13, 0, 0)),
+        endTime: new Date(Date.UTC(2030, 0, 11, 14, 0, 0)),
+        title: "Managed Org Booking",
+        uid: `managed-org-booking-${randomString()}`,
+        eventType: {
+          connect: {
+            id: managedOrgEventTypeId,
+          },
+        },
+        location: "https://meet.google.com/ghi-jkl-mno",
+        customInputs: {},
+        metadata: {},
+        responses: {
+          name: "charlie",
+          email: "charlie@gmail.com",
+        },
+        attendees: {
+          create: {
+            email: "charlie@gmail.com",
+            name: "charlie",
+            locale: "en",
+            timeZone: "Europe/Madrid",
+          },
+        },
+      });
+    }
+
+    describe("get manager organization bookings", () => {
+      it("should get bookings by organizationId for manager organization", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/organizations/${managerOrganization.id}/bookings`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .set(X_CAL_CLIENT_ID, oAuthClient.id)
+          .set(X_CAL_SECRET_KEY, oAuthClient.secret)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingsOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
+            expect(data.length).toEqual(2);
+            expect(data.map((booking) => booking.eventTypeId).sort()).toEqual(
+              [managerOrgEventTypeId, nonOrgEventTypeId].sort()
+            );
+          });
+      });
+
+      it("should get bookings by organizationId and userId", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/organizations/${managerOrganization.id}/bookings?userIds=${managerOrgUser2.id}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingsOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
+            expect(data.length).toEqual(2);
+            expect(data.map((booking) => booking.eventTypeId).sort()).toEqual(
+              [managerOrgEventTypeId, nonOrgEventTypeId].sort()
+            );
+          });
+      });
+    });
+
+    describe("get managed organization bookings", () => {
+      it("should get bookings by organizationId for managed organization", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/organizations/${managedOrganization.id}/bookings`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .set(X_CAL_CLIENT_ID, oAuthClient.id)
+          .set(X_CAL_SECRET_KEY, oAuthClient.secret)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingsOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            const data: (
+              | BookingOutput_2024_08_13
+              | RecurringBookingOutput_2024_08_13
+              | GetSeatedBookingOutput_2024_08_13
+            )[] = responseBody.data;
+            expect(data.length).toEqual(1);
+            expect(data[0].eventTypeId).toEqual(managedOrgEventTypeId);
+          });
+      });
+    });
+
+    async function createOAuthClient(organizationId: number) {
+      const data = {
+        logo: "logo-url",
+        name: "name",
+        redirectUris: ["http://localhost:5555"],
+        permissions: 32,
+        areCalendarEventsEnabled: false,
+        areEmailsEnabled: false,
+      };
+      const secret = "secret";
+
+      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+      return client;
+    }
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(managerOrganization.id);
+      await userRepositoryFixture.deleteByEmail(managerOrgUser1.email);
+      await userRepositoryFixture.deleteByEmail(nonOrgUser1.email);
+      await bookingsRepositoryFixture.deleteAllBookings(managerOrgUser1.id, managerOrgUser1.email);
+      await bookingsRepositoryFixture.deleteAllBookings(nonOrgUser1.id, nonOrgUser1.email);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/modules/organizations/event-types/organizations-event-types-private-links.e2e-spec.ts

@@ -0,0 +1,183 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { HttpExceptionFilter } from "@/filters/http-exception.filter";
+import { PrismaExceptionFilter } from "@/filters/prisma-exception.filter";
+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 { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
+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 * as request from "supertest";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.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 { withApiAuth } from "test/utils/withApiAuth";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { CreatePrivateLinkInput } from "@calcom/platform-types";
+
+describe("Organizations / Teams / Event Types / Private Links Endpoints", () => {
+  let app: INestApplication;
+
+  let orgFixture: OrganizationRepositoryFixture;
+  let teamFixture: TeamRepositoryFixture;
+  let userFixture: UserRepositoryFixture;
+  let eventTypesFixture: EventTypesRepositoryFixture;
+
+  let org: any;
+  let team: any;
+  let user: any;
+  let eventType: any;
+
+  const userEmail = `org-private-links-user-${randomString()}@api.com`;
+
+  beforeAll(async () => {
+    const testingModuleBuilder = withApiAuth(
+      userEmail,
+      Test.createTestingModule({
+        providers: [PrismaExceptionFilter, HttpExceptionFilter],
+        imports: [AppModule, UsersModule, TokensModule],
+      })
+    )
+      // Bypass org admin plan and admin API checks and roles in this e2e
+      .overrideGuard(PlatformPlanGuard)
+      .useValue({ canActivate: () => true })
+      .overrideGuard(IsAdminAPIEnabledGuard)
+      .useValue({ canActivate: () => true })
+      .overrideGuard(RolesGuard)
+      .useValue({ canActivate: () => true })
+      // Keep IsOrgGuard and IsTeamInOrg to validate org/team path integrity
+      .overrideGuard(ApiAuthGuard)
+      .useValue({ canActivate: () => true });
+
+    const moduleRef = await testingModuleBuilder.compile();
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    orgFixture = new OrganizationRepositoryFixture(moduleRef);
+    teamFixture = new TeamRepositoryFixture(moduleRef);
+    userFixture = new UserRepositoryFixture(moduleRef);
+    eventTypesFixture = new EventTypesRepositoryFixture(moduleRef);
+
+    user = await userFixture.create({
+      email: userEmail,
+      username: `org-private-links-user-${randomString()}`,
+      name: "Test User",
+    });
+
+    org = await orgFixture.create({
+      name: `org-private-links-org-${randomString()}`,
+      slug: `org-private-links-org-${randomString()}`,
+      isOrganization: true,
+    });
+
+    team = await teamFixture.create({
+      name: `org-private-links-team-${randomString()}`,
+      isOrganization: false,
+      parent: { connect: { id: org.id } },
+    });
+
+    // Create a team-owned event type
+    eventType = await eventTypesFixture.createTeamEventType({
+      title: `org-private-links-event-type-${randomString()}`,
+      slug: `org-private-links-event-type-${randomString()}`,
+      length: 30,
+      locations: [],
+      team: { connect: { id: team.id } },
+    });
+
+    await app.init();
+  });
+
+  it("POST /v2/organizations/:orgId/teams/:teamId/event-types/:eventTypeId/private-links - create", async () => {
+    const body: CreatePrivateLinkInput = { maxUsageCount: 5 };
+    const response = await request(app.getHttpServer())
+      .post(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${eventType.id}/private-links`)
+      .set("Authorization", "Bearer test")
+      .send(body)
+      .expect(201);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(response.body.data.linkId).toBeDefined();
+    expect(response.body.data.maxUsageCount).toBe(5);
+    expect(response.body.data.usageCount).toBeDefined();
+  });
+
+  it("GET /v2/organizations/:orgId/teams/:teamId/event-types/:eventTypeId/private-links - list", async () => {
+    const response = await request(app.getHttpServer())
+      .get(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${eventType.id}/private-links`)
+      .set("Authorization", "Bearer test")
+      .expect(200);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(Array.isArray(response.body.data)).toBe(true);
+  });
+
+  it("PATCH /v2/organizations/:orgId/teams/:teamId/event-types/:eventTypeId/private-links/:linkId - update", async () => {
+    // create first
+    const createResp = await request(app.getHttpServer())
+      .post(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${eventType.id}/private-links`)
+      .set("Authorization", "Bearer test")
+      .send({ maxUsageCount: 3 })
+      .expect(201);
+
+    const linkId = createResp.body.data.linkId as string;
+
+    const response = await request(app.getHttpServer())
+      .patch(
+        `/v2/organizations/${org.id}/teams/${team.id}/event-types/${eventType.id}/private-links/${linkId}`
+      )
+      .set("Authorization", "Bearer test")
+      .send({ maxUsageCount: 10 })
+      .expect(200);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(response.body.data.maxUsageCount).toBe(10);
+  });
+
+  it("DELETE /v2/organizations/:orgId/teams/:teamId/event-types/:eventTypeId/private-links/:linkId - delete", async () => {
+    // create first
+    const createResp = await request(app.getHttpServer())
+      .post(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${eventType.id}/private-links`)
+      .set("Authorization", "Bearer test")
+      .send({ maxUsageCount: 2 })
+      .expect(201);
+
+    const linkId = createResp.body.data.linkId as string;
+
+    const response = await request(app.getHttpServer())
+      .delete(
+        `/v2/organizations/${org.id}/teams/${team.id}/event-types/${eventType.id}/private-links/${linkId}`
+      )
+      .set("Authorization", "Bearer test")
+      .expect(200);
+
+    expect(response.body.status).toBe(SUCCESS_STATUS);
+    expect(response.body.data.linkId).toBe(linkId);
+  });
+
+  afterAll(async () => {
+    try {
+      if (eventType?.id) {
+        await eventTypesFixture.delete(eventType.id);
+      }
+      if (team?.id) {
+        await teamFixture.delete(team.id);
+      }
+      if (org?.id) {
+        await orgFixture.delete(org.id);
+      }
+      if (user?.email) {
+        await userFixture.deleteByEmail(user.email);
+      }
+    } catch {}
+    await app.close();
+  });
+});

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

@@ -23,6 +23,8 @@ import { OrganizationsConferencingModule } from "@/modules/organizations/confere
 import { OrganizationsConferencingService } from "@/modules/organizations/conferencing/services/organizations-conferencing.service";
 import { OrganizationsDelegationCredentialModule } from "@/modules/organizations/delegation-credentials/organizations-delegation-credential.module";
 import { OrganizationsEventTypesController } from "@/modules/organizations/event-types/organizations-event-types.controller";
+import { EventTypesPrivateLinksModule } from "@/ee/event-types-private-links/event-types-private-links.module";
+import { OrganizationsEventTypesPrivateLinksController } from "@/ee/event-types-private-links/controllers/organizations-event-types-private-links.controller";
 import { OrganizationsEventTypesRepository } from "@/modules/organizations/event-types/organizations-event-types.repository";
 import { OutputTeamEventTypesResponsePipe } from "@/modules/organizations/event-types/pipes/team-event-types-response.transformer";
 import { InputOrganizationsEventTypesService } from "@/modules/organizations/event-types/services/input.service";
@@ -91,6 +93,7 @@ import { Module } from "@nestjs/common";
     OrganizationsStripeModule,
     OrganizationsTeamsRoutingFormsModule,
     OrganizationsConferencingModule,
+    EventTypesPrivateLinksModule,
   ],
   providers: [
     OrganizationsRepository,
@@ -177,6 +180,7 @@ import { Module } from "@nestjs/common";
     OrganizationsTeamsSchedulesController,
     OrganizationsUsersOOOController,
     OrganizationTeamWorkflowsController,
+    OrganizationsEventTypesPrivateLinksController,
   ],
 })
 export class OrganizationsModule {}

apps/api/v2/src/modules/redis/redis.service.ts

@@ -7,12 +7,32 @@ import { Redis } from "ioredis";
 export class RedisService implements OnModuleDestroy {
   public redis: Redis;
   private readonly logger = new Logger("RedisService");
+  private isReady = false; // Track connection status
 
   constructor(readonly configService: ConfigService<AppConfig>) {
     const dbUrl = configService.get<string>("db.redisUrl", { infer: true });
     if (!dbUrl) throw new Error("Misconfigured Redis, halting.");
 
     this.redis = new Redis(dbUrl);
+
+    this.redis.on("error", (err) => {
+      this.logger.error(`IoRedis connection error: ${err.message}`);
+      this.isReady = false;
+    });
+
+    this.redis.on("connect", () => {
+      this.logger.log("IoRedis connected!");
+      this.isReady = true;
+    });
+
+    this.redis.on("reconnecting", (delay: string) => {
+      this.logger.warn(`IoRedis reconnecting... next retry in ${delay}ms`);
+    });
+
+    this.redis.on("end", () => {
+      this.logger.warn("IoRedis connection ended.");
+      this.isReady = false;
+    });
   }
 
   async onModuleDestroy() {
@@ -22,4 +42,99 @@ export class RedisService implements OnModuleDestroy {
       this.logger.error(err);
     }
   }
+
+  async get<TData>(key: string): Promise<TData | null> {
+    let data = null;
+    if (!this.isReady) {
+      return null;
+    }
+
+    try {
+      data = await this.redis.get(key);
+    } catch (err) {
+      if (err instanceof Error) this.logger.error(`IoRedis get failed: ${err.message}`);
+    }
+
+    if (data === null) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(data) as TData;
+    } catch (e) {
+      return data as TData;
+    }
+  }
+
+  async del(key: string): Promise<number> {
+    if (!this.isReady) {
+      return 0;
+    }
+    try {
+      return this.redis.del(key);
+    } catch (err) {
+      if (err instanceof Error) this.logger.error(`IoRedis del failed: ${err.message}`);
+      return 0;
+    }
+  }
+
+  async set<TData>(key: string, value: TData, opts?: { ttl?: number }): Promise<"OK" | TData | null> {
+    if (!this.isReady) {
+      return null;
+    }
+
+    try {
+      const stringifiedValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+      if (opts?.ttl) {
+        await this.redis.set(key, stringifiedValue, "PX", opts.ttl);
+      } else {
+        await this.redis.set(key, stringifiedValue);
+      }
+    } catch (err) {
+      if (err instanceof Error) this.logger.error(`IoRedis set failed: ${err.message}`);
+      return null;
+    }
+
+    return "OK";
+  }
+
+  async expire(key: string, seconds: number): Promise<0 | 1> {
+    if (!this.isReady) {
+      return 0;
+    }
+    try {
+      return this.redis.expire(key, seconds) as Promise<0 | 1>;
+    } catch (err) {
+      if (err instanceof Error) this.logger.error(`IoRedis expire failed: ${err.message}`);
+      return 0;
+    }
+  }
+
+  async lrange<TResult = string>(key: string, start: number, end: number): Promise<TResult[]> {
+    if (!this.isReady) {
+      return [];
+    }
+    try {
+      const results = await this.redis.lrange(key, start, end);
+      return results.map((item) => JSON.parse(item) as TResult);
+    } catch (err) {
+      if (err instanceof Error) this.logger.error(`IoRedis lrange failed: ${err.message}`);
+      return [];
+    }
+  }
+
+  async lpush<TData>(key: string, ...elements: TData[]): Promise<number> {
+    if (!this.isReady) {
+      return 0;
+    }
+    try {
+      const stringifiedElements = elements.map((element) =>
+        typeof element === "object" ? JSON.stringify(element) : String(element)
+      );
+      return this.redis.lpush(key, ...stringifiedElements);
+    } catch (err) {
+      if (err instanceof Error) this.logger.error(`IoRedis lpush failed: ${err.message}`);
+      return 0;
+    }
+  }
 }

apps/api/v2/src/modules/workflows/inputs/workflow-step.input.ts

@@ -10,6 +10,7 @@ export const SMS_ATTENDEE = "sms_attendee";
 export const SMS_NUMBER = "sms_number";
 export const WHATSAPP_ATTENDEE = "whatsapp_attendee";
 export const WHATSAPP_NUMBER = "whatsapp_number";
+export const CAL_AI_PHONE_CALL = "cal_ai_phone_call";
 
 export const STEP_ACTIONS = [
   EMAIL_HOST,
@@ -19,6 +20,7 @@ export const STEP_ACTIONS = [
   SMS_NUMBER,
   WHATSAPP_ATTENDEE,
   WHATSAPP_NUMBER,
+  CAL_AI_PHONE_CALL,
 ] as const;
 
 export const STEP_ACTIONS_TO_ENUM = {
@@ -29,6 +31,7 @@ export const STEP_ACTIONS_TO_ENUM = {
   [WHATSAPP_ATTENDEE]: WorkflowActions.WHATSAPP_ATTENDEE,
   [WHATSAPP_NUMBER]: WorkflowActions.WHATSAPP_NUMBER,
   [SMS_NUMBER]: WorkflowActions.SMS_NUMBER,
+  [CAL_AI_PHONE_CALL]: WorkflowActions.CAL_AI_PHONE_CALL,
 } as const;
 
 export const ENUM_TO_STEP_ACTIONS = {
@@ -39,6 +42,7 @@ export const ENUM_TO_STEP_ACTIONS = {
   [WorkflowActions.WHATSAPP_ATTENDEE]: WHATSAPP_ATTENDEE,
   [WorkflowActions.WHATSAPP_NUMBER]: WHATSAPP_NUMBER,
   [WorkflowActions.SMS_NUMBER]: SMS_NUMBER,
+  [WorkflowActions.CAL_AI_PHONE_CALL]: CAL_AI_PHONE_CALL,
 } as const;
 
 export type StepAction = (typeof STEP_ACTIONS)[number];

apps/api/v2/test/fixtures/repository/managed-organizations.repository.fixture.ts

@@ -34,4 +34,13 @@ export class ManagedOrganizationsRepositoryFixture {
       },
     });
   }
+
+  async createManagedOrganization(managerOrganizationId: number, managedOrganizationId: number) {
+    return this.prismaWriteClient.managedOrganization.create({
+      data: {
+        managerOrganizationId,
+        managedOrganizationId,
+      },
+    });
+  }
 }

apps/api/v2/test/setEnvVars.ts

@@ -36,4 +36,5 @@ process.env = {
   CALENDSO_ENCRYPTION_KEY: "22gfxhWUlcKliUeXcu8xNah2+HP/29ZX",
   INTEGRATION_TEST_MODE: "true",
   e2e: "true",
+  SLOTS_CACHE_TTL: "1"
 };

apps/api/v2/tsconfig.json

@@ -27,7 +27,8 @@
       "@calcom/platform-libraries/workflows": ["../../../packages/platform/libraries/workflows.ts"],
       "@calcom/platform-libraries/conferencing": ["../../../packages/platform/libraries/conferencing.ts"],
       "@calcom/platform-libraries/repositories": ["../../../packages/platform/libraries/repositories.ts"],
-      "@calcom/platform-libraries/bookings": ["../../../packages/platform/libraries/bookings.ts"]
+      "@calcom/platform-libraries/bookings": ["../../../packages/platform/libraries/bookings.ts"],
+      "@calcom/platform-libraries/private-links": ["../../../packages/platform/libraries/private-links.ts"]
     },
     "incremental": true,
     "skipLibCheck": true,

apps/web/app/(booking-page-wrapper)/team/[slug]/[type]/pageWithCachedData.tsx

@@ -16,7 +16,7 @@ import slugify from "@calcom/lib/slugify";
 import { BookingStatus, RedirectType } from "@calcom/prisma/enums";
 
 import { buildLegacyCtx, buildLegacyRequest } from "@lib/buildLegacyCtx";
-import { getTemporaryOrgRedirect } from "@lib/getTemporaryOrgRedirect";
+import { handleOrgRedirect } from "@lib/handleOrgRedirect";
 
 import CachedClientView, { type TeamBookingPageProps } from "~/team/type-view-cached";
 
@@ -124,19 +124,17 @@ export const generateMetadata = async ({ params, searchParams }: PageProps) => {
 
 const CachedTeamBooker = async ({ params, searchParams }: PageProps) => {
   const { currentOrgDomain, isValidOrgDomain, teamSlug, meetingSlug } = await _getOrgContext(await params);
-  const isOrgContext = currentOrgDomain && isValidOrgDomain;
   const legacyCtx = buildLegacyCtx(await headers(), await cookies(), await params, await searchParams);
 
-  // Handle org redirects for non-org contexts
-  if (!isOrgContext) {
-    const redirectResult = await getTemporaryOrgRedirect({
-      slugs: teamSlug,
-      redirectType: RedirectType.Team,
-      eventTypeSlug: meetingSlug,
-      currentQuery: legacyCtx.query,
-    });
-    if (redirectResult) return redirect(redirectResult.redirect.destination);
-  }
+  // Handle org redirects
+  const redirectResult = await handleOrgRedirect({
+    slugs: [teamSlug],
+    redirectType: RedirectType.Team,
+    eventTypeSlug: meetingSlug,
+    context: legacyCtx,
+    currentOrgDomain: isValidOrgDomain ? currentOrgDomain : null,
+  });
+  if (redirectResult) return redirect(redirectResult.redirect.destination);
 
   const teamData = await getCachedTeamData(teamSlug, currentOrgDomain);
 

apps/web/app/(use-page-wrapper)/apps/installed/[category]/page.tsx

@@ -1,13 +1,17 @@
 import { createRouterCaller } from "app/_trpc/context";
 import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
+import { cookies, headers } from "next/headers";
 import { redirect } from "next/navigation";
 import { z } from "zod";
 
+import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
 import { AppCategories } from "@calcom/prisma/enums";
 import { appsRouter } from "@calcom/trpc/server/routers/viewer/apps/_router";
 import { calendarsRouter } from "@calcom/trpc/server/routers/viewer/calendars/_router";
 
+import { buildLegacyRequest } from "@lib/buildLegacyCtx";
+
 import InstalledApps from "~/apps/installed/[category]/installed-category-view";
 
 const querySchema = z.object({
@@ -31,6 +35,11 @@ const InstalledAppsWrapper = async ({ params }: PageProps) => {
     redirect("/apps/installed/calendar");
   }
 
+  const session = await getServerSession({ req: buildLegacyRequest(await headers(), await cookies()) });
+  if (!session?.user?.id) {
+    return redirect("/auth/login");
+  }
+
   const [calendarsCaller, appsCaller] = await Promise.all([
     createRouterCaller(calendarsRouter),
     createRouterCaller(appsRouter),

apps/web/app/(use-page-wrapper)/getting-started/[[...step]]/page.tsx

@@ -1,14 +1,17 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
+import { createRouterCaller } from "app/_trpc/context";
 import type { PageProps as ServerPageProps } from "app/_types";
 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 { APP_NAME } from "@calcom/lib/constants";
+import { UserRepository } from "@calcom/lib/server/repository/user";
+import prisma from "@calcom/prisma";
+import { meRouter } from "@calcom/trpc/server/routers/viewer/me/_router";
 
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/getting-started/[[...step]]/getServerSideProps";
+import { buildLegacyRequest } from "@lib/buildLegacyCtx";
 
-import type { PageProps as ClientPageProps } from "~/getting-started/[[...step]]/onboarding-view";
 import Page from "~/getting-started/[[...step]]/onboarding-view";
 
 export const generateMetadata = async ({ params }: ServerPageProps) => {
@@ -23,13 +26,28 @@ export const generateMetadata = async ({ params }: ServerPageProps) => {
   );
 };
 
-const getData = withAppDirSsr<ClientPageProps>(getServerSideProps);
-
 const ServerPage = async ({ params, searchParams }: ServerPageProps) => {
-  const context = buildLegacyCtx(await headers(), await cookies(), await params, await searchParams);
+  const session = await getServerSession({ req: buildLegacyRequest(await headers(), await cookies()) });
 
-  const props = await getData(context);
-  return <Page {...props} />;
+  if (!session?.user?.id) {
+    return redirect("/auth/login");
+  }
+
+  const userRepo = new UserRepository(prisma);
+  const meCaller = await createRouterCaller(meRouter);
+
+  const [userTeams, user] = await Promise.all([
+    userRepo.findUserTeams({
+      id: session.user.id,
+    }),
+    meCaller.get(),
+  ]);
+
+  if (!userTeams || !user) {
+    return redirect("/auth/login");
+  }
+
+  return <Page user={user} hasPendingInvites={!!userTeams.teams.find((team) => team.accepted === false)} />;
 };
 
 export default ServerPage;

apps/web/app/(use-page-wrapper)/settings/organizations/new/about/page.tsx

@@ -1,10 +1,4 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
-import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
-import { cookies, headers } from "next/headers";
-
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/settings/organizations/new/getServerSideProps";
 
 import LegacyPage, { LayoutWrapper } from "~/settings/organizations/new/about-view";
 
@@ -17,10 +11,7 @@ export const generateMetadata = async () =>
     "/settings/organizations/new/about"
   );
 
-const getData = withAppDirSsr(getServerSideProps);
-
-const ServerPage = async ({ params, searchParams }: PageProps) => {
-  await getData(buildLegacyCtx(await headers(), await cookies(), await params, await searchParams));
+const ServerPage = async () => {
   return (
     <LayoutWrapper>
       <LegacyPage />

apps/web/app/(use-page-wrapper)/settings/organizations/new/add-teams/page.tsx

@@ -1,10 +1,4 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
-import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
-import { cookies, headers } from "next/headers";
-
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/settings/organizations/new/getServerSideProps";
 
 import LegacyPage, { LayoutWrapper } from "~/settings/organizations/new/add-teams-view";
 
@@ -17,10 +11,7 @@ export const generateMetadata = async () =>
     "/settings/organizations/new/add-teams"
   );
 
-const getData = withAppDirSsr(getServerSideProps);
-
-const ServerPage = async ({ params, searchParams }: PageProps) => {
-  await getData(buildLegacyCtx(await headers(), await cookies(), await params, await searchParams));
+const ServerPage = async () => {
   return (
     <LayoutWrapper>
       <LegacyPage />

apps/web/app/(use-page-wrapper)/settings/organizations/new/handover/page.tsx

@@ -1,11 +1,4 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
-import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
-import { cookies } from "next/headers";
-import { headers } from "next/headers";
-
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/settings/organizations/new/getServerSideProps";
 
 import LegacyPage, { LayoutWrapper } from "~/settings/organizations/new/onboarding-handover";
 
@@ -18,10 +11,7 @@ export const generateMetadata = async () =>
     "/settings/organizations/new/handover"
   );
 
-const getData = withAppDirSsr(getServerSideProps);
-
-const ServerPage = async ({ params, searchParams }: PageProps) => {
-  await getData(buildLegacyCtx(await headers(), await cookies(), await params, await searchParams));
+const ServerPage = async () => {
   return (
     <LayoutWrapper>
       <LegacyPage />

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

@@ -1,21 +1,16 @@
-import type { GetServerSidePropsResult } from "next";
+import { _generateMetadata } from "app/_utils";
+import { notFound } from "next/navigation";
 
 import { FeaturesRepository } from "@calcom/features/flags/features.repository";
 import { prisma } from "@calcom/prisma";
 
-export const getServerSideProps = async (): Promise<GetServerSidePropsResult<{ isOrg: boolean }>> => {
+export default async function Layout({ children }: { children: React.ReactNode }) {
   const featuresRepository = new FeaturesRepository(prisma);
   const organizations = await featuresRepository.checkIfFeatureIsEnabledGlobally("organizations");
-  // Check if organizations are enabled
+
   if (!organizations) {
-    return {
-      notFound: true,
-    };
+    return notFound();
   }
 
-  return {
-    props: {
-      isOrg: true,
-    },
-  };
-};
+  return children;
+}

apps/web/app/(use-page-wrapper)/settings/organizations/new/onboard-members/page.tsx

@@ -1,10 +1,4 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
-import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
-import { cookies, headers } from "next/headers";
-
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/settings/organizations/new/getServerSideProps";
 
 import LegacyPage, { LayoutWrapper } from "~/settings/organizations/new/onboard-members-view";
 
@@ -17,10 +11,7 @@ export const generateMetadata = async () =>
     "/settings/organizations/new/onboard-members"
   );
 
-const getData = withAppDirSsr(getServerSideProps);
-
-const ServerPage = async ({ params, searchParams }: PageProps) => {
-  await getData(buildLegacyCtx(await headers(), await cookies(), await params, await searchParams));
+const ServerPage = async () => {
   return (
     <LayoutWrapper>
       <LegacyPage />

apps/web/app/(use-page-wrapper)/settings/organizations/new/page.tsx

@@ -1,13 +1,7 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
-import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
-import { cookies, headers } from "next/headers";
 
 import LicenseRequired from "@calcom/features/ee/common/components/LicenseRequired";
 
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/settings/organizations/new/getServerSideProps";
-
 import LegacyPage, { LayoutWrapper } from "~/settings/organizations/new/create-new-view";
 
 export const generateMetadata = async () =>
@@ -19,14 +13,7 @@ export const generateMetadata = async () =>
     "/settings/organizations/new"
   );
 
-type Props = {
-  isOrg: boolean;
-};
-
-const getData = withAppDirSsr<Props>(getServerSideProps);
-
-const ServerPage = async ({ params, searchParams }: PageProps) => {
-  await getData(buildLegacyCtx(await headers(), await cookies(), await params, await searchParams));
+const ServerPage = async () => {
   return (
     <LayoutWrapper>
       <LicenseRequired>

apps/web/app/(use-page-wrapper)/settings/organizations/new/status/page.tsx

@@ -1,10 +1,4 @@
-import { withAppDirSsr } from "app/WithAppDirSsr";
-import type { PageProps } from "app/_types";
 import { _generateMetadata } from "app/_utils";
-import { cookies, headers } from "next/headers";
-
-import { buildLegacyCtx } from "@lib/buildLegacyCtx";
-import { getServerSideProps } from "@lib/settings/organizations/new/getServerSideProps";
 
 import LegacyPage, { LayoutWrapper } from "~/settings/organizations/new/payment-status-view";
 
@@ -17,10 +11,7 @@ export const generateMetadata = async () =>
     "/settings/organizations/new/status"
   );
 
-const getData = withAppDirSsr(getServerSideProps);
-
-const ServerPage = async ({ params, searchParams }: PageProps) => {
-  await getData(buildLegacyCtx(await headers(), await cookies(), await params, await searchParams));
+const ServerPage = async () => {
   return (
     <LayoutWrapper>
       <LegacyPage />

apps/web/app/_types.ts

@@ -13,5 +13,5 @@ export type PageProps = {
 
 export type LayoutProps = { params: Promise<Params>; children: React.ReactElement };
 
-export { type ReadonlyHeaders } from "next/dist/server/web/spec-extension/adapters/headers";
-export { type ReadonlyRequestCookies } from "next/dist/server/web/spec-extension/adapters/request-cookies";
+export type ReadonlyHeaders = Awaited<ReturnType<typeof import("next/headers").headers>>;
+export type ReadonlyRequestCookies = Awaited<ReturnType<typeof import("next/headers").cookies>>;

apps/web/app/api/auth/forgot-password/route.ts

@@ -7,6 +7,7 @@ import { passwordResetRequest } from "@calcom/features/auth/lib/passwordResetReq
 import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";
 import { emailSchema } from "@calcom/lib/emailSchema";
 import prisma from "@calcom/prisma";
+import { piiHasher } from "@calcom/lib/server/PiiHasher";
 
 async function handler(req: NextRequest) {
   const body = await parseRequestData(req);
@@ -28,7 +29,7 @@ async function handler(req: NextRequest) {
 
   await checkRateLimitAndThrowError({
     rateLimitingType: "core",
-    identifier: ip,
+    identifier: piiHasher.hash(ip),
   });
 
   try {

apps/web/app/api/auth/oidc/route.ts

@@ -4,13 +4,16 @@ import { NextResponse } from "next/server";
 
 import jackson from "@calcom/features/ee/sso/lib/jackson";
 import { HttpError } from "@calcom/lib/http-error";
+import logger from "@calcom/lib/logger";
 
 // This is the callback endpoint for the OIDC provider
 // A team must set this endpoint in the OIDC provider's configuration
 async function handler(req: NextRequest) {
+  const log = logger.getSubLogger({ prefix: ["[ODIC auth]"] });
   const { searchParams } = req.nextUrl;
   const code = searchParams.get("code");
   const state = searchParams.get("state");
+  const tenant = searchParams.get("tenant");
 
   if (!code || !state) {
     return NextResponse.json({ message: "Code and state are required" }, { status: 400 });
@@ -30,6 +33,7 @@ async function handler(req: NextRequest) {
 
     return NextResponse.redirect(redirect_url, 302);
   } catch (err) {
+    log.error(`Error authorizing tenant ${tenant}: ${err}`);
     const { message, statusCode = 500 } = err as HttpError;
 
     return NextResponse.json({ message }, { status: statusCode });

apps/web/app/api/auth/saml/authorize/route.ts

@@ -5,17 +5,20 @@ import { NextResponse } from "next/server";
 import type { OAuthReq } from "@calcom/features/ee/sso/lib/jackson";
 import jackson from "@calcom/features/ee/sso/lib/jackson";
 import type { HttpError } from "@calcom/lib/http-error";
+import logger from "@calcom/lib/logger";
 
 async function handler(req: NextRequest) {
+  const log = logger.getSubLogger({ prefix: ["[SAML authorize]"] });
   const { oauthController } = await jackson();
 
+  const oAuthReq = Object.fromEntries(req.nextUrl.searchParams) as unknown as OAuthReq;
+
   try {
-    const { redirect_url } = await oauthController.authorize(
-      Object.fromEntries(req.nextUrl.searchParams) as unknown as OAuthReq
-    );
+    const { redirect_url } = await oauthController.authorize(oAuthReq);
 
     return NextResponse.redirect(redirect_url as string, 302);
   } catch (err) {
+    log.error(`Error initaiting SAML login for tenant ${oAuthReq?.tenant}: ${err}`);
     const { message, statusCode = 500 } = err as HttpError;
 
     return NextResponse.json({ message }, { status: statusCode });

apps/web/app/api/auth/saml/callback/route.ts

@@ -2,19 +2,34 @@ import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
 import { parseRequestData } from "app/api/parseRequestData";
 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
+import { uuid } from "short-uuid";
 
 import jackson from "@calcom/features/ee/sso/lib/jackson";
 import type { SAMLResponsePayload } from "@calcom/features/ee/sso/lib/jackson";
+import logger from "@calcom/lib/logger";
 
 async function handler(req: NextRequest) {
+  const uid = uuid();
+  const log = logger.getSubLogger({ prefix: ["[SAML callback]", `trace: ${uid}`] });
   const { oauthController } = await jackson();
 
-  const { redirect_url } = await oauthController.samlResponse(
-    (await parseRequestData(req)) as SAMLResponsePayload
-  );
+  const requestData = (await parseRequestData(req)) as SAMLResponsePayload;
 
-  if (redirect_url) {
-    return NextResponse.redirect(redirect_url, 302);
+  try {
+    const { redirect_url, error } = await oauthController.samlResponse(requestData);
+
+    if (redirect_url) {
+      return NextResponse.redirect(redirect_url, 302);
+    }
+
+    if (error) {
+      const uid = uuid();
+      log.error(`Error authenticating user with error ${error} for relayState ${requestData?.RelayState}`);
+      return NextResponse.json({ message: `Error authorizing user. trace: ${uid}` }, { status: 400 });
+    }
+  } catch (error) {
+    log.error(`Error processing SAML response`, error);
+    return NextResponse.json({ message: `Error processing SAML response. trace: ${uid}` }, { status: 500 });
   }
 
   return NextResponse.json({ message: "No redirect URL provided" }, { status: 400 });

apps/web/app/api/auth/saml/token/route.ts

@@ -2,14 +2,26 @@ import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
 import { parseRequestData } from "app/api/parseRequestData";
 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
+import { uuid } from "short-uuid";
 
 import jackson from "@calcom/features/ee/sso/lib/jackson";
 import type { OAuthTokenReq } from "@calcom/features/ee/sso/lib/jackson";
+import logger from "@calcom/lib/logger";
 
 async function handler(req: NextRequest) {
   const { oauthController } = await jackson();
-  const tokenResponse = await oauthController.token((await parseRequestData(req)) as OAuthTokenReq);
-  return NextResponse.json(tokenResponse);
+  const log = logger.getSubLogger({ prefix: ["[SAML token]"] });
+
+  const oauthTokenReq = (await parseRequestData(req)) as OAuthTokenReq;
+
+  try {
+    const tokenResponse = await oauthController.token(oauthTokenReq);
+    return NextResponse.json(tokenResponse);
+  } catch (error) {
+    const uid = uuid();
+    log.error(`Error getting auth token for client id ${oauthTokenReq?.client_id}: ${error} trace: ${uid}`);
+    throw new Error(`Error getting auth token with error ${error} trace: ${uid}`);
+  }
 }
 
 export const POST = defaultResponderForAppDir(handler);

apps/web/app/api/auth/saml/userinfo/route.ts

@@ -1,23 +1,33 @@
 import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
-import z from "zod";
+import { uuid } from "short-uuid";
+import { z } from "zod";
 
 import jackson from "@calcom/features/ee/sso/lib/jackson";
 import { HttpError } from "@calcom/lib/http-error";
+import logger from "@calcom/lib/logger";
 
 const extractAuthToken = (req: NextRequest) => {
+  const log = logger.getSubLogger({ prefix: ["SAML extractAuthToken"] });
+  const uid = uuid();
   const authHeader = req.headers.get("authorization");
   const parts = (authHeader || "").split(" ");
   if (parts.length > 1) return parts[1];
 
   // check for query param
   let arr: string[] = [];
-  const { access_token } = requestQuery.parse(Object.fromEntries(req.nextUrl.searchParams));
+  const tokenParse = requestQuery.safeParse(Object.fromEntries(req.nextUrl.searchParams));
+  let access_token;
+  if (!tokenParse.success) {
+    log.error(`Error parsing request query: ${tokenParse.error} trace ${uid}`);
+    throw new HttpError({ statusCode: 401, message: `Unauthorized trace: ${uid}` });
+  }
+  access_token = tokenParse.data.access_token;
   arr = arr.concat(access_token);
   if (arr[0].length > 0) return arr[0];
 
-  throw new HttpError({ statusCode: 401, message: "Unauthorized" });
+  throw new HttpError({ statusCode: 401, message: `Unauthorized trace: ${uid}` });
 };
 
 const requestQuery = z.object({
@@ -25,10 +35,18 @@ const requestQuery = z.object({
 });
 
 async function handler(req: NextRequest) {
+  const log = logger.getSubLogger({ prefix: ["SAML userinfo"] });
   const { oauthController } = await jackson();
   const token = extractAuthToken(req);
-  const userInfo = await oauthController.userInfo(token);
-  return NextResponse.json(userInfo);
+
+  try {
+    const userInfo = await oauthController.userInfo(token);
+    return NextResponse.json(userInfo);
+  } catch (error) {
+    const uid = uuid();
+    log.error(`trace: ${uid} Error getting user info from token: ${error}`);
+    throw new Error(`Error getting user info from token. trace: ${uid}`);
+  }
 }
 
 export const GET = defaultResponderForAppDir(handler);

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

@@ -0,0 +1,5 @@
+import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
+
+import { handleQueuedFormResponseCleanup } from "@calcom/app-store/routing-forms/cron/queuedFormResponseCleanup";
+
+export const POST = defaultResponderForAppDir(handleQueuedFormResponseCleanup);

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

@@ -200,7 +200,7 @@ async function getHandler(request: NextRequest) {
 
       buffer = await optimizeImage({
         buffer,
-        contentType: detectContentType(buffer) ?? "image/jpeg",
+        contentType: (await detectContentType(buffer)) ?? "image/jpeg",
         quality: 100,
         width: logoDefinition.w,
         height: logoDefinition.h, // optional

apps/web/app/api/social/og/image/route.tsx

@@ -35,20 +35,31 @@ async function handler(req: NextRequest) {
   const imageType = searchParams.get("type");
 
   try {
-    const [calFontData, interFontData, interFontMediumData] = await Promise.all([
+    const fontResults = await Promise.allSettled([
       fetch(new URL("/fonts/cal.ttf", WEBAPP_URL)).then((res) => res.arrayBuffer()),
       fetch(new URL("/fonts/Inter-Regular.ttf", WEBAPP_URL)).then((res) => res.arrayBuffer()),
       fetch(new URL("/fonts/Inter-Medium.ttf", WEBAPP_URL)).then((res) => res.arrayBuffer()),
     ]);
+
+    const fonts: SatoriOptions["fonts"] = [];
+
+    if (fontResults[1].status === "fulfilled") {
+      fonts.push({ name: "inter", data: fontResults[1].value, weight: 400 });
+    }
+
+    if (fontResults[2].status === "fulfilled") {
+      fonts.push({ name: "inter", data: fontResults[2].value, weight: 500 });
+    }
+
+    if (fontResults[0].status === "fulfilled") {
+      fonts.push({ name: "cal", data: fontResults[0].value, weight: 400 });
+      fonts.push({ name: "cal", data: fontResults[0].value, weight: 600 });
+    }
+
     const ogConfig = {
       width: 1200,
       height: 630,
-      fonts: [
-        { name: "inter", data: interFontData, weight: 400 },
-        { name: "inter", data: interFontMediumData, weight: 500 },
-        { name: "cal", data: calFontData, weight: 400 },
-        { name: "cal", data: calFontData, weight: 600 },
-      ] as SatoriOptions["fonts"],
+      fonts,
     };
 
     switch (imageType) {

apps/web/components/booking/BookingListItem.tsx

@@ -546,9 +546,7 @@ function BookingListItem(booking: BookingItemProps) {
               </Link>
             </div>
           </div>
-          <div
-            data-testid="title-and-attendees"
-            className={`w-full px-4${isRejected ? " line-through" : ""}`}>
+          <div data-testid="title-and-attendees" className={`w-full px-4${isRejected ? "line-through" : ""}`}>
             <Link href={bookingLink}>
               {/* Time and Badges for mobile */}
               <div className="w-full pb-2 pt-4 sm:hidden">
@@ -893,7 +891,7 @@ const FirstAttendee = ({
   ) : (
     <a
       key={user.email}
-      className=" hover:text-blue-500"
+      className="hover:text-blue-500"
       href={`mailto:${user.email}`}
       onClick={(e) => e.stopPropagation()}>
       {user.name || user.email}
@@ -1081,7 +1079,7 @@ const GroupedAttendees = (groupedAttendeeProps: GroupedAttendeeProps) => {
             />
           ))}
           <DropdownMenuSeparator />
-          <div className="flex justify-end p-2 ">
+          <div className="flex justify-end p-2">
             <Button
               data-testid="update-no-show"
               color="secondary"
@@ -1204,7 +1202,7 @@ const GroupedGuests = ({ guests }: { guests: AttendeeProps[] }) => {
           </DropdownMenuItem>
         ))}
         <DropdownMenuSeparator />
-        <div className="flex justify-end space-x-2 p-2 ">
+        <div className="flex justify-end space-x-2 p-2">
           <Link href={`mailto:${selectedEmail}`}>
             <Button
               color="secondary"

apps/web/components/booking/bookingActions.test.ts

@@ -278,13 +278,14 @@ describe("Booking Actions", () => {
       expect(rerouteAction).toBeDefined();
     });
 
-    it("should include reassign action for round robin events", () => {
+    it("should include reassign action for round robin events with no host groups", () => {
       const context = createMockContext({
         booking: {
           ...createMockContext().booking,
           eventType: {
             ...createMockContext().booking.eventType,
             schedulingType: SchedulingType.ROUND_ROBIN,
+            hostGroups: [],
           },
         },
       });
@@ -294,6 +295,60 @@ describe("Booking Actions", () => {
       expect(reassignAction).toBeDefined();
     });
 
+    it("should include reassign action for round robin events with one host group", () => {
+      const context = createMockContext({
+        booking: {
+          ...createMockContext().booking,
+          eventType: {
+            ...createMockContext().booking.eventType,
+            schedulingType: SchedulingType.ROUND_ROBIN,
+            hostGroups: [{ id: "group-1", name: "Group 1" }],
+          },
+        },
+      });
+      const actions = getEditEventActions(context);
+
+      const reassignAction = actions.find((a) => a.id === "reassign");
+      expect(reassignAction).toBeDefined();
+    });
+
+    it("should exclude reassign action for round robin events with more than one host groups", () => {
+      const context = createMockContext({
+        booking: {
+          ...createMockContext().booking,
+          eventType: {
+            ...createMockContext().booking.eventType,
+            schedulingType: SchedulingType.ROUND_ROBIN,
+            hostGroups: [
+              { id: "group-1", name: "Group 1" },
+              { id: "group-2", name: "Group 2" },
+            ],
+          },
+        },
+      });
+      const actions = getEditEventActions(context);
+
+      const reassignAction = actions.find((a) => a.id === "reassign");
+      expect(reassignAction).toBeUndefined();
+    });
+
+    it("should exclude reassign action for non-round-robin events", () => {
+      const context = createMockContext({
+        booking: {
+          ...createMockContext().booking,
+          eventType: {
+            ...createMockContext().booking.eventType,
+            schedulingType: SchedulingType.COLLECTIVE,
+            hostGroups: [],
+          },
+        },
+      });
+      const actions = getEditEventActions(context);
+
+      const reassignAction = actions.find((a) => a.id === "reassign");
+      expect(reassignAction).toBeUndefined();
+    });
+
     it("should exclude add_members when guests are disabled", () => {
       const context = createMockContext({
         booking: {

apps/web/components/booking/bookingActions.ts

@@ -146,8 +146,9 @@ export function getEditEventActions(context: BookingActionContext): ActionType[]
           icon: "user-plus",
           disabled: false,
         },
-    // Reassign (if round robin)
-    booking.eventType.schedulingType === SchedulingType.ROUND_ROBIN
+    // Reassign if round robin with no or one host groups
+    booking.eventType.schedulingType === SchedulingType.ROUND_ROBIN &&
+    (!booking.eventType.hostGroups || booking.eventType.hostGroups?.length <= 1)
       ? {
           id: "reassign",
           label: t("reassign"),

apps/web/components/getting-started/steps-views/ConnectedVideoStep.tsx

@@ -1,7 +1,11 @@
+import { type TFunction } from "i18next";
+import { useEffect, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { userMetadata } from "@calcom/prisma/zod-utils";
 import { trpc } from "@calcom/trpc/react";
-import useMeQuery from "@calcom/trpc/react/hooks/useMeQuery";
+import type { RouterOutputs } from "@calcom/trpc/react";
 import classNames from "@calcom/ui/classNames";
 import { Button } from "@calcom/ui/components/button";
 import { List } from "@calcom/ui/components/list";
@@ -12,10 +16,18 @@ import { StepConnectionLoader } from "../components/StepConnectionLoader";
 interface ConnectedAppStepProps {
   nextStep: () => void;
   isPageLoading: boolean;
+  user: RouterOutputs["viewer"]["me"]["get"];
 }
 
-const ConnectedVideoStep = (props: ConnectedAppStepProps) => {
-  const { nextStep, isPageLoading } = props;
+const ConnectedVideoStepInner = ({
+  t,
+  setAnyInstalledVideoApps,
+  user,
+}: {
+  t: TFunction;
+  setAnyInstalledVideoApps: Dispatch<SetStateAction<boolean>>;
+  user: RouterOutputs["viewer"]["me"]["get"];
+}) => {
   const { data: queryConnectedVideoApps, isPending } = trpc.viewer.apps.integrations.useQuery({
     variant: "conferencing",
     onlyInstalled: false,
@@ -30,47 +42,59 @@ const ConnectedVideoStep = (props: ConnectedAppStepProps) => {
     sortByMostPopular: true,
     sortByInstalledFirst: true,
   });
-  const { data } = useMeQuery();
-  const { t } = useLocale();
-
-  const metadata = userMetadata.parse(data?.metadata);
 
   const hasAnyInstalledVideoApps = queryConnectedVideoApps?.items.some(
     (item) => item.userCredentialIds.length > 0
   );
 
+  useEffect(() => {
+    setAnyInstalledVideoApps(Boolean(hasAnyInstalledVideoApps));
+  }, [hasAnyInstalledVideoApps, setAnyInstalledVideoApps]);
+
+  if (isPending) {
+    return <StepConnectionLoader />;
+  }
+
+  const result = userMetadata.safeParse(user.metadata);
+  if (!result.success) {
+    return <StepConnectionLoader />;
+  }
+  const { data: metadata } = result;
   const defaultConferencingApp = metadata?.defaultConferencingApp?.appSlug;
   return (
-    <>
-      {!isPending && (
-        <List className="bg-default  border-subtle divide-subtle scroll-bar mx-1 max-h-[45vh] divide-y !overflow-y-scroll rounded-md border p-0 sm:mx-0">
-          {queryConnectedVideoApps?.items &&
-            queryConnectedVideoApps?.items.map((item) => {
-              if (item.slug === "daily-video") return null; // we dont want to show daily here as it is installed by default
-              return (
-                <li key={item.name}>
-                  {item.name && item.logo && (
-                    <AppConnectionItem
-                      type={item.type}
-                      title={item.name}
-                      isDefault={item.slug === defaultConferencingApp}
-                      description={item.description}
-                      dependencyData={item.dependencyData}
-                      logo={item.logo}
-                      slug={item.slug}
-                      installed={item.userCredentialIds.length > 0}
-                      defaultInstall={
-                        !defaultConferencingApp && item.appData?.location?.linkType === "dynamic"
-                      }
-                    />
-                  )}
-                </li>
-              );
-            })}
-        </List>
-      )}
+    <List className="bg-default  border-subtle divide-subtle scroll-bar mx-1 max-h-[45vh] divide-y !overflow-y-scroll rounded-md border p-0 sm:mx-0">
+      {queryConnectedVideoApps?.items &&
+        queryConnectedVideoApps?.items.map((item) => {
+          if (item.slug === "daily-video") return null; // we dont want to show daily here as it is installed by default
+          return (
+            <li key={item.name}>
+              {item.name && item.logo && (
+                <AppConnectionItem
+                  type={item.type}
+                  title={item.name}
+                  isDefault={item.slug === defaultConferencingApp}
+                  description={item.description}
+                  dependencyData={item.dependencyData}
+                  logo={item.logo}
+                  slug={item.slug}
+                  installed={item.userCredentialIds.length > 0}
+                  defaultInstall={!defaultConferencingApp && item.appData?.location?.linkType === "dynamic"}
+                />
+              )}
+            </li>
+          );
+        })}
+    </List>
+  );
+};
 
-      {isPending && <StepConnectionLoader />}
+const ConnectedVideoStep = (props: ConnectedAppStepProps) => {
+  const { nextStep, isPageLoading, user } = props;
+  const { t } = useLocale();
+  const [hasAnyInstalledVideoApps, setAnyInstalledVideoApps] = useState(false);
+  return (
+    <>
+      <ConnectedVideoStepInner setAnyInstalledVideoApps={setAnyInstalledVideoApps} t={t} user={user} />
       <Button
         EndIcon="arrow-right"
         data-testid="save-video-button"

apps/web/components/getting-started/steps-views/UserProfile.tsx

@@ -10,6 +10,7 @@ import { md } from "@calcom/lib/markdownIt";
 import { telemetryEventTypes } from "@calcom/lib/telemetry";
 import turndown from "@calcom/lib/turndownService";
 import { trpc } from "@calcom/trpc/react";
+import type { RouterOutputs } from "@calcom/trpc/react";
 import { UserAvatar } from "@calcom/ui/components/avatar";
 import { Button } from "@calcom/ui/components/button";
 import { Editor } from "@calcom/ui/components/editor";
@@ -21,8 +22,11 @@ type FormData = {
   bio: string;
 };
 
-const UserProfile = () => {
-  const [user] = trpc.viewer.me.get.useSuspenseQuery();
+interface UserProfileProps {
+  user: RouterOutputs["viewer"]["me"]["get"];
+}
+
+const UserProfile = ({ user }: UserProfileProps) => {
   const { t } = useLocale();
   const avatarRef = useRef<HTMLInputElement>(null);
   const { setValue, handleSubmit, getValues } = useForm<FormData>({

apps/web/components/getting-started/steps-views/UserSettings.tsx

@@ -13,6 +13,7 @@ import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { useTelemetry } from "@calcom/lib/hooks/useTelemetry";
 import { telemetryEventTypes } from "@calcom/lib/telemetry";
 import { trpc } from "@calcom/trpc/react";
+import type { RouterOutputs } from "@calcom/trpc/react";
 import { Button } from "@calcom/ui/components/button";
 import { Input } from "@calcom/ui/components/form";
 
@@ -21,11 +22,11 @@ import { UsernameAvailabilityField } from "@components/ui/UsernameAvailability";
 interface IUserSettingsProps {
   nextStep: () => void;
   hideUsername?: boolean;
+  user: RouterOutputs["viewer"]["me"]["get"];
 }
 
 const UserSettings = (props: IUserSettingsProps) => {
-  const { nextStep } = props;
-  const [user] = trpc.viewer.me.get.useSuspenseQuery();
+  const { nextStep, user } = props;
   const { t } = useLocale();
   const { setTimezone: setSelectedTimeZone, timezone: selectedTimeZone } = useTimePreferences();
   const telemetry = useTelemetry();

apps/web/components/plain/PlainContactForm.tsx

@@ -144,7 +144,7 @@ const PlainContactForm = () => {
   };
 
   return (
-    <div className="absolute bottom-4 right-4 z-50">
+    <div className="fixed bottom-[1rem] right-[1rem] z-50">
       <Popover open={isOpen} onOpenChange={setIsOpen}>
         <PopoverTrigger asChild className="enabled:hover:bg-subtle bg-subtle shadow-none">
           <Button
@@ -156,7 +156,7 @@ const PlainContactForm = () => {
 
         <PopoverContent
           style={{ maxWidth: "450px", maxHeight: "650px" }}
-          className="!bg-muted no-scrollbar mr-8 mb-2 w-[450px] overflow-hidden overflow-y-scroll px-6 py-4">
+          className="!bg-muted no-scrollbar mb-2 mr-8 w-[450px] overflow-hidden overflow-y-scroll px-6 py-4">
           <div className="flex w-full justify-between">
             <p className="mb-5 text-lg font-semibold">Contact support</p>
             <Button

apps/web/components/plain/__tests__/PlainContactForm.test.tsx

@@ -4,7 +4,7 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 
 import { showToast } from "@calcom/ui/components/toast";
 
-import PlainContactForm from "../../../lib/plain/PlainContactForm";
+import PlainContactForm from "../PlainContactForm";
 
 vi.mock("next-auth/react", () => ({
   useSession: vi.fn(),

apps/web/components/ui/UsernameAvailability/UsernameTextfield.tsx

@@ -124,8 +124,9 @@ const UsernameTextfield = (props: ICustomUsernameProps & Partial<React.Component
             autoComplete="none"
             autoCapitalize="none"
             autoCorrect="none"
+            containerClassName="[&>div]:gap-0"
             className={classNames(
-              "mb-0 mt-0 rounded-md rounded-l-none",
+              "mb-0 mt-0 rounded-md rounded-l-none pl-0",
               markAsError
                 ? "focus:shadow-0 focus:ring-shadow-0 border-red-500 focus:border-red-500 focus:outline-none focus:ring-0"
                 : ""

apps/web/lib/buildLegacyCtx.tsx

@@ -1,8 +1,7 @@
 import type { SearchParams } from "app/_types";
 import { type Params } from "app/_types";
+import type { ReadonlyHeaders, ReadonlyRequestCookies } from "app/_types";
 import type { GetServerSidePropsContext, NextApiRequest } from "next";
-import { type ReadonlyHeaders } from "next/dist/server/web/spec-extension/adapters/headers";
-import { type ReadonlyRequestCookies } from "next/dist/server/web/spec-extension/adapters/request-cookies";
 
 const createProxifiedObject = (object: Record<string, string>) =>
   new Proxy(object, {

apps/web/lib/d/[link]/[slug]/getServerSideProps.tsx

@@ -15,7 +15,7 @@ import slugify from "@calcom/lib/slugify";
 import prisma from "@calcom/prisma";
 import { RedirectType } from "@calcom/prisma/enums";
 
-import { getTemporaryOrgRedirect } from "@lib/getTemporaryOrgRedirect";
+import { getRedirectWithOriginAndSearchString } from "@lib/handleOrgRedirect";
 import type { inferSSRProps } from "@lib/types/inferSSRProps";
 
 export type PageProps = inferSSRProps<typeof getServerSideProps> & EmbedProps;
@@ -64,17 +64,26 @@ async function getUserPageProps(context: GetServerSidePropsContext) {
       return notFound;
     }
 
-    if (!org) {
-      const redirect = await getTemporaryOrgRedirect({
-        slugs: [username],
-        redirectType: RedirectType.User,
-        eventTypeSlug: slug,
-        currentQuery: context.query,
-      });
+    // Get just the origin and searchString from the redirect to ensure that we don't redirect to a URL that exposes the real path to book the user for any other events \
+    // This is important for a private booking link
+    // e.g. http://app.cal.com/d/sgdthj8mu4nsLNTYi3fW2p/demo -> should redirect to -> http://acme.cal.com/d/sgdthj8mu4nsLNTYi3fW2p/demo and not to http://acme.cal.com/john/demo(which exposes the real path to book the user for any other events)
+    const redirectWithOriginAndSearchString = await getRedirectWithOriginAndSearchString({
+      slugs: [username],
+      redirectType: RedirectType.User,
+      context,
+      currentOrgDomain: isValidOrgDomain ? currentOrgDomain : null,
+    });
 
-      if (redirect) {
-        return redirect;
-      }
+    if (redirectWithOriginAndSearchString) {
+      return {
+        redirect: {
+          permanent: false,
+          // App Router doesn't have access to the current path directly, so we build it manually
+          destination: `${redirectWithOriginAndSearchString.origin ?? ""}/d/${link}/${slug}${
+            redirectWithOriginAndSearchString.searchString
+          }`,
+        },
+      };
     }
 
     name = profileUsername || username;

apps/web/lib/getTemporaryOrgRedirect.test.ts

@@ -1,333 +0,0 @@
-import prismaMock from "../../../tests/libs/__mocks__/prismaMock";
-
-import { describe, it, expect, beforeEach } from "vitest";
-
-import { RedirectType } from "@calcom/prisma/client";
-
-import { getTemporaryOrgRedirect } from "./getTemporaryOrgRedirect";
-
-const mockData = {
-  redirects: [] as {
-    toUrl: string;
-    from: string;
-    redirectType: RedirectType;
-  }[],
-};
-
-function mockARedirectInDB({
-  toUrl,
-  slug,
-  redirectType,
-}: {
-  toUrl: string;
-  slug: string;
-  redirectType: RedirectType;
-}) {
-  mockData.redirects.push({
-    toUrl,
-    from: slug,
-    redirectType,
-  });
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  //@ts-ignore
-  prismaMock.tempOrgRedirect.findMany.mockImplementation(({ where }) => {
-    return new Promise((resolve) => {
-      const tempOrgRedirects: typeof mockData.redirects = [];
-      where.from.in.forEach((whereSlug: string) => {
-        const matchingRedirect = mockData.redirects.find((redirect) => {
-          return where.type === redirect.redirectType && whereSlug === redirect.from && where.fromOrgId === 0;
-        });
-        if (matchingRedirect) {
-          tempOrgRedirects.push(matchingRedirect);
-        }
-      });
-      resolve(tempOrgRedirects);
-    });
-  });
-}
-
-beforeEach(() => {
-  mockData.redirects = [];
-});
-
-describe("getTemporaryOrgRedirect", () => {
-  it("should generate event-type URL without existing query params", async () => {
-    mockARedirectInDB({ slug: "slug", toUrl: "https://calcom.cal.com", redirectType: RedirectType.User });
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: "slug",
-      redirectType: RedirectType.User,
-      eventTypeSlug: "30min",
-      currentQuery: {},
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/30min?orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate event-type URL with existing query params", async () => {
-    mockARedirectInDB({ slug: "slug", toUrl: "https://calcom.cal.com", redirectType: RedirectType.User });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: "slug",
-      redirectType: RedirectType.User,
-      eventTypeSlug: "30min",
-      currentQuery: {
-        abc: "1",
-      },
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/30min?abc=1&orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate User URL with existing query params", async () => {
-    mockARedirectInDB({ slug: "slug", toUrl: "https://calcom.cal.com", redirectType: RedirectType.User });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: "slug",
-      redirectType: RedirectType.User,
-      eventTypeSlug: null,
-      currentQuery: {
-        abc: "1",
-      },
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com?abc=1&orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Team Profile URL with existing query params", async () => {
-    mockARedirectInDB({
-      slug: "seeded-team",
-      toUrl: "https://calcom.cal.com",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: "seeded-team",
-      redirectType: RedirectType.Team,
-      eventTypeSlug: null,
-      currentQuery: {
-        abc: "1",
-      },
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com?abc=1&orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Team Event URL with existing query params", async () => {
-    mockARedirectInDB({
-      slug: "seeded-team",
-      toUrl: "https://calcom.cal.com",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: "seeded-team",
-      redirectType: RedirectType.Team,
-      eventTypeSlug: "30min",
-      currentQuery: {
-        abc: "1",
-      },
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/30min?abc=1&orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Team Event URL without query params", async () => {
-    mockARedirectInDB({
-      slug: "seeded-team",
-      toUrl: "https://calcom.cal.com",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: "seeded-team",
-      redirectType: RedirectType.Team,
-      eventTypeSlug: "30min",
-      currentQuery: {},
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/30min?orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Dynamic Group Booking Profile Url", async () => {
-    mockARedirectInDB({
-      slug: "first",
-      toUrl: "https://calcom.cal.com/first-in-org1",
-      redirectType: RedirectType.Team,
-    });
-    mockARedirectInDB({
-      slug: "second",
-      toUrl: "https://calcom.cal.com/second-in-org1",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: ["first", "second"],
-      redirectType: RedirectType.Team,
-      eventTypeSlug: null,
-      currentQuery: {},
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/first-in-org1+second-in-org1?orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Dynamic Group Booking Profile Url - same order", async () => {
-    mockARedirectInDB({
-      slug: "second",
-      toUrl: "https://calcom.cal.com/second-in-org1",
-      redirectType: RedirectType.Team,
-    });
-    mockARedirectInDB({
-      slug: "first",
-      toUrl: "https://calcom.cal.com/first-in-org1",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: ["first", "second"],
-      redirectType: RedirectType.Team,
-      eventTypeSlug: null,
-      currentQuery: {},
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/first-in-org1+second-in-org1?orgRedirection=true",
-      },
-    });
-
-    const redirect1 = await getTemporaryOrgRedirect({
-      slugs: ["second", "first"],
-      redirectType: RedirectType.Team,
-      eventTypeSlug: null,
-      currentQuery: {},
-    });
-
-    expect(redirect1).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/second-in-org1+first-in-org1?orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Dynamic Group Booking Profile Url with query params", async () => {
-    mockARedirectInDB({
-      slug: "first",
-      toUrl: "https://calcom.cal.com/first-in-org1",
-      redirectType: RedirectType.Team,
-    });
-    mockARedirectInDB({
-      slug: "second",
-      toUrl: "https://calcom.cal.com/second-in-org1",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: ["first", "second"],
-      redirectType: RedirectType.Team,
-      eventTypeSlug: null,
-      currentQuery: {
-        abc: "1",
-      },
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/first-in-org1+second-in-org1?abc=1&orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Dynamic Group Booking EventType Url", async () => {
-    mockARedirectInDB({
-      slug: "first",
-      toUrl: "https://calcom.cal.com/first-in-org1",
-      redirectType: RedirectType.Team,
-    });
-    mockARedirectInDB({
-      slug: "second",
-      toUrl: "https://calcom.cal.com/second-in-org1",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: ["first", "second"],
-      redirectType: RedirectType.Team,
-      eventTypeSlug: "30min",
-      currentQuery: {},
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/first-in-org1+second-in-org1/30min?orgRedirection=true",
-      },
-    });
-  });
-
-  it("should generate Dynamic Group Booking EventType Url with query params", async () => {
-    mockARedirectInDB({
-      slug: "first",
-      toUrl: "https://calcom.cal.com/first-in-org1",
-      redirectType: RedirectType.Team,
-    });
-    mockARedirectInDB({
-      slug: "second",
-      toUrl: "https://calcom.cal.com/second-in-org1",
-      redirectType: RedirectType.Team,
-    });
-
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: ["first", "second"],
-      redirectType: RedirectType.Team,
-      eventTypeSlug: "30min",
-      currentQuery: {
-        abc: "1",
-      },
-    });
-
-    expect(redirect).toEqual({
-      redirect: {
-        permanent: false,
-        destination: "https://calcom.cal.com/first-in-org1+second-in-org1/30min?abc=1&orgRedirection=true",
-      },
-    });
-  });
-});

apps/web/lib/getTemporaryOrgRedirect.ts

@@ -1,71 +0,0 @@
-import type { ParsedUrlQuery } from "querystring";
-import { stringify } from "querystring";
-
-import logger from "@calcom/lib/logger";
-import { safeStringify } from "@calcom/lib/safeStringify";
-import type { RedirectType } from "@calcom/prisma/client";
-
-const log = logger.getSubLogger({ prefix: ["lib", "getTemporaryOrgRedirect"] });
-export const getTemporaryOrgRedirect = async ({
-  slugs,
-  redirectType,
-  eventTypeSlug,
-  currentQuery,
-}: {
-  slugs: string[] | string;
-  redirectType: RedirectType;
-  eventTypeSlug: string | null;
-  currentQuery: ParsedUrlQuery;
-}) => {
-  const prisma = (await import("@calcom/prisma")).default;
-  slugs = slugs instanceof Array ? slugs : [slugs];
-  log.debug(
-    `Looking for redirect for`,
-    safeStringify({
-      slugs,
-      redirectType,
-      eventTypeSlug,
-    })
-  );
-
-  const redirects = await prisma.tempOrgRedirect.findMany({
-    where: {
-      type: redirectType,
-      from: {
-        in: slugs,
-      },
-      fromOrgId: 0,
-    },
-  });
-
-  const currentQueryString = stringify(currentQuery);
-  if (!redirects.length) {
-    return null;
-  }
-
-  // Use the first redirect origin as the new origin as we aren't supposed to handle different org usernames in a group
-  const newOrigin = new URL(redirects[0].toUrl).origin;
-  const query = currentQueryString ? `?${currentQueryString}&orgRedirection=true` : "?orgRedirection=true";
-  // Use the same order as in input slugs - It is important from Dynamic Group perspective as the first user's settings are used for various things
-  const newSlugs = slugs.map((slug) => {
-    const redirect = redirects.find((redirect) => redirect.from === slug);
-    if (!redirect) {
-      return slug;
-    }
-    const newSlug = new URL(redirect.toUrl).pathname.slice(1);
-    return newSlug;
-  });
-
-  const newSlug = newSlugs.join("+");
-  const newPath = newSlug ? `/${newSlug}` : "";
-
-  const newDestination = `${newOrigin}${newPath}${eventTypeSlug ? `/${eventTypeSlug}` : ""}${query}`;
-  log.debug(`Suggesting redirect from ${slugs} to ${newDestination}`);
-
-  return {
-    redirect: {
-      permanent: false,
-      destination: newDestination,
-    },
-  } as const;
-};

apps/web/lib/getting-started/[[...step]]/getServerSideProps.tsx

@@ -1,30 +0,0 @@
-import type { GetServerSidePropsContext } from "next";
-
-import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
-import { UserRepository } from "@calcom/lib/server/repository/user";
-import prisma from "@calcom/prisma";
-
-export const getServerSideProps = async (context: GetServerSidePropsContext) => {
-  const { req } = context;
-
-  const session = await getServerSession({ req });
-
-  if (!session?.user?.id) {
-    return { redirect: { permanent: false, destination: "/auth/login" } };
-  }
-
-  const userRepo = new UserRepository(prisma);
-  const user = await userRepo.findUserTeams({
-    id: session.user.id,
-  });
-
-  if (!user) {
-    throw new Error("User from session not found");
-  }
-
-  return {
-    props: {
-      hasPendingInvites: user.teams.find((team) => team.accepted === false) ?? false,
-    },
-  };
-};

apps/web/lib/handleOrgRedirect.test.ts

@@ -0,0 +1,704 @@
+import type { GetServerSidePropsContext } from "next";
+import type { ParsedUrlQuery } from "querystring";
+import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
+
+import * as constants from "@calcom/lib/constants";
+import { RedirectType } from "@calcom/prisma/client";
+
+import { handleOrgRedirect, getRedirectWithOriginAndSearchString } from "./handleOrgRedirect";
+
+// Mock prisma for all tests
+const prismaMock = vi.hoisted(() => ({
+  tempOrgRedirect: {
+    findMany: vi.fn(),
+  },
+}));
+
+vi.mock("@calcom/prisma", () => ({
+  default: prismaMock,
+}));
+
+const createTestContext = (overrides?: {
+  host?: string;
+  query?: ParsedUrlQuery;
+}): GetServerSidePropsContext =>
+  ({
+    req: {
+      headers: {
+        host: overrides?.host || "cal.local:3000",
+      },
+    },
+    query: overrides?.query || {},
+  } as unknown as GetServerSidePropsContext);
+
+const createTestRedirectParams = (overrides?: {
+  slugs?: string[];
+  redirectType?: RedirectType;
+  eventTypeSlug?: string | null;
+  context?: GetServerSidePropsContext;
+  currentOrgDomain?: string | null;
+}) => ({
+  slugs: overrides?.slugs || ["pro"],
+  redirectType: overrides?.redirectType || RedirectType.User,
+  eventTypeSlug: overrides?.eventTypeSlug ?? null,
+  context: overrides?.context || createTestContext(),
+  currentOrgDomain: overrides?.currentOrgDomain ?? null,
+});
+
+interface RedirectScenario {
+  redirects: Array<{
+    from: string;
+    toUrl: string;
+    type?: RedirectType;
+  }>;
+}
+
+const createRedirectScenario = (scenario: RedirectScenario) => {
+  // Create a map for quick lookup based on input parameters
+  const redirectMap = new Map<string, (typeof scenario.redirects)[0]>();
+
+  scenario.redirects.forEach((redirect) => {
+    const key = `${redirect.type || RedirectType.User}-${redirect.from}`;
+    redirectMap.set(key, redirect);
+  });
+
+  // Return a mock implementation that returns data based on the actual query
+  prismaMock.tempOrgRedirect.findMany.mockImplementation(async (params) => {
+    const { type, from } = params?.where || {};
+    const slugsToFind = from?.in || [];
+
+    // Return redirects that match the requested type and slugs
+    const matchingRedirects = slugsToFind
+      .map((slug: string) => {
+        const key = `${type}-${slug}`;
+        const redirect = redirectMap.get(key);
+        if (redirect) {
+          return {
+            from: redirect.from,
+            toUrl: redirect.toUrl,
+            type: redirect.type || type,
+            fromOrgId: 0,
+          };
+        }
+        return null;
+      })
+      .filter(Boolean);
+
+    return matchingRedirects;
+  });
+};
+
+const expectRedirectTo = (result: any, expectedDestination: string) => {
+  expect(result).toEqual({
+    redirect: {
+      permanent: false,
+      destination: expectedDestination,
+    },
+  });
+};
+
+const expectNoRedirect = (result: any) => {
+  expect(result).toBeNull();
+};
+
+const expectPrismaCalledWith = (expectedParams: { type: RedirectType; slugs: string[] }) => {
+  expect(prismaMock.tempOrgRedirect.findMany).toHaveBeenCalledWith({
+    where: {
+      type: expectedParams.type,
+      from: {
+        in: expectedParams.slugs,
+      },
+      fromOrgId: 0,
+    },
+  });
+};
+
+const expectPrismaNotCalled = () => {
+  expect(prismaMock.tempOrgRedirect.findMany).not.toHaveBeenCalled();
+};
+
+// Verify that the redirect was actually built from the data returned by Prisma
+const expectRedirectUsesData = (
+  result: any,
+  expectedSlug: string,
+  expectedOrigin = "https://acme.cal.local:3000"
+) => {
+  if (!result || !result.redirect) {
+    throw new Error("Expected a redirect result but got null/undefined");
+  }
+  const url = new URL(result.redirect.destination);
+  expect(url.origin).toBe(expectedOrigin);
+  expect(url.pathname).toContain(expectedSlug);
+};
+
+describe("handleOrgRedirect", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Default to no redirects - tests will override with specific scenarios
+    createRedirectScenario({ redirects: [] });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("when not in organization context", () => {
+    it("should redirect to organization URL when redirect exists", async () => {
+      // Setup scenario with unique test data to verify correct usage
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+          // Add a decoy redirect to ensure the code picks the right one
+          {
+            from: "other-user",
+            toUrl: "https://acme.cal.local:3000/wrong-redirect",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["pro"],
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.User, slugs: ["pro"] });
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example?orgRedirection=true");
+      expectRedirectUsesData(result, "pro-example");
+    });
+
+    it("should return null when no redirect exists", async () => {
+      // Explicitly set up no redirects scenario
+      createRedirectScenario({ redirects: [] });
+
+      const params = createTestRedirectParams({
+        slugs: ["pro"],
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.User, slugs: ["pro"] });
+      expectNoRedirect(result);
+    });
+
+    it("should handle Team redirect type", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "sales-team",
+            toUrl: "https://acme.cal.local:3000/sales",
+            type: RedirectType.Team,
+          },
+          // Add a User redirect with same slug to verify type filtering
+          {
+            from: "sales-team",
+            toUrl: "https://acme.cal.local:3000/wrong-user-redirect",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["sales-team"],
+        redirectType: RedirectType.Team,
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.Team, slugs: ["sales-team"] });
+      expectRedirectTo(result, "https://acme.cal.local:3000/sales?orgRedirection=true");
+      expectRedirectUsesData(result, "sales");
+    });
+  });
+
+  describe("when SINGLE_ORG_SLUG mode is enabled", () => {
+    beforeEach(() => {
+      vi.spyOn(constants, "SINGLE_ORG_SLUG", "get").mockReturnValue("acme");
+    });
+
+    it("should redirect using relative path when accessing from base domain", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        context: createTestContext({ host: "cal.local:3000" }),
+        currentOrgDomain: "acme",
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.User, slugs: ["pro"] });
+      // Should use relative path to stay on same domain
+      expectRedirectTo(result, "/pro-example?orgRedirection=true");
+    });
+
+    it("should redirect john87 to john using relative path in single org mode", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "john87",
+            toUrl: "https://acme.cal.local:3000/john",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["john87"],
+        context: createTestContext({
+          host: "my-instance.com",
+        }),
+        currentOrgDomain: "acme",
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.User, slugs: ["john87"] });
+      // Should redirect to relative path /john to stay on my-instance.com
+      expectRedirectTo(result, "/john?orgRedirection=true");
+    });
+
+    describe("when orgRedirection parameter is present", () => {
+      it("should not redirect to prevent loops", async () => {
+        const params = createTestRedirectParams({
+          context: createTestContext({ query: { orgRedirection: "true" } }),
+          currentOrgDomain: "acme",
+        });
+        const result = await handleOrgRedirect(params);
+
+        expectPrismaNotCalled();
+        expectNoRedirect(result);
+      });
+    });
+  });
+
+  describe("when event type slug is provided", () => {
+    it("should include event type slug in redirect destination", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        eventTypeSlug: "30min",
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.User, slugs: ["pro"] });
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example/30min?orgRedirection=true");
+      // Verify the event type slug was properly appended
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.pathname).toBe("/pro-example/30min");
+    });
+
+    it("should handle empty event type slug", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        eventTypeSlug: null,
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example?orgRedirection=true");
+      expectRedirectUsesData(result, "pro-example");
+    });
+  });
+
+  describe("when handling multiple slugs (group bookings)", () => {
+    it("should preserve order of slugs in redirect", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "user1",
+            toUrl: "https://acme.cal.local:3000/org-user1",
+            type: RedirectType.User,
+          },
+          {
+            from: "user2",
+            toUrl: "https://acme.cal.local:3000/org-user2",
+            type: RedirectType.User,
+          },
+          {
+            from: "user3",
+            toUrl: "https://acme.cal.local:3000/org-user3",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["user1", "user2", "user3"],
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(
+        result,
+        "https://acme.cal.local:3000/org-user1+org-user2+org-user3?orgRedirection=true"
+      );
+      // Verify order is preserved from input slugs
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.pathname).toBe("/org-user1+org-user2+org-user3");
+    });
+
+    it("should handle partial redirects in group bookings", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "user1",
+            toUrl: "https://acme.cal.local:3000/org-user1",
+            type: RedirectType.User,
+          },
+          // user2 has no redirect - it should stay as-is
+          {
+            from: "user3",
+            toUrl: "https://acme.cal.local:3000/org-user3",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["user1", "user2", "user3"],
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/org-user1+user2+org-user3?orgRedirection=true");
+      // Verify that user2 remains unchanged while others are redirected
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.pathname).toBe("/org-user1+user2+org-user3");
+    });
+
+    it("should handle different origins in redirects", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "user1",
+            toUrl: "https://org1.cal.com/john",
+            type: RedirectType.User,
+          },
+          {
+            from: "user2",
+            toUrl: "https://org1.cal.com/jane",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["user1", "user2"],
+      });
+      const result = await handleOrgRedirect(params);
+
+      // Should use the first redirect's origin
+      expectRedirectTo(result, "https://org1.cal.com/john+jane?orgRedirection=true");
+      expectRedirectUsesData(result, "john+jane", "https://org1.cal.com");
+    });
+  });
+
+  describe("when handling query parameters", () => {
+    it("should add orgRedirection=true to empty query", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        context: createTestContext({ query: {} }),
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example?orgRedirection=true");
+      expectRedirectUsesData(result, "pro-example");
+    });
+
+    it("should preserve existing query parameters", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        context: createTestContext({
+          query: { abc: "1", xyz: "test" },
+        }),
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example?abc=1&xyz=test&orgRedirection=true");
+      // Verify query parameters are preserved
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.searchParams.get("abc")).toBe("1");
+      expect(url.searchParams.get("xyz")).toBe("test");
+    });
+
+    it("should not duplicate orgRedirection parameter", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        context: createTestContext({
+          query: { orgRedirection: "true", abc: "1" },
+        }),
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example?abc=1&orgRedirection=true");
+
+      // Verify only one orgRedirection parameter exists
+      const url = new URL(result?.redirect.destination || "");
+      const orgRedirectionParams = url.searchParams.getAll("orgRedirection");
+      expect(orgRedirectionParams).toHaveLength(1);
+      expect(orgRedirectionParams[0]).toBe("true");
+    });
+
+    it("should handle array query parameters", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        context: createTestContext({
+          query: { tags: ["tag1", "tag2"], filter: "active" },
+        }),
+      });
+      const result = await handleOrgRedirect(params);
+
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.searchParams.getAll("tags")).toEqual(["tag1", "tag2"]);
+      expect(url.searchParams.get("filter")).toBe("active");
+      expect(url.searchParams.get("orgRedirection")).toBe("true");
+    });
+  });
+
+  describe("edge cases and error scenarios", () => {
+    it("should handle empty slugs array", async () => {
+      createRedirectScenario({ redirects: [] });
+
+      const params = createTestRedirectParams({
+        slugs: [],
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaCalledWith({ type: RedirectType.User, slugs: [] });
+      expectNoRedirect(result);
+    });
+
+    it("should handle redirects with trailing slashes", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000/pro-example/",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams();
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/pro-example/?orgRedirection=true");
+      // Verify trailing slash is preserved
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.pathname).toBe("/pro-example/");
+    });
+
+    it("should handle redirects to root path", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "pro",
+            toUrl: "https://acme.cal.local:3000",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams();
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000?orgRedirection=true");
+      // Verify root path redirect
+      const url = new URL(result?.redirect.destination || "");
+      expect(url.pathname).toBe("/");
+    });
+
+    it("should handle special characters in slugs", async () => {
+      createRedirectScenario({
+        redirects: [
+          {
+            from: "user-name.test",
+            toUrl: "https://acme.cal.local:3000/user_name_test",
+            type: RedirectType.User,
+          },
+        ],
+      });
+
+      const params = createTestRedirectParams({
+        slugs: ["user-name.test"],
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectRedirectTo(result, "https://acme.cal.local:3000/user_name_test?orgRedirection=true");
+      expectRedirectUsesData(result, "user_name_test");
+    });
+  });
+
+  describe("when SINGLE_ORG_SLUG is not set", () => {
+    beforeEach(() => {
+      vi.spyOn(constants, "SINGLE_ORG_SLUG", "get").mockReturnValue(undefined);
+    });
+
+    it("should not check for redirects when in org context", async () => {
+      const params = createTestRedirectParams({
+        currentOrgDomain: "acme",
+      });
+      const result = await handleOrgRedirect(params);
+
+      expectPrismaNotCalled();
+      expectNoRedirect(result);
+    });
+  });
+});
+
+describe("getRedirectWithOriginAndSearchString", () => {
+  beforeEach(() => {
+    vi.spyOn(constants, "SINGLE_ORG_SLUG", "get").mockReturnValue(undefined);
+  });
+
+  afterEach(() => {
+    prismaMock.tempOrgRedirect.findMany.mockReset();
+  });
+
+  it("should return origin and search string for absolute URL redirects", async () => {
+    createRedirectScenario({
+      redirects: [
+        {
+          from: "john",
+          toUrl: "https://acme.cal.local:3000/john-org",
+          type: RedirectType.User,
+        },
+      ],
+    });
+
+    const params = {
+      slugs: ["john"],
+      redirectType: RedirectType.User,
+      context: createTestContext(),
+      currentOrgDomain: null,
+    };
+    const result = await getRedirectWithOriginAndSearchString(params);
+
+    expect(result).not.toBeNull();
+    expect(result?.origin).toBe("https://acme.cal.local:3000");
+    expect(result?.searchString).toBe("?orgRedirection=true");
+  });
+
+  it("should return null origin for relative path redirects", async () => {
+    // Enable SINGLE_ORG_SLUG for this test to get relative paths
+    vi.spyOn(constants, "SINGLE_ORG_SLUG", "get").mockReturnValue("acme");
+
+    createRedirectScenario({
+      redirects: [
+        {
+          from: "john",
+          toUrl: "https://acme.cal.local:3000/john-org",
+          type: RedirectType.User,
+        },
+      ],
+    });
+
+    const params = {
+      slugs: ["john"],
+      redirectType: RedirectType.User,
+      context: createTestContext({ host: "my-instance.com" }),
+      currentOrgDomain: "acme",
+    };
+    const result = await getRedirectWithOriginAndSearchString(params);
+
+    expect(result).not.toBeNull();
+    expect(result?.origin).toBeNull(); // Relative path has no origin
+    expect(result?.searchString).toBe("?orgRedirection=true");
+  });
+
+  it("should preserve existing query parameters in search string", async () => {
+    createRedirectScenario({
+      redirects: [
+        {
+          from: "john",
+          toUrl: "https://acme.cal.local:3000/john-org",
+          type: RedirectType.User,
+        },
+      ],
+    });
+
+    const params = {
+      slugs: ["john"],
+      redirectType: RedirectType.User,
+      context: createTestContext({ query: { foo: "bar", baz: "qux" } }),
+      currentOrgDomain: null,
+    };
+    const result = await getRedirectWithOriginAndSearchString(params);
+
+    expect(result).not.toBeNull();
+    expect(result?.origin).toBe("https://acme.cal.local:3000");
+    expect(result?.searchString).toBe("?foo=bar&baz=qux&orgRedirection=true");
+  });
+
+  it("should return null when no redirect exists", async () => {
+    createRedirectScenario({ redirects: [] });
+
+    const params = {
+      slugs: ["john"],
+      redirectType: RedirectType.User,
+      context: createTestContext(),
+      currentOrgDomain: null,
+    };
+    const result = await getRedirectWithOriginAndSearchString(params);
+
+    expect(result).toBeNull();
+  });
+});

apps/web/lib/handleOrgRedirect.ts

@@ -0,0 +1,203 @@
+import type { ParsedUrlQuery } from "querystring";
+import { stringify } from "querystring";
+
+import { SINGLE_ORG_SLUG } from "@calcom/lib/constants";
+import logger from "@calcom/lib/logger";
+import { safeStringify } from "@calcom/lib/safeStringify";
+import type { RedirectType } from "@calcom/prisma/client";
+
+const log = logger.getSubLogger({ prefix: ["lib", "handleOrgRedirect"] });
+type NextJsRedirect = {
+  redirect: {
+    permanent: false;
+    /**
+     * It could be a full URL or a relative path
+     */
+    destination: string;
+  };
+};
+
+function getSearchString(relativeOrAbsoluteUrl: string) {
+  const url = new URL(relativeOrAbsoluteUrl, "http://localhost");
+  return url.search;
+}
+
+const getTemporaryOrgRedirect = async ({
+  slugs,
+  redirectType,
+  eventTypeSlug,
+  currentQuery,
+  useRelativePath = false,
+}: {
+  slugs: string[];
+  redirectType: RedirectType;
+  eventTypeSlug: string | null;
+  currentQuery: ParsedUrlQuery;
+  useRelativePath?: boolean;
+}): Promise<NextJsRedirect | null> => {
+  const prisma = (await import("@calcom/prisma")).default;
+  log.debug(
+    `Looking for redirect for`,
+    safeStringify({
+      slugs,
+      redirectType,
+      eventTypeSlug,
+    })
+  );
+
+  const redirects = await prisma.tempOrgRedirect.findMany({
+    where: {
+      type: redirectType,
+      from: {
+        in: slugs,
+      },
+      fromOrgId: 0,
+    },
+  });
+
+  if (!redirects.length) {
+    return null;
+  }
+
+  // Use the first redirect origin as the new origin as we aren't supposed to handle different org usernames in a group
+  const newOrigin = new URL(redirects[0].toUrl).origin;
+
+  // Filter out any existing orgRedirection parameter to avoid duplicates
+  // querystring.stringify transforms undefined values to empty strings, so we need to filter those out as well initially
+  const filteredQuery = Object.entries(currentQuery).reduce((acc, [key, value]) => {
+    if (key !== "orgRedirection" && value !== undefined) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {} as ParsedUrlQuery);
+
+  const currentQueryString = stringify(filteredQuery);
+  const query = currentQueryString ? `?${currentQueryString}&orgRedirection=true` : "?orgRedirection=true";
+  // Use the same order as in input slugs - It is important from Dynamic Group perspective as the first user's settings are used for various things
+  const newSlugs = slugs.map((slug) => {
+    const redirect = redirects.find((redirect) => redirect.from === slug);
+    if (!redirect) {
+      return slug;
+    }
+    const newSlug = new URL(redirect.toUrl).pathname.slice(1);
+    return newSlug;
+  });
+
+  const newSlug = newSlugs.join("+");
+  const newPath = newSlug ? `/${newSlug}` : "";
+
+  // When in single org mode and not on actual org subdomain, use relative path to stay on same domain
+  const newDestination = useRelativePath
+    ? `${newPath}${eventTypeSlug ? `/${eventTypeSlug}` : ""}${query}`
+    : `${newOrigin}${newPath}${eventTypeSlug ? `/${eventTypeSlug}` : ""}${query}`;
+  log.debug(`Suggesting redirect from ${slugs} to ${newDestination}`);
+
+  return {
+    redirect: {
+      permanent: false,
+      destination: newDestination,
+    },
+  } as const;
+};
+
+interface HandleOrgRedirectParams {
+  slugs: string[];
+  redirectType: RedirectType;
+  eventTypeSlug: string | null;
+  context: {
+    query: ParsedUrlQuery;
+  };
+  currentOrgDomain: string | null;
+}
+
+/**
+ * Handles organization redirects for both regular org context and SINGLE_ORG_SLUG mode
+ * The redirect is required for all existing user links and team links to keep working when a user/team is moved to an organization
+ * Example:
+ * - User "john87" is added to organization "acme" and his username in the organization is "john". So, cal.com/john87 is redirected to cal.com/john
+ * - Team "acme-sales" is added to organization "acme" and its slug in the organization is "sales". So, cal.com/acme-sales is redirected to cal.com/sales
+ *
+ * Returns a redirect object if a redirect is needed, null otherwise
+ */
+export async function handleOrgRedirect({
+  slugs,
+  redirectType,
+  eventTypeSlug,
+  context,
+  currentOrgDomain,
+}: HandleOrgRedirectParams) {
+  const isOrgContext = !!currentOrgDomain;
+  const isARedirectFromNonOrgLink = context.query.orgRedirection === "true";
+
+  // If we're not in an org context, the request could clearly be eligible for a redirect
+  if (!isOrgContext) {
+    const nextJsRedirect = await getTemporaryOrgRedirect({
+      slugs,
+      redirectType,
+      eventTypeSlug,
+      currentQuery: context.query,
+    });
+
+    if (nextJsRedirect) {
+      return nextJsRedirect;
+    }
+  }
+
+  const isSingleOrgMode = SINGLE_ORG_SLUG && isOrgContext;
+
+  // When SINGLE_ORG_SLUG is set(which is possible in Self-Hosted instances), isOrgContext could be true even when the current domain is not an org subdomain
+  // Example: my-instance.com could technically mean acme.my-instance.com where acme is the org slug
+  // In such a case, the existing links which were on my-instance.com e.g. my-instance.com/john87 should be redirected to my-instance.com/john where john is the new username in Organization
+  // This is why we need to follow redirect even when in Org Context
+  if (!isSingleOrgMode) {
+    return null;
+  }
+
+  // If already redirected from a non-org link, we shouldn't redirect again. Protects against infinite redirects
+  if (isARedirectFromNonOrgLink) {
+    return null;
+  }
+
+  // We're in single org mode but not on an actual org subdomain
+  // Check if there's a redirect for this username
+  // Use relative path since we want to stay on the same domain (my-instance.com)
+  const nextJsRedirect = await getTemporaryOrgRedirect({
+    slugs,
+    redirectType,
+    eventTypeSlug,
+    currentQuery: context.query,
+    useRelativePath: true,
+  });
+
+  return nextJsRedirect;
+}
+
+export async function getRedirectWithOriginAndSearchString({
+  slugs,
+  redirectType,
+  context,
+  currentOrgDomain,
+}: Omit<HandleOrgRedirectParams, "eventTypeSlug">) {
+  const nextJsRedirect = await handleOrgRedirect({
+    slugs,
+    redirectType,
+    eventTypeSlug: null,
+    context,
+    currentOrgDomain,
+  });
+  if (!nextJsRedirect) {
+    return null;
+  }
+
+  const newDestination = nextJsRedirect.redirect.destination;
+  // If there is an origin use it, otherwise mark no new Origin and it remains the same domain
+  const newOrigin =
+    newDestination.startsWith("http://") || newDestination.startsWith("https://")
+      ? new URL(newDestination).origin
+      : null;
+
+  return {
+    origin: newOrigin,
+    searchString: getSearchString(newDestination),
+  };
+}

apps/web/lib/org/[orgSlug]/[user]/getServerSideProps.tsx

@@ -23,15 +23,18 @@ export const getServerSideProps = async (ctx: GetServerSidePropsContext) => {
   if (team) {
     return GSSTeamPage({
       ...ctx,
-      query: { slug: ctx.query.user, orgRedirection: ctx.query.orgRedirection },
+      query: {
+        slug: ctx.query.user,
+        ...(ctx.query.orgRedirection !== undefined && { orgRedirection: ctx.query.orgRedirection }),
+      },
     });
   }
   return GSSUserPage({
     ...ctx,
     query: {
       user: ctx.query.user,
-      redirect: ctx.query.redirect,
-      orgRedirection: ctx.query.orgRedirection,
+      ...(ctx.query.redirect !== undefined && { redirect: ctx.query.redirect }),
+      ...(ctx.query.orgRedirection !== undefined && { orgRedirection: ctx.query.orgRedirection }),
     },
   });
 };

apps/web/lib/plain/dynamicProvider.tsx

@@ -2,4 +2,6 @@ import dynamic from "next/dynamic";
 import { Fragment } from "react";
 
 // Preload caused by dynamic import doesn't seem to add nonce and thus preload fails but the functionality still works - https://github.com/vercel/next.js/issues/81260
-export default process.env.NEXT_PUBLIC_PLAIN_CHAT_ID ? dynamic(() => import("./plainChat")) : Fragment;
+export default process.env.NEXT_PUBLIC_PLAIN_CHAT_ID
+  ? dynamic(() => import("../../components/plain/plainChat"))
+  : Fragment;

apps/web/lib/team/[slug]/[type]/getServerSideProps.tsx

@@ -15,7 +15,7 @@ import type { User } from "@calcom/prisma/client";
 import { BookingStatus, RedirectType } from "@calcom/prisma/client";
 import { EventTypeMetaDataSchema } from "@calcom/prisma/zod-utils";
 
-import { getTemporaryOrgRedirect } from "@lib/getTemporaryOrgRedirect";
+import { handleOrgRedirect } from "@lib/handleOrgRedirect";
 
 const paramsSchema = z.object({
   type: z.string().transform((s) => slugify(s)),
@@ -33,19 +33,17 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
   const { rescheduleUid, isInstantMeeting: queryIsInstantMeeting, email } = query;
   const allowRescheduleForCancelledBooking = query.allowRescheduleForCancelledBooking === "true";
   const { currentOrgDomain, isValidOrgDomain } = orgDomainConfig(req, params?.orgSlug);
-  const isOrgContext = currentOrgDomain && isValidOrgDomain;
 
-  if (!isOrgContext) {
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: teamSlug,
-      redirectType: RedirectType.Team,
-      eventTypeSlug: meetingSlug,
-      currentQuery: context.query,
-    });
+  const redirect = await handleOrgRedirect({
+    slugs: [teamSlug],
+    redirectType: RedirectType.Team,
+    eventTypeSlug: meetingSlug,
+    context,
+    currentOrgDomain: isValidOrgDomain ? currentOrgDomain : null,
+  });
 
-    if (redirect) {
-      return redirect;
-    }
+  if (redirect) {
+    return redirect;
   }
 
   const team = await getTeamWithEventsData(teamSlug, meetingSlug, isValidOrgDomain, currentOrgDomain);

apps/web/lib/team/[slug]/getServerSideProps.tsx

@@ -19,7 +19,7 @@ import type { Team, OrganizationSettings } from "@calcom/prisma/client";
 import { RedirectType } from "@calcom/prisma/client";
 import { teamMetadataSchema } from "@calcom/prisma/zod-utils";
 
-import { getTemporaryOrgRedirect } from "@lib/getTemporaryOrgRedirect";
+import { handleOrgRedirect } from "@lib/handleOrgRedirect";
 
 const log = logger.getSubLogger({ prefix: ["team/[slug]"] });
 
@@ -67,7 +67,6 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
     context.req,
     context.params?.orgSlug ?? context.query?.orgSlug
   );
-  const isOrgContext = isValidOrgDomain && currentOrgDomain;
 
   // Provided by Rewrite from next.config.js
   const isOrgProfile = context.query?.isOrgProfile === "1";
@@ -89,12 +88,13 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
     isOrgView: isValidOrgDomain && isOrgProfile,
   });
 
-  if (!isOrgContext && slug) {
-    const redirect = await getTemporaryOrgRedirect({
-      slugs: slug,
+  if (slug) {
+    const redirect = await handleOrgRedirect({
+      slugs: [slug],
       redirectType: RedirectType.Team,
       eventTypeSlug: null,
-      currentQuery: context.query,
+      context,
+      currentOrgDomain: isValidOrgDomain ? currentOrgDomain : null,
     });
 
     if (redirect) {

apps/web/lib/video/[uid]/getServerSideProps.ts

@@ -117,7 +117,7 @@ const checkIfUserIsHost = async ({
   });
 
   // If eventType exists, it means user is either owner, host or user
-  return !eventType;
+  return !!eventType;
 };
 
 export async function getServerSideProps(context: GetServerSidePropsContext) {

apps/web/modules/getting-started/[[...step]]/onboarding-view.tsx

@@ -10,16 +10,13 @@ import { z } from "zod";
 import { APP_NAME } from "@calcom/lib/constants";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { useParamsWithFallback } from "@calcom/lib/hooks/useParamsWithFallback";
-import { trpc } from "@calcom/trpc";
-import type { inferSSRProps } from "@calcom/types/inferSSRProps";
+import type { RouterOutputs } from "@calcom/trpc/react";
 import classNames from "@calcom/ui/classNames";
 import { Button } from "@calcom/ui/components/button";
 import { StepCard } from "@calcom/ui/components/card";
 import { Steps } from "@calcom/ui/components/form";
 import { Icon } from "@calcom/ui/components/icon";
 
-import type { getServerSideProps } from "@lib/getting-started/[[...step]]/getServerSideProps";
-
 import { ConnectedCalendars } from "@components/getting-started/steps-views/ConnectCalendars";
 import { ConnectedVideoStep } from "@components/getting-started/steps-views/ConnectedVideoStep";
 import { SetupAvailability } from "@components/getting-started/steps-views/SetupAvailability";
@@ -85,13 +82,16 @@ const stepRouteSchema = z.object({
   from: z.string().optional(),
 });
 
-export type PageProps = inferSSRProps<typeof getServerSideProps>;
+type PageProps = {
+  hasPendingInvites: boolean;
+  user: RouterOutputs["viewer"]["me"]["get"];
+};
+
 const OnboardingPage = (props: PageProps) => {
   const pathname = usePathname();
   const params = useParamsWithFallback();
-
+  const user = props.user;
   const router = useRouter();
-  const [user] = trpc.viewer.me.get.useSuspenseQuery();
   const { t } = useLocale();
   const [isNextStepLoading, startTransition] = useTransition();
 
@@ -162,20 +162,20 @@ const OnboardingPage = (props: PageProps) => {
             <StepCard>
               <Suspense fallback={<Icon name="loader" />}>
                 {currentStep === "user-settings" && (
-                  <UserSettings nextStep={goToNextStep} hideUsername={from === "signup"} />
+                  <UserSettings nextStep={goToNextStep} hideUsername={from === "signup"} user={user} />
                 )}
                 {currentStep === "connected-calendar" && (
                   <ConnectedCalendars nextStep={goToNextStep} isPageLoading={isNextStepLoading} />
                 )}
 
                 {currentStep === "connected-video" && (
-                  <ConnectedVideoStep nextStep={goToNextStep} isPageLoading={isNextStepLoading} />
+                  <ConnectedVideoStep nextStep={goToNextStep} isPageLoading={isNextStepLoading} user={user} />
                 )}
 
                 {currentStep === "setup-availability" && (
                   <SetupAvailability nextStep={goToNextStep} defaultScheduleId={user.defaultScheduleId} />
                 )}
-                {currentStep === "user-profile" && <UserProfile />}
+                {currentStep === "user-profile" && <UserProfile user={user} />}
               </Suspense>
             </StepCard>