chore: release v5.4.0

* fix: getBookings for team admins within orgs

* fixup! fix: getBookings for team admins within orgs

* chore: update getUserIdsAndEmailsWhereUserIsAdminOrOwner and remove unused orgId

---------

Co-authored-by: Anik Dhabal Babu <81948346+anikdhabal@users.noreply.github.com>

.env.example

@@ -188,6 +188,10 @@ TWILIO_TOKEN=
 TWILIO_MESSAGING_SID=
 TWILIO_PHONE_NUMBER=
 TWILIO_WHATSAPP_PHONE_NUMBER=
+TWILIO_WHATSAPP_REMINDER_CONTENT_SID=
+TWILIO_WHATSAPP_CANCELLED_CONTENT_SID=
+TWILIO_WHATSAPP_RESCHEDULED_CONTENT_SID=
+TWILIO_WHATSAPP_COMPLETED_CONTENT_SID=
 # For NEXT_PUBLIC_SENDER_ID only letters, numbers and spaces are allowed (max. 11 characters)
 NEXT_PUBLIC_SENDER_ID=
 TWILIO_VERIFY_SID=
@@ -441,6 +445,10 @@ NEXT_PUBLIC_INVALIDATE_AVAILABLE_SLOTS_ON_BOOKING_FORM=0
 # Used to enable quick availability checks for x% of all visitors
 NEXT_PUBLIC_QUICK_AVAILABILITY_ROLLOUT=10
 
+# Used to generate token for cal video recordings expiry token
+# You can use: `openssl rand -base64 32` to generate one
+CAL_VIDEO_RECORDING_TOKEN_SECRET=
+
 #  Deprecated. Use NEXT_PUBLIC_BODY_SCRIPTS instead. NEXT_PUBLIC_HEAD_SCRIPTS are now injected into the body only.
 NEXT_PUBLIC_HEAD_SCRIPTS=
 NEXT_PUBLIC_BODY_SCRIPTS=

.github/CODEOWNERS

@@ -17,6 +17,7 @@
 /packages/app-store/larkcalendar/**/* @calcom/Foundation
 /packages/app-store/office365calendar/**/* @calcom/Foundation
 /packages/app-store/zohocalendar/**/* @calcom/Foundation
+/packages/embeds/**/* @calcom/Foundation
 /packages/features/bookings/lib/**/* @calcom/Foundation
 /packages/lib/getAggregatedAvailability.ts @calcom/Foundation
 /packages/lib/getUserAvailability.ts @calcom/Foundation

.github/workflows/submodule-sync.yml

@@ -1,21 +0,0 @@
-name: Submodule Sync
-on:
-  schedule:
-    # Runs "At minute 15 past every 4th hour." (see https://crontab.guru)
-    - cron: "15 */4 * * *"
-  workflow_dispatch: ~
-jobs:
-  submodule-sync:
-    name: Submodule update
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          token: ${{ secrets.GH_ACCESS_TOKEN }}
-      - name: Commit
-        run: |
-          git config user.email "actions@github.com"
-          git config user.name "github-actions"
-          git commit -am "Auto updated submodule references" && git push || echo "No changes to commit"

.husky/post-receive

@@ -1,6 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-echo "Updating submodules recursively"
-pwd
-git submodule update --init --recursive

.yarn/versions/23ae8c6d.yml

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

.yarn/versions/6c0e495f.yml

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

.yarn/versions/85a860e5.yml

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

.yarn/versions/a34274f5.yml

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

.yarn/versions/acdee5f7.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/b0121b13.yml

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

.yarn/versions/df39e9bf.yml

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

PERMISSIONS.md

