chore: version packages (#22813)

* chore: version packages

* Update CHANGELOG.md

* Update package.json

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Lauris Skraucis <lauris.skraucis@gmail.com>

.changeset/config.json

@@ -7,7 +7,7 @@
   "access": "public",
   "baseBranch": "main",
   "updateInternalDependencies": "patch",
-  "ignore": [],
+  "ignore": ["@calcom/platform-libraries"],
   "privatePackages": {
     "version": false,
     "tag": false

.cursor/rules/review.mdc

@@ -0,0 +1,36 @@
+# Review Instructions
+
+## File Naming Conventions
+
+- **Repository Files**: Must include `Repository` suffix, prefix with technology if applicable (e.g., `PrismaAppRepository.ts`), use PascalCase matching exported class
+- **Service Files**: Must include `Service` suffix, use PascalCase matching exported class, avoid generic names (e.g., `MembershipService.ts`)
+- **New files**: Avoid dot-suffixes like `.service.ts` or `.repository.ts`; reserve `.test.ts`, `.spec.ts`, `.types.ts` for their specific purposes
+
+## Code Quality
+
+- Prefer early returns. It is recommended to throw/return early so we can ensure null-checks and prevent further nesting.
+- Prefer Composition over Prop Drilling. Instead of relying on prop drilling, let's try to take advantage of react children feature.
+- For Prisma queries:
+  - Only select data you need
+    1) Increased performance overhead: When you select all columns from a table, Prisma retrieves all the data associated with each row, which can result in a significant performance impact. This includes reading unnecessary columns and transferring a large volume of data between your application and the database.
+    2) Unnecessary data exposure: Selecting all columns exposes sensitive data that might not be required by your application. This can pose security risks, especially if the table contains sensitive user information or proprietary data. (In our case app credentials and booking information)
+  - TLDR: Never use Includes - use select
+  - Select selects only the fields you specify explicitly
+  - Include selects the relationship AND all the fields of the table the relationship belongs to
+  - Make sure the credential.key field is never returned back from tRPC endpoints or APIs
+- Always use t() for text localization in frontend code; direct text embedding should trigger a warning.
+- Check if there's any O(n^2) logic in backend code; we should aim for O(n log n) or O(n) ideally.
+- Check if there are circular references introduced. We should never allow these.
+- Flag excessive Day.js use in performance-critical code. Functions like `.add`, `.diff`, `.isBefore`, and `.isAfter` are slow, especially in timezone mode. Prefer `.utc()` for better performance. Where possible, replace with native Date and direct `.valueOf()` comparisons for faster execution. Recommend using native methods or Day.js `.utc()` consistently in hot paths like loops.
+- When docs changes are made in /docs/api-reference/v2/openapi.json, ensure the following
+  - "summary" fields are short and concise
+  - "summary" fields do not end with a period
+  - "summary" fields are written in proper American english
+- When changes to API v2 or v1 are made, ensure there are no breaking changes on existing endpoints. Instead, there needs to be a newly versioned endpoint with the updated functionality but the old one must remain functional
+- For large pull requests (>500 lines changed or >10 files touched), advise splitting into smaller, focused PRs:
+  - Split by feature boundaries: separate different features or user stories
+  - Split by layer/component: frontend changes, backend changes, database migrations, and tests in separate PRs
+  - Split by dependency chain: create PRs that can be merged sequentially
+  - Split by file/module: group related file changes together
+  - Suggested pattern: Database migrations → Backend logic → Frontend components → Integration tests
+  - Benefits: easier review, faster feedback, reduced conflicts, easier rollback, better history

.env.example

@@ -164,6 +164,7 @@ SENTRY_PROJECT=
 SENTRY_AUTH_TOKEN=
 # Used for capturing exceptions and logging messages
 NEXT_PUBLIC_SENTRY_DSN=
+NEXT_PUBLIC_SENTRY_DSN_CLIENT=
 SENTRY_DEBUG=
 SENTRY_MAX_SPANS=
 SENTRY_SAMPLE_RATE=

.github/CODEOWNERS

@@ -17,13 +17,15 @@
 /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
 /packages/lib/server/getLuckyUser.ts @calcom/Foundation
 /packages/lib/slots.ts @calcom/Foundation
+/packages/platform/atoms/**/*WebWrapper.tsx @calcom/Consumer
 /packages/platform/**/* @calcom/Platform @calcom/Foundation
-/packages/prisma/**/* @calcom/Foundation
+/packages/prisma/**/* @calcom/DBA
 /packages/trpc/server/routers/viewer/bookings/confirm.handler.ts @calcom/Foundation
 /packages/trpc/server/routers/viewer/bookings/get.handler.ts @calcom/Foundation
 /packages/trpc/server/routers/viewer/slots/**/* @calcom/Foundation

.github/workflows/changesets.yml

@@ -15,7 +15,7 @@ jobs:
       contents: write # to create release by changesets/action below
       pull-requests: write # to create pull request by changesets/action below
     name: Release
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - name: Checkout Repo
         uses: actions/checkout@v4
@@ -34,4 +34,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          VITE_BOOKER_EMBED_OAUTH_CLIENT_ID: ${{ secrets.VITE_BOOKER_EMBED_OAUTH_CLIENT_ID }}
+          VITE_BOOKER_EMBED_API_URL: ${{ secrets.VITE_BOOKER_EMBED_API_URL }}
+          NEXT_PUBLIC_WEBAPP_URL: ${{ secrets.NEXT_PUBLIC_WEBAPP_URL }}

.github/workflows/draft-release.yml

@@ -27,8 +27,24 @@ jobs:
 
       - name: Configure git
         run: |
-          git config --local user.email "github-actions@github.com"
-          git config --local user.name "GitHub Actions"
+          # Define authorized users and their emails using organization secret
+          # Expected format: JSON object with username -> email mapping
+          # Example: {"zomars": "zomars@cal.com", "peer": "peer@cal.com", "username3": "email3@cal.com"}
+          USER_EMAILS='${{ secrets.RELEASE_USER_EMAILS }}'
+          
+          # Extract email for the triggering user
+          USER_EMAIL=$(echo "$USER_EMAILS" | jq -r --arg user "${{ github.actor }}" '.[$user] // empty')
+          
+          # Fail if user is not authorized or not in mapping
+          if [ -z "$USER_EMAIL" ] || [ "$USER_EMAIL" = "null" ]; then
+            echo "Error: User '${{ github.actor }}' is not authorized to run the release workflow."
+            echo "Only authorized team members can trigger releases."
+            echo "Contact your administrator to be added to the authorized users list."
+            exit 1
+          fi
+          
+          git config --local user.email "$USER_EMAIL"
+          git config --local user.name "${{ github.actor }}"
 
       - uses: ./.github/actions/yarn-install
 

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

@@ -26,7 +26,7 @@ jobs:
   e2e:
     timeout-minutes: 20
     name: E2E API v2
-    runs-on: buildjet-8vcpu-ubuntu-2204
+    runs-on: buildjet-16vcpu-ubuntu-2204
     services:
       postgres:
         image: postgres:13

.github/workflows/i18n.yml

@@ -17,6 +17,10 @@ jobs:
       pull-requests: write
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
       - uses: lingodotdev/lingo.dev@main
         env:
           GH_TOKEN: ${{ secrets.GH_ACCESS_TOKEN }}

.github/workflows/labeler.yml

@@ -26,7 +26,7 @@ jobs:
         with:
           repo-token: ${{ secrets.EQUITY_BEE_TEAM_LABELER_ACTION_TOKEN }}
           organization-name: calcom
-          ignore-labels: "admin, app-store, ai, authentication, automated-testing, devops, billing, bookings, caldav, calendar-apps, ci, console, crm-apps, docs, documentation, emails, embeds, event-types, i18n, impersonation, manual-testing, ui, performance, ops-stack, organizations, public-api, routing-forms, seats, teams, webhooks, workflows, zapier"
+          ignore-labels: "admin, app-store, ai, authentication, automated-testing, billing, bookings, caldav, calendar-apps, ci, console, crm-apps, dba, devops, docs, documentation, emails, embeds, event-types, i18n, impersonation, manual-testing, ui, performance, ops-stack, organizations, public-api, routing-forms, seats, teams, webhooks, workflows, zapier"
   apply-labels-from-issue:
     runs-on: ubuntu-latest
 

.github/workflows/pr.yml

@@ -46,7 +46,7 @@ jobs:
     permissions:
       pull-requests: read
     outputs:
-      run-e2e: ${{ steps.check-if-pr-has-label.outputs.run-e2e == 'true' && (github.event.action != 'labeled' || (github.event.action == 'labeled' && github.event.label.name == 'ready-for-e2e')) }}
+      run-e2e: ${{ steps.check-if-pr-has-label.outputs.run-e2e == 'true' && (github.event.action != 'labeled' || github.event.label.name == 'ready-for-e2e') }}
     steps:
       - name: Check if PR exists with ready-for-e2e label for this SHA
         id: check-if-pr-has-label

.yarn/versions/09fae648.yml

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

.yarn/versions/0de8a967.yml

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

.yarn/versions/1085cfbb.yml

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

.yarn/versions/178162d8.yml

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

.yarn/versions/2324e59b.yml

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

.yarn/versions/23ae8c6d.yml

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

.yarn/versions/26346cfc.yml

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

.yarn/versions/2992178c.yml

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

.yarn/versions/34be8820.yml

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

.yarn/versions/68190699.yml

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

.yarn/versions/74629f39.yml

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

.yarn/versions/95b6ac81.yml

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

.yarn/versions/98703c4b.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/a1693f8b.yml

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

.yarn/versions/a34274f5.yml

@@ -0,0 +1,3 @@
+undecided:
+  - calcom-monorepo
+  - "@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/b1103ee7.yml

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

.yarn/versions/c08cbab0.yml

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

.yarn/versions/df39e9bf.yml

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

.yarn/versions/e5255dda.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/f164e842.yml

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

.yarn/versions/fc9f64e8.yml

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

CONTRIBUTING.md

@@ -95,6 +95,57 @@ Write with the future in mind. If there are trade-offs, edge cases, or temporary
   </tr>
 </table>
 
+## File Naming Conventions
+
+To ensure consistency and make files easy to fuzzy-find, we follow the naming conventions below for **services**, **repositories**, and other class-based files.
+
+### Repository Files
+
+- Repository class files must include the `Repository` suffix.
+- If the repository is backed by a specific technology (e.g. Prisma), prefix the filename and class name with it.
+- File name must match the exported class exactly (PascalCase).
+
+**Pattern:**
+
+`Prisma<Entity>Repository.ts`
+
+**Examples:**
+
+```ts
+// File: PrismaAppRepository.ts
+export class PrismaAppRepository { ... }
+
+// File: PrismaMembershipRepository.ts
+export class PrismaMembershipRepository { ... }
+```
+
+This avoids ambiguous filenames like app.ts and improves discoverability in editors.
+
+### Service Files
+
+- Service class files must include the Service suffix.
+- File name should be in PascalCase, matching the exported class.
+- Keep naming specific — avoid generic names like AppService.ts.
+
+**Pattern:**
+
+`<Entity>Service.ts`
+
+**Examples:**
+
+```ts
+// File: MembershipService.ts
+export class MembershipService { ... }
+
+// File: HashedLinkService.ts
+export class HashedLinkService { ... }
+```
+
+**Note:**
+
+- New files must avoid dot-suffixes like .service.ts or .repository.ts; these will be migrated from the existing codebase progressively.
+- We still reserve suffixes such as .test.ts, .spec.ts, and .types.ts for their respective use cases.
+
 ## Developing
 
 [See README](https://github.com/calcom/cal.com#development)

README.md

@@ -80,6 +80,8 @@ That's where Cal.com comes in. Self-hosted or hosted by us. White-label by desig
 
 <a href="https://producthunt.com/posts/calendso?utm_source=badge-top-post-badge&utm_medium=badge&utm_souce=badge-calendso" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=291910&theme=light&period=monthly" alt="Cal.com - The open source Calendly alternative | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a> <a href="https://producthunt.com/posts/calendso?utm_source=badge-featured&utm_medium=badge&utm_souce=badge-calendso" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=291910&theme=light" alt="Cal.com - The open source Calendly alternative | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a> <a href="https://producthunt.com/stories/how-this-open-source-calendly-alternative-rocketed-to-product-of-the-day" target="_blank"><img src="https://cal.com/maker-grant.svg" alt="Cal.com - The open source Calendly alternative | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
 
+This project is tested with browserstack
+
 ### Built With
 
 - [Next.js](https://nextjs.org/?ref=cal.com)
@@ -488,13 +490,8 @@ Don't code but still want to contribute? Join our [Discussions](https://github.c
 - Set CSP_POLICY="non-strict" env variable, which enables [Strict CSP](https://web.dev/strict-csp/) except for unsafe-inline in style-src . If you have some custom changes in your instance, you might have to make some code change to make your instance CSP compatible. Right now it enables strict CSP only on login page and on other SSR pages it is enabled in Report only mode to detect possible issues. On, SSG pages it is still not supported.
 
 ## Single Org Mode
-If you want to have booker.yourcompany.com to be the domain used for both dashboard(e.g. https://booker.yourcompany.com/event-types) and booking pages(e.g. https://booker.yourcompany.com/john.joe/15min).
-- Set the `NEXT_PUBLIC_SINGLE_ORG_SLUG` environment variable to the slug of the organization you want to use. `NEXT_PUBLIC_SINGLE_ORG_SLUG=booker`
-- Set the `NEXT_PUBLIC_WEBAPP_URL` environment variable to the URL of the Cal.com self-hosted instance e.g. `NEXT_PUBLIC_WEBAPP_URL=https://booker.yourcompany.com`.
-- Set the `NEXT_PUBLIC_WEBSITE_URL` environment variable to the URL of the Cal.com self-hosted instance e.g. `NEXT_PUBLIC_WEBSITE_URL=https://booker.yourcompany.com`.
-- Set the `NEXTAUTH_URL` environment variable to the URL of the Cal.com self-hosted instance e.g. `NEXTAUTH_URL=https://booker.yourcompany.com`.
+Refer to docs [here](./docs/self-hosting/guides/organization/single-organization-setup) for a detailed documentation with screenshots.
 
-Note: It causes root to serve the dashboard and not the organization profile page which shows all bookable users in the organization.
 
 ## Integrations
 

__checks__/README.md

@@ -1,4 +1,6 @@
 # Checkly Tests
 
 Run as `yarn checkly test`
+Optionally, run as `yarn checkly test --record` to be able to get detailed debugging view in Checkly UI
+Run the tests for a particylar file as `yarn checkly test {filePattern}`
 Deploy the tests as `yarn checkly deploy`

__checks__/csp-login.spec.ts

@@ -0,0 +1,22 @@
+import { test, expect } from "@playwright/test";
+
+test.describe("CSP Headers", () => {
+  test("Login page should have CSP header with nonce", async ({ page }) => {
+    const targetUrl = process.env.ENVIRONMENT_URL || "https://app.cal.com";
+
+    const response = await page.goto(`${targetUrl}/auth/login`);
+
+    expect(response?.status()).toBe(200);
+
+    const cspHeader = response?.headers()["content-security-policy"];
+    expect(cspHeader).toBeTruthy();
+
+    // Verify nonce is present in CSP header
+    const nonceMatch = cspHeader?.match(/'nonce-([^']+)'/);
+    expect(nonceMatch).toBeTruthy();
+    expect(nonceMatch![1]).toHaveLength(24);
+    expect(nonceMatch![1]).toMatch(/==$/);
+
+    await page.screenshot({ path: "screenshot.jpg" });
+  });
+});

apps/api/package.json

@@ -3,6 +3,7 @@
   "version": "1.0.0",
   "description": "",
   "main": "index.js",
+  "private": true,
   "scripts": {
     "dev": "node ./index.js"
   },

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,25 +7,40 @@ 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 "./verifyApiKey";
 
-import { verifyApiKey } from "../../../lib/helpers/verifyApiKey";
+vi.mock("@calcom/lib/crypto", () => ({
+  symmetricDecrypt: vi.fn().mockReturnValue("mocked-decrypted-value"),
+  symmetricEncrypt: vi.fn().mockReturnValue("mocked-encrypted-value"),
+}));
 
 type CustomNextApiRequest = NextApiRequest & Request;
 type CustomNextApiResponse = NextApiResponse & Response;
 
+beforeEach(() => {
+  vi.stubEnv("CALENDSO_ENCRYPTION_KEY", "22gfxhWUlcKliUeXcu8xNah2+HP/29ZX");
+});
+
 afterEach(() => {
   vi.resetAllMocks();
+  vi.unstubAllEnvs();
 });
 
+const mockDeploymentRepository: IDeploymentRepository = {
+  getLicenseKeyWithId: vi.fn().mockResolvedValue("mockLicenseKey"), // Mocked return value
+  getSignatureToken: vi.fn().mockResolvedValue("mockSignatureToken"),
+};
+
 describe("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/user.ts

@@ -43,6 +43,7 @@ enum locales {
   SR = "sr",
   SV = "sv",
   VI = "vi",
+  BN = "bn",
 }
 enum theme {
   DARK = "dark",

apps/api/v1/next-env.d.ts

@@ -2,4 +2,4 @@
 /// <reference types="next/image-types/global" />
 
 // NOTE: This file should not be edited
-// see https://nextjs.org/docs/basic-features/typescript for more information.
+// see https://nextjs.org/docs/pages/api-reference/config/typescript for more information.

apps/api/v1/next.config.js

@@ -5,9 +5,6 @@ const plugins = [withAxiom];
 
 /** @type {import("next").NextConfig} */
 const nextConfig = {
-  experimental: {
-    instrumentationHook: true,
-  },
   transpilePackages: [
     "@calcom/app-store",
     "@calcom/dayjs",

apps/api/v1/package.json

@@ -33,12 +33,12 @@
     "@sentry/nextjs": "^9.15.0",
     "bcryptjs": "^2.4.3",
     "memory-cache": "^0.2.0",
-    "next": "^13.5.9",
+    "next": "^15.3.0",
     "next-api-middleware": "^1.0.1",
     "next-axiom": "^0.17.0",
     "next-swagger-doc": "^0.3.6",
     "next-validations": "^0.2.0",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.0-beta",
     "tzdata": "^1.0.30",
     "uuid": "^8.3.2",
     "zod": "^3.22.4"

apps/api/v1/pages/api/bookings/[id]/_get.ts

@@ -1,5 +1,7 @@
 import type { NextApiRequest } from "next";
 
+import { ErrorCode } from "@calcom/lib/errorCodes";
+import { ErrorWithCode } from "@calcom/lib/errors";
 import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import prisma from "@calcom/prisma";
 
@@ -106,6 +108,11 @@ export async function getHandler(req: NextApiRequest) {
       eventType: expand.includes("team") ? { include: { team: true } } : false,
     },
   });
+
+  if (!booking) {
+    throw new ErrorWithCode(ErrorCode.BookingNotFound, "Booking not found");
+  }
+
   return { booking: schemaBookingReadPublic.parse(booking) };
 }
 

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

@@ -222,6 +222,13 @@ async function handler(req: NextApiRequest) {
   };
   if (isSystemWideAdmin) userId = req.body.userId || userId;
 
+  if (req.body.eventTypeId !== undefined && typeof req.body.eventTypeId !== "number") {
+    throw new HttpError({
+      statusCode: 400,
+      message: "Bad request, eventTypeId must be a number",
+    });
+  }
+
   if (isOrganizationOwnerOrAdmin) {
     const accessibleUsersIds = await getAccessibleUsers({
       adminUserId: userId,
@@ -247,6 +254,14 @@ async function handler(req: NextApiRequest) {
       throw new HttpError({ statusCode: 400, message: knownError.message });
     }
 
+    if (knownError?.message === ErrorCode.RequestBodyInvalid) {
+      throw new HttpError({ statusCode: 400, message: knownError.message });
+    }
+
+    if (knownError?.message === ErrorCode.EventTypeNotFound) {
+      throw new HttpError({ statusCode: 400, message: knownError.message });
+    }
+
     throw error;
   }
 }

apps/api/v1/pages/api/connected-calendars/_get.ts

@@ -105,7 +105,9 @@ async function getHandler(req: NextApiRequest) {
 
   const userIds = req.query.userId ? extractUserIdsFromQuery(req) : [userId];
 
-  const usersWithCalendars = await UserRepository.findManyByIdsIncludeDestinationAndSelectedCalendars({
+  const usersWithCalendars = await new UserRepository(
+    prisma
+  ).findManyByIdsIncludeDestinationAndSelectedCalendars({
     ids: userIds,
   });
 

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/pages/api/slots/_get.ts

@@ -4,11 +4,11 @@ import type { NextApiRequest, NextApiResponse } from "next";
 
 import dayjs from "@calcom/dayjs";
 import { isSupportedTimeZone } from "@calcom/lib/dayjs";
+import { getAvailableSlotsService } from "@calcom/lib/di/containers/available-slots";
 import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server/defaultResponder";
 import { createContext } from "@calcom/trpc/server/createContext";
 import { getScheduleSchema } from "@calcom/trpc/server/routers/viewer/slots/types";
-import { getAvailableSlots } from "@calcom/trpc/server/routers/viewer/slots/util";
 
 import { TRPCError } from "@trpc/server";
 import { getHTTPStatusCodeFromError } from "@trpc/server/http";
@@ -27,7 +27,13 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
     }
     const input = getScheduleSchema.parse({ usernameList: slugs, isTeamEvent: parsedIsTeamEvent, ...rest });
     const timeZoneSupported = input.timeZone ? isSupportedTimeZone(input.timeZone) : false;
-    const availableSlots = await getAvailableSlots({ ctx: await createContext({ req, res }), input });
+
+    const availableSlotsService = getAvailableSlotsService();
+    const availableSlots = await availableSlotsService.getAvailableSlots({
+      ctx: await createContext({ req, res }),
+      input,
+    });
+
     const slotsInProvidedTimeZone = timeZoneSupported
       ? Object.keys(availableSlots.slots).reduce(
           (acc: Record<string, { time: string; attendees?: number; bookingUid?: string }[]>, date) => {

apps/api/v1/test/lib/bookings/[id]/_delete.test.ts

@@ -0,0 +1,184 @@
+import prismaMock from "../../../../../../../tests/libs/__mocks__/prismaMock";
+
+import type { Request, Response } from "express";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { createMocks } from "node-mocks-http";
+import { describe, expect, test, vi, afterEach, beforeEach } from "vitest";
+
+import { buildBooking, buildEventType } from "@calcom/lib/test/builder";
+
+import handler from "../../../../pages/api/bookings/[id]/_delete";
+
+vi.mock("@calcom/features/bookings/lib/handleCancelBooking", () => ({
+  default: vi.fn().mockResolvedValue({ success: true }),
+  handleCancelBooking: vi.fn().mockResolvedValue({ success: true }),
+}));
+
+type CustomNextApiRequest = NextApiRequest & Request;
+type CustomNextApiResponse = NextApiResponse & Response;
+
+const userId = 1;
+const bookingId = 123;
+
+beforeEach(() => {
+  prismaMock.user.findUnique.mockResolvedValue({
+    id: userId,
+    email: "test@example.com",
+    name: "Test User",
+  });
+});
+
+afterEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("DELETE /api/bookings/[id]", () => {
+  describe("Success", () => {
+    test("should cancel booking successfully", async () => {
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "DELETE",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          reason: "User requested cancellation",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+      const responseData = JSON.parse(res._getData());
+      expect(responseData.success).toBe(true);
+    });
+
+    test("should allow system-wide admin to cancel any booking", async () => {
+      const adminUserId = 999;
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "DELETE",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          reason: "Admin cancellation",
+        },
+      });
+
+      req.userId = adminUserId;
+      req.isSystemWideAdmin = true;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+    });
+  });
+
+  describe("Errors", () => {
+    test("should return 404 when booking not found", async () => {
+      prismaMock.booking.findUnique.mockResolvedValue(null);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "DELETE",
+        query: {
+          id: "999",
+        },
+        body: {
+          reason: "Test cancellation",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+    });
+
+    test("should return 400 for invalid booking ID", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "DELETE",
+        query: {
+          id: "invalid",
+        },
+        body: {
+          reason: "Test cancellation",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(400);
+    });
+
+    test("should return 403 when user doesn't have permission to cancel booking", async () => {
+      const otherUserId = 999;
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: otherUserId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "DELETE",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          reason: "Unauthorized cancellation",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+    });
+
+    test("should return 400 when required cancellation reason is missing", async () => {
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "DELETE",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {},
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+    });
+  });
+});

apps/api/v1/test/lib/bookings/[id]/_patch.test.ts

@@ -0,0 +1,263 @@
+import prismaMock from "../../../../../../../tests/libs/__mocks__/prismaMock";
+
+import type { Request, Response } from "express";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { createMocks } from "node-mocks-http";
+import { describe, expect, test, vi, afterEach, beforeEach } from "vitest";
+
+import { buildBooking, buildEventType } from "@calcom/lib/test/builder";
+
+import handler from "../../../../pages/api/bookings/[id]/_patch";
+
+type CustomNextApiRequest = NextApiRequest & Request;
+type CustomNextApiResponse = NextApiResponse & Response;
+
+const userId = 1;
+const bookingId = 123;
+
+beforeEach(() => {
+  prismaMock.user.findUnique.mockResolvedValue({
+    id: userId,
+    email: "test@example.com",
+    name: "Test User",
+  });
+});
+
+afterEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("PATCH /api/bookings/[id]", () => {
+  describe("Success", () => {
+    test("should update booking successfully", async () => {
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        title: "Original Title",
+        eventTypeId: buildEventType().id,
+      });
+
+      const updatedBooking = {
+        ...mockBooking,
+        title: "Updated Title",
+      };
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+      prismaMock.booking.update.mockResolvedValue(updatedBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          title: "Updated Title",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+      const responseData = JSON.parse(res._getData());
+      expect(responseData.booking.title).toBe("Updated Title");
+    });
+
+    test("should allow system-wide admin to update any booking", async () => {
+      const adminUserId = 999;
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        title: "Original Title",
+        eventTypeId: buildEventType().id,
+      });
+
+      const updatedBooking = {
+        ...mockBooking,
+        title: "Admin Updated Title",
+      };
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+      prismaMock.booking.update.mockResolvedValue(updatedBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          title: "Admin Updated Title",
+        },
+      });
+
+      req.userId = adminUserId;
+      req.isSystemWideAdmin = true;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+    });
+
+    test("should update booking times successfully", async () => {
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        startTime: new Date("2024-01-01T10:00:00Z"),
+        endTime: new Date("2024-01-01T11:00:00Z"),
+        eventTypeId: buildEventType().id,
+      });
+
+      const newStartTime = new Date("2024-01-01T14:00:00Z");
+      const newEndTime = new Date("2024-01-01T15:00:00Z");
+
+      const updatedBooking = {
+        ...mockBooking,
+        startTime: newStartTime,
+        endTime: newEndTime,
+      };
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+      prismaMock.booking.update.mockResolvedValue(updatedBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          startTime: newStartTime.toISOString(),
+          endTime: newEndTime.toISOString(),
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+      const responseData = JSON.parse(res._getData());
+      expect(new Date(responseData.booking.startTime)).toEqual(newStartTime);
+      expect(new Date(responseData.booking.endTime)).toEqual(newEndTime);
+    });
+  });
+
+  describe("Errors", () => {
+    test("should return 404 when booking not found", async () => {
+      prismaMock.booking.findUnique.mockResolvedValue(null);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: "999",
+        },
+        body: {
+          title: "Updated Title",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(400);
+    });
+
+    test("should return 400 for invalid booking ID", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: "invalid",
+        },
+        body: {
+          title: "Updated Title",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(400);
+    });
+
+    test("should return 403 when user doesn't have permission to update booking", async () => {
+      const otherUserId = 999;
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: otherUserId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          title: "Unauthorized Update",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(400);
+    });
+
+    test("should return 401 when non-admin tries to change userId", async () => {
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          userId: 999,
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(403);
+    });
+
+    test("should return 400 for invalid date format", async () => {
+      const mockBooking = buildBooking({
+        id: bookingId,
+        userId: userId,
+        eventTypeId: buildEventType().id,
+      });
+
+      prismaMock.booking.findUnique.mockResolvedValue(mockBooking);
+
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "PATCH",
+        query: {
+          id: bookingId.toString(),
+        },
+        body: {
+          startTime: "invalid-date",
+        },
+      });
+
+      req.userId = userId;
+
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(400);
+    });
+  });
+});

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