@@ -0,0 +1,189 @@
+# Cal.com Permission Documentation
+
+This document maps existing role-based permission checks to the new PBAC (Permission-Based Access Control) system's permission strings in the format `resource.action`.
+
+## Permissions by Resource
+
+### Team Permissions
+
+| Permission String | Description | File Path | Line |
+|------------------|-------------|-----------|------|
+| team.create | Create teams | [packages/trpc/server/routers/viewer/teams/create.handler.ts](packages/trpc/server/routers/viewer/teams/create.handler.ts) | 55-57 |
+| team.update | Update team settings | [packages/trpc/server/routers/viewer/teams/update.handler.ts](packages/trpc/server/routers/viewer/teams/update.handler.ts) | 18 |
+| team.changeMemberRole | Change role of team members | [packages/trpc/server/routers/viewer/teams/changeMemberRole.handler.ts](packages/trpc/server/routers/viewer/teams/changeMemberRole.handler.ts) | 18-21 |
+| team.remove | Remove members from team | [packages/trpc/server/routers/viewer/teams/removeMember.handler.ts](packages/trpc/server/routers/viewer/teams/removeMember.handler.ts) | 35-36, 51-55 |
+| team.invite | Invite members to team | [packages/trpc/server/routers/viewer/teams/invite.handler.ts](packages/trpc/server/routers/viewer/teams/invite.handler.ts) | - |
+
+### Event Type Permissions
+
+| Permission String | Description | File Path | Line |
+|------------------|-------------|-----------|------|
+| eventType.create | Create event types | [packages/trpc/server/routers/viewer/eventTypes/create.handler.ts](packages/trpc/server/routers/viewer/eventTypes/create.handler.ts) | - |
+| eventType.update | Update event types | [packages/trpc/server/routers/viewer/eventTypes/update.handler.ts](packages/trpc/server/routers/viewer/eventTypes/update.handler.ts) | 162-164 |
+| eventType.delete | Delete event types | [packages/trpc/server/routers/viewer/eventTypes/delete.handler.ts](packages/trpc/server/routers/viewer/eventTypes/delete.handler.ts) | 13-31 |
+
+### Booking Permissions
+
+| Permission String | Description | File Path | Line |
+|------------------|-------------|-----------|------|
+| booking.read | Read booking details | [packages/trpc/server/routers/viewer/bookings/get.handler.ts](packages/trpc/server/routers/viewer/bookings/get.handler.ts) | 95-107, 132-134 |
+| booking.readTeamBookings | Read team bookings | [packages/trpc/server/routers/viewer/bookings/get.handler.ts](packages/trpc/server/routers/viewer/bookings/get.handler.ts) | 240-252 |
+| booking.readOrgBookings | Read organization bookings | [packages/trpc/server/routers/viewer/bookings/get.handler.ts](packages/trpc/server/routers/viewer/bookings/get.handler.ts) | 240-252 |
+
+### Organization Permissions
+
+| Permission String | Description | File Path | Line |
+|------------------|-------------|-----------|------|
+| organization.read | Read organization details | [packages/trpc/server/routers/viewer/organizations/get.handler.ts](packages/trpc/server/routers/viewer/organizations/get.handler.ts) | - |
+| organization.listMembers | List organization members | [packages/trpc/server/routers/viewer/organizations/listMembers.handler.ts](packages/trpc/server/routers/viewer/organizations/listMembers.handler.ts) | 68-76 |
+| organization.create | Create organization | [packages/trpc/server/routers/viewer/organizations/create.handler.ts](packages/trpc/server/routers/viewer/organizations/create.handler.ts) | - |
+
+### API Key Permissions
+
+| Permission String | Description | File Path | Line |
+|------------------|-------------|-----------|------|
+| apiKey.create | Create API keys | [packages/trpc/server/routers/viewer/apiKeys/create.handler.ts](packages/trpc/server/routers/viewer/apiKeys/create.handler.ts) | 25-26 |
+| apiKey.findKeyOfType | Find API keys by type | [packages/trpc/server/routers/viewer/apiKeys/findKeyOfType.handler.ts](packages/trpc/server/routers/viewer/apiKeys/findKeyOfType.handler.ts) | 18-19 |
+
+## Helper Functions and Utilities
+
+The following helper functions are commonly used for permission checks:
+
+| Function | Description | File Path |
+|----------|-------------|-----------|
+| isTeamAdmin | Checks if user is admin or owner of a team | [packages/lib/server/queries/teams/index.ts](packages/lib/server/queries/teams/index.ts#L385-L405) |
+| isTeamOwner | Checks if user is owner of a team | [packages/lib/server/queries/teams/index.ts](packages/lib/server/queries/teams/index.ts#L407-L416) |
+| isTeamMember | Checks if user is a member of a team | [packages/lib/server/queries/teams/index.ts](packages/lib/server/queries/teams/index.ts#L418-L426) |
+| canEditEntity | Checks if user can edit an entity | [packages/lib/entityPermissionUtils.ts](packages/lib/entityPermissionUtils.ts#L13-L22) |
+| canAccessEntity | Checks if user can access an entity | [packages/lib/entityPermissionUtils.ts](packages/lib/entityPermissionUtils.ts#L24-L34) |
+| getEntityPermissionLevel | Gets permission level for an entity | [packages/lib/entityPermissionUtils.ts](packages/lib/entityPermissionUtils.ts#L36-L73) |
+| canCreateEntity | Checks if user can create an entity | [packages/lib/entityPermissionUtils.ts](packages/lib/entityPermissionUtils.ts#L102-L115) |
+| withRoleCanCreateEntity | Checks if role allows entity creation | [packages/lib/entityPermissionUtils.ts](packages/lib/entityPermissionUtils.ts#L119-L121) |
+
+## Permission Level Enums
+
+The codebase uses several enums to define permission levels:
+
+### MembershipRole Enum
+
+```typescript
+enum MembershipRole {
+  OWNER = "OWNER",
+  ADMIN = "ADMIN",
+  MEMBER = "MEMBER"
+}
+```
+
+### Entity Permission Level Enum
+
+```typescript
+enum ENTITY_PERMISSION_LEVEL {
+  NONE,
+  USER_ONLY_WRITE,
+  TEAM_READ_ONLY,
+  TEAM_WRITE
+}
+```
+
+## Common Permission Patterns
+
+1. **Team Admin/Owner Check**: Many operations require the user to be a team admin or owner.
+   ```typescript
+   if (!(await isTeamAdmin(ctx.user?.id, input.teamId))) throw new TRPCError({ code: "UNAUTHORIZED" });
+   ```
+
+2. **Team Owner Check**: Some operations (like changing an owner's role) require the user to be a team owner.
+   ```typescript
+   if (input.role === MembershipRole.OWNER && !(await isTeamOwner(ctx.user?.id, input.teamId)))
+     throw new TRPCError({ code: "UNAUTHORIZED" });
+   ```
+
+3. **Organization Admin Check**: Operations within an organization require the user to be an organization admin.
+   ```typescript
+   if (user.profile?.organizationId && !user.organization.isOrgAdmin) {
+     throw new TRPCError({ code: "FORBIDDEN", message: "org_admins_can_create_new_teams" });
+   }
+   ```
+
+4. **Entity Permission Check**: Entity operations use permission level checks.
+   ```typescript
+   const permissionLevel = await getEntityPermissionLevel(entity, userId);
+   return permissionLevel === ENTITY_PERMISSION_LEVEL.TEAM_WRITE || 
+          permissionLevel === ENTITY_PERMISSION_LEVEL.USER_ONLY_WRITE;
+   ```
+
+5. **Booking Access Control**: Complex permission checks for retrieving bookings based on user roles and team/organization membership.
+   ```typescript
+   const membershipIdsWhereUserIsAdminOwner = (
+     await prisma.membership.findMany({
+       where: {
+         userId: user.id,
+         role: {
+           in: ["ADMIN", "OWNER"],
+         },
+       },
+       select: {
+         id: true,
+       },
+     })
+   ).map((membership) => membership.id);
+   ```
+
+## Migration to PBAC
+
+When migrating to the new PBAC system, these existing role-based checks should be replaced with permission string checks using the `permissionMatches` function:
+
+```typescript
+import { permissionMatches } from "@calcom/features/pbac/types/permission-registry";
+
+// Instead of:
+if (!(await isTeamAdmin(ctx.user?.id, input.teamId))) throw new TRPCError({ code: "UNAUTHORIZED" });
+
+// Use:
+if (!permissionMatches("team.update", userPermissions)) throw new TRPCError({ code: "UNAUTHORIZED" });
+```
+
+## Permission String Alternatives for Helper Functions
+
+The following table provides permission string alternatives for common helper functions:
+
+| Helper Function | Permission String Alternative | Description |
+|-----------------|-------------------------------|-------------|
+| isTeamAdmin | `team.*` | Grants all team permissions |
+| isTeamAdmin | `team.update` | Update team settings |
+| isTeamAdmin | `team.invite` | Invite team members |
+| isTeamAdmin | `team.remove` | Remove team members |
+| isTeamOwner | `team.changeMemberRole` | Change role of team members |
+| isTeamOwner | `team.delete` | Delete team |
+| isTeamMember | `team.read` | Read-only access to team |
+
+## Entity Permission Functions and Resources
+
+The following functions are used to check permissions for entities with userId and teamId properties:
+
+| Function | Description | Permission String Alternative |
+|----------|-------------|-------------------------------|
+| canEditEntity | Checks if user can edit an entity | `{resource}.update` |
+| canAccessEntity | Checks if user can access an entity | `{resource}.read` |
+| getEntityPermissionLevel | Gets permission level for an entity | N/A - Implementation detail |
+| canCreateEntity | Checks if user can create an entity | `{resource}.create` |
+
+### Resources Used with Entity Permission Functions
+
+| Resource | canEditEntity Usage | canAccessEntity Usage | Permission String |
+|----------|-------------------|---------------------|------------------|
+| routingForm | [packages/app-store/routing-forms/trpc/forms.handler.ts](packages/app-store/routing-forms/trpc/forms.handler.ts#L72) | [packages/app-store/routing-forms/trpc/getResponseWithFormFields.handler.ts](packages/app-store/routing-forms/trpc/getResponseWithFormFields.handler.ts#L78) | `routingForm.update`, `routingForm.read` |
+| routingForm | [packages/app-store/routing-forms/trpc/formMutation.handler.ts](packages/app-store/routing-forms/trpc/formMutation.handler.ts#L315) | | `routingForm.update` |
+| routingForm | [packages/app-store/routing-forms/api/responses/[formId].ts](packages/app-store/routing-forms/api/responses/[formId].ts#L96) | | `routingForm.update` |
+
+These functions can be used with any entity that has userId and teamId properties. When migrating to PBAC, replace these checks with appropriate permission string checks:
+
+```typescript
+// Instead of:
+if (!(await canEditEntity(form, user.id))) throw new TRPCError({ code: "UNAUTHORIZED" });
+
+// Use:
+if (!permissionMatches("routingForm.update", userPermissions)) throw new TRPCError({ code: "UNAUTHORIZED" });
+```
+
+This allows for more granular permission control and the creation of custom roles with specific permissions.

apps/api/v1/lib/helpers/verifyApiKey.test.ts

@@ -1,4 +1,4 @@
-import prismock from "../../../../../../tests/libs/__mocks__/prisma";
+import prismock from "../../../../../tests/libs/__mocks__/prisma";
 
 import type { Request, Response } from "express";
 import type { NextApiRequest, NextApiResponse } from "next";
@@ -7,12 +7,12 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import type { ILicenseKeyService } from "@calcom/ee/common/server/LicenseKeyService";
 import LicenseKeyService from "@calcom/ee/common/server/LicenseKeyService";
+import { hashAPIKey } from "@calcom/features/ee/api-keys/lib/apiKeys";
+import type { IDeploymentRepository } from "@calcom/lib/server/repository/deployment.interface";
 import prisma from "@calcom/prisma";
 import { MembershipRole, UserPermissionRole } from "@calcom/prisma/enums";
 
-import { hashAPIKey } from "~/../../../packages/features/ee/api-keys/lib/apiKeys";
-
-import { verifyApiKey } from "../../../lib/helpers/verifyApiKey";
+import { verifyApiKey } from "./verifyApiKey";
 
 type CustomNextApiRequest = NextApiRequest & Request;
 type CustomNextApiResponse = NextApiResponse & Response;
@@ -21,11 +21,16 @@ afterEach(() => {
   vi.resetAllMocks();
 });
 
-describe("Verify API key", () => {
+const mockDeploymentRepository: IDeploymentRepository = {
+  getLicenseKeyWithId: vi.fn().mockResolvedValue("mockLicenseKey"), // Mocked return value
+};
+
+// TODO: Fix the skip condition for this test suite
+describe.skip("Verify API key", () => {
   let service: ILicenseKeyService;
 
   beforeEach(async () => {
-    service = await LicenseKeyService.create();
+    service = await LicenseKeyService.create(mockDeploymentRepository);
 
     vi.spyOn(service, "checkLicense");
   });

apps/api/v1/lib/helpers/verifyApiKey.ts

@@ -3,6 +3,7 @@ import type { NextMiddleware } from "next-api-middleware";
 import { LicenseKeySingleton } from "@calcom/ee/common/server/LicenseKeyService";
 import { hashAPIKey } from "@calcom/features/ee/api-keys/lib/apiKeys";
 import { IS_PRODUCTION } from "@calcom/lib/constants";
+import { DeploymentRepository } from "@calcom/lib/server/repository/deployment";
 import prisma from "@calcom/prisma";
 
 import { isAdminGuard } from "../utils/isAdmin";
@@ -19,11 +20,12 @@ export const dateNotInPast = function (date: Date) {
 
 // This verifies the apiKey and sets the user if it is valid.
 export const verifyApiKey: NextMiddleware = async (req, res, next) => {
-  const licenseKeyService = await LicenseKeySingleton.getInstance();
+  const deploymentRepo = new DeploymentRepository(prisma);
+  const licenseKeyService = await LicenseKeySingleton.getInstance(deploymentRepo);
   const hasValidLicense = await licenseKeyService.checkLicense();
 
   if (!hasValidLicense && IS_PRODUCTION) {
-    return res.status(401).json({ error: "Invalid or missing CALCOM_LICENSE_KEY environment variable" });
+    return res.status(401).json({ message: "Invalid or missing CALCOM_LICENSE_KEY environment variable" });
   }
 
   if (!req.query.apiKey) return res.status(401).json({ message: "No apiKey provided" });

apps/api/v1/lib/validations/event-type.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 
-import { MAX_SEATS_PER_TIME_SLOT } from "@calcom/lib/constants";
+import {
+  MAX_SEATS_PER_TIME_SLOT,
+  MAX_EVENT_DURATION_MINUTES,
+  MIN_EVENT_DURATION_MINUTES,
+} from "@calcom/lib/constants";
 import slugify from "@calcom/lib/slugify";
 import { _EventTypeModel as EventType, _HostModel } from "@calcom/prisma/zod";
 import { customInputSchema, eventTypeBookingFields } from "@calcom/prisma/zod-utils";
@@ -80,7 +84,7 @@ const schemaEventTypeCreateParams = z
     title: z.string(),
     slug: z.string().transform((s) => slugify(s)),
     description: z.string().optional().nullable(),
-    length: z.number().int(),
+    length: z.number().int().min(MIN_EVENT_DURATION_MINUTES).max(MAX_EVENT_DURATION_MINUTES),
     metadata: z.any().optional(),
     recurringEvent: recurringEventInputSchema.optional(),
     seatsPerTimeSlot: z.number().optional(),

apps/api/v1/lib/validations/selected-calendar.ts

@@ -18,6 +18,11 @@ export const schemaSelectedCalendarBodyParams = schemaSelectedCalendarBaseBodyPa
     id: true,
     // No eventTypeId support in API v1
     eventTypeId: true,
+
+    /** No watch related fields support in API v1 */
+    watchAttempts: true,
+    unwatchAttempts: true,
+    maxAttempts: true,
   });
 
 export const schemaSelectedCalendarUpdateBodyParams = schemaSelectedCalendarBaseBodyParams

apps/api/v1/package.json

@@ -38,7 +38,7 @@
     "next-axiom": "^0.17.0",
     "next-swagger-doc": "^0.3.6",
     "next-validations": "^0.2.0",
-    "typescript": "^4.9.4",
+    "typescript": "^5.8.3",
     "tzdata": "^1.0.30",
     "uuid": "^8.3.2",
     "zod": "^3.22.4"

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

@@ -42,11 +42,6 @@ describe("GET /api/slots", () => {
       await handler(req, res);
 
       expect(res.statusCode).toBe(400);
-      expect(JSON.parse(res._getData())).toMatchInlineSnapshot(`
-        {
-          "message": "invalid_type in 'startTime': Required; invalid_type in 'endTime': Required",
-        }
-      `);
     });
   });
 

apps/api/v1/test/lib/bookings/_get.integration-test.ts

@@ -38,7 +38,8 @@ describe("GET /api/bookings", async () => {
 
     expect(responseData.bookings.find((b) => b.userId === memberUser.id)).toBeDefined();
     expect(groupedUsers.size).toBe(1);
-    expect(groupedUsers.entries().next().value[0]).toBe(memberUser.id);
+    const firstEntry = groupedUsers.entries().next().value;
+    expect(firstEntry?.[0]).toBe(memberUser.id);
   });
 
   it("Returns bookings for regular user", async () => {

apps/api/v1/test/lib/selected-calendars/_post.test.ts

@@ -89,6 +89,10 @@ describe("POST /api/selected-calendars", () => {
         googleChannelResourceUri: null,
         googleChannelExpiration: null,
         error: null,
+        lastErrorAt: null,
+        watchAttempts: 0,
+        maxAttempts: 3,
+        unwatchAttempts: 0,
       });
 
       await handler(req, res);
@@ -128,6 +132,10 @@ describe("POST /api/selected-calendars", () => {
         domainWideDelegationCredentialId: null,
         eventTypeId: null,
         error: null,
+        lastErrorAt: null,
+        watchAttempts: 0,
+        maxAttempts: 3,
+        unwatchAttempts: 0,
       });
 
       await handler(req, res);

apps/api/v2/.env.example

@@ -37,4 +37,8 @@ AXIOM_TOKEN=
 # INFO: 1
 # WARN: 2
 # ERROR: 3
-LOGGER_BRIDGE_LOG_LEVEL="1"
+LOGGER_BRIDGE_LOG_LEVEL="1"
+
+# 1: Rewrite /api/v2 to /v2
+# 0: Don't rewrite
+REWRITE_API_V2_PREFIX="1"

apps/api/v2/package.json

@@ -37,7 +37,7 @@
     "@axiomhq/winston": "^1.2.0",
     "@calcom/platform-constants": "*",
     "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.208",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.223",
     "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",
@@ -108,7 +108,7 @@
     "ts-loader": "^9.4.3",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.1.0",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.3"
   },
   "prisma": {
     "schema": "../../../packages/prisma/schema.prisma"

apps/api/v2/src/config/app.ts

@@ -36,7 +36,7 @@ const loadConfig = (): AppConfig => {
     app: {
       baseUrl: getEnv("WEB_APP_URL", "https://app.cal.com"),
     },
-    e2e: getEnv("IS_E2E", false),
+    e2e: getEnv("IS_E2E", "false") === "true" ? true : false,
   };
 };
 

apps/api/v2/src/ee/bookings/2024-04-15/controllers/bookings.controller.ts

@@ -77,6 +77,7 @@ type OAuthRequestParams = {
   platformBookingUrl: string;
   platformBookingLocation?: string;
   arePlatformEmailsEnabled: boolean;
+  areCalendarEventsEnabled: boolean;
 };
 
 const DEFAULT_PLATFORM_PARAMS = {
@@ -86,6 +87,7 @@ const DEFAULT_PLATFORM_PARAMS = {
   platformBookingUrl: "",
   arePlatformEmailsEnabled: false,
   platformBookingLocation: undefined,
+  areCalendarEventsEnabled: false,
 };
 
 @Controller({
@@ -135,9 +137,13 @@ export class BookingsController_2024_04_15 {
       },
     });
 
+    let nextCursor = null;
+    if (bookings.totalCount > (cursor ?? 0) + (limit ?? 10)) {
+      nextCursor = (cursor ?? 0) + (limit ?? 10);
+    }
     return {
       status: SUCCESS_STATUS,
-      data: bookings,
+      data: { ...bookings, nextCursor },
     };
   }
 
@@ -191,6 +197,7 @@ export class BookingsController_2024_04_15 {
         platformCancelUrl: bookingRequest.platformCancelUrl,
         platformBookingUrl: bookingRequest.platformBookingUrl,
         platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
       });
       if (booking.userId && booking.uid && booking.startTime) {
         void (await this.billingService.increaseUsageByUserId(booking.userId, {
@@ -424,7 +431,7 @@ export class BookingsController_2024_04_15 {
 
     if (isEmbed) {
       // embed should ignore oauth client settings and enable emails by default
-      return { ...res, arePlatformEmailsEnabled: true };
+      return { ...res, arePlatformEmailsEnabled: true, areCalendarEventsEnabled: true };
     }
 
     try {
@@ -436,6 +443,7 @@ export class BookingsController_2024_04_15 {
         res.platformRescheduleUrl = client.bookingRescheduleRedirectUri ?? "";
         res.platformBookingUrl = client.bookingRedirectUri ?? "";
         res.arePlatformEmailsEnabled = client.areEmailsEnabled ?? false;
+        res.areCalendarEventsEnabled = client.areCalendarEventsEnabled;
       }
       return res;
     } catch (err) {

apps/api/v2/src/ee/bookings/2024-04-15/outputs/get-bookings.output.ts

@@ -16,13 +16,15 @@ import {
 
 import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
 
-enum Status {
-  CANCELLED = "CANCELLED",
-  REJECTED = "REJECTED",
-  ACCEPTED = "ACCEPTED",
-  PENDING = "PENDING",
-  AWAITING_HOST = "AWAITING_HOST",
-}
+const Status = {
+  CANCELLED: "CANCELLED",
+  REJECTED: "REJECTED",
+  ACCEPTED: "ACCEPTED",
+  PENDING: "PENDING",
+  AWAITING_HOST: "AWAITING_HOST",
+} as const;
+
+export type Status = (typeof Status)[keyof typeof Status];
 
 class Attendee {
   @IsInt()

apps/api/v2/src/ee/bookings/2024-08-13/booking-references.repository.ts

@@ -24,4 +24,26 @@ export class BookingReferencesRepository_2024_08_13 {
       },
     });
   }
+
+  async getBookingReferencesIncludeSensitiveCredentials(eventUid: string) {
+    return this.dbRead.prisma.bookingReference.findFirst({
+      where: {
+        uid: eventUid,
+      },
+      include: {
+        credential: true,
+        delegationCredential: true,
+        booking: {
+          select: {
+            user: {
+              select: {
+                id: true,
+                email: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
 }

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

@@ -3,6 +3,7 @@ import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings
 import { BookingsController_2024_08_13 } from "@/ee/bookings/2024-08-13/controllers/bookings.controller";
 import { BookingReferencesService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/booking-references.service";
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
+import { CalVideoService } from "@/ee/bookings/2024-08-13/services/cal-video.service";
 import { ErrorsBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/errors.service";
 import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/input.service";
 import { OutputBookingReferencesService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output-booking-references.service";
@@ -77,6 +78,7 @@ import { Module } from "@nestjs/common";
     ErrorsBookingsService_2024_08_13,
     BookingReferencesService_2024_08_13,
     BookingReferencesRepository_2024_08_13,
+    CalVideoService,
   ],
   controllers: [BookingsController_2024_08_13],
   exports: [InputBookingsService_2024_08_13, OutputBookingsService_2024_08_13, BookingsService_2024_08_13],

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

@@ -169,4 +169,15 @@ export class BookingsRepository_2024_08_13 {
       },
     });
   }
+
+  async getByUidWithBookingReference(uid: string) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        uid,
+      },
+      select: {
+        references: true,
+      },
+    });
+  }
 }

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

@@ -9,6 +9,7 @@ import { ReassignBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outpu
 import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
 import { BookingReferencesService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/booking-references.service";
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
+import { CalVideoService } from "@/ee/bookings/2024-08-13/services/cal-video.service";
 import { VERSION_2024_08_13_VALUE, VERSION_2024_08_13 } from "@/lib/api-versions";
 import { API_KEY_OR_ACCESS_TOKEN_HEADER } from "@/lib/docs/headers";
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
@@ -54,6 +55,8 @@ import {
   RescheduleBookingInput_2024_08_13,
   RescheduleBookingInputPipe,
   RescheduleSeatedBookingInput_2024_08_13,
+  GetBookingRecordingsOutput,
+  GetBookingTranscriptsOutput,
 } from "@calcom/platform-types";
 import {
   CreateBookingInputPipe,
@@ -88,7 +91,8 @@ export class BookingsController_2024_08_13 {
   constructor(
     private readonly bookingsService: BookingsService_2024_08_13,
     private readonly usersService: UsersService,
-    private readonly bookingReferencesService: BookingReferencesService_2024_08_13
+    private readonly bookingReferencesService: BookingReferencesService_2024_08_13,
+    private readonly calVideoService: CalVideoService
   ) {}
 
   @Post("/")
@@ -171,6 +175,36 @@ export class BookingsController_2024_08_13 {
     };
   }
 
+  @Get("/:bookingUid/recordings")
+  @UseGuards(BookingUidGuard)
+  @ApiOperation({
+    summary: "Get all the recordings for the booking",
+    description: `Fetches all the recordings for the booking \`:bookingUid\``,
+  })
+  async getBookingRecordings(@Param("bookingUid") bookingUid: string): Promise<GetBookingRecordingsOutput> {
+    const recordings = await this.calVideoService.getRecordings(bookingUid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: recordings,
+    };
+  }
+
+  @Get("/:bookingUid/transcripts")
+  @UseGuards(BookingUidGuard)
+  @ApiOperation({
+    summary: "Get all the transcripts download links for the booking",
+    description: `Fetches all the transcripts download links for the booking \`:bookingUid\``,
+  })
+  async getBookingTranscripts(@Param("bookingUid") bookingUid: string): Promise<GetBookingTranscriptsOutput> {
+    const transcripts = await this.calVideoService.getTranscripts(bookingUid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: transcripts ?? [],
+    };
+  }
+
   @Get("/")
   @UseGuards(ApiAuthGuard)
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
@@ -290,7 +324,8 @@ export class BookingsController_2024_08_13 {
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
     summary: "Reassign a booking to auto-selected host",
-    description: "The provided authorization header refers to the owner of the booking.",
+    description:
+      "Currently only supports reassigning host for round robin bookings. The provided authorization header refers to the owner of the booking.",
   })
   async reassignBooking(
     @Param("bookingUid") bookingUid: string,
@@ -311,7 +346,8 @@ export class BookingsController_2024_08_13 {
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
     summary: "Reassign a booking to a specific host",
-    description: "The provided authorization header refers to the owner of the booking.",
+    description:
+      "Currently only supports reassigning host for round robin bookings. The provided authorization header refers to the owner of the booking.",
   })
   async reassignBookingToUser(
     @Param("bookingUid") bookingUid: string,

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/emails/team-emails.e2e-spec.ts

@@ -874,9 +874,8 @@ describe("Bookings Endpoints 2024-08-13 team emails", () => {
             expect(responseBody.status).toEqual(SUCCESS_STATUS);
             expect(responseBody.data).toBeDefined();
             expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
-            expect(AttendeeRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
 
-            expect(OrganizerRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
             expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
             expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
             emailsEnabledSetup.roundRobinEventType.rescheduledBookingUid = responseBody.data.uid;

apps/api/v2/src/ee/bookings/2024-08-13/controllers/e2e/user-bookings.e2e-spec.ts

@@ -35,6 +35,7 @@ import {
   X_CAL_CLIENT_ID,
 } from "@calcom/platform-constants";
 import { AttendeeScheduledEmail, OrganizerScheduledEmail } from "@calcom/platform-libraries/emails";
+import { EventManager } from "@calcom/platform-libraries/event-types";
 import {
   CreateEventTypeInput_2024_06_14,
   FAILED_EVENT_TYPE_IDENTIFICATION_ERROR_MESSAGE,
@@ -78,6 +79,8 @@ describe("Bookings Endpoints 2024-08-13", () => {
     const eventTypeSlug = `user-bookings-event-type-${randomString()}`;
     let recurringEventTypeId: number;
     const recurringEventTypeSlug = `user-bookings-event-type-${randomString()}`;
+    let eventTypeRequiresConfirmationId: number;
+    const eventTypeRequiresConfirmationSlug = `user-bookings-event-type-requires-confirmation-${randomString()}`;
 
     let createdBooking: BookingOutput_2024_08_13;
     let rescheduledBooking: BookingOutput_2024_08_13;
@@ -153,6 +156,17 @@ describe("Bookings Endpoints 2024-08-13", () => {
       );
       recurringEventTypeId = recurringEvent.id;
 
+      const eventTypeRequiresConfirmation = await eventTypesRepositoryFixture.create(
+        {
+          title: `user-bookings-2024-08-13-event-type-requires-confirmation-${randomString()}`,
+          slug: eventTypeRequiresConfirmationSlug,
+          length: 60,
+          requiresConfirmation: true,
+        },
+        user.id
+      );
+      eventTypeRequiresConfirmationId = eventTypeRequiresConfirmation.id;
+
       bookingInThePast = await bookingsRepositoryFixture.create({
         user: {
           connect: {
@@ -2399,6 +2413,425 @@ describe("Bookings Endpoints 2024-08-13", () => {
       });
     });
 
+    describe("cant't reschedule cancelled booking", () => {
+      it("should not be able to reschedule cancelled booking", async () => {
+        const cancelledBooking = await bookingsRepositoryFixture.create({
+          status: "CANCELLED",
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+          startTime: new Date(Date.UTC(2050, 0, 8, 13, 0, 0)),
+          endTime: new Date(Date.UTC(2050, 0, 8, 14, 0, 0)),
+          title: "peer coding lets goo",
+          uid: `cancelled-booking-${randomString()}`,
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          location: "integrations:daily",
+          customInputs: {},
+          metadata: {},
+          responses: {
+            name: "Oldie",
+            email: "oldie@gmail.com",
+          },
+          attendees: {
+            create: {
+              email: "oldie@gmail.com",
+              name: "Oldie",
+              locale: "lv",
+              timeZone: "Europe/Rome",
+            },
+          },
+        });
+
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2040, 0, 9, 14, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        const response = await request(app.getHttpServer())
+          .post(`/v2/bookings/${cancelledBooking.uid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(400);
+
+        expect(response.body.error.message).toEqual(
+          `Can't reschedule booking with uid=${cancelledBooking.uid} because it has been cancelled. Please provide uid of a booking that is not cancelled.`
+        );
+        await bookingsRepositoryFixture.deleteById(cancelledBooking.id);
+      });
+
+      it("should not be able to reschedule rescheduled booking", async () => {
+        const rescheduledBooking = await bookingsRepositoryFixture.create({
+          status: "CANCELLED",
+          rescheduled: true,
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+          startTime: new Date(Date.UTC(2050, 0, 8, 13, 0, 0)),
+          endTime: new Date(Date.UTC(2050, 0, 8, 14, 0, 0)),
+          title: "peer coding lets goo",
+          uid: `cancelled-booking-${randomString()}`,
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          location: "integrations:daily",
+          customInputs: {},
+          metadata: {},
+          responses: {
+            name: "Oldie",
+            email: "oldie@gmail.com",
+          },
+          attendees: {
+            create: {
+              email: "oldie@gmail.com",
+              name: "Oldie",
+              locale: "lv",
+              timeZone: "Europe/Rome",
+            },
+          },
+        });
+
+        const newBooking = await bookingsRepositoryFixture.create({
+          status: "ACCEPTED",
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+          fromReschedule: rescheduledBooking.uid,
+          startTime: new Date(Date.UTC(2050, 0, 8, 13, 0, 0)),
+          endTime: new Date(Date.UTC(2050, 0, 8, 14, 0, 0)),
+          title: "peer coding lets goo",
+          uid: `new-booking-${randomString()}`,
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          location: "integrations:daily",
+          customInputs: {},
+          metadata: {},
+          responses: {
+            name: "Oldie",
+            email: "oldie@gmail.com",
+          },
+          attendees: {
+            create: {
+              email: "oldie@gmail.com",
+              name: "Oldie",
+              locale: "lv",
+              timeZone: "Europe/Rome",
+            },
+          },
+        });
+
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2040, 0, 9, 14, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        const response = await request(app.getHttpServer())
+          .post(`/v2/bookings/${rescheduledBooking.uid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(400);
+
+        expect(response.body.error.message).toEqual(
+          `Can't reschedule booking with uid=${rescheduledBooking.uid} because it has been cancelled and rescheduled already to booking with uid=${newBooking.uid}. You probably want to reschedule ${newBooking.uid} instead by passing it within the request URL.`
+        );
+        await bookingsRepositoryFixture.deleteById(rescheduledBooking.id);
+        await bookingsRepositoryFixture.deleteById(newBooking.id);
+      });
+    });
+
+    describe("calendar events", () => {
+      beforeEach(() => {
+        jest.restoreAllMocks();
+        jest
+          .spyOn(EventManager.prototype, "create")
+          .mockImplementation(() => Promise.resolve({ results: [], referencesToCreate: [] }));
+      });
+
+      describe("platform oAuth client has calendar events enabled", () => {
+        beforeAll(async () => {
+          await oauthClientRepositoryFixture.update(oAuthClient.id, {
+            areCalendarEventsEnabled: true,
+          });
+        });
+
+        it("should create calendar event when booking normal event", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 9, 9, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsBooking(responseBody.data)) {
+                const data: BookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(EventManager.prototype.create).toHaveBeenCalledTimes(1);
+              } else {
+                throw new Error(
+                  "Invalid response data - expected booking but received array of possibly recurring bookings"
+                );
+              }
+            });
+        });
+
+        it("should create calendar events when booking recurring event", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 10, 9, 0, 0)).toISOString(),
+            eventTypeId: recurringEventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(EventManager.prototype.create).toHaveBeenCalledTimes(3);
+            });
+        });
+
+        describe("event type requires confirmation", () => {
+          let bookingThatRequiresConfirmationUid: string;
+
+          it("should not create calendar event when booking event that requires confirmation", async () => {
+            const body: CreateBookingInput_2024_08_13 = {
+              start: new Date(Date.UTC(2040, 0, 12, 9, 0, 0)).toISOString(),
+              eventTypeId: eventTypeRequiresConfirmationId,
+              attendee: {
+                name: "Mr Proper",
+                email: "mr_proper@gmail.com",
+                timeZone: "Europe/Rome",
+                language: "it",
+              },
+            };
+
+            return request(app.getHttpServer())
+              .post("/v2/bookings")
+              .send(body)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(201)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+                  bookingThatRequiresConfirmationUid = data.uid;
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+
+          it("should create calendar event when confirming event that requires confirmation", async () => {
+            return request(app.getHttpServer())
+              .post(`/v2/bookings/${bookingThatRequiresConfirmationUid}/confirm`)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(200)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(1);
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+        });
+      });
+
+      describe("platform oAuth client has calendar events disabled", () => {
+        beforeAll(async () => {
+          await oauthClientRepositoryFixture.update(oAuthClient.id, {
+            areCalendarEventsEnabled: false,
+          });
+        });
+
+        it("should not create calendar event when booking", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 9, 10, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          const beforeCreate = new Date();
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const afterCreate = new Date();
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsBooking(responseBody.data)) {
+                const data: BookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+              } else {
+                throw new Error(
+                  "Invalid response data - expected booking but received array of possibly recurring bookings"
+                );
+              }
+            });
+        });
+
+        it("should not create calendar events when booking recurring event", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 11, 10, 0, 0)).toISOString(),
+            eventTypeId: recurringEventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+            });
+        });
+
+        describe("event type requires confirmation", () => {
+          let bookingThatRequiresConfirmationUid: string;
+
+          it("should not create calendar event when booking event that requires confirmation", async () => {
+            const body: CreateBookingInput_2024_08_13 = {
+              start: new Date(Date.UTC(2040, 0, 12, 10, 0, 0)).toISOString(),
+              eventTypeId: eventTypeRequiresConfirmationId,
+              attendee: {
+                name: "Mr Proper",
+                email: "mr_proper@gmail.com",
+                timeZone: "Europe/Rome",
+                language: "it",
+              },
+            };
+
+            return request(app.getHttpServer())
+              .post("/v2/bookings")
+              .send(body)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(201)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+                  bookingThatRequiresConfirmationUid = data.uid;
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+
+          it("should not create calendar event when confirming event that requires confirmation", async () => {
+            return request(app.getHttpServer())
+              .post(`/v2/bookings/${bookingThatRequiresConfirmationUid}/confirm`)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(200)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+        });
+      });
+    });
+
     function responseDataIsRecurranceBooking(data: any): data is RecurringBookingOutput_2024_08_13 {
       return (
         !Array.isArray(data) &&

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

@@ -5,6 +5,7 @@ import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/servic
 import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
 import { PlatformBookingsService } from "@/ee/bookings/shared/platform-bookings.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { getPagination } from "@/lib/pagination/pagination";
 import { BillingService } from "@/modules/billing/services/billing.service";
 import { BookingSeatRepository } from "@/modules/booking-seat/booking-seat.repository";
 import { KyselyReadService } from "@/modules/kysely/kysely-read.service";
@@ -108,6 +109,12 @@ export class BookingsService_2024_08_13 {
         this.errorsBookingsService.handleEventTypeToBeBookedNotFound(body);
       }
 
+      if (eventType.schedulingType === "MANAGED") {
+        throw new BadRequestException(
+          `Event type with id=${eventType.id} is the parent managed event type that can't be booked. You have to provide the child event type id aka id of event type that has been assigned to one of the users.`
+        );
+      }
+
       body.eventTypeId = eventType.id;
 
       if ("instant" in body && body.instant) {
@@ -397,6 +404,7 @@ export class BookingsService_2024_08_13 {
       platformBookingUrl: bookingRequest.platformBookingUrl,
       platformBookingLocation: bookingRequest.platformBookingLocation,
       noEmail: bookingRequest.noEmail,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
     });
     const ids = bookings.map((booking) => booking.id || 0);
     return this.outputService.getOutputRecurringBookings(ids);
@@ -417,6 +425,7 @@ export class BookingsService_2024_08_13 {
       platformCancelUrl: bookingRequest.platformCancelUrl,
       platformBookingUrl: bookingRequest.platformBookingUrl,
       platformBookingLocation: bookingRequest.platformBookingLocation,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
     });
     return this.outputService.getOutputCreateRecurringSeatedBookings(
       bookings.map((booking) => ({ uid: booking.uid || "", seatUid: booking.seatReferenceUid || "" }))
@@ -438,6 +447,7 @@ export class BookingsService_2024_08_13 {
       platformCancelUrl: bookingRequest.platformCancelUrl,
       platformBookingUrl: bookingRequest.platformBookingUrl,
       platformBookingLocation: bookingRequest.platformBookingLocation,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
     });
 
     if (!booking.uid) {
@@ -468,6 +478,7 @@ export class BookingsService_2024_08_13 {
         platformCancelUrl: bookingRequest.platformCancelUrl,
         platformBookingUrl: bookingRequest.platformBookingUrl,
         platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
       });
 
       if (!booking.uid) {
@@ -532,10 +543,13 @@ export class BookingsService_2024_08_13 {
       queryParams.attendeeEmail = await this.getAttendeeEmail(queryParams.attendeeEmail, user);
     }
 
+    const skip = Math.abs(queryParams?.skip ?? 0);
+    const take = Math.abs(queryParams?.take ?? 100);
+
     const fetchedBookings: { bookings: { id: number }[]; totalCount: number } = await getAllUserBookings({
       bookingListingByStatus: queryParams.status || [],
-      skip: queryParams.skip ?? 0,
-      take: queryParams.take ?? 100,
+      skip,
+      take,
       filters: {
         ...this.inputService.transformGetBookingsFilters(queryParams),
         ...(userIds?.length ? { userIds } : {}),
@@ -588,28 +602,11 @@ export class BookingsService_2024_08_13 {
       }
     }
 
-    const skip = Math.abs(queryParams?.skip ?? 0);
-    const take = Math.abs(queryParams?.take ?? 100);
-    const itemsPerPage = take;
-    const totalPages = itemsPerPage !== 0 ? Math.ceil(fetchedBookings.totalCount / itemsPerPage) : 0;
-    const currentPage = Math.floor(skip / itemsPerPage) + 1;
-    const hasNextPage = skip + itemsPerPage < fetchedBookings.totalCount;
-    const hasPreviousPage = skip > 0;
+    const pagination = getPagination({ skip, take, totalCount: fetchedBookings.totalCount });
+
     return {
       bookings: formattedBookings,
-      pagination: {
-        totalItems: fetchedBookings.totalCount,
-        // clamp remainingItems between 0 and totalCount
-        remainingItems: Math.min(
-          Math.max(fetchedBookings.totalCount - (skip + take), 0),
-          fetchedBookings.totalCount
-        ),
-        itemsPerPage: itemsPerPage,
-        currentPage: currentPage,
-        totalPages: totalPages,
-        hasNextPage: hasNextPage,
-        hasPreviousPage: hasPreviousPage,
-      },
+      pagination,
     };
   }
 
@@ -644,6 +641,7 @@ export class BookingsService_2024_08_13 {
 
   async rescheduleBooking(request: Request, bookingUid: string, body: RescheduleBookingInput) {
     try {
+      await this.canRescheduleBooking(bookingUid);
       const bookingRequest = await this.inputService.createRescheduleBookingRequest(
         request,
         bookingUid,
@@ -658,6 +656,7 @@ export class BookingsService_2024_08_13 {
         platformCancelUrl: bookingRequest.platformCancelUrl,
         platformBookingUrl: bookingRequest.platformBookingUrl,
         platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
       });
       if (!booking.uid) {
         throw new Error("Booking missing uid");
@@ -689,15 +688,29 @@ export class BookingsService_2024_08_13 {
       }
       return this.outputService.getOutputBooking(databaseBooking);
     } catch (error) {
-      if (error instanceof Error) {
-        if (error.message === "no_available_users_found_error") {
-          throw new BadRequestException("User either already has booking at this time or is not available");
-        }
-      }
-      throw error;
+      this.errorsBookingsService.handleBookingError(error, false);
     }
   }
 
+  async canRescheduleBooking(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    if (!booking) {
+      throw new Error(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+    if (booking.status === "CANCELLED" && !booking.rescheduled) {
+      throw new BadRequestException(
+        `Can't reschedule booking with uid=${bookingUid} because it has been cancelled. Please provide uid of a booking that is not cancelled.`
+      );
+    }
+    if (booking.status === "CANCELLED" && booking.rescheduled) {
+      const rescheduledTo = await this.bookingsRepository.getByFromReschedule(bookingUid);
+      throw new BadRequestException(
+        `Can't reschedule booking with uid=${bookingUid} because it has been cancelled and rescheduled already to booking with uid=${rescheduledTo?.uid}. You probably want to reschedule ${rescheduledTo?.uid} instead by passing it within the request URL.`
+      );
+    }
+    return booking;
+  }
+
   async cancelBooking(request: Request, bookingUid: string, body: CancelBookingInput) {
     if (this.inputService.isCancelSeatedBody(body)) {
       const seat = await this.bookingSeatRepository.getByReferenceUid(body.seatUid);
@@ -922,15 +935,19 @@ export class BookingsService_2024_08_13 {
       : undefined;
 
     const emailsEnabled = platformClientParams ? platformClientParams.arePlatformEmailsEnabled : true;
+    const userCalendars = await this.usersRepository.findByIdWithCalendars(requestUser.id);
 
     await confirmBookingHandler({
       ctx: {
-        user: requestUser,
+        user: {
+          ...requestUser,
+          destinationCalendar: userCalendars?.destinationCalendar ?? null,
+        },
       },
       input: {
         bookingId: booking.id,
         confirmed: true,
-        recurringEventId: booking.recurringEventId,
+        recurringEventId: booking.recurringEventId ?? undefined,
         emailsEnabled,
         platformClientParams,
       },
@@ -950,15 +967,19 @@ export class BookingsService_2024_08_13 {
       : undefined;
 
     const emailsEnabled = platformClientParams ? platformClientParams.arePlatformEmailsEnabled : true;
+    const userCalendars = await this.usersRepository.findByIdWithCalendars(requestUser.id);
 
     await confirmBookingHandler({
       ctx: {
-        user: requestUser,
+        user: {
+          ...requestUser,
+          destinationCalendar: userCalendars?.destinationCalendar ?? null,
+        },
       },
       input: {
         bookingId: booking.id,
         confirmed: false,
-        recurringEventId: booking.recurringEventId,
+        recurringEventId: booking.recurringEventId ?? undefined,
         reason,
         emailsEnabled,
         platformClientParams,

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

@@ -0,0 +1,83 @@
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
+import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
+import { Injectable, Logger, NotFoundException } from "@nestjs/common";
+
+import {
+  getRecordingsOfCalVideoByRoomName,
+  getAllTranscriptsAccessLinkFromRoomName,
+  getDownloadLinkOfCalVideoByRecordingId,
+} from "@calcom/platform-libraries/conferencing";
+
+@Injectable()
+export class CalVideoService {
+  private readonly logger = new Logger("CalVideoService");
+  constructor(
+    private readonly bookingsRepository: BookingsRepository_2024_08_13,
+    private readonly outputService: OutputBookingsService_2024_08_13
+  ) {}
+
+  async getRecordings(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUidWithBookingReference(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const roomName =
+      booking?.references?.filter((reference) => reference.type === "daily_video")?.pop()?.meetingId ??
+      undefined;
+    if (!roomName) {
+      throw new NotFoundException(`No Cal Video reference found with booking uid ${bookingUid}`);
+    }
+
+    const recordings = await getRecordingsOfCalVideoByRoomName(roomName);
+
+    if (!recordings || !("data" in recordings)) return [];
+
+    const recordingWithDownloadLink = recordings.data.map((recording) => {
+      return getDownloadLinkOfCalVideoByRecordingId(recording.id)
+        .then((res: { download_link: string } | undefined) => ({
+          id: recording.id,
+          roomName: recording.room_name,
+          startTs: recording.start_ts,
+          status: recording.status,
+          maxParticipants: recording.max_participants,
+          duration: recording.duration,
+          shareToken: recording.share_token,
+          downloadLink: res?.download_link,
+        }))
+        .catch((err: Error) => ({
+          id: recording.id,
+          roomName: recording.room_name,
+          startTs: recording.start_ts,
+          status: recording.status,
+          maxParticipants: recording.max_participants,
+          duration: recording.duration,
+          shareToken: recording.share_token,
+          downloadLink: null,
+          error: err.message,
+        }));
+    });
+    const allRecordingsWithDownloadLink = await Promise.all(recordingWithDownloadLink);
+
+    return allRecordingsWithDownloadLink;
+  }
+
+  async getTranscripts(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUidWithBookingReference(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const roomName =
+      booking?.references?.filter((reference) => reference.type === "daily_video")?.pop()?.meetingId ??
+      undefined;
+
+    if (!roomName) {
+      throw new NotFoundException(`No Cal Video reference found with booking uid ${bookingUid}`);
+    }
+
+    const transcripts = await getAllTranscriptsAccessLinkFromRoomName(roomName);
+
+    return transcripts;
+  }
+}

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

@@ -10,6 +10,7 @@ import {
 import { PlatformBookingsService } from "@/ee/bookings/shared/platform-bookings.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
+import { apiToInternalintegrationsMapping } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
 import { defaultBookingResponses } from "@/lib/safe-parse/default-responses-booking";
 import { safeParse } from "@/lib/safe-parse/safe-parse";
@@ -29,10 +30,7 @@ import { NextApiRequest } from "next/types";
 import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";
 
-import {
-  EventTypeMetaDataSchema,
-  apiToInternalintegrationsMapping,
-} from "@calcom/platform-libraries/event-types";
+import { EventTypeMetaDataSchema } from "@calcom/platform-libraries/event-types";
 import {
   CancelBookingInput,
   CancelBookingInput_2024_08_13,
@@ -61,6 +59,7 @@ type OAuthRequestParams = {
   platformBookingUrl: string;
   platformBookingLocation?: string;
   arePlatformEmailsEnabled: boolean;
+  areCalendarEventsEnabled: boolean;
 };
 
 export enum Frequency {

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

@@ -22,7 +22,7 @@ import {
   RecurringBookingOutput_2024_08_13,
   SeatedAttendee,
 } from "@calcom/platform-types";
-import { Booking, BookingReference, BookingSeat } from "@calcom/prisma/client";
+import { Booking, BookingSeat } from "@calcom/prisma/client";
 
 export const bookingResponsesSchema = z
   .object({

apps/api/v2/src/ee/bookings/shared/platform-bookings.service.ts

@@ -54,6 +54,7 @@ export class PlatformBookingsService {
         platformRescheduleUrl: oAuthClient.bookingRescheduleRedirectUri,
         platformBookingUrl: oAuthClient.bookingRedirectUri,
         arePlatformEmailsEnabled: oAuthClient.areEmailsEnabled,
+        areCalendarEventsEnabled: oAuthClient.areCalendarEventsEnabled,
       };
     }
 
@@ -78,6 +79,7 @@ export class PlatformBookingsService {
         platformRescheduleUrl: oAuthClient.bookingRescheduleRedirectUri,
         platformBookingUrl: oAuthClient.bookingRedirectUri,
         arePlatformEmailsEnabled: oAuthClient.areEmailsEnabled,
+        areCalendarEventsEnabled: oAuthClient.areCalendarEventsEnabled,
       };
     }
 

apps/api/v2/src/ee/calendars/calendars.module.ts

@@ -1,3 +1,5 @@
+import { BookingReferencesRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/booking-references.repository";
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
 import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
 import { CalendarsController } from "@/ee/calendars/controllers/calendars.controller";
 import { AppleCalendarService } from "@/ee/calendars/services/apple-calendar.service";
@@ -25,8 +27,10 @@ import { Module } from "@nestjs/common";
     SelectedCalendarsRepository,
     AppsRepository,
     CalendarsRepository,
+    BookingsRepository_2024_08_13,
+    BookingReferencesRepository_2024_08_13,
   ],
   controllers: [CalendarsController],
-  exports: [CalendarsService],
+  exports: [CalendarsService, GoogleCalendarService],
 })
 export class CalendarsModule {}

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

@@ -22,6 +22,7 @@ import { APPS_TYPE_ID_MAPPING } from "@calcom/platform-constants";
 import {
   getConnectedDestinationCalendarsAndEnsureDefaultsInDb,
   getBusyCalendarTimes,
+  type EventBusyDate,
 } from "@calcom/platform-libraries";
 import { Calendar } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
@@ -45,6 +46,7 @@ export class CalendarsService {
         ...credential,
         delegatedTo: null,
         delegatedToId: null,
+        delegationCredentialId: null,
       }))
       .filter((credential) => !!credential);
   }
@@ -88,18 +90,19 @@ export class CalendarsService {
         dateTo,
         composedSelectedCalendars
       );
-      // @ts-expect-error Element implicitly has any type
-      const calendarBusyTimesConverted = calendarBusyTimes.map((busyTime) => {
-        const busyTimeStart = DateTime.fromJSDate(new Date(busyTime.start)).setZone(timezone);
-        const busyTimeEnd = DateTime.fromJSDate(new Date(busyTime.end)).setZone(timezone);
-        const busyTimeStartDate = busyTimeStart.toJSDate();
-        const busyTimeEndDate = busyTimeEnd.toJSDate();
-        return {
-          ...busyTime,
-          start: busyTimeStartDate,
-          end: busyTimeEndDate,
-        };
-      });
+      const calendarBusyTimesConverted = calendarBusyTimes.map(
+        (busyTime: EventBusyDate & { timeZone?: string }) => {
+          const busyTimeStart = DateTime.fromJSDate(new Date(busyTime.start)).setZone(timezone);
+          const busyTimeEnd = DateTime.fromJSDate(new Date(busyTime.end)).setZone(timezone);
+          const busyTimeStartDate = busyTimeStart.toJSDate();
+          const busyTimeEndDate = busyTimeEnd.toJSDate();
+          return {
+            ...busyTime,
+            start: busyTimeStartDate,
+            end: busyTimeEndDate,
+          };
+        }
+      );
       return calendarBusyTimesConverted;
     } catch (error) {
       throw new InternalServerErrorException(

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

@@ -23,7 +23,7 @@ const CALENDAR_SCOPES = [
 
 @Injectable()
 export class GoogleCalendarService implements OAuthCalendarApp {
-  private redirectUri = `${this.config.get("api.url")}/gcal/oauth/save`;
+  public readonly redirectUri = `${this.config.get("api.url")}/gcal/oauth/save`;
   private gcalResponseSchema = z.object({ client_id: z.string(), client_secret: z.string() });
   private logger = new Logger("GcalService");
 

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

@@ -5,6 +5,7 @@ import { Editable } from "@/ee/event-types/event-types_2024_04_15/inputs/enums/e
 import { BaseField } from "@/ee/event-types/event-types_2024_04_15/inputs/enums/field-type";
 import { UpdateEventTypeInput_2024_04_15 } from "@/ee/event-types/event-types_2024_04_15/inputs/update-event-type.input";
 import { EventTypeOutput } from "@/ee/event-types/event-types_2024_04_15/outputs/event-type.output";
+import { systemBeforeFieldEmail } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
@@ -17,7 +18,6 @@ import {
   updateEventType,
   EventTypesPublic,
   getEventTypesPublic,
-  systemBeforeFieldEmail,
 } from "@calcom/platform-libraries/event-types";
 import { EventType } from "@calcom/prisma/client";
 

apps/api/v2/src/ee/event-types/event-types_2024_06_14/constants/constants.ts

@@ -1,4 +1,4 @@
-import { OrganizerIntegrationLocation } from "@calcom/lib/event-types/transformers/internal/locations";
+import { OrganizerIntegrationLocation } from "@/ee/event-types/event-types_2024_06_14/transformers";
 
 type BaseEventType = {
   length: number;

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

@@ -962,6 +962,10 @@ describe("Event types Endpoints", () => {
         title: newTitle,
         scheduleId: secondSchedule.id,
         lengthInMinutesOptions: [15, 30],
+        calVideoSettings: {
+          disableRecordingForGuests: true,
+          disableRecordingForOrganizer: true,
+        },
         bookingFields: [
           nameBookingField,
           {
@@ -1082,6 +1086,12 @@ describe("Event types Endpoints", () => {
             body.lockTimeZoneToggleOnBookingPage
           );
           expect(updatedEventType.color).toEqual(body.color);
+          expect(updatedEventType.calVideoSettings?.disableRecordingForGuests).toEqual(
+            body.calVideoSettings?.disableRecordingForGuests
+          );
+          expect(updatedEventType.calVideoSettings?.disableRecordingForOrganizer).toEqual(
+            body.calVideoSettings?.disableRecordingForOrganizer
+          );
 
           eventType.title = newTitle;
           eventType.scheduleId = secondSchedule.id;
@@ -1841,6 +1851,40 @@ describe("Event types Endpoints", () => {
             expect(slug2).not.toEqual(slug);
           });
       });
+
+      it("should create event type with cal video settings", async () => {
+        const body: CreateEventTypeInput_2024_06_14 = {
+          title: "event type with cal video settings",
+          slug: "event-type-with-cal-video-settings",
+          lengthInMinutes: 60,
+          calVideoSettings: {
+            disableRecordingForGuests: true,
+            disableRecordingForOrganizer: true,
+          },
+          locations: [
+            {
+              type: "integration",
+              integration: "cal-video",
+            },
+          ],
+        };
+
+        return request(app.getHttpServer())
+          .post("/api/v2/event-types")
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+          .send(body)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+            const createdEventType = responseBody.data;
+            expect(createdEventType).toHaveProperty("id");
+            expect(createdEventType.title).toEqual(body.title);
+            expect(createdEventType.locations).toEqual(body.locations);
+            expect(createdEventType.calVideoSettings?.disableRecordingForGuests).toEqual(true);
+            expect(createdEventType.calVideoSettings?.disableRecordingForOrganizer).toEqual(true);
+            firstCreatedEventType = responseBody.data;
+          });
+      });
     });
 
     afterAll(async () => {

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

@@ -114,6 +114,9 @@ export class EventTypesController_2024_06_14 {
     @Query() queryParams: GetEventTypesQuery_2024_06_14
   ): Promise<GetEventTypesOutput_2024_06_14> {
     const eventTypes = await this.eventTypesService.getEventTypes(queryParams);
+    if (!eventTypes || eventTypes.length === 0) {
+      throw new NotFoundException(`Event types not found`);
+    }
     const eventTypesFormatted = this.eventTypeResponseTransformPipe.transform(eventTypes);
     const eventTypesWithoutHiddenFields = eventTypesFormatted.map((eventType) => {
       return {

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

@@ -1,10 +1,9 @@
+import { InputEventTransformed_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/transformed";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { Injectable } from "@nestjs/common";
 import type { Prisma } from "@prisma/client";
 
-import { InputEventTransformed_2024_06_14 } from "@calcom/platform-types";
-
 @Injectable()
 export class EventTypesRepository_2024_06_14 {
   constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
@@ -13,13 +12,20 @@ export class EventTypesRepository_2024_06_14 {
     userId: number,
     body: Omit<InputEventTransformed_2024_06_14, "destinationCalendar">
   ) {
+    const { calVideoSettings, ...restBody } = body;
+
     return this.dbWrite.prisma.eventType.create({
       data: {
-        ...body,
+        ...restBody,
         userId,
         locations: body.locations,
         bookingFields: body.bookingFields,
         users: { connect: { id: userId } },
+        ...(calVideoSettings && {
+          calVideoSettings: {
+            create: calVideoSettings,
+          },
+        }),
       },
     });
   }
@@ -72,7 +78,7 @@ export class EventTypesRepository_2024_06_14 {
   async getEventTypeById(eventTypeId: number) {
     return this.dbRead.prisma.eventType.findUnique({
       where: { id: eventTypeId },
-      include: { users: true, schedule: true, destinationCalendar: true },
+      include: { users: true, schedule: true, destinationCalendar: true, calVideoSettings: true },
     });
   }
 

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

@@ -1,5 +1,7 @@
 import { DEFAULT_EVENT_TYPES } from "@/ee/event-types/event-types_2024_06_14/constants/constants";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { InputEventTransformed_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/transformed";
+import { SystemField, CustomField } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
@@ -14,10 +16,8 @@ import {
   updateEventType,
   getEventTypesPublic,
   EventTypesPublic,
-  SystemField,
-  CustomField,
 } from "@calcom/platform-libraries/event-types";
-import { GetEventTypesQuery_2024_06_14, InputEventTransformed_2024_06_14 } from "@calcom/platform-types";
+import { GetEventTypesQuery_2024_06_14 } from "@calcom/platform-types";
 import { EventType } from "@calcom/prisma/client";
 
 @Injectable()

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

@@ -1,13 +1,7 @@
 import { ConnectedCalendarsData } from "@/ee/calendars/outputs/connected-calendars.output";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
-import { ConferencingService } from "@/modules/conferencing/services/conferencing.service";
-import { UserWithProfile } from "@/modules/users/users.repository";
-import { Injectable, BadRequestException } from "@nestjs/common";
-
-import { CONFERENCING_APPS } from "@calcom/platform-constants";
-import { getUsersCredentials } from "@calcom/platform-libraries";
-import { getApps } from "@calcom/platform-libraries/app-store";
+import { InputEventTransformed_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/transformed";
 import {
   transformBookingFieldsApiToInternal,
   transformLocationsApiToInternal,
@@ -21,21 +15,23 @@ import {
   systemAfterFieldNotes,
   systemAfterFieldGuests,
   systemAfterFieldRescheduleReason,
-  EventTypeMetaDataSchema,
   transformBookerLayoutsApiToInternal,
   transformConfirmationPolicyApiToInternal,
   transformEventColorsApiToInternal,
-  validateCustomEventName,
   transformSeatsApiToInternal,
   SystemField,
   CustomField,
   InternalLocation,
   InternalLocationSchema,
-} from "@calcom/platform-libraries/event-types";
+} from "@/ee/event-types/event-types_2024_06_14/transformers";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { Injectable, BadRequestException } from "@nestjs/common";
+
+import { getApps, getUsersCredentialsIncludeServiceAccountKey } from "@calcom/platform-libraries/app-store";
+import { validateCustomEventName, EventTypeMetaDataSchema } from "@calcom/platform-libraries/event-types";
 import {
   CreateEventTypeInput_2024_06_14,
   DestinationCalendar_2024_06_14,
-  InputEventTransformed_2024_06_14,
   OutputUnknownLocation_2024_06_14,
   UpdateEventTypeInput_2024_06_14,
 } from "@calcom/platform-types";
@@ -478,7 +474,7 @@ export class InputEventTypesService_2024_06_14 {
       appSlug = "msteams";
     }
 
-    const credentials = await getUsersCredentials(user);
+    const credentials = await getUsersCredentialsIncludeServiceAccountKey(user);
 
     const foundApp = getApps(credentials, true).filter((app) => app.slug === appSlug)[0];
 

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

@@ -1,14 +1,4 @@
-import { Injectable } from "@nestjs/common";
-import type { EventType, User, Schedule, DestinationCalendar } from "@prisma/client";
-
 import {
-  userMetadata,
-  parseBookingLimit,
-  parseRecurringEvent,
-  getBookingFieldsWithSystemFields,
-} from "@calcom/platform-libraries";
-import {
-  EventTypeMetaDataSchema,
   transformLocationsInternalToApi,
   transformBookingFieldsInternalToApi,
   InternalLocationSchema,
@@ -20,11 +10,20 @@ import {
   transformBookerLayoutsInternalToApi,
   transformRequiresConfirmationInternalToApi,
   transformEventTypeColorsInternalToApi,
-  parseEventTypeColor,
   transformSeatsInternalToApi,
   InternalLocation,
   BookingFieldSchema,
-} from "@calcom/platform-libraries/event-types";
+} from "@/ee/event-types/event-types_2024_06_14/transformers";
+import { Injectable } from "@nestjs/common";
+import type { EventType, User, Schedule, DestinationCalendar, CalVideoSettings } from "@prisma/client";
+
+import {
+  userMetadata,
+  parseBookingLimit,
+  parseRecurringEvent,
+  getBookingFieldsWithSystemFields,
+} from "@calcom/platform-libraries";
+import { EventTypeMetaDataSchema, parseEventTypeColor } from "@calcom/platform-libraries/event-types";
 import {
   TransformFutureBookingsLimitSchema_2024_06_14,
   BookerLayoutsTransformedSchema,
@@ -38,8 +37,9 @@ type EventTypeRelations = {
   users: User[];
   schedule: Schedule | null;
   destinationCalendar?: DestinationCalendar | null;
+  calVideoSettings?: CalVideoSettings | null;
 };
-export type DatabaseEventType = EventType & EventTypeRelations;
+export type DatabaseEventType = Omit<EventType, "allowReschedulingCancelledBookings"> & EventTypeRelations;
 
 type Input = Pick<
   DatabaseEventType,
@@ -88,6 +88,7 @@ type Input = Pick<
   | "useEventTypeDestinationCalendarEmail"
   | "hideCalendarEventDetails"
   | "hideOrganizerEmail"
+  | "calVideoSettings"
 >;
 
 @Injectable()
@@ -125,6 +126,7 @@ export class OutputEventTypesService_2024_06_14 {
       useEventTypeDestinationCalendarEmail,
       hideCalendarEventDetails,
       hideOrganizerEmail,
+      calVideoSettings,
     } = databaseEventType;
 
     const locations = this.transformLocations(databaseEventType.locations);
@@ -200,6 +202,7 @@ export class OutputEventTypesService_2024_06_14 {
       useDestinationCalendarEmail: useEventTypeDestinationCalendarEmail,
       hideCalendarEventDetails,
       hideOrganizerEmail,
+      calVideoSettings,
     };
   }
 

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformed/event-type.tranformed.ts

@@ -1,5 +1,3 @@
-import type { z } from "zod";
-
 import type {
   transformEventColorsApiToInternal,
   transformFutureBookingLimitsApiToInternal,
@@ -8,9 +6,13 @@ import type {
   transformSeatsApiToInternal,
   transformBookingFieldsApiToInternal,
   InternalLocationsSchema,
-} from "@calcom/lib/event-types/transformers";
+} from "@/ee/event-types/event-types_2024_06_14/transformers";
+import type { z } from "zod";
 
-import type { CreateEventTypeInput_2024_06_14, ConfirmationPolicyTransformedSchema } from "../inputs";
+import type {
+  CreateEventTypeInput_2024_06_14,
+  ConfirmationPolicyTransformedSchema,
+} from "@calcom/platform-types";
 
 export type InputEventTransformed_2024_06_14 = Omit<
   CreateEventTypeInput_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/api-to-internal/api-to-internal.spec.ts

@@ -1,12 +1,10 @@
-import { describe, expect, it } from "vitest";
-
 import {
   BookerLayoutsInputEnum_2024_06_14,
   BookerLayoutsOutputEnum_2024_06_14,
   ConfirmationPolicyEnum,
   NoticeThresholdUnitEnum,
   FrequencyInput,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type {
   InputBookingField_2024_06_14,
   InputLocation_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/api-to-internal/booker-layouts.ts

@@ -1,7 +1,7 @@
 import {
   BookerLayoutsInputEnum_2024_06_14,
   BookerLayoutsOutputEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import { type CreateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
 
 export function transformBookerLayoutsApiToInternal(

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/api-to-internal/confirmation-policy.ts

@@ -1,4 +1,4 @@
-import { ConfirmationPolicyEnum } from "@calcom/platform-enums/monorepo";
+import { ConfirmationPolicyEnum } from "@calcom/platform-enums";
 import type {
   ConfirmationPolicyTransformedSchema,
   NoticeThresholdTransformedSchema,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/api-to-internal/future-booking-limits.ts

@@ -1,7 +1,7 @@
 import {
   BookingWindowPeriodInputTypeEnum_2024_06_14,
   BookingWindowPeriodOutputTypeEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import {
   type CreateEventTypeInput_2024_06_14,
   type BusinessDaysWindow_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/api-to-internal/interval-limits.ts

@@ -1,4 +1,4 @@
-import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums/monorepo";
+import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums";
 import {
   type CreateEventTypeInput_2024_06_14,
   type BookingLimitsKeyOutputType_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/api-to-internal/recurrence.ts

@@ -1,4 +1,4 @@
-import { Frequency } from "@calcom/platform-enums/monorepo";
+import { Frequency } from "@calcom/platform-enums";
 import type { Recurrence_2024_06_14 } from "@calcom/platform-types";
 import { type TransformRecurringEventSchema_2024_06_14 } from "@calcom/platform-types";
 

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/internal-to-api/booker-layouts.ts

@@ -1,7 +1,7 @@
 import {
   BookerLayoutsInputEnum_2024_06_14,
   BookerLayoutsOutputEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type { BookerLayoutsTransformedSchema } from "@calcom/platform-types";
 
 export function transformBookerLayoutsInternalToApi(

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/internal-to-api/future-booking-limits.ts

@@ -1,7 +1,7 @@
 import {
   BookingWindowPeriodInputTypeEnum_2024_06_14,
   BookingWindowPeriodOutputTypeEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type {
   TransformFutureBookingsLimitSchema_2024_06_14,
   BookingWindow_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/internal-to-api/internal-to-api.spec.ts

@@ -1,11 +1,9 @@
-import { describe, expect, it } from "vitest";
-
 import {
   BookerLayoutsInputEnum_2024_06_14,
   BookerLayoutsOutputEnum_2024_06_14,
   ConfirmationPolicyEnum,
   NoticeThresholdUnitEnum,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type {
   TransformBookingLimitsSchema_2024_06_14,
   TransformFutureBookingsLimitSchema_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/internal-to-api/interval-limits.ts

@@ -1,4 +1,4 @@
-import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums/monorepo";
+import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums";
 import type {
   BookingLimitsKeysInputType,
   TransformBookingLimitsSchema_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/internal-to-api/recurrence.ts

@@ -1,4 +1,4 @@
-import { Frequency, FrequencyInput } from "@calcom/platform-enums/monorepo";
+import { Frequency, FrequencyInput } from "@calcom/platform-enums";
 import type { Recurrence_2024_06_14, TransformRecurringEventSchema_2024_06_14 } from "@calcom/platform-types";
 
 export function transformRecurrenceInternalToApi(

apps/api/v2/src/ee/event-types/event-types_2024_06_14/transformers/internal-to-api/requires-confirmation.ts

@@ -1,4 +1,4 @@
-import { ConfirmationPolicyEnum } from "@calcom/platform-enums/monorepo";
+import { ConfirmationPolicyEnum } from "@calcom/platform-enums";
 import type { NoticeThresholdTransformedSchema, ConfirmationPolicy_2024_06_14 } from "@calcom/platform-types";
 
 export function transformRequiresConfirmationInternalToApi(

apps/api/v2/src/ee/schedules/schedules_2024_06_11/services/input-schedules.service.ts

@@ -1,11 +1,7 @@
 import { Injectable } from "@nestjs/common";
 
-import {
-  transformApiScheduleOverrides,
-  transformApiScheduleAvailability,
-} from "@calcom/platform-libraries/schedules";
 import { CreateScheduleInput_2024_06_11, ScheduleAvailabilityInput_2024_06_11 } from "@calcom/platform-types";
-import { ScheduleOverrideInput_2024_06_11 } from "@calcom/platform-types";
+import { ScheduleOverrideInput_2024_06_11, WeekDay } from "@calcom/platform-types";
 
 @Injectable()
 export class InputSchedulesService_2024_06_11 {
@@ -34,10 +30,52 @@ export class InputSchedulesService_2024_06_11 {
   }
 
   transformInputScheduleAvailability(inputAvailability: ScheduleAvailabilityInput_2024_06_11[]) {
-    return transformApiScheduleAvailability(inputAvailability);
+    return inputAvailability.map((availability) => ({
+      days: availability.days.map(this.transformDayToNumber),
+      startTime: this.createDateFromHoursMinutes(availability.startTime),
+      endTime: this.createDateFromHoursMinutes(availability.endTime),
+    }));
   }
 
   transformInputOverrides(inputOverrides: ScheduleOverrideInput_2024_06_11[]) {
-    return transformApiScheduleOverrides(inputOverrides);
+    return inputOverrides.map((override) => ({
+      date: new Date(override.date),
+      startTime: this.createDateFromHoursMinutes(override.startTime),
+      endTime: this.createDateFromHoursMinutes(override.endTime),
+    }));
+  }
+
+  createDateFromHoursMinutes(hoursMinutes: string): Date {
+    const parts = hoursMinutes.split(":");
+
+    if (parts.length < 2) {
+      throw new Error("Invalid time format. Please use 'hh:mm'.");
+    }
+
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+
+    if (isNaN(hours) || hours < 0 || hours > 23) {
+      throw new Error("Hours must be a number between 0 and 23.");
+    }
+    if (isNaN(minutes) || minutes < 0 || minutes > 59) {
+      throw new Error("Minutes must be a number between 0 and 59.");
+    }
+
+    const utcDate = new Date(Date.UTC(1970, 0, 1, hours, minutes));
+
+    return utcDate;
+  }
+  transformDayToNumber(day: WeekDay): number {
+    const weekMap: { [key in WeekDay]: number } = {
+      Sunday: 0,
+      Monday: 1,
+      Tuesday: 2,
+      Wednesday: 3,
+      Thursday: 4,
+      Friday: 5,
+      Saturday: 6,
+    };
+    return weekMap[day];
   }
 }

apps/api/v2/src/env.ts

@@ -17,7 +17,7 @@ export type Environment = {
   STRIPE_API_KEY: string;
   STRIPE_WEBHOOK_SECRET: string;
   WEB_APP_URL: string;
-  IS_E2E: boolean;
+  IS_E2E: string;
   CALCOM_LICENSE_KEY: string;
   GET_LICENSE_KEY_URL: string;
   API_KEY_PREFIX: string;
@@ -32,6 +32,8 @@ export type Environment = {
   AXIOM_TOKEN: string;
   STRIPE_TEAM_MONTHLY_PRICE_ID: string;
   IS_TEAM_BILLING_ENABLED: boolean;
+  // Used to enable/disable the rewrite of /api/v2 to /v2, active by default.
+  REWRITE_API_V2_PREFIX: string;
 };
 
 export const getEnv = <K extends keyof Environment>(key: K, fallback?: Environment[K]): Environment[K] => {

apps/api/v2/src/lib/pagination/pagination.spec.ts

@@ -0,0 +1,101 @@
+import { getPagination, clamp } from "./pagination";
+
+describe("getPagination", () => {
+  it("handles the first page correctly", () => {
+    const pagination = getPagination({ skip: 0, take: 10, totalCount: 35 });
+    expect(pagination).toEqual({
+      returnedItems: 10,
+      totalItems: 35,
+      itemsPerPage: 10,
+      remainingItems: 25,
+      currentPage: 1,
+      totalPages: 4,
+      hasNextPage: true,
+      hasPreviousPage: false,
+    });
+  });
+
+  it("handles a middle page correctly", () => {
+    const pagination = getPagination({ skip: 10, take: 10, totalCount: 35 });
+    expect(pagination).toEqual({
+      returnedItems: 10,
+      totalItems: 35,
+      itemsPerPage: 10,
+      remainingItems: 15,
+      currentPage: 2,
+      totalPages: 4,
+      hasNextPage: true,
+      hasPreviousPage: true,
+    });
+  });
+
+  it("handles the last page when it is not completely full", () => {
+    const pagination = getPagination({ skip: 30, take: 10, totalCount: 35 });
+    expect(pagination).toEqual({
+      returnedItems: 5,
+      totalItems: 35,
+      itemsPerPage: 10,
+      remainingItems: 0,
+      currentPage: 4,
+      totalPages: 4,
+      hasNextPage: false,
+      hasPreviousPage: true,
+    });
+  });
+
+  it("clamps skip values that exceed the total item count", () => {
+    const pagination = getPagination({ skip: 40, take: 10, totalCount: 35 });
+    expect(pagination).toEqual({
+      returnedItems: 0,
+      totalItems: 35,
+      itemsPerPage: 10,
+      remainingItems: 0,
+      currentPage: 4,
+      totalPages: 4,
+      hasNextPage: false,
+      hasPreviousPage: true,
+    });
+  });
+
+  it("works when itemsPerPage (take) is zero", () => {
+    const pagination = getPagination({ skip: 0, take: 0, totalCount: 35 });
+    expect(pagination).toEqual({
+      returnedItems: 0,
+      totalItems: 35,
+      itemsPerPage: 0,
+      remainingItems: 35,
+      currentPage: 0,
+      totalPages: 0,
+      hasNextPage: true,
+      hasPreviousPage: false,
+    });
+  });
+
+  it("works when the collection is empty", () => {
+    const pagination = getPagination({ skip: 0, take: 10, totalCount: 0 });
+    expect(pagination).toEqual({
+      returnedItems: 0,
+      totalItems: 0,
+      itemsPerPage: 10,
+      remainingItems: 0,
+      currentPage: 0,
+      totalPages: 0,
+      hasNextPage: false,
+      hasPreviousPage: false,
+    });
+  });
+});
+
+describe("clamp", () => {
+  it("returns the value unchanged when it is inside the range", () => {
+    expect(clamp({ value: 5, min: 1, max: 10 })).toBe(5);
+  });
+
+  it("clamps values below the minimum", () => {
+    expect(clamp({ value: -3, min: 0, max: 10 })).toBe(0);
+  });
+
+  it("clamps values above the maximum", () => {
+    expect(clamp({ value: 42, min: 0, max: 10 })).toBe(10);
+  });
+});

apps/api/v2/src/lib/pagination/pagination.ts

@@ -0,0 +1,78 @@
+import { PaginationMetaDto } from "@calcom/platform-types";
+
+type Pagination = {
+  skip: number;
+  take: number;
+  totalCount: number;
+};
+
+export function getPagination(pagination: Pagination): PaginationMetaDto {
+  const { skip, take, totalCount } = pagination;
+
+  const safeSkip = clamp({ value: skip, min: 0, max: totalCount });
+  const itemsPerPage = take;
+  const remainingItems = getRemainingItems(safeSkip, itemsPerPage, totalCount);
+  const totalPages = getTotalPages(itemsPerPage, totalCount);
+  const currentPage = getCurrentPage(safeSkip, itemsPerPage, totalPages);
+  const hasNextPage = getHasNextPage(safeSkip, itemsPerPage, totalCount);
+  const hasPreviousPage = getHasPreviousPage(safeSkip);
+  const returnedItems = getReturnedItems(safeSkip, itemsPerPage, totalCount);
+
+  return {
+    returnedItems,
+    totalItems: totalCount,
+    itemsPerPage,
+    remainingItems,
+    currentPage,
+    totalPages,
+    hasNextPage,
+    hasPreviousPage,
+  };
+}
+
+function getRemainingItems(skip: number, itemsPerPage: number, totalCount: number) {
+  return clamp({
+    value: totalCount - (skip + itemsPerPage),
+    min: 0,
+    max: totalCount,
+  });
+}
+
+function getTotalPages(itemsPerPage: number, totalCount: number) {
+  return itemsPerPage !== 0 ? Math.ceil(totalCount / itemsPerPage) : 0;
+}
+
+function getCurrentPage(skip: number, itemsPerPage: number, totalPages: number) {
+  const rawCurrentPage = Math.floor(skip / itemsPerPage) + 1;
+  if (totalPages === 0) {
+    return 0;
+  }
+  return clamp({ value: rawCurrentPage, min: 1, max: totalPages });
+}
+
+function getHasNextPage(skip: number, itemsPerPage: number, totalCount: number) {
+  return skip + itemsPerPage < totalCount;
+}
+
+function getHasPreviousPage(skip: number) {
+  return skip > 0;
+}
+
+function getReturnedItems(skip: number, itemsPerPage: number, totalCount: number) {
+  const remaining = totalCount - skip;
+  return clamp({
+    value: remaining,
+    min: 0,
+    max: itemsPerPage,
+  });
+}
+
+type ClampArgs = {
+  value: number;
+  min: number;
+  max: number;
+};
+
+export function clamp({ value, min, max }: ClampArgs): number {
+  return Math.max(min, Math.min(value, max));
+}

apps/api/v2/src/middleware/app.rewrites.middleware.ts

@@ -1,10 +1,11 @@
+import { getEnv } from "@/env";
 import { Injectable, NestMiddleware } from "@nestjs/common";
 import { Request, Response } from "express";
 
 @Injectable()
 export class RewriterMiddleware implements NestMiddleware {
   use(req: Request, res: Response, next: () => void) {
-    if (req.url.startsWith("/api/v2")) {
+    if (shouldRewriteApiV2Prefix() && req.url.startsWith("/api/v2")) {
       req.url = req.url.replace("/api/v2", "/v2");
     }
     if (req.url.startsWith("/v2/ee")) {
@@ -16,3 +17,12 @@ export class RewriterMiddleware implements NestMiddleware {
     next();
   }
 }
+
+const shouldRewriteApiV2Prefix = () => {
+  try {
+    // rewrite is active even if REWRITE_API_V2_PREFIX is not set
+    return getEnv("REWRITE_API_V2_PREFIX", "1") === "1";
+  } catch (error) {
+    return true;
+  }
+};

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

@@ -1,10 +1,13 @@
 import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
-import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { AtomsRepository } from "@/modules/atoms/atoms.repository";
+import { AtomsConferencingAppsController } from "@/modules/atoms/controllers/atoms.conferencing-apps.controller";
 import { AtomsController } from "@/modules/atoms/controllers/atoms.controller";
+import { AtomsEventTypesController } from "@/modules/atoms/controllers/atoms.event-types.controller";
+import { AtomsSchedulesController } from "@/modules/atoms/controllers/atoms.schedules.controller";
 import { AttributesAtomsService } from "@/modules/atoms/services/attributes-atom.service";
 import { ConferencingAtomsService } from "@/modules/atoms/services/conferencing-atom.service";
 import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
+import { SchedulesAtomsService } from "@/modules/atoms/services/schedules-atom.service";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { OrganizationsModule } from "@/modules/organizations/organizations.module";
@@ -26,10 +29,15 @@ import { Module } from "@nestjs/common";
     UsersRepository,
     AtomsRepository,
     UsersService,
-    SchedulesRepository_2024_06_11,
+    SchedulesAtomsService,
     RedisService,
   ],
   exports: [EventTypesAtomService],
-  controllers: [AtomsController],
+  controllers: [
+    AtomsController,
+    AtomsEventTypesController,
+    AtomsConferencingAppsController,
+    AtomsSchedulesController,
+  ],
 })
 export class AtomsModule {}

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

@@ -0,0 +1,62 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { ConferencingAtomsService } from "@/modules/atoms/services/conferencing-atom.service";
+import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
+import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+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 { UserWithProfile } from "@/modules/users/users.repository";
+import { Controller, Get, Param, ParseIntPipe, UseGuards, Version, VERSION_NEUTRAL } from "@nestjs/common";
+import { ApiTags as DocsTags, ApiExcludeController as DocsExcludeController } from "@nestjs/swagger";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { ConnectedApps } from "@calcom/platform-libraries/app-store";
+import { ApiResponse } from "@calcom/platform-types";
+
+/*
+Conferencing endpoints for atoms, split from AtomsController for clarity and maintainability.
+These endpoints should not be recommended for use by third party and are excluded from docs.
+*/
+
+@Controller({
+  path: "/v2/atoms",
+  version: API_VERSIONS_VALUES,
+})
+@DocsTags("Atoms - conferencing endpoints for atoms")
+@DocsExcludeController(true)
+export class AtomsConferencingAppsController {
+  constructor(private readonly conferencingService: ConferencingAtomsService) {}
+
+  @Get("/organizations/:orgId/teams/:teamId/conferencing")
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  @Version(VERSION_NEUTRAL)
+  async listTeamInstalledConferencingApps(
+    @GetUser() user: UserWithProfile,
+    @Param("teamId", ParseIntPipe) teamId: number
+  ): Promise<ApiResponse<ConnectedApps>> {
+    const conferencingApps = await this.conferencingService.getTeamConferencingApps(user, teamId);
+    return {
+      status: SUCCESS_STATUS,
+      data: conferencingApps,
+    };
+  }
+
+  @Get("/conferencing")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async listUserInstalledConferencingApps(
+    @GetUser() user: UserWithProfile
+  ): Promise<ApiResponse<ConnectedApps>> {
+    const conferencingApps = await this.conferencingService.getUserConferencingApps(user);
+    return {
+      status: SUCCESS_STATUS,
+      data: conferencingApps,
+    };
+  }
+}

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

@@ -1,21 +1,9 @@
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
-import {
-  BulkUpdateEventTypeToDefaultLocationDto,
-  EventTypesAppInput,
-} from "@/modules/atoms/inputs/event-types-app.input";
 import { FindTeamMembersMatchingAttributeQueryDto } from "@/modules/atoms/inputs/find-team-members-matching-attribute.input";
 import { AttributesAtomsService } from "@/modules/atoms/services/attributes-atom.service";
 import { ConferencingAtomsService } from "@/modules/atoms/services/conferencing-atom.service";
-import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
-import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
-import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
-import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
-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 { UserWithProfile } from "@/modules/users/users.repository";
 import {
   Controller,
@@ -25,24 +13,17 @@ import {
   UseGuards,
   Version,
   VERSION_NEUTRAL,
-  Patch,
-  Body,
   Query,
 } from "@nestjs/common";
 import { ApiTags as DocsTags, ApiExcludeController as DocsExcludeController } from "@nestjs/swagger";
 
-import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
-import { ConnectedApps } from "@calcom/platform-libraries/app-store";
-import type { UpdateEventTypeReturn } from "@calcom/platform-libraries/event-types";
-import { ApiResponse } from "@calcom/platform-types";
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
 
 import { FindTeamMembersMatchingAttributeResponseDto } from "../outputs/find-team-members-matching-attribute.output";
 
 /*
-
 Endpoints used only by platform atoms, reusing code from other modules, data is already formatted and ready to be used by frontend atoms
 these endpoints should not be recommended for use by third party and are excluded from docs
-
 */
 
 @Controller({
@@ -53,180 +34,10 @@ these endpoints should not be recommended for use by third party and are exclude
 @DocsExcludeController(true)
 export class AtomsController {
   constructor(
-    private readonly eventTypesService: EventTypesAtomService,
     private readonly conferencingService: ConferencingAtomsService,
     private readonly attributesService: AttributesAtomsService
   ) {}
 
-  @Get("event-types/:eventTypeId")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async getAtomEventType(
-    @GetUser() user: UserWithProfile,
-    @Param("eventTypeId", ParseIntPipe) eventTypeId: number
-  ): Promise<ApiResponse<unknown>> {
-    const eventType = await this.eventTypesService.getUserEventType(user, eventTypeId);
-    return {
-      status: SUCCESS_STATUS,
-      data: eventType,
-    };
-  }
-
-  @Get("/organizations/:orgId/teams/:teamId/event-types")
-  @Roles("TEAM_ADMIN")
-  @PlatformPlan("ESSENTIALS")
-  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-  @Version(VERSION_NEUTRAL)
-  async listTeamEventTypes(@Param("teamId", ParseIntPipe) teamId: number): Promise<ApiResponse<unknown>> {
-    const eventTypes = await this.eventTypesService.getTeamEventTypes(teamId);
-    return {
-      status: SUCCESS_STATUS,
-      data: eventTypes,
-    };
-  }
-
-  @Get("/event-types")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async listUserEventTypes(@GetUser("id") userId: number): Promise<ApiResponse<unknown>> {
-    const eventTypes = await this.eventTypesService.getUserEventTypes(userId);
-    return {
-      status: SUCCESS_STATUS,
-      data: eventTypes,
-    };
-  }
-
-  @Get("event-types-app/:appSlug")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async getAtomEventTypeApp(
-    @GetUser() user: UserWithProfile,
-    @Param("appSlug") appSlug: string,
-    @Query() queryParams: EventTypesAppInput
-  ): Promise<ApiResponse<unknown>> {
-    const { teamId } = queryParams;
-
-    const app = await this.eventTypesService.getEventTypesAppIntegration(appSlug, user, teamId);
-
-    return {
-      status: SUCCESS_STATUS,
-      data: {
-        app,
-      },
-    };
-  }
-
-  @Get("payment/:uid")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async getUserPaymentInfoById(@Param("uid") uid: string): Promise<ApiResponse<unknown>> {
-    const data = await this.eventTypesService.getUserPaymentInfo(uid);
-
-    return {
-      status: SUCCESS_STATUS,
-      data,
-    };
-  }
-
-  @Patch("/event-types/bulk-update-to-default-location")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async bulkUpdateAtomEventTypes(
-    @GetUser() user: UserWithProfile,
-    @Body() body: BulkUpdateEventTypeToDefaultLocationDto
-  ): Promise<{ status: typeof SUCCESS_STATUS | typeof ERROR_STATUS }> {
-    await this.eventTypesService.bulkUpdateEventTypesDefaultLocation(user, body.eventTypeIds);
-    return {
-      status: SUCCESS_STATUS,
-    };
-  }
-
-  @Patch("/organizations/:orgId/teams/:teamId/event-types/bulk-update-to-default-location")
-  @Version(VERSION_NEUTRAL)
-  @Roles("TEAM_ADMIN")
-  @PlatformPlan("ESSENTIALS")
-  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-  async bulkUpdateAtomTeamEventTypes(
-    @GetUser() user: UserWithProfile,
-    @Body() body: BulkUpdateEventTypeToDefaultLocationDto,
-    @Param("teamId", ParseIntPipe) teamId: number
-  ): Promise<{ status: typeof SUCCESS_STATUS | typeof ERROR_STATUS }> {
-    await this.eventTypesService.bulkUpdateTeamEventTypesDefaultLocation(body.eventTypeIds, teamId);
-    return {
-      status: SUCCESS_STATUS,
-    };
-  }
-
-  @Patch("event-types/:eventTypeId")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async updateAtomEventType(
-    @GetUser() user: UserWithProfile,
-    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
-    @Body() body: UpdateEventTypeReturn
-  ): Promise<ApiResponse<UpdateEventTypeReturn>> {
-    const eventType = await this.eventTypesService.updateEventType(
-      eventTypeId,
-      { ...body, id: eventTypeId },
-      user
-    );
-    return {
-      status: SUCCESS_STATUS,
-      data: eventType,
-    };
-  }
-
-  @Patch("/organizations/:orgId/teams/:teamId/event-types/:eventTypeId")
-  @Version(VERSION_NEUTRAL)
-  @Roles("TEAM_ADMIN")
-  @PlatformPlan("ESSENTIALS")
-  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-  async updateAtomTeamEventType(
-    @GetUser() user: UserWithProfile,
-    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
-    @Param("teamId", ParseIntPipe) teamId: number,
-    @Body() body: UpdateEventTypeReturn
-  ): Promise<ApiResponse<UpdateEventTypeReturn>> {
-    const eventType = await this.eventTypesService.updateTeamEventType(
-      eventTypeId,
-      { ...body, id: eventTypeId },
-      user,
-      teamId
-    );
-    return {
-      status: SUCCESS_STATUS,
-      data: eventType,
-    };
-  }
-  @Get("/organizations/:orgId/teams/:teamId/conferencing")
-  @Roles("TEAM_ADMIN")
-  @PlatformPlan("ESSENTIALS")
-  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-  @Version(VERSION_NEUTRAL)
-  async listTeamInstalledConferencingApps(
-    @GetUser() user: UserWithProfile,
-    @Param("teamId", ParseIntPipe) teamId: number
-  ): Promise<ApiResponse<ConnectedApps>> {
-    const conferencingApps = await this.conferencingService.getTeamConferencingApps(user, teamId);
-
-    return {
-      status: SUCCESS_STATUS,
-      data: conferencingApps,
-    };
-  }
-
-  @Get("/conferencing")
-  @Version(VERSION_NEUTRAL)
-  @UseGuards(ApiAuthGuard)
-  async listUserInstalledConferencingApps(
-    @GetUser() user: UserWithProfile
-  ): Promise<ApiResponse<ConnectedApps>> {
-    const conferencingApps = await this.conferencingService.getUserConferencingApps(user);
-    return {
-      status: SUCCESS_STATUS,
-      data: conferencingApps,
-    };
-  }
   @Get("/organizations/:orgId/teams/:teamId/members-matching-attribute")
   @Version(VERSION_NEUTRAL)
   @UseGuards(ApiAuthGuard)

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

@@ -0,0 +1,210 @@
+import { GetEventTypePublicOutput } from "@/ee/event-types/event-types_2024_04_15/outputs/get-event-type-public.output";
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import {
+  BulkUpdateEventTypeToDefaultLocationDto,
+  EventTypesAppInput,
+} from "@/modules/atoms/inputs/event-types-app.input";
+import { GetAtomPublicEventTypeQueryParams } from "@/modules/atoms/inputs/get-atom-public-event-type-query-params.input";
+import { EventTypesAtomService } from "@/modules/atoms/services/event-types-atom.service";
+import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
+import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PlatformPlanGuard } from "@/modules/auth/guards/billing/platform-plan.guard";
+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 { UserWithProfile } from "@/modules/users/users.repository";
+import {
+  Controller,
+  Get,
+  Param,
+  ParseIntPipe,
+  UseGuards,
+  Version,
+  VERSION_NEUTRAL,
+  Patch,
+  Body,
+  Query,
+} from "@nestjs/common";
+import { ApiTags as DocsTags, ApiExcludeController as DocsExcludeController } from "@nestjs/swagger";
+
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
+import type { UpdateEventTypeReturn } from "@calcom/platform-libraries/event-types";
+import { PublicEventType } from "@calcom/platform-libraries/event-types";
+import { ApiResponse } from "@calcom/platform-types";
+
+/*
+Event-types endpoints for atoms, split from AtomsController for clarity and maintainability.
+These endpoints should not be recommended for use by third party and are excluded from docs.
+*/
+
+@Controller({
+  path: "/v2/atoms",
+  version: API_VERSIONS_VALUES,
+})
+@DocsTags("Atoms - event-types endpoints for atoms")
+@DocsExcludeController(true)
+export class AtomsEventTypesController {
+  constructor(private readonly eventTypesService: EventTypesAtomService) {}
+
+  @Get("/event-types/:eventSlug/public")
+  async getPublicEventType(
+    @Param("eventSlug") eventSlug: string,
+    @Query() queryParams: GetAtomPublicEventTypeQueryParams
+  ): Promise<ApiResponse<PublicEventType>> {
+    const { username, teamId, orgId, isTeamEvent } = queryParams;
+
+    const event = await this.eventTypesService.getPublicEventTypeForAtoms({
+      username,
+      eventSlug,
+      isTeamEvent: isTeamEvent ?? false,
+      teamId,
+      orgId,
+    });
+
+    return {
+      data: event,
+      status: SUCCESS_STATUS,
+    };
+  }
+
+  @Get("event-types/:eventTypeId")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async getAtomEventType(
+    @GetUser() user: UserWithProfile,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number
+  ): Promise<ApiResponse<unknown>> {
+    const eventType = await this.eventTypesService.getUserEventType(user, eventTypeId);
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
+
+  @Get("/organizations/:orgId/teams/:teamId/event-types")
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  @Version(VERSION_NEUTRAL)
+  async listTeamEventTypes(@Param("teamId", ParseIntPipe) teamId: number): Promise<ApiResponse<unknown>> {
+    const eventTypes = await this.eventTypesService.getTeamEventTypes(teamId);
+    return {
+      status: SUCCESS_STATUS,
+      data: eventTypes,
+    };
+  }
+
+  @Get("/event-types")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async listUserEventTypes(@GetUser("id") userId: number): Promise<ApiResponse<unknown>> {
+    const eventTypes = await this.eventTypesService.getUserEventTypes(userId);
+    return {
+      status: SUCCESS_STATUS,
+      data: eventTypes,
+    };
+  }
+
+  @Get("event-types-app/:appSlug")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async getAtomEventTypeApp(
+    @GetUser() user: UserWithProfile,
+    @Param("appSlug") appSlug: string,
+    @Query() queryParams: EventTypesAppInput
+  ): Promise<ApiResponse<unknown>> {
+    const { teamId } = queryParams;
+    const app = await this.eventTypesService.getEventTypesAppIntegration(appSlug, user, teamId);
+    return {
+      status: SUCCESS_STATUS,
+      data: {
+        app,
+      },
+    };
+  }
+
+  @Get("payment/:uid")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async getUserPaymentInfoById(@Param("uid") uid: string): Promise<ApiResponse<unknown>> {
+    const data = await this.eventTypesService.getUserPaymentInfo(uid);
+    return {
+      status: SUCCESS_STATUS,
+      data,
+    };
+  }
+
+  @Patch("/event-types/bulk-update-to-default-location")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async bulkUpdateAtomEventTypes(
+    @GetUser() user: UserWithProfile,
+    @Body() body: BulkUpdateEventTypeToDefaultLocationDto
+  ): Promise<{ status: typeof SUCCESS_STATUS | typeof ERROR_STATUS }> {
+    await this.eventTypesService.bulkUpdateEventTypesDefaultLocation(user, body.eventTypeIds);
+    return {
+      status: SUCCESS_STATUS,
+    };
+  }
+
+  @Patch("/organizations/:orgId/teams/:teamId/event-types/bulk-update-to-default-location")
+  @Version(VERSION_NEUTRAL)
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  async bulkUpdateAtomTeamEventTypes(
+    @GetUser() user: UserWithProfile,
+    @Body() body: BulkUpdateEventTypeToDefaultLocationDto,
+    @Param("teamId", ParseIntPipe) teamId: number
+  ): Promise<{ status: typeof SUCCESS_STATUS | typeof ERROR_STATUS }> {
+    await this.eventTypesService.bulkUpdateTeamEventTypesDefaultLocation(body.eventTypeIds, teamId);
+    return {
+      status: SUCCESS_STATUS,
+    };
+  }
+
+  @Patch("event-types/:eventTypeId")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  async updateAtomEventType(
+    @GetUser() user: UserWithProfile,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Body() body: UpdateEventTypeReturn
+  ): Promise<ApiResponse<UpdateEventTypeReturn>> {
+    const eventType = await this.eventTypesService.updateEventType(
+      eventTypeId,
+      { ...body, id: eventTypeId },
+      user
+    );
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
+
+  @Patch("/organizations/:orgId/teams/:teamId/event-types/:eventTypeId")
+  @Version(VERSION_NEUTRAL)
+  @Roles("TEAM_ADMIN")
+  @PlatformPlan("ESSENTIALS")
+  @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+  async updateAtomTeamEventType(
+    @GetUser() user: UserWithProfile,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Body() body: UpdateEventTypeReturn
+  ): Promise<ApiResponse<UpdateEventTypeReturn>> {
+    const eventType = await this.eventTypesService.updateTeamEventType(
+      eventTypeId,
+      { ...body, id: eventTypeId },
+      user,
+      teamId
+    );
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
+}

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

@@ -0,0 +1,86 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { GetAtomSchedulesQueryParams } from "@/modules/atoms/inputs/get-atom-schedules-query-params.input";
+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 { UserWithProfile } from "@/modules/users/users.repository";
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Query,
+  UseGuards,
+  Version,
+  VERSION_NEUTRAL,
+} from "@nestjs/common";
+import {
+  ApiTags as DocsTags,
+  ApiExcludeController as DocsExcludeController,
+  ApiOperation,
+} from "@nestjs/swagger";
+
+import { SCHEDULE_READ, SCHEDULE_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
+import { FindDetailedScheduleByIdReturnType } from "@calcom/platform-libraries/schedules";
+import { ApiResponse, UpdateAtomScheduleDto } from "@calcom/platform-types";
+
+import { SchedulesAtomsService } from "../services/schedules-atom.service";
+
+/*
+Endpoints used only by platform atoms, reusing code from other modules, data is already formatted and ready to be used by frontend atoms
+these endpoints should not be recommended for use by third party and are excluded from docs
+*/
+
+@Controller({
+  path: "/v2/atoms",
+  version: API_VERSIONS_VALUES,
+})
+@DocsTags("Atoms - endpoints for atoms")
+@DocsExcludeController(true)
+export class AtomsSchedulesController {
+  constructor(private readonly schedulesService: SchedulesAtomsService) {}
+
+  @Get("/schedules")
+  @Version(VERSION_NEUTRAL)
+  @UseGuards(ApiAuthGuard)
+  @Permissions([SCHEDULE_READ])
+  async getSchedule(
+    @GetUser() user: UserWithProfile,
+    @Query() queryParams: GetAtomSchedulesQueryParams
+  ): Promise<ApiResponse<FindDetailedScheduleByIdReturnType | null>> {
+    const { isManagedEventType, scheduleId } = queryParams;
+    const schedule = await this.schedulesService.getSchedule({
+      scheduleId,
+      userId: user.id,
+      timeZone: user.timeZone,
+      isManagedEventType,
+    });
+
+    return {
+      status: SUCCESS_STATUS,
+      data: schedule,
+    };
+  }
+  @Patch("schedules/:scheduleId")
+  @Permissions([SCHEDULE_WRITE])
+  @UseGuards(ApiAuthGuard)
+  @ApiOperation({ summary: "Update atom schedule" })
+  async updateSchedule(
+    @GetUser() user: UserWithProfile,
+    @Body() bodySchedule: UpdateAtomScheduleDto,
+    @Param("scheduleId", ParseIntPipe) scheduleId: number
+  ): Promise<ApiResponse<any>> {
+    const updatedSchedule = await this.schedulesService.updateUserSchedule({
+      user,
+      input: bodySchedule,
+      scheduleId,
+    });
+
+    return {
+      status: SUCCESS_STATUS,
+      data: updatedSchedule,
+    };
+  }
+}

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

@@ -1,12 +1,12 @@
-import { ApiPropertyOptional } from "@nestjs/swagger";
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
 
 import type { TFindTeamMembersMatchingAttributeLogicInputSchema } from "@calcom/platform-libraries";
 
 export class FindTeamMembersMatchingAttributeQueryDto {
-  @ApiPropertyOptional({
+  @ApiProperty({
     nullable: true,
   })
-  attributesQueryValue: TFindTeamMembersMatchingAttributeLogicInputSchema["attributesQueryValue"];
+  attributesQueryValue!: TFindTeamMembersMatchingAttributeLogicInputSchema["attributesQueryValue"] | null;
 
   @ApiPropertyOptional({
     type: Boolean,

apps/api/v2/src/modules/atoms/inputs/get-atom-public-event-type-query-params.input.ts

@@ -0,0 +1,28 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform, Type } from "class-transformer";
+import { IsBoolean, IsOptional, IsString, IsNumber } from "class-validator";
+
+export class GetAtomPublicEventTypeQueryParams {
+  @Transform(({ value }: { value: string }) => value === "true")
+  @IsBoolean()
+  @IsOptional()
+  @ApiPropertyOptional()
+  isTeamEvent?: boolean;
+
+  @IsOptional()
+  @Transform(({ value }: { value: string }) => value && parseInt(value))
+  @IsNumber()
+  @ApiPropertyOptional({ type: Number })
+  teamId?: number;
+
+  @IsOptional()
+  @Transform(({ value }: { value: string }) => value && parseInt(value))
+  @IsNumber()
+  @ApiPropertyOptional({ type: Number })
+  orgId?: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ type: String })
+  username?: string;
+}

apps/api/v2/src/modules/atoms/inputs/get-atom-schedules-query-params.input.ts

@@ -0,0 +1,15 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform } from "class-transformer";
+import { IsBoolean, IsOptional } from "class-validator";
+
+export class GetAtomSchedulesQueryParams {
+  @IsOptional()
+  @Transform(({ value }: { value: string }) => value && parseInt(value))
+  @ApiPropertyOptional({ type: Number })
+  scheduleId?: number;
+
+  @IsOptional()
+  @IsBoolean()
+  @ApiPropertyOptional({ type: Boolean })
+  isManagedEventType?: boolean;
+}

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

@@ -1,4 +1,5 @@
 import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
+import { systemBeforeFieldEmail } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { AtomsRepository } from "@/modules/atoms/atoms.repository";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
@@ -7,7 +8,7 @@ import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { TeamsEventTypesService } from "@/modules/teams/event-types/services/teams-event-types.service";
 import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
-import { Injectable, NotFoundException, ForbiddenException } from "@nestjs/common";
+import { Injectable, NotFoundException, ForbiddenException, BadRequestException } from "@nestjs/common";
 
 import { checkAdminOrOwner, getClientSecretFromPayment } from "@calcom/platform-libraries";
 import type { TeamQuery } from "@calcom/platform-libraries";
@@ -21,6 +22,7 @@ import type {
   CredentialDataWithTeamName,
   LocationOption,
 } from "@calcom/platform-libraries/app-store";
+import { type PublicEventType, getPublicEvent } from "@calcom/platform-libraries/event-types";
 import {
   getEventTypeById,
   bulkUpdateEventsToDefaultLocation,
@@ -31,7 +33,6 @@ import {
 import {
   updateEventType,
   TUpdateEventTypeInputSchema,
-  systemBeforeFieldEmail,
   EventTypeMetaDataSchema,
 } from "@calcom/platform-libraries/event-types";
 import { PrismaClient } from "@calcom/prisma";
@@ -55,6 +56,18 @@ export class EventTypesAtomService {
     private readonly teamEventTypeService: TeamsEventTypesService
   ) {}
 
+  private async getTeamSlug(teamId: number): Promise<string> {
+    const team = await this.dbRead.prisma.team.findUnique({
+      where: { id: teamId },
+      select: { slug: true },
+    });
+
+    if (!team?.slug) {
+      throw new NotFoundException(`Team with id ${teamId} not found`);
+    }
+    return team.slug;
+  }
+
   async getUserEventType(user: UserWithProfile, eventTypeId: number) {
     const organizationId = this.usersService.getUserMainOrgId(user);
 
@@ -226,20 +239,26 @@ export class EventTypesAtomService {
       } else {
         credentials = credentials.concat(teamAppCredentials);
       }
+    } else {
+      if (slug !== "stripe") {
+        // We only add delegationCredentials if the request for location options is for a user because DelegationCredential Credential is applicable to Users only.
+        const { credentials: allCredentials } =
+          await enrichUserWithDelegationConferencingCredentialsWithoutOrgId({
+            user: {
+              ...user,
+              credentials,
+            },
+          });
+        credentials = allCredentials;
+      }
     }
-    // We only add delegationCredentials if the request for location options is for a user because DelegationCredential Credential is applicable to Users only.
-    const { credentials: allCredentials } = await enrichUserWithDelegationConferencingCredentialsWithoutOrgId(
+
+    const enabledApps = await getEnabledAppsFromCredentials(
+      credentials as unknown as CredentialDataWithTeamName[],
       {
-        user: {
-          ...user,
-          credentials,
-        },
+        where: { slug },
       }
     );
-    credentials = allCredentials;
-    const enabledApps = await getEnabledAppsFromCredentials(allCredentials, {
-      where: { slug },
-    });
     const apps = await Promise.all(
       enabledApps
         .filter(({ ...app }) => app.slug === slug)
@@ -363,4 +382,61 @@ export class EventTypesAtomService {
       teamId,
     });
   }
+  /**
+   * Returns the public event type for atoms, handling both team and user events.
+   */
+  async getPublicEventTypeForAtoms({
+    username,
+    eventSlug,
+    isTeamEvent,
+    orgId,
+    teamId,
+  }: {
+    username?: string;
+    eventSlug: string;
+    isTeamEvent?: boolean;
+    orgId?: number;
+    teamId?: number;
+  }): Promise<PublicEventType> {
+    const orgSlug = orgId ? await this.getTeamSlug(orgId) : null;
+
+    let slug: string | null = null;
+    if (isTeamEvent) {
+      if (!teamId) {
+        throw new BadRequestException("teamId is required for team events, please provide a valid teamId");
+      }
+      slug = await this.getTeamSlug(teamId);
+    } else {
+      if (!username) {
+        throw new BadRequestException(
+          "username is required for non-team events, please provide a valid username"
+        );
+      }
+      slug = username;
+    }
+
+    const slugLower = slug.toLowerCase();
+
+    try {
+      const event = await getPublicEvent(
+        slugLower,
+        eventSlug,
+        isTeamEvent,
+        orgSlug,
+        this.dbRead.prisma as unknown as PrismaClient,
+        true
+      );
+
+      if (!event) {
+        throw new NotFoundException(`Event type with slug ${eventSlug} not found`);
+      }
+
+      return event;
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new NotFoundException(err.message);
+      }
+      throw new NotFoundException(`Event type with slug ${eventSlug} not found`);
+    }
+  }
 }

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

@@ -0,0 +1,63 @@
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { UsersRepository } from "@/modules/users/users.repository";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { Logger } from "@nestjs/common";
+import { Injectable } from "@nestjs/common";
+
+import { ScheduleRepository, UpdateScheduleResponse } from "@calcom/platform-libraries/schedules";
+import { updateSchedule } from "@calcom/platform-libraries/schedules";
+import { UpdateAtomScheduleDto } from "@calcom/platform-types";
+import { PrismaClient } from "@calcom/prisma";
+
+@Injectable()
+export class SchedulesAtomsService {
+  private logger = new Logger("SchedulesAtomService");
+
+  constructor(
+    private readonly usersRepository: UsersRepository,
+    private readonly dbWrite: PrismaWriteService
+  ) {}
+
+  async getSchedule({
+    timeZone,
+    userId,
+    scheduleId,
+    isManagedEventType,
+  }: {
+    timeZone: string;
+    userId: number;
+    scheduleId?: number;
+    isManagedEventType?: boolean;
+  }) {
+    const user = await this.usersRepository.findById(userId);
+
+    if (!user?.defaultScheduleId) return null;
+
+    return await ScheduleRepository.findDetailedScheduleById({
+      scheduleId: scheduleId ?? user.defaultScheduleId,
+      isManagedEventType,
+      userId,
+      timeZone,
+      defaultScheduleId: user.defaultScheduleId,
+    });
+  }
+
+  async updateUserSchedule({
+    input,
+    user,
+    scheduleId,
+  }: {
+    input: UpdateAtomScheduleDto;
+    user: UserWithProfile;
+    scheduleId: number;
+  }): Promise<UpdateScheduleResponse> {
+    return updateSchedule({
+      input: {
+        scheduleId,
+        ...input,
+      },
+      user,
+      prisma: this.dbWrite.prisma as unknown as PrismaClient,
+    });
+  }
+}

apps/api/v2/src/modules/auth/guards/billing/platform-plan.guard.ts

@@ -1,6 +1,6 @@
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
 import { ApiAuthGuardUser } from "@/modules/auth/strategies/api-auth/api-auth.strategy";
-import { PlatformPlanType } from "@/modules/billing/types";
+import { PlatformPlanType, orderedPlans } from "@/modules/billing/types";
 import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
 import { RedisService } from "@/modules/redis/redis.service";
 import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from "@nestjs/common";
@@ -61,7 +61,7 @@ export class PlatformPlanGuard implements CanActivate {
       !hasMinimumPlan({
         currentPlan: organization.platformBilling?.plan as PlatformPlanType,
         minimumPlan: minimumPlan,
-        plans: ["FREE", "STARTER", "ESSENTIALS", "SCALE", "ENTERPRISE"],
+        plans: orderedPlans,
       })
     ) {
       throw new ForbiddenException(
@@ -79,7 +79,7 @@ export class PlatformPlanGuard implements CanActivate {
 type HasMinimumPlanProp = {
   currentPlan: PlatformPlanType;
   minimumPlan: PlatformPlanType;
-  plans: PlatformPlanType[];
+  plans: readonly PlatformPlanType[];
 };
 
 export function hasMinimumPlan(props: HasMinimumPlanProp): boolean {
@@ -87,7 +87,7 @@ export function hasMinimumPlan(props: HasMinimumPlanProp): boolean {
   const minimumPlanIndex = props.plans.indexOf(props.minimumPlan);
 
   if (currentPlanIndex === -1 || minimumPlanIndex === -1) {
-    throw new Error(
+    throw new ForbiddenException(
       `PlatformPlanGuard - Invalid platform billing plan provided. Current plan: ${props.currentPlan}, Minimum plan: ${props.minimumPlan}`
     );
   }

apps/api/v2/src/modules/auth/guards/workflows/is-workflow-in-team.ts

@@ -0,0 +1,56 @@
+import { WorkflowsRepository, WorkflowType } from "@/modules/workflows/workflows.repository";
+import {
+  Injectable,
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  NotFoundException,
+} from "@nestjs/common";
+import { Request } from "express";
+
+@Injectable()
+export class IsWorkflowInTeam implements CanActivate {
+  constructor(private workflowsRepository: WorkflowsRepository) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request & { workflow?: WorkflowType }>();
+    const teamId: string = request.params.teamId;
+    const workflowId: string = request.params.workflowId;
+
+    if (!workflowId) {
+      throw new ForbiddenException("IsWorkflowInTeam - No workflow found in request params.");
+    }
+
+    if (!teamId) {
+      throw new ForbiddenException("IsWorkflowInTeam - No team id found in request params.");
+    }
+
+    const { canAccess, workflow } = await this.checkIfWorkflowIsInTeam(teamId, workflowId);
+
+    if (!canAccess) {
+      throw new ForbiddenException(
+        `IsTeamInOrg - Workflow with id=${workflowId} is not part of the team with id=${teamId}.`
+      );
+    }
+
+    request.workflow = workflow;
+    return true;
+  }
+
+  async checkIfWorkflowIsInTeam(
+    teamId: string,
+    workflowId: string
+  ): Promise<{ canAccess: boolean; workflow?: WorkflowType }> {
+    const workflow = await this.workflowsRepository.getTeamWorkflowById(Number(teamId), Number(workflowId));
+
+    if (!workflow) {
+      throw new NotFoundException(`IsWorkflowInTeam - workflow (${workflowId}) not found.`);
+    }
+
+    if (workflow.teamId === Number(teamId)) {
+      return { canAccess: true, workflow };
+    }
+
+    return { canAccess: false };
+  }
+}

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

@@ -124,6 +124,9 @@ export class BillingController {
       case "checkout.session.completed":
         await this.billingService.handleStripeCheckoutEvents(event);
         break;
+      case "customer.subscription.updated":
+        await this.billingService.handleStripePaymentPastDue(event);
+        break;
       case "customer.subscription.deleted":
         await this.billingService.handleStripeSubscriptionDeleted(event);
         break;

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

@@ -216,6 +216,30 @@ export class BillingService implements OnModuleDestroy {
     }
   }
 
+  async handleStripePaymentPastDue(event: Stripe.Event) {
+    const invoice = event.data.object as Stripe.Invoice;
+    const subscriptionId = this.getSubscriptionIdFromInvoice(invoice);
+    const customerId = this.getCustomerIdFromInvoice(invoice);
+
+    if (subscriptionId && customerId) {
+      const existingUserSubscription = await this.stripeService
+        .getStripe()
+        .subscriptions.retrieve(subscriptionId);
+
+      if (existingUserSubscription.status === "past_due") {
+        await this.billingRepository.updateBillingOverdue(subscriptionId, customerId, true);
+      }
+
+      if (existingUserSubscription.status === "active") {
+        await this.billingRepository.updateBillingOverdue(subscriptionId, customerId, false);
+      }
+    }
+
+    if (!subscriptionId || !customerId) {
+      this.logger.log(`SubscriptionId: ${subscriptionId} or customerId: ${customerId} missing`);
+    }
+  }
+
   async handleStripeCheckoutEvents(event: Stripe.Event) {
     const checkoutSession = event.data.object as Stripe.Checkout.Session;
 

apps/api/v2/src/modules/billing/types.ts

@@ -7,4 +7,13 @@ export enum PlatformPlan {
   PER_ACTIVE_USER = "PER_ACTIVE_USER",
 }
 
-export type PlatformPlanType = "FREE" | "STARTER" | "ESSENTIALS" | "SCALE" | "ENTERPRISE" | "PER_ACTIVE_USER";
+export const orderedPlans = [
+  "FREE",
+  "STARTER",
+  "ESSENTIALS",
+  "SCALE",
+  "PER_ACTIVE_USER",
+  "ENTERPRISE",
+] as const;
+
+export type PlatformPlanType = (typeof orderedPlans)[number];