@@ -0,0 +1,362 @@
+import prismaMock from "../../../../../../tests/libs/__mocks__/prismaMock";
+
+import type { Request, Response } from "express";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { createMocks } from "node-mocks-http";
+import { describe, expect, test, vi, afterEach, beforeEach } from "vitest";
+import { ZodError } from "zod";
+
+import { buildBooking } from "@calcom/lib/test/builder";
+
+import {
+  getAccessibleUsers,
+  retrieveOrgScopedAccessibleUsers,
+} from "~/lib/utils/retrieveScopedAccessibleUsers";
+
+import { handler } from "../../../pages/api/bookings/_get";
+
+vi.mock("~/lib/utils/retrieveScopedAccessibleUsers", () => ({
+  getAccessibleUsers: vi.fn(),
+  retrieveOrgScopedAccessibleUsers: vi.fn(),
+}));
+
+type CustomNextApiRequest = NextApiRequest & Request;
+type CustomNextApiResponse = NextApiResponse & Response;
+
+const userId = 1;
+
+beforeEach(() => {
+  prismaMock.user.findUnique.mockResolvedValue({
+    id: userId,
+    email: "test@example.com",
+    name: "Test User",
+  });
+  (getAccessibleUsers as any).mockResolvedValue([userId]);
+  (retrieveOrgScopedAccessibleUsers as any).mockResolvedValue([userId]);
+
+  prismaMock.membership.findMany.mockResolvedValue([
+    {
+      team: {
+        id: 1,
+        isOrganization: true,
+      },
+    },
+  ]);
+
+  prismaMock.user.findMany.mockResolvedValue([
+    {
+      id: userId,
+      email: "test@example.com",
+    },
+  ]);
+});
+
+afterEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("GET /api/bookings", () => {
+  describe("Query parameter validation", () => {
+    test("should validate status parameter correctly", async () => {
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          status: "invalid_status",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      await expect(handler(req)).rejects.toThrow(ZodError);
+    });
+
+    test("should accept valid status parameter", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(0);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          status: "upcoming",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toEqual([]);
+    });
+
+    test("should validate dateFrom parameter format", async () => {
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          dateFrom: "invalid-date",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      await expect(handler(req)).rejects.toThrow();
+    });
+
+    test("should validate dateTo parameter format", async () => {
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          dateTo: "invalid-date",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      await expect(handler(req)).rejects.toThrow();
+    });
+
+    test("should validate sortBy parameter", async () => {
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          sortBy: "invalid_field",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      await expect(handler(req)).rejects.toThrow();
+    });
+
+    test("should validate order parameter", async () => {
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          order: "invalid_order",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      await expect(handler(req)).rejects.toThrow();
+    });
+  });
+
+  describe("Permission logic", () => {
+    test("should only return user's own bookings for regular user", async () => {
+      const mockBookings = [buildBooking({ id: 1, userId: userId }), buildBooking({ id: 2, userId: userId })];
+
+      prismaMock.booking.findMany.mockResolvedValue(mockBookings);
+      prismaMock.booking.count.mockResolvedValue(2);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toHaveLength(2);
+      expect(result.bookings.every((b) => b.userId === userId)).toBe(true);
+    });
+
+    test("should allow system-wide admin to access all bookings", async () => {
+      const adminUserId = 999;
+      const mockBookings = [
+        buildBooking({ id: 1, userId: 1 }),
+        buildBooking({ id: 2, userId: 2 }),
+        buildBooking({ id: 3, userId: 3 }),
+      ];
+
+      prismaMock.booking.findMany.mockResolvedValue(mockBookings);
+      prismaMock.booking.count.mockResolvedValue(3);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = adminUserId;
+      req.isSystemWideAdmin = true;
+
+      const result = await handler(req);
+      expect(result.bookings).toHaveLength(3);
+    });
+
+    test("should allow org admin to access org bookings", async () => {
+      const orgAdminUserId = 999;
+      const mockBookings = [buildBooking({ id: 1, userId: 1 }), buildBooking({ id: 2, userId: 2 })];
+
+      prismaMock.booking.findMany.mockResolvedValue(mockBookings);
+      prismaMock.booking.count.mockResolvedValue(2);
+
+      (retrieveOrgScopedAccessibleUsers as any).mockResolvedValue([1, 2]);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = orgAdminUserId;
+      req.isOrganizationOwnerOrAdmin = true;
+
+      const result = await handler(req);
+      expect(result.bookings).toHaveLength(2);
+    });
+  });
+
+  describe("Filtering edge cases", () => {
+    test("should handle empty attendeeEmail array", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(0);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          attendeeEmail: [],
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toEqual([]);
+    });
+
+    test("should handle single attendeeEmail string", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(0);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          attendeeEmail: "test@example.com",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toEqual([]);
+    });
+
+    test("should handle pagination edge cases", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(0);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        pagination: {
+          take: 0,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toEqual([]);
+    });
+
+    test("should handle large skip values", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(5);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        pagination: {
+          take: 10,
+          skip: 1000,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toEqual([]);
+    });
+  });
+
+  describe("Expand parameter functionality", () => {
+    test("should handle invalid expand parameter", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(0);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          expand: "invalid_field",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      await expect(handler(req)).rejects.toThrow();
+    });
+
+    test("should handle valid expand parameter", async () => {
+      prismaMock.booking.findMany.mockResolvedValue([]);
+      prismaMock.booking.count.mockResolvedValue(0);
+
+      const { req } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "GET",
+        query: {
+          expand: "team",
+        },
+        pagination: {
+          take: 10,
+          skip: 0,
+        },
+      });
+
+      req.userId = userId;
+
+      const result = await handler(req);
+      expect(result.bookings).toEqual([]);
+    });
+  });
+});

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

@@ -4,30 +4,243 @@ import prismaMock from "../../../../../../tests/libs/__mocks__/prismaMock";
 import type { Request, Response } from "express";
 import type { NextApiRequest, NextApiResponse } from "next";
 import { createMocks } from "node-mocks-http";
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi, beforeEach } from "vitest";
 
 import dayjs from "@calcom/dayjs";
+import { getEventTypesFromDB } from "@calcom/features/bookings/lib/handleNewBooking/getEventTypesFromDB";
 import sendPayload from "@calcom/features/webhooks/lib/sendOrSchedulePayload";
 import { ErrorCode } from "@calcom/lib/errorCodes";
-import { buildBooking, buildEventType, buildWebhook } from "@calcom/lib/test/builder";
+import { buildBooking, buildEventType, buildWebhook, buildUser } from "@calcom/lib/test/builder";
 import prisma from "@calcom/prisma";
 import type { Booking } from "@calcom/prisma/client";
 import { CreationSource } from "@calcom/prisma/enums";
 
 import handler from "../../../pages/api/bookings/_post";
 
+vi.mock("@calcom/features/bookings/lib/handleNewBooking/getEventTypesFromDB", () => ({
+  getEventTypesFromDB: vi.fn(),
+}));
+
+const mockEventTypeData = {
+  eventType: {
+    id: 1,
+    title: "Test Event",
+    profile: { organizationId: null },
+    users: [{ id: 1, email: "test@example.com", credentials: [] }],
+    hosts: [],
+    customInputs: [],
+    recurringEvent: null,
+    length: 15,
+    slug: "test-event",
+    price: 0,
+    currency: "USD",
+    requiresConfirmation: false,
+    disableGuests: false,
+    minimumBookingNotice: 120,
+    beforeEventBuffer: 0,
+    afterEventBuffer: 0,
+    seatsPerTimeSlot: null,
+    seatsShowAttendees: false,
+    schedulingType: null,
+    periodType: "UNLIMITED",
+    periodStartDate: null,
+    periodEndDate: null,
+    periodDays: null,
+    periodCountCalendarDays: false,
+    locations: [],
+    metadata: {},
+    successRedirectUrl: null,
+    description: null,
+    team: null,
+    owner: { id: 1, email: "test@example.com", credentials: [] },
+  },
+  users: [{ id: 1, email: "test@example.com", credentials: [] }],
+  allCredentials: [],
+  destinationCalendar: null,
+};
+
 type CustomNextApiRequest = NextApiRequest & Request;
 type CustomNextApiResponse = NextApiResponse & Response;
-vi.mock("@calcom/features/webhooks/lib/sendPayload");
+vi.mock("@calcom/features/webhooks/lib/sendOrSchedulePayload", () => ({
+  default: vi.fn().mockResolvedValue({}),
+}));
+
+const mockFindOriginalRescheduledBooking = vi.fn();
+vi.mock("@calcom/lib/server/repository/booking", () => ({
+  BookingRepository: vi.fn().mockImplementation(() => ({
+    findOriginalRescheduledBooking: mockFindOriginalRescheduledBooking,
+  })),
+}));
+
+vi.mock("@calcom/features/watchlist/operations/check-if-users-are-blocked.controller", () => ({
+  checkIfUsersAreBlocked: vi.fn().mockResolvedValue(false),
+}));
+
+vi.mock("@calcom/lib/bookings/findQualifiedHostsWithDelegationCredentials", () => ({
+  findQualifiedHostsWithDelegationCredentials: vi.fn().mockResolvedValue({
+    qualifiedRRHosts: [],
+    allFallbackRRHosts: [],
+    fixedHosts: [],
+  }),
+}));
+
+vi.mock("@calcom/lib/EventManager", () => ({
+  default: vi.fn().mockImplementation(() => ({
+    reschedule: vi.fn().mockResolvedValue({
+      results: [],
+      referencesToCreate: [],
+    }),
+    create: vi.fn().mockResolvedValue({
+      results: [],
+      referencesToCreate: [],
+    }),
+    update: vi.fn().mockResolvedValue({
+      results: [],
+      referencesToCreate: [],
+    }),
+    createAllCalendarEvents: vi.fn().mockResolvedValue([]),
+    updateAllCalendarEvents: vi.fn().mockResolvedValue([]),
+    deleteEventsAndMeetings: vi.fn().mockResolvedValue([]),
+  })),
+  placeholderCreatedEvent: {
+    results: [],
+    referencesToCreate: [],
+  },
+}));
+
+vi.mock("@calcom/lib/availability", () => ({
+  getUserAvailability: vi.fn().mockResolvedValue([
+    {
+      start: new Date("1970-01-01T09:00:00.000Z"),
+      end: new Date("1970-01-01T17:00:00.000Z"),
+    },
+  ]),
+  getAvailableSlots: vi.fn().mockResolvedValue([
+    {
+      time: new Date().toISOString(),
+      attendees: 1,
+      bookingUid: null,
+      users: [2],
+    },
+  ]),
+}));
+
+vi.mock("@calcom/features/bookings/lib/handleNewBooking/ensureAvailableUsers", () => ({
+  ensureAvailableUsers: vi.fn().mockImplementation(async (eventType) => {
+    return eventType.users || [{ id: 2, email: "test@example.com", name: "Test User", isFixed: false }];
+  }),
+}));
+
+vi.mock("@calcom/lib/server/repository/profile", () => ({
+  ProfileRepository: {
+    findManyForUser: vi.fn().mockResolvedValue([]),
+    buildPersonalProfileFromUser: vi.fn().mockReturnValue({
+      id: null,
+      upId: "usr-2",
+      username: "test-user",
+      organizationId: null,
+      organization: null,
+    }),
+  },
+}));
+vi.mock("@calcom/features/flags/features.repository", () => ({
+  FeaturesRepository: vi.fn().mockImplementation(() => ({
+    checkIfFeatureIsEnabledGlobally: vi.fn().mockResolvedValue(false),
+    checkIfTeamHasFeature: vi.fn().mockResolvedValue(false),
+  })),
+}));
+
+vi.mock("@calcom/features/webhooks/lib/getWebhooks", () => ({
+  default: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("@calcom/features/ee/workflows/lib/getAllWorkflows", () => ({
+  getAllWorkflows: vi.fn().mockResolvedValue([]),
+  workflowSelect: {},
+}));
+
+vi.mock("@calcom/trpc/server/routers/viewer/workflows/util", () => ({
+  getAllWorkflowsFromEventType: vi.fn().mockResolvedValue([]),
+}));
+
 vi.mock("@calcom/lib/server/i18n", () => {
+  const mockT = (key: string, options?: any) => {
+    if (key === "event_between_users") {
+      return `${options?.eventName} between ${options?.host} and ${options?.attendeeName}`;
+    }
+    if (key === "scheduler") {
+      return "Scheduler";
+    }
+    if (key === "google_meet_warning") {
+      return "Google Meet warning";
+    }
+    return key;
+  };
+
   return {
-    getTranslation: (key: string) => key,
+    getTranslation: vi.fn().mockResolvedValue(mockT),
+    t: mockT,
   };
 });
 
-describe.skipIf(true)("POST /api/bookings", () => {
+describe("POST /api/bookings - eventTypeId validation", () => {
+  test("String eventTypeId should return 400", async () => {
+    const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+      method: "POST",
+      body: {
+        eventTypeId: "invalid-string",
+      },
+    });
+
+    await handler(req, res);
+
+    expect(res._getStatusCode()).toBe(400);
+    expect(JSON.parse(res._getData())).toEqual(
+      expect.objectContaining({
+        message: "Bad request, eventTypeId must be a number",
+      })
+    );
+  });
+
+  test("Number eventTypeId should not trigger validation error", async () => {
+    const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+      method: "POST",
+      body: {
+        eventTypeId: 123,
+      },
+    });
+
+    prismaMock.eventType.findUniqueOrThrow.mockResolvedValue(
+      buildEventType({
+        id: 123,
+        profileId: null,
+        locations: [{ type: "integrations:daily" }],
+      })
+    );
+
+    await handler(req, res);
+
+    const statusCode = res._getStatusCode();
+    const responseData = JSON.parse(res._getData());
+
+    if (statusCode === 400) {
+      expect(responseData.message).not.toBe("Bad request, eventTypeId must be a number");
+    }
+  });
+});
+
+describe("POST /api/bookings", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindOriginalRescheduledBooking.mockResolvedValue(null);
+
+    (getEventTypesFromDB as any).mockResolvedValue(mockEventTypeData.eventType);
+  });
+
   describe("Errors", () => {
     test("Missing required data", async () => {
+      (getEventTypesFromDB as any).mockRejectedValue(new Error(ErrorCode.RequestBodyInvalid));
+
       const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
         method: "POST",
         body: {},
@@ -35,102 +248,45 @@ describe.skipIf(true)("POST /api/bookings", () => {
 
       await handler(req, res);
 
-      expect(res.statusCode).toBe(400);
+      expect(res._getStatusCode()).toBe(400);
       expect(JSON.parse(res._getData())).toEqual(
         expect.objectContaining({
-          message:
-            "invalid_type in 'eventTypeId': Required; invalid_type in 'title': Required; invalid_type in 'startTime': Required; invalid_type in 'startTime': Required; invalid_type in 'endTime': Required; invalid_type in 'endTime': Required",
+          message: ErrorCode.RequestBodyInvalid,
         })
       );
     });
 
     test("Invalid eventTypeId", async () => {
+      (getEventTypesFromDB as any).mockRejectedValue(new Error(ErrorCode.EventTypeNotFound));
+
       const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
         method: "POST",
         body: {
           title: "test",
-          eventTypeId: 2,
-          startTime: dayjs().toDate(),
-          endTime: dayjs().add(1, "day").toDate(),
+          eventTypeId: 999,
+          startTime: dayjs().add(1, "day").toDate(),
+          endTime: dayjs().add(1, "day").add(15, "minutes").toDate(),
         },
         prisma,
       });
 
-      prismaMock.eventType.findUnique.mockResolvedValue(null);
-
       await handler(req, res);
 
       expect(res._getStatusCode()).toBe(400);
       expect(JSON.parse(res._getData())).toEqual(
         expect.objectContaining({
-          message:
-            "'invalid_type' in 'email': Required; 'invalid_type' in 'end': Required; 'invalid_type' in 'location': Required; 'invalid_type' in 'name': Required; 'invalid_type' in 'start': Required; 'invalid_type' in 'timeZone': Required; 'invalid_type' in 'language': Required; 'invalid_type' in 'customInputs': Required; 'invalid_type' in 'metadata': Required",
+          message: ErrorCode.EventTypeNotFound,
         })
       );
     });
 
-    test("Missing recurringCount", async () => {
-      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
-        method: "POST",
-        body: {
-          title: "test",
-          eventTypeId: 2,
-          startTime: dayjs().toDate(),
-          endTime: dayjs().add(1, "day").toDate(),
-        },
-        prisma,
-      });
-
-      prismaMock.eventType.findUnique.mockResolvedValue(
-        buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } })
-      );
-
-      await handler(req, res);
-
-      expect(res._getStatusCode()).toBe(400);
-      expect(JSON.parse(res._getData())).toEqual(
-        expect.objectContaining({
-          message:
-            "'invalid_type' in 'email': Required; 'invalid_type' in 'end': Required; 'invalid_type' in 'location': Required; 'invalid_type' in 'name': Required; 'invalid_type' in 'start': Required; 'invalid_type' in 'timeZone': Required; 'invalid_type' in 'language': Required; 'invalid_type' in 'customInputs': Required; 'invalid_type' in 'metadata': Required",
-        })
-      );
-    });
-
-    test("Invalid recurringCount", async () => {
-      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
-        method: "POST",
-        body: {
-          title: "test",
-          eventTypeId: 2,
-          startTime: dayjs().toDate(),
-          endTime: dayjs().add(1, "day").toDate(),
-          recurringCount: 15,
-        },
-        prisma,
-      });
-
-      prismaMock.eventType.findUnique.mockResolvedValue(
-        buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } })
-      );
-
-      await handler(req, res);
-
-      expect(res._getStatusCode()).toBe(400);
-      expect(JSON.parse(res._getData())).toEqual(
-        expect.objectContaining({
-          message:
-            "'invalid_type' in 'email': Required; 'invalid_type' in 'end': Required; 'invalid_type' in 'location': Required; 'invalid_type' in 'name': Required; 'invalid_type' in 'start': Required; 'invalid_type' in 'timeZone': Required; 'invalid_type' in 'language': Required; 'invalid_type' in 'customInputs': Required; 'invalid_type' in 'metadata': Required",
-        })
-      );
-    });
-
-    test("No available users", async () => {
+    test.skip("Missing recurringCount", async () => {
       const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
         method: "POST",
         body: {
           name: "test",
-          start: dayjs().format(),
-          end: dayjs().add(1, "day").format(),
+          start: dayjs().add(1, "day").format(),
+          end: dayjs().add(1, "day").add(15, "minutes").format(),
           eventTypeId: 2,
           email: "test@example.com",
           location: "Cal.com Video",
@@ -143,15 +299,93 @@ describe.skipIf(true)("POST /api/bookings", () => {
         prisma,
       });
 
-      prismaMock.eventType.findUniqueOrThrow.mockResolvedValue(buildEventType());
+      prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+        ...buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } }),
+        profile: { organizationId: null },
+        hosts: [],
+        users: [buildUser()],
+      });
+
+      await handler(req, res);
+
+      expect(res._getStatusCode()).toBe(400);
+      expect(JSON.parse(res._getData())).toEqual(
+        expect.objectContaining({
+          message: expect.stringContaining("recurringCount"),
+        })
+      );
+    });
+
+    test.skip("Invalid recurringCount", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "POST",
+        body: {
+          name: "test",
+          start: dayjs().add(1, "day").format(),
+          end: dayjs().add(1, "day").add(15, "minutes").format(),
+          eventTypeId: 2,
+          email: "test@example.com",
+          location: "Cal.com Video",
+          timeZone: "America/Montevideo",
+          language: "en",
+          customInputs: [],
+          metadata: {},
+          userId: 4,
+          recurringCount: 15,
+        },
+        prisma,
+      });
+
+      prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+        ...buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } }),
+        profile: { organizationId: null },
+        hosts: [],
+        users: [buildUser()],
+      });
+
+      await handler(req, res);
+
+      expect(res._getStatusCode()).toBe(400);
+      expect(JSON.parse(res._getData())).toEqual(
+        expect.objectContaining({
+          message: expect.stringContaining("recurringCount"),
+        })
+      );
+    });
+
+    test.skip("No available users", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "POST",
+        body: {
+          name: "test",
+          start: dayjs().add(1, "day").format(),
+          end: dayjs().add(1, "day").add(1, "hour").format(),
+          eventTypeId: 2,
+          email: "test@example.com",
+          location: "Cal.com Video",
+          timeZone: "America/Montevideo",
+          language: "en",
+          customInputs: [],
+          metadata: {},
+          userId: 4,
+        },
+        prisma,
+      });
+
+      prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+        ...buildEventType({ profileId: null }),
+        profile: { organizationId: null },
+        hosts: [],
+        users: [buildUser()],
+      });
 
       await handler(req, res);
       console.log({ statusCode: res._getStatusCode(), data: JSON.parse(res._getData()) });
 
-      expect(res._getStatusCode()).toBe(500);
+      expect(res._getStatusCode()).toBe(400);
       expect(JSON.parse(res._getData())).toEqual(
         expect.objectContaining({
-          message: ErrorCode.NoAvailableUsersFound,
+          message: "Invalid event length",
         })
       );
     });
@@ -165,8 +399,8 @@ describe.skipIf(true)("POST /api/bookings", () => {
           method: "POST",
           body: {
             name: "test",
-            start: dayjs().format(),
-            end: dayjs().add(1, "day").format(),
+            start: dayjs().add(1, "day").format(),
+            end: dayjs().add(1, "day").add(15, "minutes").format(),
             eventTypeId: 2,
             email: "test@example.com",
             location: "Cal.com Video",
@@ -179,8 +413,38 @@ describe.skipIf(true)("POST /api/bookings", () => {
           prisma,
         });
 
-        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue(buildEventType());
+        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+          ...buildEventType({ profileId: null, length: 15 }),
+          profile: { organizationId: null },
+          hosts: [],
+          users: [buildUser()],
+        });
         prismaMock.booking.findMany.mockResolvedValue([]);
+        const mockBooking = buildBooking({
+          id: 1,
+          uid: "test-booking-uid",
+          title: "Test Event",
+          startTime: new Date(dayjs().add(1, "day").format()),
+          endTime: new Date(dayjs().add(1, "day").add(15, "minutes").format()),
+          eventTypeId: buildEventType({
+            id: 2,
+            profileId: null,
+          }).id,
+          oneTimePassword: null,
+          creationSource: "API_V1",
+        });
+        prismaMock.$transaction.mockImplementation(async (callback) => {
+          const mockTx = {
+            booking: {
+              create: prismaMock.booking.create.mockResolvedValue(mockBooking),
+              update: vi.fn().mockResolvedValue({}),
+            },
+            app_RoutingForms_FormResponse: {
+              update: vi.fn().mockResolvedValue({}),
+            },
+          };
+          return await callback(prismaMock);
+        });
 
         await handler(req, res);
         console.log({ statusCode: res._getStatusCode(), data: JSON.parse(res._getData()) });
@@ -189,12 +453,28 @@ describe.skipIf(true)("POST /api/bookings", () => {
       });
 
       test("Reschedule created booking", async () => {
+        const originalBooking = buildBooking({
+          uid: "original-booking-uid",
+          userId: 4,
+          eventTypeId: buildEventType({
+            id: 2,
+            locations: [{ type: "integrations:daily" }],
+          }).id,
+          references: [],
+        });
+        mockFindOriginalRescheduledBooking.mockResolvedValue(originalBooking);
+
+        prismaMock.booking.findUnique.mockResolvedValue({
+          ...originalBooking,
+          status: "cancelled",
+        });
+
         const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
           method: "POST",
           body: {
             name: "testReschedule",
             start: dayjs().add(2, "day").format(),
-            end: dayjs().add(3, "day").format(),
+            end: dayjs().add(2, "day").add(15, "minutes").format(),
             eventTypeId: 2,
             email: "test@example.com",
             location: "Cal.com Video",
@@ -203,21 +483,52 @@ describe.skipIf(true)("POST /api/bookings", () => {
             customInputs: [],
             metadata: {},
             userId: 4,
-            rescheduleUid: createdBooking.uid,
+            rescheduleUid: "original-booking-uid",
           },
           prisma,
         });
 
-        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue(buildEventType());
+        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+          ...buildEventType({ profileId: null, length: 15 }),
+          profile: { organizationId: null },
+          hosts: [],
+          users: [buildUser()],
+        });
         prismaMock.booking.findMany.mockResolvedValue([]);
+        const mockBooking = buildBooking({
+          id: 2,
+          uid: "test-reschedule-uid",
+          title: "Test Reschedule Event",
+          startTime: new Date(dayjs().add(2, "day").format()),
+          endTime: new Date(dayjs().add(2, "day").add(15, "minutes").format()),
+          eventTypeId: buildEventType({
+            id: 2,
+            profileId: null,
+            locations: [{ type: "integrations:daily" }],
+          }).id,
+          oneTimePassword: null,
+          fromReschedule: "original-booking-uid",
+        });
+        prismaMock.$transaction.mockImplementation(async (callback) => {
+          const mockTx = {
+            booking: {
+              create: prismaMock.booking.create.mockResolvedValue(mockBooking),
+              update: vi.fn().mockResolvedValue({}),
+            },
+            app_RoutingForms_FormResponse: {
+              update: vi.fn().mockResolvedValue({}),
+            },
+          };
+          return await callback(prismaMock);
+        });
 
         await handler(req, res);
         console.log({ statusCode: res._getStatusCode(), data: JSON.parse(res._getData()) });
         const rescheduledBooking = JSON.parse(res._getData()) as Booking;
         expect(prismaMock.booking.create).toHaveBeenCalledTimes(1);
-        expect(rescheduledBooking.fromReschedule).toEqual(createdBooking.uid);
+        expect(rescheduledBooking.fromReschedule).toEqual("original-booking-uid");
         const previousBooking = await prisma.booking.findUnique({
-          where: { uid: createdBooking.uid },
+          where: { uid: "original-booking-uid" },
         });
         expect(previousBooking?.status).toBe("cancelled");
       });
@@ -227,8 +538,8 @@ describe.skipIf(true)("POST /api/bookings", () => {
           method: "POST",
           body: {
             name: "test",
-            start: dayjs().format(),
-            end: dayjs().add(1, "day").format(),
+            start: dayjs().add(1, "day").format(),
+            end: dayjs().add(1, "day").add(15, "minutes").format(),
             eventTypeId: 2,
             email: "test@example.com",
             location: "Cal.com Video",
@@ -241,8 +552,38 @@ describe.skipIf(true)("POST /api/bookings", () => {
           prisma,
         });
 
-        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue(buildEventType());
+        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+          ...buildEventType({ profileId: null, length: 15 }),
+          profile: { organizationId: null },
+          hosts: [],
+          users: [buildUser()],
+        });
         prismaMock.booking.findMany.mockResolvedValue([]);
+        const mockBooking = buildBooking({
+          id: 3,
+          uid: "test-api-v1-uid",
+          title: "Test API V1 Event",
+          startTime: new Date(dayjs().add(1, "day").format()),
+          endTime: new Date(dayjs().add(1, "day").add(15, "minutes").format()),
+          eventTypeId: buildEventType({
+            id: 2,
+            profileId: null,
+          }).id,
+          oneTimePassword: null,
+          creationSource: "API_V1",
+        });
+        prismaMock.$transaction.mockImplementation(async (callback) => {
+          const mockTx = {
+            booking: {
+              create: prismaMock.booking.create.mockResolvedValue(mockBooking),
+              update: vi.fn().mockResolvedValue({}),
+            },
+            app_RoutingForms_FormResponse: {
+              update: vi.fn().mockResolvedValue({}),
+            },
+          };
+          return await callback(prismaMock);
+        });
 
         await handler(req, res);
         createdBooking = JSON.parse(res._getData());
@@ -252,25 +593,50 @@ describe.skipIf(true)("POST /api/bookings", () => {
     });
 
     describe("Recurring event-type", () => {
-      test("Creates multiple bookings", async () => {
+      test.skip("Creates multiple bookings", async () => {
+        const recurringDates = Array.from(Array(12).keys()).map((i) => ({
+          start: dayjs().add(1, "day").add(i, "week").toISOString(),
+          end: dayjs().add(1, "day").add(i, "week").add(15, "minutes").toISOString(),
+        }));
+
         const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
           method: "POST",
           body: {
             title: "test",
             eventTypeId: 2,
-            startTime: dayjs().toDate(),
-            endTime: dayjs().add(1, "day").toDate(),
+            start: recurringDates[0].start,
+            end: recurringDates[0].end,
+            timeZone: "UTC",
+            language: "en",
+            responses: {
+              name: "Test User",
+              email: "test@example.com",
+              location: { optionValue: "", value: "integrations:daily" },
+            },
+            metadata: {},
             recurringCount: 12,
+            recurringEventId: "test-recurring-event-id",
+            allRecurringDates: recurringDates,
+            isFirstRecurringSlot: true,
+            numSlotsToCheckForAvailability: 12,
           },
           prisma,
         });
 
-        prismaMock.eventType.findUnique.mockResolvedValue(
-          buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } })
+        prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+          ...buildEventType({ profileId: null, length: 15 }),
+          profile: { organizationId: null },
+          hosts: [],
+          users: [buildUser()],
+        });
+
+        const mockBookings = Array.from(Array(12).keys()).map((i) =>
+          buildBooking({ id: i + 1, uid: `recurring-booking-${i}` })
         );
 
-        Array.from(Array(12).keys()).map(async () => {
-          prismaMock.booking.create.mockResolvedValue(buildBooking());
+        prismaMock.booking.create.mockResolvedValue(buildBooking({ id: 1, uid: "test-booking-uid" }));
+        prismaMock.$transaction.mockImplementation(async (callback) => {
+          return await callback(prismaMock);
         });
 
         prismaMock.webhook.findMany.mockResolvedValue([]);
@@ -278,32 +644,57 @@ describe.skipIf(true)("POST /api/bookings", () => {
         await handler(req, res);
         const data = JSON.parse(res._getData());
 
-        expect(prismaMock.booking.create).toHaveBeenCalledTimes(12);
-        expect(res._getStatusCode()).toBe(201);
+        expect(prismaMock.$transaction).toHaveBeenCalled();
+        expect(res._getStatusCode()).toBe(200);
         expect(data.message).toEqual("Bookings created successfully.");
         expect(data.bookings.length).toEqual(12);
       });
     });
-    test("Notifies multiple bookings", async () => {
+    test.skip("Notifies multiple bookings", async () => {
+      const recurringDates = Array.from(Array(12).keys()).map((i) => ({
+        start: dayjs().add(1, "day").add(i, "week").toISOString(),
+        end: dayjs().add(1, "day").add(i, "week").add(15, "minutes").toISOString(),
+      }));
+
       const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
         method: "POST",
         body: {
           title: "test",
           eventTypeId: 2,
-          startTime: dayjs().toDate(),
-          endTime: dayjs().add(1, "day").toDate(),
+          start: recurringDates[0].start,
+          end: recurringDates[0].end,
+          timeZone: "UTC",
+          language: "en",
+          responses: {
+            name: "Test User",
+            email: "test@example.com",
+            location: { optionValue: "", value: "integrations:daily" },
+          },
+          metadata: {},
           recurringCount: 12,
+          recurringEventId: "test-recurring-event-id",
+          allRecurringDates: recurringDates,
+          isFirstRecurringSlot: true,
+          numSlotsToCheckForAvailability: 12,
         },
         prisma,
       });
 
-      prismaMock.eventType.findUnique.mockResolvedValue(
-        buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } })
-      );
+      prismaMock.eventType.findUniqueOrThrow.mockResolvedValue({
+        ...buildEventType({ recurringEvent: { freq: 2, count: 12, interval: 1 } }),
+        profile: { organizationId: null },
+        hosts: [],
+        users: [buildUser()],
+      });
 
       const createdAt = new Date();
-      Array.from(Array(12).keys()).map(async () => {
-        prismaMock.booking.create.mockResolvedValue(buildBooking({ createdAt }));
+      const mockBookings = Array.from(Array(12).keys()).map((i) =>
+        buildBooking({ id: i + 1, uid: `webhook-booking-${i}`, createdAt })
+      );
+
+      prismaMock.booking.create.mockResolvedValue(buildBooking({ id: 1, uid: "test-booking-uid" }));
+      prismaMock.$transaction.mockImplementation(async (callback) => {
+        return await callback(prismaMock);
       });
 
       const mockedWebhooks = [

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

@@ -93,6 +93,8 @@ describe("POST /api/selected-calendars", () => {
         watchAttempts: 0,
         maxAttempts: 3,
         unwatchAttempts: 0,
+        createdAt: new Date(),
+        updatedAt: new Date(),
       });
 
       await handler(req, res);
@@ -136,6 +138,8 @@ describe("POST /api/selected-calendars", () => {
         watchAttempts: 0,
         maxAttempts: 3,
         unwatchAttempts: 0,
+        createdAt: new Date(),
+        updatedAt: new Date(),
       });
 
       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/jest-e2e.json

@@ -1,18 +0,0 @@
-{
-  "moduleFileExtensions": ["js", "json", "ts"],
-  "rootDir": ".",
-  "moduleNameMapper": {
-    "@/(.*)": "<rootDir>/src/$1",
-    "test/(.*)": "<rootDir>/test/$1"
-  },
-  "testEnvironment": "node",
-  "testRegex": ".e2e-spec.ts$",
-  "transform": {
-    "^.+\\.(t|j)s$": "ts-jest"
-  },
-  "setupFiles": ["<rootDir>/test/setEnvVars.ts", "jest-date-mock"],
-  "setupFilesAfterEnv": ["<rootDir>/test/jest.setup-e2e.ts"],
-  "reporters": ["default", "jest-summarizing-reporter"],
-  "workerIdleMemoryLimit": "512MB",
-  "maxWorkers": 8
-}

apps/api/v2/jest-e2e.ts

@@ -0,0 +1,25 @@
+import type { Config } from "jest";
+
+const config: Config = {
+  preset: "ts-jest",
+  moduleFileExtensions: ["js", "json", "ts"],
+  rootDir: ".",
+  moduleNameMapper: {
+    "@/(.*)": "<rootDir>/src/$1",
+    "test/(.*)": "<rootDir>/test/$1",
+  },
+  testEnvironment: "node",
+  testRegex: ".e2e-spec.ts$",
+  transform: {
+    "^.+\\.ts$": "ts-jest",
+  },
+  setupFiles: ["<rootDir>/test/setEnvVars.ts", "jest-date-mock"],
+  setupFilesAfterEnv: ["<rootDir>/test/jest.setup-e2e.ts"],
+  reporters: ["default", "jest-summarizing-reporter"],
+  workerIdleMemoryLimit: "512MB",
+  maxWorkers: 8,
+  testPathIgnorePatterns: ["/dist/", "/node_modules/"],
+  transformIgnorePatterns: ["/dist/", "/node_modules/"],
+};
+
+export default config;

apps/api/v2/jest.config.json

@@ -1,14 +0,0 @@
-{
-  "moduleFileExtensions": ["js", "json", "ts"],
-  "rootDir": ".",
-  "moduleNameMapper": {
-    "@/(.*)": "<rootDir>/src/$1",
-    "test/(.*)": "<rootDir>/test/$1"
-  },
-  "testEnvironment": "node",
-  "testRegex": ".*\\.spec\\.ts$",
-  "transform": {
-    "^.+\\.ts$": "ts-jest"
-  },
-  "setupFiles": ["<rootDir>/test/setEnvVars.ts"]
-}

apps/api/v2/jest.config.ts

@@ -0,0 +1,21 @@
+import type { Config } from "jest";
+
+const config: Config = {
+  preset: "ts-jest",
+  moduleFileExtensions: ["ts", "js", "json"],
+  rootDir: ".",
+  moduleNameMapper: {
+    "@/(.*)": "<rootDir>/src/$1",
+    "test/(.*)": "<rootDir>/test/$1",
+  },
+  testEnvironment: "node",
+  testRegex: ".*\\.spec\\.ts$",
+  transform: {
+    "^.+\\.ts$": "ts-jest",
+  },
+  setupFiles: ["<rootDir>/test/setEnvVars.ts"],
+  testPathIgnorePatterns: ["/dist/", "/node_modules/"],
+  transformIgnorePatterns: ["/dist/", "/node_modules/"],
+};
+
+export default config;

apps/api/v2/package.json

@@ -4,6 +4,7 @@
   "description": "Platform API for Cal.com",
   "author": "Cal.com Inc.",
   "license": "UNLICENSED",
+  "private": true,
   "scripts": {
     "build": "yarn dev:build && nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
@@ -24,9 +25,9 @@
     "test:watch": "yarn dev:build && jest --watch",
     "test:cov": "yarn dev:build && jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "yarn dev:build && NODE_OPTIONS='--max_old_space_size=8192 --experimental-vm-modules' jest --ci --forceExit --config ./jest-e2e.json",
+    "test:e2e": "yarn dev:build && NODE_OPTIONS='--max_old_space_size=8192 --experimental-vm-modules' jest --ci --forceExit --config ./jest-e2e.ts",
     "test:e2e:local": "yarn test:e2e --maxWorkers=4",
-    "test:e2e:watch": "yarn dev:build && jest --runInBand --detectOpenHandles --forceExit --config ./jest-e2e.json --watch",
+    "test:e2e:watch": "yarn dev:build && jest --runInBand --detectOpenHandles --forceExit --config ./jest-e2e.ts --watch",
     "prisma": "yarn workspace @calcom/prisma prisma",
     "generate-schemas": "yarn prisma generate && yarn prisma format",
     "copy-swagger-module": "ts-node -r tsconfig-paths/register swagger/copy-swagger-module.ts",
@@ -37,8 +38,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-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.276",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",
     "@calcom/prisma": "*",
@@ -108,7 +108,7 @@
     "ts-loader": "^9.4.3",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.1.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.0-beta"
   },
   "prisma": {
     "schema": "../../../packages/prisma/schema.prisma"

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

@@ -86,10 +86,16 @@ export class AppModule implements NestModule {
   configure(consumer: MiddlewareConsumer): void {
     consumer
       .apply(RawBodyMiddleware)
-      .forRoutes({
-        path: "/api/v2/billing/webhook",
-        method: RequestMethod.POST,
-      })
+      .forRoutes(
+        {
+          path: "/api/v2/billing/webhook",
+          method: RequestMethod.POST,
+        },
+        {
+          path: "/v2/billing/webhook",
+          method: RequestMethod.POST,
+        }
+      )
       .apply(JsonBodyMiddleware)
       .forRoutes("*")
       .apply(RequestIdMiddleware)

apps/api/v2/src/app.ts

@@ -81,5 +81,9 @@ export const bootstrap = (app: NestExpressApplication): NestExpressApplication =
 
   app.use(cookieParser());
 
+  if (process?.env?.API_GLOBAL_PREFIX) {
+    app.setGlobalPrefix(process?.env?.API_GLOBAL_PREFIX);
+  }
+
   return app;
 };

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

@@ -5,7 +5,7 @@ import { GetBookingOutput_2024_04_15 } from "@/ee/bookings/2024-04-15/outputs/ge
 import { GetBookingsOutput_2024_04_15 } from "@/ee/bookings/2024-04-15/outputs/get-bookings.output";
 import { MarkNoShowOutput_2024_04_15 } from "@/ee/bookings/2024-04-15/outputs/mark-no-show.output";
 import { PlatformBookingsService } from "@/ee/bookings/shared/platform-bookings.service";
-import { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
+import { sha256Hash, isApiKey, stripApiKey } from "@/lib/api-key";
 import { VERSION_2024_04_15, VERSION_2024_06_11, VERSION_2024_06_14 } from "@/lib/api-versions";
 import { ApiKeysRepository } from "@/modules/api-keys/api-keys-repository";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
@@ -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, {
@@ -225,6 +232,15 @@ export class BookingsController_2024_04_15 {
     }
 
     if (bookingUid) {
+      const { bookingInfo } = await getBookingInfo(bookingUid);
+      if (!bookingInfo) {
+        throw new NotFoundException(`Booking with UID=${bookingUid} does not exist.`);
+      }
+      if (bookingInfo.status === "CANCELLED") {
+        throw new BadRequestException(
+          `Can't cancel booking with uid=${bookingUid} because it has been cancelled already. Please provide uid of a booking that is not cancelled.`
+        );
+      }
       try {
         req.body.uid = bookingUid;
         const bookingRequest = await this.createNextApiBookingRequest(req, oAuthClientId, undefined, isEmbed);
@@ -370,7 +386,7 @@ export class BookingsController_2024_04_15 {
       if (bearerToken) {
         if (isApiKey(bearerToken, this.config.get<string>("api.apiKeyPrefix") ?? "cal_")) {
           const strippedApiKey = stripApiKey(bearerToken, this.config.get<string>("api.keyPrefix"));
-          const apiKeyHash = hashAPIKey(strippedApiKey);
+          const apiKeyHash = sha256Hash(strippedApiKey);
           const keyData = await this.apiKeyRepository.getApiKeyFromHash(apiKeyHash);
           return keyData?.userId;
         } else {
@@ -424,7 +440,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 +452,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/inputs/create-booking.input.ts

@@ -31,12 +31,7 @@ function ValidateBookingName(validationOptions?: ValidationOptions) {
             return value.trim().length > 0;
           }
           if (typeof value === "object" && value !== null) {
-            return (
-              typeof value.firstName === "string" &&
-              typeof value.lastName === "string" &&
-              value.firstName.trim().length > 0 &&
-              value.lastName.trim().length > 0
-            );
+            return typeof value.firstName === "string" && value.firstName.trim().length > 0;
           }
           return false;
         },

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)
@@ -233,7 +267,14 @@ export class BookingsController_2024_08_13 {
   @ApiOperation({
     summary: "Cancel a booking",
     description: `:bookingUid can be :bookingUid of an usual booking, individual recurrence or recurring booking to cancel all recurrences.
-    For seated bookings to cancel one individual booking provide :bookingUid and :seatUid in the request body. For recurring seated bookings it is not possible to cancel all of them with 1 call
+    
+    \nCancelling seated bookings:
+    It is possible to cancel specific seat within a booking as an attendee or all of the seats as the host.
+    \n1. As an attendee - provide :bookingUid in the request URL \`/bookings/:bookingUid/cancel\` and seatUid in the request body \`{"seatUid": "123-123-123"}\` . This will remove this particular attendance from the booking.
+    \n2. As the host - host can cancel booking for all attendees aka for every seat. Provide :bookingUid in the request URL \`/bookings/:bookingUid/cancel\` and cancellationReason in the request body \`{"cancellationReason": "Will travel"}\` and \`Authorization: Bearer token\` request header where token is event type owner (host) credential. This will cancel the booking for all attendees.
+    
+    \nCancelling recurring seated bookings:
+    For recurring seated bookings it is not possible to cancel all of them with 1 call
     like with non-seated recurring bookings by providing recurring bookind uid - you have to cancel each recurrence booking by its bookingUid + seatUid.`,
   })
   @ApiBody({
@@ -402,7 +443,7 @@ export class BookingsController_2024_08_13 {
   @Permissions([BOOKING_READ])
   @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
   @ApiOperation({
-    summary: "Get 'Booking References' for a booking",
+    summary: "Get booking references",
   })
   @HttpCode(HttpStatus.OK)
   async getBookingReferences(

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/seated-bookings.e2e-spec.ts

@@ -14,29 +14,27 @@ import { Test } from "@nestjs/testing";
 import { User } from "@prisma/client";
 import { DateTime } from "luxon";
 import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { BookingSeatRepositoryFixture } from "test/fixtures/repository/booking-seat.repository.fixture";
 import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
 import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
 import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
 import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
 import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
 import { randomString } from "test/utils/randomString";
-import { withApiAuth } from "test/utils/withApiAuth";
 
 import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
 import {
+  CancelBookingInput_2024_08_13,
   CancelSeatedBookingInput_2024_08_13,
   CreateRecurringSeatedBookingOutput_2024_08_13,
   CreateSeatedBookingOutput_2024_08_13,
   GetBookingOutput_2024_08_13,
   GetBookingsOutput_2024_08_13,
-  GetRecurringSeatedBookingOutput_2024_08_13,
   GetSeatedBookingOutput_2024_08_13,
   RescheduleSeatedBookingInput_2024_08_13,
 } from "@calcom/platform-types";
-import {
-  CreateBookingInput_2024_08_13,
-  CreateRecurringBookingInput_2024_08_13,
-} from "@calcom/platform-types";
+import { CreateBookingInput_2024_08_13 } from "@calcom/platform-types";
 import { PlatformOAuthClient, Team } from "@calcom/prisma/client";
 
 describe("Bookings Endpoints 2024-08-13", () => {
@@ -51,11 +49,13 @@ describe("Bookings Endpoints 2024-08-13", () => {
     let schedulesService: SchedulesService_2024_04_15;
     let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
     let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
-    let oAuthClient: PlatformOAuthClient;
     let teamRepositoryFixture: TeamRepositoryFixture;
+    let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+    let bookingSeatRepositoryFixture: BookingSeatRepositoryFixture;
 
     const userEmail = `seated-bookings-user-${randomString()}@api.com`;
     let user: User;
+    let apiKeyString: string;
 
     let seatedEventTypeId: number;
     const maxRecurrenceCount = 3;
@@ -63,6 +63,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
     const seatedEventSlug = `seated-bookings-event-type-${randomString()}`;
 
     let createdSeatedBooking: CreateSeatedBookingOutput_2024_08_13;
+    let createdSeatedBooking2: CreateSeatedBookingOutput_2024_08_13;
 
     const emailAttendeeOne = `seated-bookings-attendee1-${randomString()}@api.com`;
     const nameAttendeeOne = `Attendee One ${randomString()}`;
@@ -70,12 +71,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
     const nameAttendeeTwo = `Attendee Two ${randomString()}`;
 
     beforeAll(async () => {
-      const moduleRef = await withApiAuth(
-        userEmail,
-        Test.createTestingModule({
-          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
-        })
-      )
+      const moduleRef = await Test.createTestingModule({
+        imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+      })
         .overrideGuard(PermissionsGuard)
         .useValue({
           canActivate: () => true,
@@ -87,22 +85,21 @@ describe("Bookings Endpoints 2024-08-13", () => {
       eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
       oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
       teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
       schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+      bookingSeatRepositoryFixture = new BookingSeatRepositoryFixture(moduleRef);
 
       organization = await teamRepositoryFixture.create({
         name: `seated-bookings-organization-${randomString()}`,
       });
-      oAuthClient = await createOAuthClient(organization.id);
 
       user = await userRepositoryFixture.create({
         email: userEmail,
-        platformOAuthClients: {
-          connect: {
-            id: oAuthClient.id,
-          },
-        },
       });
 
+      const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+      apiKeyString = `cal_test_${keyString}`;
+
       const userSchedule: CreateScheduleInput_2024_04_15 = {
         name: `seated-bookings-2024-08-13-schedule-${randomString()}`,
         timeZone: "Europe/Rome",
@@ -118,6 +115,14 @@ describe("Bookings Endpoints 2024-08-13", () => {
           seatsShowAttendees: true,
           seatsShowAvailabilityCount: true,
           locations: [{ type: "inPerson", address: "via 10, rome, italy" }],
+          metadata: {
+            disableStandardEmails: {
+              all: {
+                attendee: true,
+                host: true,
+              },
+            },
+          },
         },
         user.id
       );
@@ -129,19 +134,6 @@ describe("Bookings Endpoints 2024-08-13", () => {
       await app.init();
     });
 
-    async function createOAuthClient(organizationId: number) {
-      const data = {
-        logo: "logo-url",
-        name: "name",
-        redirectUris: ["http://localhost:5555"],
-        permissions: 32,
-      };
-      const secret = "secret";
-
-      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
-      return client;
-    }
-
     it("should book an event type with seats for the first time", async () => {
       const body: CreateBookingInput_2024_08_13 = {
         start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
@@ -333,6 +325,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
       return request(app.getHttpServer())
         .get("/v2/bookings?sortCreated=asc")
         .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .set("Authorization", `Bearer ${apiKeyString}`)
         .expect(200)
         .then(async (response) => {
           const responseBody: GetBookingsOutput_2024_08_13 = response.body;
@@ -350,6 +343,22 @@ describe("Bookings Endpoints 2024-08-13", () => {
         });
     });
 
+    it("should not be able to reschedule seated booking if seatUid is not provided", async () => {
+      const body = {
+        start: new Date(Date.UTC(2030, 0, 8, 15, 0, 0)).toISOString(),
+      };
+
+      const response = await request(app.getHttpServer())
+        .post(`/v2/bookings/${createdSeatedBooking.uid}/reschedule`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(400);
+
+      expect(response.body.error.message).toEqual(
+        `Booking with uid=${createdSeatedBooking.uid} is a seated booking which means you have to provide seatUid in the request body to specify which seat specifically you want to reschedule. First, fetch the booking using https://cal.com/docs/api-reference/v2/bookings/get-a-booking and then within the attendees array you will find the seatUid of the booking you want to reschedule. Second, provide the seatUid in the request body to specify which seat specifically you want to reschedule using the reschedule endpoint https://cal.com/docs/api-reference/v2/bookings/reschedule-a-booking#option-2`
+      );
+    });
+
     it("should reschedule seated booking", async () => {
       const body: RescheduleSeatedBookingInput_2024_08_13 = {
         start: new Date(Date.UTC(2030, 0, 8, 15, 0, 0)).toISOString(),
@@ -409,67 +418,186 @@ describe("Bookings Endpoints 2024-08-13", () => {
         });
     });
 
-    it("should cancel seated booking", async () => {
-      const body: CancelSeatedBookingInput_2024_08_13 = {
-        seatUid: createdSeatedBooking.seatUid,
-      };
+    describe("cancel seated booking", () => {
+      describe("cancel seated booking as attendee", () => {
+        it("should cancel seated booking", async () => {
+          const body: CancelSeatedBookingInput_2024_08_13 = {
+            seatUid: createdSeatedBooking.seatUid,
+          };
 
-      return request(app.getHttpServer())
-        .post(`/v2/bookings/${createdSeatedBooking.uid}/cancel`)
-        .send(body)
-        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
-        .expect(200)
-        .then(async (response) => {
-          const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
-          expect(responseBody.status).toEqual(SUCCESS_STATUS);
-          expect(responseBody.data).toBeDefined();
-          expect(responseDataIsGetSeatedBooking(responseBody.data)).toBe(true);
+          return request(app.getHttpServer())
+            .post(`/v2/bookings/${createdSeatedBooking.uid}/cancel`)
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(200)
+            .then(async (response) => {
+              const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsGetSeatedBooking(responseBody.data)).toBe(true);
 
-          if (responseDataIsGetSeatedBooking(responseBody.data)) {
-            const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
-            expect(data.id).toBeDefined();
-            expect(data.uid).toBeDefined();
-            expect(data.hosts[0].id).toEqual(user.id);
-            expect(data.status).toEqual("cancelled");
-            expect(data.start).toEqual(createdSeatedBooking.start);
-            expect(data.end).toEqual(createdSeatedBooking.end);
-            expect(data.duration).toEqual(60);
-            expect(data.eventTypeId).toEqual(seatedEventTypeId);
-            expect(data.eventType).toEqual({
-              id: seatedEventTypeId,
-              slug: seatedEventSlug,
+              if (responseDataIsGetSeatedBooking(responseBody.data)) {
+                const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(data.hosts[0].id).toEqual(user.id);
+                expect(data.status).toEqual("cancelled");
+                expect(data.start).toEqual(createdSeatedBooking.start);
+                expect(data.end).toEqual(createdSeatedBooking.end);
+                expect(data.duration).toEqual(60);
+                expect(data.eventTypeId).toEqual(seatedEventTypeId);
+                expect(data.eventType).toEqual({
+                  id: seatedEventTypeId,
+                  slug: seatedEventSlug,
+                });
+                expect(data.attendees.length).toEqual(0);
+                expect(data.location).toBeDefined();
+                expect(data.absentHost).toEqual(false);
+              } else {
+                throw new Error("Invalid response data - expected booking but received array response");
+              }
             });
-            expect(data.attendees.length).toEqual(0);
-            expect(data.location).toBeDefined();
-            expect(data.absentHost).toEqual(false);
-          } else {
-            throw new Error("Invalid response data - expected booking but received array response");
-          }
         });
+      });
+
+      describe("cancel seated booking as host", () => {
+        it("should book an event type with seats", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString(),
+            eventTypeId: seatedEventTypeId,
+            attendee: {
+              name: nameAttendeeOne,
+              email: emailAttendeeOne,
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+            bookingFieldsResponses: {
+              codingLanguage: "TypeScript",
+            },
+            metadata: {
+              userId: "100",
+            },
+          };
+
+          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(responseDataIsCreateSeatedBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsCreateSeatedBooking(responseBody.data)) {
+                const data: CreateSeatedBookingOutput_2024_08_13 = responseBody.data;
+                expect(data.seatUid).toBeDefined();
+                const seatUid = data.seatUid;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(data.hosts[0].id).toEqual(user.id);
+                expect(data.status).toEqual("accepted");
+                expect(data.start).toEqual(body.start);
+                expect(data.end).toEqual(
+                  DateTime.fromISO(body.start, { zone: "utc" }).plus({ hours: 1 }).toISO()
+                );
+                expect(data.duration).toEqual(60);
+                expect(data.eventTypeId).toEqual(seatedEventTypeId);
+                expect(data.eventType).toEqual({
+                  id: seatedEventTypeId,
+                  slug: seatedEventSlug,
+                });
+                expect(data.attendees.length).toEqual(1);
+                expect(data.attendees[0]).toEqual({
+                  name: body.attendee.name,
+                  email: body.attendee.email,
+                  timeZone: body.attendee.timeZone,
+                  language: body.attendee.language,
+                  absent: false,
+                  seatUid,
+                  bookingFieldsResponses: {
+                    name: body.attendee.name,
+                    ...body.bookingFieldsResponses,
+                  },
+                  metadata: body.metadata,
+                });
+                expect(data.location).toBeDefined();
+                expect(data.absentHost).toEqual(false);
+                createdSeatedBooking2 = data;
+              } else {
+                throw new Error(
+                  "Invalid response data - expected recurring booking but received non array response"
+                );
+              }
+            });
+        });
+
+        it("should not be able to cancel without cancellation reason", async () => {
+          const response = await request(app.getHttpServer())
+            .post(`/v2/bookings/${createdSeatedBooking2.uid}/cancel`)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .set("Authorization", `Bearer ${apiKeyString}`)
+            .expect(400);
+
+          expect(response.body.message).toEqual("Cancellation reason is required when you are the host");
+        });
+
+        it("should cancel seated booking", async () => {
+          const body: CancelBookingInput_2024_08_13 = {
+            cancellationReason: "I will be travelling without internet",
+          };
+
+          return request(app.getHttpServer())
+            .post(`/v2/bookings/${createdSeatedBooking2.uid}/cancel`)
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .set("Authorization", `Bearer ${apiKeyString}`)
+            .expect(200)
+            .then(async (response) => {
+              const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsGetSeatedBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsGetSeatedBooking(responseBody.data)) {
+                const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(data.hosts[0].id).toEqual(user.id);
+                expect(data.status).toEqual("cancelled");
+                expect(data.start).toEqual(createdSeatedBooking2.start);
+                expect(data.end).toEqual(createdSeatedBooking2.end);
+                expect(data.duration).toEqual(60);
+                expect(data.eventTypeId).toEqual(seatedEventTypeId);
+                expect(data.eventType).toEqual({
+                  id: seatedEventTypeId,
+                  slug: seatedEventSlug,
+                });
+                expect(data.attendees.length).toEqual(0);
+                expect(data.location).toBeDefined();
+                expect(data.absentHost).toEqual(false);
+                expect(data.cancellationReason).toEqual("I will be travelling without internet");
+
+                const seats = await bookingSeatRepositoryFixture.findAllByBookingId(data.id);
+                expect(seats.length).toEqual(0);
+              } else {
+                throw new Error("Invalid response data - expected booking but received array response");
+              }
+            });
+        });
+      });
     });
 
     function responseDataIsCreateSeatedBooking(data: any): data is CreateSeatedBookingOutput_2024_08_13 {
       return data.hasOwnProperty("seatUid");
     }
 
-    function responseDataIsCreateRecurringSeatedBooking(
-      data: any
-    ): data is CreateRecurringSeatedBookingOutput_2024_08_13[] {
-      return Array.isArray(data);
-    }
-
     function responseDataIsGetSeatedBooking(data: any): data is GetSeatedBookingOutput_2024_08_13 {
       return data?.attendees?.every((attendee: any) => attendee?.hasOwnProperty("seatUid"));
     }
 
-    function responseDataIsGetRecurringSeatedBooking(
-      data: any
-    ): data is GetRecurringSeatedBookingOutput_2024_08_13[] {
-      return Array.isArray(data);
-    }
-
     afterAll(async () => {
-      await oauthClientRepositoryFixture.delete(oAuthClient.id);
       await teamRepositoryFixture.delete(organization.id);
       await userRepositoryFixture.deleteByEmail(user.email);
       await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);

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: {
@@ -1411,8 +1425,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
             // @ts-ignore
             const data: BookingOutput_2024_08_13 = responseBody.data;
             expect(data.status).toEqual("cancelled");
-
-            createdBooking = data;
+            expect(data.rescheduledToUid).toEqual(rescheduledBooking.uid);
           });
       });
 
@@ -1568,17 +1581,55 @@ describe("Bookings Endpoints 2024-08-13", () => {
     });
 
     describe("cancel bookings", () => {
+      afterEach(async () => {
+        await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      });
+
       it("should cancel booking", async () => {
+        const createBody: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 15, 0, 0)).toISOString(),
+          eventTypeId,
+          attendee: {
+            name: "Mr Proper Cancel",
+            email: "mr_proper_cancel@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            customField: "customValue",
+          },
+          metadata: {
+            userId: "100",
+          },
+        };
+
+        const createResponse = await request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(createBody)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .set(X_CAL_CLIENT_ID, oAuthClient.id)
+          .expect(201);
+
+        const createResponseBody: CreateBookingOutput_2024_08_13 = createResponse.body;
+        expect(responseDataIsBooking(createResponseBody.data)).toBe(true);
+
+        if (!responseDataIsBooking(createResponseBody.data)) {
+          throw new Error("Failed to create booking for test");
+        }
+
+        const testBooking: BookingOutput_2024_08_13 = createResponseBody.data;
+
+        const booking = await bookingsRepositoryFixture.getByUid(testBooking.uid);
+        expect(booking).toBeDefined();
+        expect(booking?.status).toEqual("ACCEPTED");
+
         const body: CancelBookingInput_2024_08_13 = {
           cancellationReason: "Going on a vacation",
         };
 
-        const booking = await bookingsRepositoryFixture.getByUid(rescheduledBooking.uid);
-        expect(booking).toBeDefined();
-        expect(booking?.status).toEqual("ACCEPTED");
-
         return request(app.getHttpServer())
-          .post(`/v2/bookings/${rescheduledBooking.uid}/cancel`)
+          .post(`/v2/bookings/${testBooking.uid}/cancel`)
           .send(body)
           .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
           .set(X_CAL_CLIENT_ID, oAuthClient.id)
@@ -1597,27 +1648,61 @@ describe("Bookings Endpoints 2024-08-13", () => {
             expect(data.hosts[0].email).toEqual(user.email);
             expect(data.status).toEqual("cancelled");
             expect(data.cancellationReason).toEqual(body.cancellationReason);
-            expect(data.start).toEqual(rescheduledBooking.start);
-            expect(data.end).toEqual(rescheduledBooking.end);
-            expect(data.duration).toEqual(rescheduledBooking.duration);
-            expect(data.eventTypeId).toEqual(rescheduledBooking.eventTypeId);
-            expect(data.attendees[0]).toEqual(rescheduledBooking.attendees[0]);
-            expect(data.location).toEqual(rescheduledBooking.location);
-            expect(data.absentHost).toEqual(rescheduledBooking.absentHost);
+            expect(data.start).toEqual(testBooking.start);
+            expect(data.end).toEqual(testBooking.end);
+            expect(data.duration).toEqual(testBooking.duration);
+            expect(data.eventTypeId).toEqual(testBooking.eventTypeId);
+            expect(data.attendees[0]).toEqual(testBooking.attendees[0]);
+            expect(data.location).toEqual(testBooking.location);
+            expect(data.absentHost).toEqual(testBooking.absentHost);
 
-            const cancelledBooking = await bookingsRepositoryFixture.getByUid(rescheduledBooking.uid);
+            const cancelledBooking = await bookingsRepositoryFixture.getByUid(testBooking.uid);
             expect(cancelledBooking).toBeDefined();
             expect(cancelledBooking?.status).toEqual("CANCELLED");
           });
       });
 
       it("should cancel recurring booking", async () => {
+        const createBody: CreateRecurringBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 1, 4, 13, 0, 0)).toISOString(),
+          eventTypeId: recurringEventTypeId,
+          attendee: {
+            name: "Mr Proper Recurring Cancel",
+            email: "mr_proper_recurring_cancel@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          location: "https://meet.google.com/abc-def-ghi",
+          bookingFieldsResponses: {
+            customField: "customValue",
+          },
+          metadata: {
+            userId: "100",
+          },
+        };
+
+        const createResponse = await request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(createBody)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .set(X_CAL_CLIENT_ID, oAuthClient.id)
+          .expect(201);
+
+        const createResponseBody: CreateBookingOutput_2024_08_13 = createResponse.body;
+        expect(responseDataIsRecurringBooking(createResponseBody.data)).toBe(true);
+
+        if (!responseDataIsRecurringBooking(createResponseBody.data)) {
+          throw new Error("Failed to create recurring booking for test");
+        }
+
+        const testRecurringBooking: RecurringBookingOutput_2024_08_13[] = createResponseBody.data;
+
         const body: CancelBookingInput_2024_08_13 = {
           cancellationReason: "Going on a vacation",
         };
 
         return request(app.getHttpServer())
-          .post(`/v2/bookings/${createdRecurringBooking[1].recurringBookingUid}/cancel`)
+          .post(`/v2/bookings/${testRecurringBooking[1].recurringBookingUid}/cancel`)
           .send(body)
           .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
           .set(X_CAL_CLIENT_ID, oAuthClient.id)
@@ -1630,7 +1715,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
             if (responseDataIsRecurringBooking(responseBody.data)) {
               const data: RecurringBookingOutput_2024_08_13[] = responseBody.data;
-              expect(data.length).toEqual(4);
+              expect(data.length).toEqual(3);
 
               const firstBooking = data[0];
               expect(firstBooking.status).toEqual("cancelled");
@@ -1640,9 +1725,6 @@ describe("Bookings Endpoints 2024-08-13", () => {
 
               const thirdBooking = data[2];
               expect(thirdBooking.status).toEqual("cancelled");
-
-              const fourthBooking = data[3];
-              expect(fourthBooking.status).toEqual("cancelled");
             } else {
               throw new Error(
                 "Invalid response data - expected recurring booking but received non array response"
@@ -1752,6 +1834,88 @@ describe("Bookings Endpoints 2024-08-13", () => {
             }
           });
       });
+
+      it("should return who rescheduled the booking, in the new booking", async () => {
+        const rescheduledByEmail = `user-bookings-rescheduler-${randomString()}@rescheduler.com`;
+        // Create the original booking that will be rescheduled
+        const originalBooking = await bookingsRepositoryFixture.create({
+          uid: `original-booking-uid-${eventTypeId}`,
+          title: "original booking title",
+          startTime: "2050-09-05T10:00:00.000Z",
+          endTime: "2050-09-05T11:00:00.000Z",
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          status: "CANCELLED",
+          rescheduledBy: rescheduledByEmail,
+          metadata: {},
+          responses: {
+            name: "original tester",
+            email: "original@example.com",
+            guests: [],
+          },
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+        });
+
+        // Create the new booking that is the result of the reschedule
+        const newBooking = await bookingsRepositoryFixture.create({
+          uid: `new-booking-uid-${eventTypeId}`,
+          title: "rescheduled booking title",
+          startTime: "2050-09-05T14:00:00.000Z",
+          endTime: "2050-09-05T15:00:00.000Z",
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          status: "ACCEPTED",
+          fromReschedule: originalBooking.uid,
+          metadata: {},
+          responses: {
+            name: "new tester",
+            email: "newtester@example.com",
+            guests: [],
+          },
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+        });
+
+        return request(app.getHttpServer())
+          .get(`/v2/bookings/${newBooking.uid}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            // Fetch the original booking to get its rescheduledBy value
+            const originalBookingFromDb = await bookingsRepositoryFixture.getByUid(originalBooking.uid);
+            const expectedRescheduledBy = originalBookingFromDb?.rescheduledBy;
+
+            await bookingsRepositoryFixture.deleteById(originalBooking.id);
+            await bookingsRepositoryFixture.deleteById(newBooking.id);
+            const responseBody: GetBookingOutput_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.uid).toEqual(newBooking.uid);
+              expect(rescheduledByEmail).toEqual(expectedRescheduledBy);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibly recurring bookings"
+              );
+            }
+          });
+      });
     });
 
     describe("book by username and event type slug", () => {
@@ -2399,6 +2563,478 @@ 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("cant't cancel already cancelled booking", () => {
+      it("should not be able to cancel alraedy 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: CancelBookingInput_2024_08_13 = {
+          cancellationReason: "Going on a vacation",
+        };
+
+        const response = await request(app.getHttpServer())
+          .post(`/v2/bookings/${cancelledBooking.uid}/cancel`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .set(X_CAL_CLIENT_ID, oAuthClient.id)
+          .expect(400);
+
+        expect(response.body.error.message).toEqual(
+          `Can't cancel booking with uid=${cancelledBooking.uid} because it has been cancelled already. Please provide uid of a booking that is not cancelled.`
+        );
+        await bookingsRepositoryFixture.deleteById(cancelledBooking.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";
@@ -403,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);
@@ -423,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 || "" }))
@@ -444,6 +447,7 @@ export class BookingsService_2024_08_13 {
       platformCancelUrl: bookingRequest.platformCancelUrl,
       platformBookingUrl: bookingRequest.platformBookingUrl,
       platformBookingLocation: bookingRequest.platformBookingLocation,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
     });
 
     if (!booking.uid) {
@@ -474,6 +478,7 @@ export class BookingsService_2024_08_13 {
         platformCancelUrl: bookingRequest.platformCancelUrl,
         platformBookingUrl: bookingRequest.platformBookingUrl,
         platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
       });
 
       if (!booking.uid) {
@@ -538,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,34 +596,17 @@ export class BookingsService_2024_08_13 {
       } else if (isRecurring && isSeated) {
         formattedBookings.push(this.outputService.getOutputRecurringSeatedBooking(formatted));
       } else if (isSeated) {
-        formattedBookings.push(this.outputService.getOutputSeatedBooking(formatted));
+        formattedBookings.push(await this.outputService.getOutputSeatedBooking(formatted));
       } else {
-        formattedBookings.push(this.outputService.getOutputBooking(formatted));
+        formattedBookings.push(await this.outputService.getOutputBooking(formatted));
       }
     }
 
-    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,
     };
   }
 
@@ -650,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,
@@ -664,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");
@@ -695,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);
@@ -928,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,
       },
@@ -956,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,7 +10,8 @@ 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 { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
+import { apiToInternalintegrationsMapping } from "@/ee/event-types/event-types_2024_06_14/transformers";
+import { sha256Hash, isApiKey, stripApiKey } from "@/lib/api-key";
 import { defaultBookingResponses } from "@/lib/safe-parse/default-responses-booking";
 import { safeParse } from "@/lib/safe-parse/safe-parse";
 import { ApiKeysRepository } from "@/modules/api-keys/api-keys-repository";
@@ -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 {
@@ -187,6 +186,31 @@ export class InputBookingsService_2024_08_13 {
         guests,
         location,
       },
+      ...this.getRoutingFormData(inputBooking.routing),
+    };
+  }
+
+  private getRoutingFormData(
+    routing:
+      | {
+          teamMemberIds?: number[];
+          responseId?: number;
+          teamMemberEmail?: string;
+          skipContactOwner?: boolean;
+          crmAppSlug?: string;
+          crmOwnerRecordType?: string;
+        }
+      | undefined
+  ) {
+    if (!routing) return null;
+
+    return {
+      routedTeamMemberIds: routing.teamMemberIds,
+      routingFormResponseId: routing.responseId,
+      teamMemberEmail: routing.teamMemberEmail,
+      skipContactOwner: routing.skipContactOwner,
+      crmAppSlug: routing.crmAppSlug,
+      crmOwnerRecordType: routing.crmOwnerRecordType,
     };
   }
 
@@ -454,6 +478,7 @@ export class InputBookingsService_2024_08_13 {
           location,
         },
         schedulingType: eventType.schedulingType,
+        ...this.getRoutingFormData(inputBooking.routing),
       });
 
       switch (timeBetween) {
@@ -587,6 +612,11 @@ export class InputBookingsService_2024_08_13 {
     if (!eventType) {
       throw new NotFoundException(`Event type with id=${booking.eventTypeId} not found`);
     }
+    if (eventType.seatsPerTimeSlot) {
+      throw new BadRequestException(
+        `Booking with uid=${bookingUid} is a seated booking which means you have to provide seatUid in the request body to specify which seat specifically you want to reschedule. First, fetch the booking using https://cal.com/docs/api-reference/v2/bookings/get-a-booking and then within the attendees array you will find the seatUid of the booking you want to reschedule. Second, provide the seatUid in the request body to specify which seat specifically you want to reschedule using the reschedule endpoint https://cal.com/docs/api-reference/v2/bookings/reschedule-a-booking#option-2`
+      );
+    }
 
     const bookingResponses = safeParse(
       bookingResponsesSchema,
@@ -645,7 +675,7 @@ export class InputBookingsService_2024_08_13 {
       if (bearerToken) {
         if (isApiKey(bearerToken, this.config.get<string>("api.apiKeyPrefix") ?? "cal_")) {
           const strippedApiKey = stripApiKey(bearerToken, this.config.get<string>("api.keyPrefix"));
-          const apiKeyHash = hashAPIKey(strippedApiKey);
+          const apiKeyHash = sha256Hash(strippedApiKey);
           const keyData = await this.apiKeyRepository.getApiKeyFromHash(apiKeyHash);
           return keyData?.userId;
         } else {
@@ -707,6 +737,12 @@ export class InputBookingsService_2024_08_13 {
       throw new NotFoundException(`Booking with uid=${bookingUid} not found`);
     }
 
+    if (booking.status === "CANCELLED") {
+      throw new BadRequestException(
+        `Can't cancel booking with uid=${bookingUid} because it has been cancelled already. Please provide uid of a booking that is not cancelled.`
+      );
+    }
+
     const oAuthClientParams = booking.eventTypeId
       ? await this.platformBookingsService.getOAuthClientParams(booking.eventTypeId)
       : undefined;

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({
@@ -90,7 +90,7 @@ type DatabaseMetadata = z.infer<typeof bookingMetadataSchema>;
 export class OutputBookingsService_2024_08_13 {
   constructor(private readonly bookingsRepository: BookingsRepository_2024_08_13) {}
 
-  getOutputBooking(databaseBooking: DatabaseBooking) {
+  async getOutputBooking(databaseBooking: DatabaseBooking) {
     const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
     const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
     const duration = dateEnd.diff(dateStart, "minutes").minutes;
@@ -101,6 +101,13 @@ export class OutputBookingsService_2024_08_13 {
     );
     const metadata = safeParse(bookingMetadataSchema, databaseBooking.metadata, defaultBookingMetadata);
     const location = metadata?.videoCallUrl || databaseBooking.location;
+    const rescheduledToInfo = databaseBooking.rescheduled
+      ? await this.getRescheduledToInfo(databaseBooking.uid)
+      : undefined;
+    
+    const rescheduledToUid = rescheduledToInfo?.uid;
+    const rescheduledByEmail = databaseBooking.rescheduled ? rescheduledToInfo?.rescheduledBy : databaseBooking.rescheduledBy;
+
 
     const booking = {
       id: databaseBooking.id,
@@ -109,10 +116,10 @@ export class OutputBookingsService_2024_08_13 {
       description: databaseBooking.description,
       hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
-      cancellationReason: databaseBooking.cancellationReason || undefined,
-      cancelledByEmail: databaseBooking.cancelledBy || undefined,
+      cancellationReason:
+        databaseBooking.status === "CANCELLED" ? databaseBooking.cancellationReason : undefined,
+      cancelledByEmail: databaseBooking.status === "CANCELLED" ? databaseBooking.cancelledBy : undefined,
       reschedulingReason: bookingResponses?.rescheduledReason,
-      rescheduledByEmail: databaseBooking.rescheduledBy || undefined,
       rescheduledFromUid: databaseBooking.fromReschedule || undefined,
       start: databaseBooking.startTime,
       end: databaseBooking.endTime,
@@ -137,6 +144,8 @@ export class OutputBookingsService_2024_08_13 {
       updatedAt: databaseBooking.updatedAt,
       rating: databaseBooking.rating,
       icsUid: databaseBooking.iCalUID,
+      rescheduledToUid,
+      rescheduledByEmail,
     };
 
     const bookingTransformed = plainToClass(BookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
@@ -146,6 +155,15 @@ export class OutputBookingsService_2024_08_13 {
     return bookingTransformed;
   }
 
+  async getRescheduledToInfo(bookingUid: string): Promise<{ uid?: string; rescheduledBy?: string | null }> {
+    const rescheduledTo = await this.bookingsRepository.getByFromReschedule(bookingUid);
+    return { 
+      uid: rescheduledTo?.uid, 
+      rescheduledBy: rescheduledTo?.rescheduledBy 
+    };
+  }
+
+
   getUserDefinedMetadata(databaseMetadata: DatabaseMetadata) {
     if (databaseMetadata === null) return {};
 
@@ -204,10 +222,10 @@ export class OutputBookingsService_2024_08_13 {
       description: databaseBooking.description,
       hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
-      cancellationReason: databaseBooking.cancellationReason || undefined,
-      cancelledByEmail: databaseBooking.cancelledBy || undefined,
+      cancellationReason:
+        databaseBooking.status === "CANCELLED" ? databaseBooking.cancellationReason : undefined,
+      cancelledByEmail: databaseBooking.status === "CANCELLED" ? databaseBooking.cancelledBy : undefined,
       reschedulingReason: bookingResponses?.rescheduledReason,
-      rescheduledByEmail: databaseBooking.rescheduledBy || undefined,
       rescheduledFromUid: databaseBooking.fromReschedule || undefined,
       start: databaseBooking.startTime,
       end: databaseBooking.endTime,
@@ -244,20 +262,26 @@ export class OutputBookingsService_2024_08_13 {
     return bookingTransformed;
   }
 
-  getOutputCreateSeatedBooking(
+  async getOutputCreateSeatedBooking(
     databaseBooking: DatabaseBooking,
     seatUid: string
-  ): CreateSeatedBookingOutput_2024_08_13 {
-    const getSeatedBookingOutput = this.getOutputSeatedBooking(databaseBooking);
+  ): Promise<CreateSeatedBookingOutput_2024_08_13> {
+    const getSeatedBookingOutput = await this.getOutputSeatedBooking(databaseBooking);
     return { ...getSeatedBookingOutput, seatUid };
   }
 
-  getOutputSeatedBooking(databaseBooking: DatabaseBooking) {
+  async getOutputSeatedBooking(databaseBooking: DatabaseBooking) {
     const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
     const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
     const duration = dateEnd.diff(dateStart, "minutes").minutes;
     const metadata = safeParse(bookingMetadataSchema, databaseBooking.metadata, defaultBookingMetadata);
     const location = metadata?.videoCallUrl || databaseBooking.location;
+    const rescheduledToInfo = databaseBooking.rescheduled
+      ? await this.getRescheduledToInfo(databaseBooking.uid)
+      : undefined;
+    
+    const rescheduledToUid = rescheduledToInfo?.uid;
+    const rescheduledByEmail = databaseBooking.rescheduled ? rescheduledToInfo?.rescheduledBy : databaseBooking.rescheduledBy;
 
     const booking = {
       id: databaseBooking.id,
@@ -266,6 +290,8 @@ export class OutputBookingsService_2024_08_13 {
       description: databaseBooking.description,
       hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
+      cancellationReason:
+        databaseBooking.status === "CANCELLED" ? databaseBooking.cancellationReason : undefined,
       rescheduledFromUid: databaseBooking.fromReschedule || undefined,
       start: databaseBooking.startTime,
       end: databaseBooking.endTime,
@@ -282,6 +308,8 @@ export class OutputBookingsService_2024_08_13 {
       updatedAt: databaseBooking.updatedAt,
       rating: databaseBooking.rating,
       icsUid: databaseBooking.iCalUID,
+      rescheduledToUid,
+      rescheduledByEmail,
     };
 
     const parsed = plainToClass(GetSeatedBookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
@@ -374,7 +402,8 @@ export class OutputBookingsService_2024_08_13 {
       description: databaseBooking.description,
       hosts: [this.getHost(databaseBooking.user)],
       status: databaseBooking.status.toLowerCase(),
-      cancellationReason: databaseBooking.cancellationReason || undefined,
+      cancellationReason:
+        databaseBooking.status === "CANCELLED" ? databaseBooking.cancellationReason : undefined,
       rescheduledFromUid: databaseBooking.fromReschedule || undefined,
       start: databaseBooking.startTime,
       end: databaseBooking.endTime,

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,
       };
     }