chore: Release v4.5.5 (#16804)

* Revert "feat: Update UI of signup / login pages (#16710)"

This reverts commit b879aeef09.

* revert

.env.example

@@ -333,6 +333,8 @@ E2E_TEST_OIDC_USER_PASSWORD=
 AB_TEST_BUCKET_PROBABILITY=50
 # whether we redirect to the future/event-types from event-types or not
 APP_ROUTER_EVENT_TYPES_ENABLED=0
+APP_ROUTER_SETTINGS_DEVELOPER_ENABLED=0
+APP_ROUTER_SETTINGS_SECURITY_ENABLED=0
 APP_ROUTER_SETTINGS_ADMIN_ENABLED=0
 APP_ROUTER_SETTINGS_PLATFORM_ENABLED=0
 APP_ROUTER_SETTINGS_ORG_ENABLED=0

.github/ISSUE_TEMPLATE/feature_request.md

@@ -49,7 +49,9 @@ assignees: ""
 (Share it here.)
 
 ---
+
 ##### House rules
+
 - If this issue has a `🚨 needs approval` label, don't start coding yet. Wait until a core member approves feature request by removing this label, then you can start coding.
   - For clarity: Non-core member issues automatically get the `🚨 needs approval` label.
   - Your feature ideas are invaluable to us! However, they undergo review to ensure alignment with the product's direction.

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

@@ -15,7 +15,7 @@ env:
   IS_E2E: true
   NEXTAUTH_SECRET: ${{ secrets.CI_NEXTAUTH_SECRET }}
   NEXTAUTH_URL: ${{ secrets.CI_NEXTAUTH_URL }}
-  NODE_OPTIONS: --max-old-space-size=4096
+  NODE_OPTIONS: --max-old-space-size=29000
   REDIS_URL: "redis://localhost:6379"
   STRIPE_PRIVATE_KEY: ${{ secrets.CI_STRIPE_PRIVATE_KEY }}
   STRIPE_API_KEY: ${{ secrets.CI_STRIPE_PRIVATE_KEY }}

.github/workflows/pr.yml

@@ -224,6 +224,7 @@ jobs:
         build,
         build-api-v1,
         build-api-v2,
+        build-atoms,
         e2e,
         e2e-api-v2,
         e2e-embed,

.github/workflows/unit-tests.yml

@@ -7,14 +7,14 @@ jobs:
   test:
     name: Unit
     timeout-minutes: 20
-    runs-on: buildjet-2vcpu-ubuntu-2204
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
       - uses: ./.github/actions/dangerous-git-checkout
       - uses: ./.github/actions/yarn-install
-      - run: yarn test
+      - run: yarn test -- --no-isolate
       # We could add different timezones here that we need to run our tests in
-      - run: TZ=America/Los_Angeles yarn test -- --timeZoneDependentTestsOnly
+      - run: TZ=America/Los_Angeles yarn test -- --timeZoneDependentTestsOnly --no-isolate
       - name: Run API v2 tests
         working-directory: apps/api/v2
         run: |

CONTRIBUTING.md

@@ -177,24 +177,25 @@ Do not commit your `yarn.lock` unless you've made changes to the `package.json`.
 
 If your last commit has the `yarn.lock` file alongside other files and you only wish to uncommit the `yarn.lock`:
 
-   ```bash
-   git checkout HEAD~1 yarn.lock
-   git commit -m "Revert yarn.lock changes"
-   ```
+```bash
+git checkout HEAD~1 yarn.lock
+git commit -m "Revert yarn.lock changes"
+```
 
 _NB_: You may have to bypass the pre-commit hook with by appending `--no-verify` to the git commit
 If you've pushed the commit with the `yarn.lock`:
 
-   1. Correct the commit locally using the above method.
-   2. Carefully force push:
+1.  Correct the commit locally using the above method.
+2.  Carefully force push:
 
-   ```bash
-   git push origin <your-branch-name> --force
-   ```
+```bash
+git push origin <your-branch-name> --force
+```
 
 If `yarn.lock` was committed a while ago and there have been several commits since, you can use the following steps to revert just the `yarn.lock` changes without impacting the subsequent changes:
 
 1. **Checkout a Previous Version**:
+
    - Find the commit hash before the `yarn.lock` was unintentionally committed. You can do this by viewing the Git log:
 
      ```bash
@@ -208,6 +209,7 @@ If `yarn.lock` was committed a while ago and there have been several commits sin
      ```
 
 2. **Commit the Reverted Version**:
+
    - After checking out the previous version of the `yarn.lock`, commit this change:
 
      ```bash
@@ -215,6 +217,7 @@ If `yarn.lock` was committed a while ago and there have been several commits sin
      ```
 
 3. **Proceed with Caution**:
+
    - If you need to push this change, first pull the latest changes from your remote branch to ensure you're not overwriting other recent changes:
 
      ```bash

README.md

@@ -175,7 +175,7 @@ yarn dx
 
 Add `NEXT_PUBLIC_LOGGER_LEVEL={level}` to your .env file to control the logging verbosity for all tRPC queries and mutations.\
 Where {level} can be one of the following:
- 
+
 `0` for silly \
 `1` for trace \
 `2` for debug \
@@ -187,14 +187,14 @@ Where {level} can be one of the following:
 When you set `NEXT_PUBLIC_LOGGER_LEVEL={level}` in your .env file, it enables logging at that level and higher. Here's how it works:
 
 The logger will include all logs that are at the specified level or higher. For example: \
+
 - If you set `NEXT_PUBLIC_LOGGER_LEVEL=2`, it will log from level 2 (debug) upwards, meaning levels 2 (debug), 3 (info), 4 (warn), 5 (error), and (fatal) will be logged. \
 - If you set `NEXT_PUBLIC_LOGGER_LEVEL=3`, it will log from level 3 (info) upwards, meaning levels 3 (info), 4 (warn), 5 (error), and 6 (fatal) will be logged, but level 2 (debug) and level 1 (trace) will be ignored. \
 
-
-
 ```sh
 echo 'NEXT_PUBLIC_LOGGER_LEVEL=3' >> .env
 ```
+
 for Logger level to be set at info, for example.
 
 #### Gitpod Setup
@@ -417,25 +417,25 @@ Cal.com, Inc. is a commercial open source company, which means some parts of thi
 > [!NOTE]  
 > Our philosophy is simple, all "Singleplayer APIs" are open-source under AGPLv3. All commercial "Multiplayer APIs" are under a commercial license.
 
-|   | AGPLv3  | EE  | 
-|---|---|---|
-| Self-host for commercial purposes	  | ✅  |  ✅ |
-| Clone privately  | ✅  | ✅  |
-| Fork publicly  | ✅  | ✅ |
-| Requires CLA  |  ✅ | ✅  |
-| Official Support| ❌ | ✅ |
-| Derivative work privately | ❌  | ✅ |
-| SSO | ❌  | ✅ |
-| Admin Panel | ❌  | ✅ |
-| Impersonation | ❌  | ✅ |
-| Managed Event Types | ❌  | ✅ |
-| Organizations | ❌  | ✅ |
-| Payments | ❌  | ✅ |
-| Platform | ❌  | ✅ |
-| Teams | ❌  | ✅ |
-| Users | ❌  | ✅ |
-| Video | ❌  | ✅ |
-| Workflows | ❌  | ✅ |
+|                                   | AGPLv3 | EE  |
+| --------------------------------- | ------ | --- |
+| Self-host for commercial purposes | ✅     | ✅  |
+| Clone privately                   | ✅     | ✅  |
+| Fork publicly                     | ✅     | ✅  |
+| Requires CLA                      | ✅     | ✅  |
+|  Official Support                 | ❌     | ✅  |
+| Derivative work privately         | ❌     | ✅  |
+|  SSO                              | ❌     | ✅  |
+| Admin Panel                       | ❌     | ✅  |
+| Impersonation                     | ❌     | ✅  |
+| Managed Event Types               | ❌     | ✅  |
+| Organizations                     | ❌     | ✅  |
+| Payments                          | ❌     | ✅  |
+| Platform                          | ❌     | ✅  |
+| Teams                             | ❌     | ✅  |
+| Users                             | ❌     | ✅  |
+| Video                             | ❌     | ✅  |
+| Workflows                         | ❌     | ✅  |
 
 > [!TIP]
 > We work closely with the community and always invite feedback about what should be open and what is fine to be commercial. This list is not set and stone and we have moved things from commercial to open in the past. Please open a [discussion](https://github.com/calcom/cal.com/discussions) if you feel like something is wrong.
@@ -531,17 +531,18 @@ following
 
 1. Open [Zoom Marketplace](https://marketplace.zoom.us/) and sign in with your Zoom account.
 2. On the upper right, click "Develop" => "Build App".
-3. On "OAuth", select "Create".
+3. Select "General App" , click "Create".
 4. Name your App.
-5. Choose "User-managed app" as the app type.
-6. De-select the option to publish the app on the Zoom App Marketplace.
-7. Click "Create".
-8. Now copy the Client ID and Client Secret to your `.env` file into the `ZOOM_CLIENT_ID` and `ZOOM_CLIENT_SECRET` fields.
-9. Set the Redirect URL for OAuth `<Cal.com URL>/api/integrations/zoomvideo/callback` replacing Cal.com URL with the URI at which your application runs.
-10. Also add the redirect URL given above as an allow list URL and enable "Subdomain check". Make sure, it says "saved" below the form.
-11. You don't need to provide basic information about your app. Instead click on "Scopes" and then on "+ Add Scopes". On the left, click the category "Meeting" and check the scope `meeting:write`.
-12. Click "Done".
-13. You're good to go. Now you can easily add your Zoom integration in the Cal.com settings.
+5. Choose "User-managed app" for "Select how the app is managed".
+6. De-select the option to publish the app on the Zoom App Marketplace, if asked.
+7. Now copy the Client ID and Client Secret to your `.env` file into the `ZOOM_CLIENT_ID` and `ZOOM_CLIENT_SECRET` fields.
+8. Set the "OAuth Redirect URL" under "OAuth Information" as `<Cal.com URL>/api/integrations/zoomvideo/callback` replacing Cal.com URL with the URI at which your application runs.
+9. Also add the redirect URL given above as an allow list URL and enable "Subdomain check". Make sure, it says "saved" below the form.
+10. You don't need to provide basic information about your app. Instead click on "Scopes" and then on "+ Add Scopes". On the left,
+    1. click the category "Meeting" and check the scope `meeting:write:meeting`.
+    2. click the category "User" and check the scope `user:read:settings`.
+11. Click "Done".
+12. You're good to go. Now you can easily add your Zoom integration in the Cal.com settings.
 
 ### Obtaining Daily API Credentials
 

apps/api/v1/lib/validations/team.ts

@@ -10,6 +10,7 @@ export const schemaTeamBaseBodyParams = Team.omit({ id: true, createdAt: true })
   isPlatform: true,
   smsLockState: true,
   smsLockReviewedByAdmin: true,
+  bookingLimits: true,
 });
 
 const schemaTeamRequiredParams = z.object({

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

@@ -41,8 +41,6 @@ import { getTranscriptFromRecordingId } from "~/lib/validations/shared/queryIdTr
  *     responses:
  *       200:
  *         description: OK
- *         content:
- *           application/json:
  *       401:
  *         description: Authorization information is missing or invalid.
  *       404:

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

@@ -32,8 +32,6 @@ import { schemaQueryIdParseInt } from "~/lib/validations/shared/queryIdTransform
  *     responses:
  *       200:
  *         description: OK
- *         content:
- *           application/json:
  *       401:
  *         description: Authorization information is missing or invalid.
  *       404:

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

@@ -123,9 +123,11 @@ export async function patchHandler(req: NextApiRequest) {
   // TODO: Perhaps there is a better fix for this?
   const cloneData: typeof data & {
     metadata: NonNullable<typeof data.metadata> | undefined;
+    bookingLimits: NonNullable<typeof data.bookingLimits> | undefined;
   } = {
     ...data,
     smsLockReviewedByAdmin: false,
+    bookingLimits: data.bookingLimits === null ? {} : data.bookingLimits,
     metadata: data.metadata === null ? {} : data.metadata || undefined,
   };
   const team = await prisma.team.update({ where: { id: teamId }, data: cloneData });

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

@@ -123,9 +123,11 @@ async function postHandler(req: NextApiRequest) {
   // TODO: Perhaps there is a better fix for this?
   const cloneData: typeof data & {
     metadata: NonNullable<typeof data.metadata> | undefined;
+    bookingLimits: NonNullable<typeof data.bookingLimits> | undefined;
   } = {
     ...data,
     smsLockReviewedByAdmin: false,
+    bookingLimits: data.bookingLimits === null ? {} : data.bookingLimits || undefined,
     metadata: data.metadata === null ? {} : data.metadata || undefined,
   };
 

apps/api/v2/README.md

@@ -44,8 +44,8 @@ Copy `.env.example` to `.env` and fill values.
 
 ## Add license Key to deployments table in DB
 
-id, logo  theme licenseKey                              agreedLicenseAt
-1,  null, null, 'c4234812-12ab-42s6-a1e3-55bedd4a5bb7', '2023-05-15 21:39:47.611'
+id, logo theme licenseKey agreedLicenseAt
+1, null, null, 'c4234812-12ab-42s6-a1e3-55bedd4a5bb7', '2023-05-15 21:39:47.611'
 
 your CALCOM_LICENSE_KEY env var need to contain the same value
 

apps/api/v2/jest-e2e.json

@@ -11,5 +11,7 @@
     "^.+\\.(t|j)s$": "ts-jest"
   },
   "setupFiles": ["<rootDir>/test/setEnvVars.ts"],
-  "reporters": ["default", "jest-summarizing-reporter"]
+  "reporters": ["default", "jest-summarizing-reporter"],
+  "workerIdleMemoryLimit": "512MB",
+  "maxWorkers": 2
 }

apps/api/v2/package.json

@@ -19,7 +19,7 @@
     "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 && jest --runInBand --detectOpenHandles --forceExit --config ./jest-e2e.json",
+    "test:e2e": "yarn dev:build && NODE_OPTIONS='--max_old_space_size=8192' jest --ci --forceExit --config ./jest-e2e.json",
     "test:e2e:watch": "yarn dev:build && jest --runInBand --detectOpenHandles --forceExit --config ./jest-e2e.json --watch",
     "prisma": "yarn workspace @calcom/prisma prisma",
     "generate-schemas": "yarn prisma generate && yarn prisma format",
@@ -28,7 +28,7 @@
   "dependencies": {
     "@calcom/platform-constants": "*",
     "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.36",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.40",
     "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",

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

@@ -1,4 +1,4 @@
-import { BookingsController } from "@/ee/bookings/controllers/bookings.controller";
+import { BookingsController_2024_04_15 } from "@/ee/bookings/2024-04-15/controllers/bookings.controller";
 import { ApiKeyRepository } from "@/modules/api-key/api-key-repository";
 import { BillingModule } from "@/modules/billing/billing.module";
 import { OAuthClientRepository } from "@/modules/oauth-clients/oauth-client.repository";
@@ -12,6 +12,6 @@ import { Module } from "@nestjs/common";
 @Module({
   imports: [PrismaModule, RedisModule, TokensModule, BillingModule],
   providers: [TokensRepository, OAuthFlowService, OAuthClientRepository, ApiKeyRepository],
-  controllers: [BookingsController],
+  controllers: [BookingsController_2024_04_15],
 })
-export class BookingsModule {}
+export class BookingsModule_2024_04_15 {}

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

@@ -1,8 +1,8 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
-import { CreateBookingInput } from "@/ee/bookings/inputs/create-booking.input";
-import { GetBookingOutput } from "@/ee/bookings/outputs/get-booking.output";
-import { GetBookingsOutput } from "@/ee/bookings/outputs/get-bookings.output";
+import { CreateBookingInput_2024_04_15 } from "@/ee/bookings/2024-04-15/inputs/create-booking.input";
+import { GetBookingOutput_2024_04_15 } from "@/ee/bookings/2024-04-15/outputs/get-booking.output";
+import { GetBookingsOutput_2024_04_15 } from "@/ee/bookings/2024-04-15/outputs/get-bookings.output";
 import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
 import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
 import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
@@ -24,7 +24,7 @@ import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
 import { handleNewBooking } from "@calcom/platform-libraries";
 import { ApiSuccessResponse, ApiResponse, ApiErrorResponse } from "@calcom/platform-types";
 
-describe("Bookings Endpoints", () => {
+describe("Bookings Endpoints 2024-04-15", () => {
   describe("User Authenticated", () => {
     let app: INestApplication;
 
@@ -111,7 +111,7 @@ describe("Bookings Endpoints", () => {
         guests: [],
       };
 
-      const body: CreateBookingInput = {
+      const body: CreateBookingInput_2024_04_15 = {
         start: bookingStart,
         end: bookingEnd,
         eventTypeId: bookingEventTypeId,
@@ -166,7 +166,7 @@ describe("Bookings Endpoints", () => {
         guests: [],
       };
 
-      const body: CreateBookingInput = {
+      const body: CreateBookingInput_2024_04_15 = {
         start: bookingStart,
         end: bookingEnd,
         eventTypeId: bookingEventTypeId,
@@ -209,7 +209,7 @@ describe("Bookings Endpoints", () => {
         guests: [],
       };
 
-      const body: CreateBookingInput = {
+      const body: CreateBookingInput_2024_04_15 = {
         start: bookingStart,
         end: bookingEnd,
         eventTypeId: bookingEventTypeId,
@@ -266,7 +266,7 @@ describe("Bookings Endpoints", () => {
           guests: [],
         };
 
-        const body: CreateBookingInput = {
+        const body: CreateBookingInput_2024_04_15 = {
           rescheduleUid: createdBooking.uid,
           start: newBookingStart,
           end: newBookingEnd,
@@ -305,7 +305,7 @@ describe("Bookings Endpoints", () => {
       return request(app.getHttpServer())
         .get("/v2/bookings?filters[status]=upcoming")
         .then((response) => {
-          const responseBody: GetBookingsOutput = response.body;
+          const responseBody: GetBookingsOutput_2024_04_15 = response.body;
 
           expect(responseBody.data.bookings.length).toEqual(2);
           const fetchedBooking = responseBody.data.bookings.find(
@@ -329,7 +329,7 @@ describe("Bookings Endpoints", () => {
       return request(app.getHttpServer())
         .get(`/v2/bookings/${createdBooking.uid}`)
         .then((response) => {
-          const responseBody: GetBookingOutput = response.body;
+          const responseBody: GetBookingOutput_2024_04_15 = response.body;
           const bookingInfo = responseBody.data;
 
           expect(responseBody.status).toEqual(SUCCESS_STATUS);

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

@@ -1,11 +1,11 @@
-import { CreateBookingInput } from "@/ee/bookings/inputs/create-booking.input";
-import { CreateRecurringBookingInput } from "@/ee/bookings/inputs/create-recurring-booking.input";
-import { MarkNoShowInput } from "@/ee/bookings/inputs/mark-no-show.input";
-import { GetBookingOutput } from "@/ee/bookings/outputs/get-booking.output";
-import { GetBookingsOutput } from "@/ee/bookings/outputs/get-bookings.output";
-import { MarkNoShowOutput } from "@/ee/bookings/outputs/mark-no-show.output";
+import { CreateBookingInput_2024_04_15 } from "@/ee/bookings/2024-04-15/inputs/create-booking.input";
+import { CreateRecurringBookingInput_2024_04_15 } from "@/ee/bookings/2024-04-15/inputs/create-recurring-booking.input";
+import { MarkNoShowInput_2024_04_15 } from "@/ee/bookings/2024-04-15/inputs/mark-no-show.input";
+import { GetBookingOutput_2024_04_15 } from "@/ee/bookings/2024-04-15/outputs/get-booking.output";
+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 { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
-import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { VERSION_2024_04_15, VERSION_2024_06_11, VERSION_2024_06_14 } from "@/lib/api-versions";
 import { ApiKeyRepository } from "@/modules/api-key/api-key-repository";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { Permissions } from "@/modules/auth/decorators/permissions/permissions.decorator";
@@ -31,7 +31,7 @@ import {
   UseGuards,
 } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
-import { ApiQuery, ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiQuery, ApiExcludeController as DocsExcludeController } from "@nestjs/swagger";
 import { User } from "@prisma/client";
 import { Request } from "express";
 import { NextApiRequest } from "next/types";
@@ -40,10 +40,10 @@ import { v4 as uuidv4 } from "uuid";
 import { X_CAL_CLIENT_ID } from "@calcom/platform-constants";
 import { BOOKING_READ, SUCCESS_STATUS, BOOKING_WRITE } from "@calcom/platform-constants";
 import {
+  handleNewRecurringBooking,
   handleNewBooking,
   BookingResponse,
   HttpError,
-  handleNewRecurringBooking,
   handleInstantMeeting,
   handleMarkNoShow,
   getAllUserBookings,
@@ -52,7 +52,11 @@ import {
   getBookingForReschedule,
   ErrorCode,
 } from "@calcom/platform-libraries";
-import { GetBookingsInput, CancelBookingInput, Status } from "@calcom/platform-types";
+import {
+  GetBookingsInput_2024_04_15,
+  CancelBookingInput_2024_04_15,
+  Status_2024_04_15,
+} from "@calcom/platform-types";
 import { ApiResponse } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
 
@@ -80,11 +84,11 @@ const DEFAULT_PLATFORM_PARAMS = {
 
 @Controller({
   path: "/v2/bookings",
-  version: API_VERSIONS_VALUES,
+  version: [VERSION_2024_04_15, VERSION_2024_06_11, VERSION_2024_06_14],
 })
 @UseGuards(PermissionsGuard)
-@DocsTags("Bookings")
-export class BookingsController {
+@DocsExcludeController(true)
+export class BookingsController_2024_04_15 {
   private readonly logger = new Logger("BookingsController");
 
   constructor(
@@ -99,16 +103,16 @@ export class BookingsController {
   @Get("/")
   @UseGuards(ApiAuthGuard)
   @Permissions([BOOKING_READ])
-  @ApiQuery({ name: "filters[status]", enum: Status, required: true })
+  @ApiQuery({ name: "filters[status]", enum: Status_2024_04_15, required: true })
   @ApiQuery({ name: "limit", type: "number", required: false })
   @ApiQuery({ name: "cursor", type: "number", required: false })
   async getBookings(
     @GetUser() user: User,
-    @Query() queryParams: GetBookingsInput
-  ): Promise<GetBookingsOutput> {
+    @Query() queryParams: GetBookingsInput_2024_04_15
+  ): Promise<GetBookingsOutput_2024_04_15> {
     const { filters, cursor, limit } = queryParams;
     const bookings = await getAllUserBookings({
-      bookingListingByStatus: filters.status,
+      bookingListingByStatus: [filters.status],
       skip: cursor ?? 0,
       take: limit ?? 10,
       filters,
@@ -125,7 +129,7 @@ export class BookingsController {
   }
 
   @Get("/:bookingUid")
-  async getBooking(@Param("bookingUid") bookingUid: string): Promise<GetBookingOutput> {
+  async getBooking(@Param("bookingUid") bookingUid: string): Promise<GetBookingOutput_2024_04_15> {
     const { bookingInfo } = await getBookingInfo(bookingUid);
 
     if (!bookingInfo) {
@@ -155,7 +159,7 @@ export class BookingsController {
   @Post("/")
   async createBooking(
     @Req() req: BookingRequest,
-    @Body() body: CreateBookingInput,
+    @Body() body: CreateBookingInput_2024_04_15,
     @Headers(X_CAL_CLIENT_ID) clientId?: string
   ): Promise<ApiResponse<Partial<BookingResponse>>> {
     const oAuthClientId = clientId?.toString();
@@ -186,7 +190,7 @@ export class BookingsController {
   async cancelBooking(
     @Req() req: BookingRequest,
     @Param("bookingId") bookingId: string,
-    @Body() _: CancelBookingInput,
+    @Body() _: CancelBookingInput_2024_04_15,
     @Headers(X_CAL_CLIENT_ID) clientId?: string
   ): Promise<ApiResponse<{ bookingId: number; bookingUid: string; onlyRemovedAttendee: boolean }>> {
     const oAuthClientId = clientId?.toString();
@@ -219,9 +223,9 @@ export class BookingsController {
   @UseGuards(ApiAuthGuard)
   async markNoShow(
     @GetUser("id") userId: number,
-    @Body() body: MarkNoShowInput,
+    @Body() body: MarkNoShowInput_2024_04_15,
     @Param("bookingUid") bookingUid: string
-  ): Promise<MarkNoShowOutput> {
+  ): Promise<MarkNoShowOutput_2024_04_15> {
     try {
       const markNoShowResponse = await handleMarkNoShow({
         bookingUid: bookingUid,
@@ -240,7 +244,7 @@ export class BookingsController {
   @Post("/recurring")
   async createRecurringBooking(
     @Req() req: BookingRequest,
-    @Body() _: CreateRecurringBookingInput[],
+    @Body() _: CreateRecurringBookingInput_2024_04_15[],
     @Headers(X_CAL_CLIENT_ID) clientId?: string
   ): Promise<ApiResponse<BookingResponse[]>> {
     const oAuthClientId = clientId?.toString();
@@ -278,7 +282,7 @@ export class BookingsController {
   @Post("/instant")
   async createInstantBooking(
     @Req() req: BookingRequest,
-    @Body() _: CreateBookingInput,
+    @Body() _: CreateBookingInput_2024_04_15,
     @Headers(X_CAL_CLIENT_ID) clientId?: string
   ): Promise<ApiResponse<Awaited<ReturnType<typeof handleInstantMeeting>>>> {
     const oAuthClientId = clientId?.toString();
@@ -369,7 +373,12 @@ export class BookingsController {
     const oAuthParams = oAuthClientId
       ? await this.getOAuthClientsParams(oAuthClientId)
       : DEFAULT_PLATFORM_PARAMS;
-    Object.assign(req, { userId, ...oAuthParams, platformBookingLocation });
+    Object.assign(req, {
+      userId,
+      ...oAuthParams,
+      platformBookingLocation,
+      noEmail: !oAuthParams.arePlatformEmailsEnabled,
+    });
     return req as unknown as NextApiRequest & { userId?: number } & OAuthRequestParams;
   }
 

apps/api/v2/src/ee/bookings/2024-04-15/inputs/create-booking.input.ts

@@ -40,7 +40,7 @@ class Response {
   notes?: string;
 }
 
-export class CreateBookingInput {
+export class CreateBookingInput_2024_04_15 {
   @IsString()
   @IsOptional()
   end?: string;

apps/api/v2/src/ee/bookings/2024-04-15/inputs/create-recurring-booking.input.ts

@@ -1,9 +1,9 @@
-import { CreateBookingInput } from "@/ee/bookings/inputs/create-booking.input";
+import { CreateBookingInput_2024_04_15 } from "@/ee/bookings/2024-04-15/inputs/create-booking.input";
 import { IsBoolean, IsString, IsNumber, IsOptional } from "class-validator";
 
 import type { AppsStatus } from "@calcom/platform-libraries";
 
-export class CreateRecurringBookingInput extends CreateBookingInput {
+export class CreateRecurringBookingInput_2024_04_15 extends CreateBookingInput_2024_04_15 {
   @IsBoolean()
   @IsOptional()
   noEmail?: boolean;

apps/api/v2/src/ee/bookings/2024-04-15/inputs/mark-no-show.input.ts

@@ -9,7 +9,7 @@ class Attendee {
   noShow!: boolean;
 }
 
-export class MarkNoShowInput {
+export class MarkNoShowInput_2024_04_15 {
   @IsBoolean()
   @IsOptional()
   noShowHost?: boolean;

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

@@ -88,7 +88,7 @@ class EventType {
   timeZone!: string | null;
 }
 
-class GetBookingData {
+class GetBookingData_2024_04_15 {
   @IsString()
   title!: string;
 
@@ -159,15 +159,15 @@ class GetBookingData {
   eventType!: EventType | null;
 }
 
-export class GetBookingOutput {
+export class GetBookingOutput_2024_04_15 {
   @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
   @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
   status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
 
   @ApiProperty({
-    type: GetBookingData,
+    type: GetBookingData_2024_04_15,
   })
   @ValidateNested()
-  @Type(() => GetBookingData)
-  data!: GetBookingData;
+  @Type(() => GetBookingData_2024_04_15)
+  data!: GetBookingData_2024_04_15;
 }

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

@@ -202,7 +202,7 @@ class GetBookingsDataEntry {
   rescheduled?: any;
 }
 
-class GetBookingsData {
+class GetBookingsData_2024_04_15 {
   @ValidateNested()
   @Type(() => GetBookingsDataEntry)
   @IsArray()
@@ -215,15 +215,15 @@ class GetBookingsData {
   nextCursor!: number | null;
 }
 
-export class GetBookingsOutput {
+export class GetBookingsOutput_2024_04_15 {
   @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
   @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
   status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
 
   @ApiProperty({
-    type: GetBookingsData,
+    type: GetBookingsData_2024_04_15,
   })
   @ValidateNested()
-  @Type(() => GetBookingsData)
-  data!: GetBookingsData;
+  @Type(() => GetBookingsData_2024_04_15)
+  data!: GetBookingsData_2024_04_15;
 }

apps/api/v2/src/ee/bookings/2024-04-15/outputs/mark-no-show.output.ts

@@ -12,7 +12,7 @@ class Attendee {
   noShow!: boolean;
 }
 
-class HandleMarkNoShowData {
+class HandleMarkNoShowData_2024_04_15 {
   @IsString()
   message!: string;
 
@@ -27,15 +27,15 @@ class HandleMarkNoShowData {
   attendees?: Attendee[];
 }
 
-export class MarkNoShowOutput {
+export class MarkNoShowOutput_2024_04_15 {
   @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
   @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
   status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
 
   @ApiProperty({
-    type: HandleMarkNoShowData,
+    type: HandleMarkNoShowData_2024_04_15,
   })
   @ValidateNested()
-  @Type(() => HandleMarkNoShowData)
-  data!: HandleMarkNoShowData;
+  @Type(() => HandleMarkNoShowData_2024_04_15)
+  data!: HandleMarkNoShowData_2024_04_15;
 }

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

@@ -0,0 +1,33 @@
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
+import { BookingsController_2024_08_13 } from "@/ee/bookings/2024-08-13/controllers/bookings.controller";
+import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
+import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/input.service";
+import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
+import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { ApiKeyRepository } from "@/modules/api-key/api-key-repository";
+import { BillingModule } from "@/modules/billing/billing.module";
+import { OAuthClientRepository } from "@/modules/oauth-clients/oauth-client.repository";
+import { OAuthFlowService } from "@/modules/oauth-clients/services/oauth-flow.service";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { RedisModule } from "@/modules/redis/redis.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { TokensRepository } from "@/modules/tokens/tokens.repository";
+import { UsersModule } from "@/modules/users/users.module";
+import { Module } from "@nestjs/common";
+
+@Module({
+  imports: [PrismaModule, RedisModule, TokensModule, BillingModule, UsersModule],
+  providers: [
+    TokensRepository,
+    OAuthFlowService,
+    OAuthClientRepository,
+    BookingsService_2024_08_13,
+    InputBookingsService_2024_08_13,
+    OutputBookingsService_2024_08_13,
+    BookingsRepository_2024_08_13,
+    EventTypesRepository_2024_06_14,
+    ApiKeyRepository,
+  ],
+  controllers: [BookingsController_2024_08_13],
+})
+export class BookingsModule_2024_08_13 {}

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

@@ -0,0 +1,86 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class BookingsRepository_2024_08_13 {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getById(id: number) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        id,
+      },
+    });
+  }
+
+  async getByIdsWithAttendeesAndUser(ids: number[]) {
+    return this.dbRead.prisma.booking.findMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+      include: {
+        attendees: true,
+        user: true,
+      },
+    });
+  }
+
+  async getByUid(bookingUid: string) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        uid: bookingUid,
+      },
+    });
+  }
+
+  async getByIdWithAttendeesAndUser(id: number) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        id,
+      },
+      include: {
+        attendees: true,
+        user: true,
+      },
+    });
+  }
+
+  async getByUidWithAttendeesAndUser(uid: string) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        uid,
+      },
+      include: {
+        attendees: true,
+        user: true,
+      },
+    });
+  }
+
+  async getRecurringByUidWithAttendeesAndUser(uid: string) {
+    return this.dbRead.prisma.booking.findMany({
+      where: {
+        recurringEventId: uid,
+      },
+      include: {
+        attendees: true,
+        user: true,
+      },
+    });
+  }
+
+  async getByFromReschedule(fromReschedule: string) {
+    return this.dbRead.prisma.booking.findFirst({
+      where: {
+        fromReschedule,
+      },
+      include: {
+        attendees: true,
+        user: true,
+      },
+    });
+  }
+}

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

@@ -0,0 +1,160 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import { CreateBookingInput_2024_08_13, BookingOutput_2024_08_13 } from "@calcom/platform-types";
+import { Team } from "@calcom/prisma/client";
+
+describe("Bookings Endpoints 2024-08-13", () => {
+  describe("With api key", () => {
+    let app: INestApplication;
+    let organization: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+    let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+    let apiKeyString: string;
+
+    const userEmail = "bookings-controller-e2e@api.com";
+    let user: User;
+
+    let eventTypeId: number;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+      apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
+
+      organization = await teamRepositoryFixture.create({ name: "organization bookings" });
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+      });
+
+      const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+      apiKeyString = keyString;
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(user.id, userSchedule);
+      const event = await eventTypesRepositoryFixture.create(
+        { title: "peer coding", slug: "peer-coding", length: 60 },
+        user.id
+      );
+      eventTypeId = event.id;
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    it("should be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(user).toBeDefined();
+    });
+
+    describe("create bookings", () => {
+      it("should create a booking with api key", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+          eventTypeId,
+          attendee: {
+            name: "Mr Key",
+            email: "mr_key@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          meetingUrl: "https://meet.google.com/abc-def-ghi",
+        };
+
+        return request(app.getHttpServer())
+          .post("/v2/bookings")
+          .send(body)
+          .set({ Authorization: `Bearer cal_test_${apiKeyString}` })
+          .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(data.hosts[0].id).toEqual(user.id);
+              expect(data.status).toEqual("accepted");
+              expect(data.start).toEqual(body.start);
+              expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString());
+              expect(data.duration).toEqual(60);
+              expect(data.eventTypeId).toEqual(eventTypeId);
+              expect(data.attendees[0]).toEqual({
+                name: body.attendee.name,
+                timeZone: body.attendee.timeZone,
+                language: body.attendee.language,
+                absent: false,
+              });
+              expect(data.meetingUrl).toEqual(body.meetingUrl);
+              expect(data.absentHost).toEqual(false);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+    });
+
+    function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+      return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+    }
+
+    afterAll(async () => {
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
+      await app.close();
+    });
+  });
+});

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

@@ -0,0 +1,222 @@
+import { BookingUidGuard } from "@/ee/bookings/2024-08-13/guards/booking-uid.guard";
+import { CancelBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/cancel-booking.output";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { GetBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/get-booking.output";
+import { GetBookingsOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/get-bookings.output";
+import { MarkAbsentBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/mark-absent.output";
+import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
+import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
+import { VERSION_2024_08_13_VALUE } from "@/lib/api-versions";
+import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
+import { Permissions } from "@/modules/auth/decorators/permissions/permissions.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import {
+  Controller,
+  Post,
+  Logger,
+  Body,
+  UseGuards,
+  Req,
+  Get,
+  Param,
+  Query,
+  HttpCode,
+  HttpStatus,
+} from "@nestjs/common";
+import {
+  ApiOperation,
+  ApiTags as DocsTags,
+  ApiHeader,
+  getSchemaPath,
+  ApiBody,
+  ApiExtraModels,
+} from "@nestjs/swagger";
+import { User } from "@prisma/client";
+import { Request } from "express";
+
+import { BOOKING_READ, BOOKING_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
+import {
+  CreateBookingInputPipe,
+  CreateBookingInput,
+  GetBookingsInput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+  CancelBookingInput_2024_08_13,
+  MarkAbsentBookingInput_2024_08_13,
+  CreateBookingInput_2024_08_13,
+  CreateInstantBookingInput_2024_08_13,
+  CreateRecurringBookingInput_2024_08_13,
+} from "@calcom/platform-types";
+
+@Controller({
+  path: "/v2/bookings",
+  version: VERSION_2024_08_13_VALUE,
+})
+@UseGuards(PermissionsGuard)
+@DocsTags("Bookings")
+@ApiHeader({
+  name: "cal-api-version",
+  description: `Must be set to \`2024-08-13\``,
+  required: true,
+})
+export class BookingsController_2024_08_13 {
+  private readonly logger = new Logger("BookingsController");
+
+  constructor(private readonly bookingsService: BookingsService_2024_08_13) {}
+
+  @Post("/")
+  @ApiOperation({
+    summary: "Create a booking",
+    description: `
+      POST /v2/bookings is used to create regular bookings, recurring bookings and instant bookings. The request bodies for all 3 are almost the same except:
+      If eventTypeId in the request body is id of a regular event, then regular booking is created.
+
+      If it is an id of a recurring event type, then recurring booking is created.
+
+      Meaning that the request bodies are equal but the outcome depends on what kind of event type it is with the goal of making it as seamless for developers as possible.
+
+      For team event types it is possible to create instant meeting. To do that just pass \`"instant": true\` to the request body.
+
+      The start needs to be in UTC aka if the timezone is GMT+2 in Rome and meeting should start at 11, then UTC time should have hours 09:00 aka without time zone.
+      `,
+  })
+  @ApiBody({
+    schema: {
+      oneOf: [
+        { $ref: getSchemaPath(CreateBookingInput_2024_08_13) },
+        { $ref: getSchemaPath(CreateInstantBookingInput_2024_08_13) },
+        { $ref: getSchemaPath(CreateRecurringBookingInput_2024_08_13) },
+      ],
+    },
+    description:
+      "Accepts different types of booking input: CreateBookingInput_2024_08_13, CreateInstantBookingInput_2024_08_13, or CreateRecurringBookingInput_2024_08_13",
+  })
+  @ApiExtraModels(
+    CreateBookingInput_2024_08_13,
+    CreateInstantBookingInput_2024_08_13,
+    CreateRecurringBookingInput_2024_08_13
+  )
+  async createBooking(
+    @Body(new CreateBookingInputPipe())
+    body: CreateBookingInput,
+    @Req() request: Request
+  ): Promise<CreateBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.createBooking(request, body);
+
+    if (Array.isArray(booking)) {
+      await this.bookingsService.billBookings(booking);
+    } else {
+      await this.bookingsService.billBooking(booking);
+    }
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
+
+  @Get("/:bookingUid")
+  @UseGuards(BookingUidGuard)
+  @ApiOperation({
+    summary: "Get a booking",
+    description: `\`:bookingUid\` can be
+
+      1. uid of a normal booking
+
+      2. uid of one of the recurring booking recurrences
+
+      3. uid of recurring booking which will return an array of all recurring booking recurrences (stored as recurringBookingUid on one of the individual recurrences).`,
+  })
+  async getBooking(@Param("bookingUid") bookingUid: string): Promise<GetBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.getBooking(bookingUid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
+
+  @Get("/")
+  @UseGuards(ApiAuthGuard)
+  @ApiHeader({
+    name: "Authorization",
+    description:
+      "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
+    required: true,
+  })
+  @Permissions([BOOKING_READ])
+  @ApiOperation({ summary: "Get all bookings" })
+  async getBookings(
+    @Query() queryParams: GetBookingsInput_2024_08_13,
+    @GetUser() user: User
+  ): Promise<GetBookingsOutput_2024_08_13> {
+    const bookings = await this.bookingsService.getBookings(queryParams, user);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: bookings,
+    };
+  }
+
+  @Post("/:bookingUid/reschedule")
+  @UseGuards(BookingUidGuard)
+  @ApiOperation({
+    summary: "Reschedule a booking",
+    description:
+      "Reschedule a booking by passing `:bookingUid` of the booking that should be rescheduled and pass request body with a new start time to create a new booking.",
+  })
+  async rescheduleBooking(
+    @Param("bookingUid") bookingUid: string,
+    @Body() body: RescheduleBookingInput_2024_08_13,
+    @Req() request: Request
+  ): Promise<RescheduleBookingOutput_2024_08_13> {
+    const newBooking = await this.bookingsService.rescheduleBooking(request, bookingUid, body);
+    await this.bookingsService.billRescheduledBooking(newBooking, bookingUid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: newBooking,
+    };
+  }
+
+  @Post("/:bookingUid/cancel")
+  @UseGuards(BookingUidGuard)
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Cancel a booking" })
+  async cancelBooking(
+    @Req() request: Request,
+    @Param("bookingUid") bookingUid: string,
+    @Body() body: CancelBookingInput_2024_08_13
+  ): Promise<CancelBookingOutput_2024_08_13> {
+    const cancelledBooking = await this.bookingsService.cancelBooking(request, bookingUid, body);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: cancelledBooking,
+    };
+  }
+
+  @Post("/:bookingUid/mark-absent")
+  @HttpCode(HttpStatus.OK)
+  @Permissions([BOOKING_WRITE])
+  @UseGuards(ApiAuthGuard, BookingUidGuard)
+  @ApiHeader({
+    name: "Authorization",
+    description:
+      "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
+    required: true,
+  })
+  @ApiOperation({ summary: "Mark a booking absence" })
+  async markNoShow(
+    @Param("bookingUid") bookingUid: string,
+    @Body() body: MarkAbsentBookingInput_2024_08_13,
+    @GetUser("id") ownerId: number
+  ): Promise<MarkAbsentBookingOutput_2024_08_13> {
+    const booking = await this.bookingsService.markAbsent(bookingUid, ownerId, body);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: booking,
+    };
+  }
+}

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

@@ -0,0 +1,435 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CreateBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/create-booking.output";
+import { GetBookingsOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/get-bookings.output";
+import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
+import { SchedulesModule_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.module";
+import { SchedulesService_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/services/schedules.service";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { HostsRepositoryFixture } from "test/fixtures/repository/hosts.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { OrganizationRepositoryFixture } from "test/fixtures/repository/organization.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
+import {
+  CreateBookingInput_2024_08_13,
+  BookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { PlatformOAuthClient, Team } from "@calcom/prisma/client";
+
+describe("Bookings Endpoints 2024-08-13", () => {
+  describe("Team bookings", () => {
+    let app: INestApplication;
+    let organization: Team;
+    let team1: Team;
+    let team2: Team;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let bookingsRepositoryFixture: BookingsRepositoryFixture;
+    let schedulesService: SchedulesService_2024_04_15;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+    let oAuthClient: PlatformOAuthClient;
+    let teamRepositoryFixture: TeamRepositoryFixture;
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
+    let hostsRepositoryFixture: HostsRepositoryFixture;
+    let organizationsRepositoryFixture: OrganizationRepositoryFixture;
+    let profileRepositoryFixture: ProfileRepositoryFixture;
+
+    const teamUserEmail = "orgUser1team1@api.com";
+    const teamUserEmail2 = "orgUser2team1@api.com";
+    let teamUser: User;
+    let teamUser2: User;
+
+    let team1EventTypeId: number;
+    let team2EventTypeId: number;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        teamUserEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+        })
+      )
+        .overrideGuard(PermissionsGuard)
+        .useValue({
+          canActivate: () => true,
+        })
+        .compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      bookingsRepositoryFixture = new BookingsRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      organizationsRepositoryFixture = new OrganizationRepositoryFixture(moduleRef);
+      profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+      hostsRepositoryFixture = new HostsRepositoryFixture(moduleRef);
+      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+
+      organization = await organizationsRepositoryFixture.create({ name: "organization team bookings" });
+      team1 = await teamRepositoryFixture.create({
+        name: "team 1",
+        isOrganization: false,
+        parent: { connect: { id: organization.id } },
+      });
+
+      team2 = await teamRepositoryFixture.create({
+        name: "team 2",
+        isOrganization: false,
+        parent: { connect: { id: organization.id } },
+      });
+
+      oAuthClient = await createOAuthClient(organization.id);
+
+      teamUser = await userRepositoryFixture.create({
+        email: teamUserEmail,
+        locale: "it",
+        name: "orgUser1team1",
+      });
+
+      teamUser2 = await userRepositoryFixture.create({
+        email: teamUserEmail2,
+        locale: "es",
+        name: "orgUser2team1",
+      });
+
+      const userSchedule: CreateScheduleInput_2024_04_15 = {
+        name: "working time",
+        timeZone: "Europe/Rome",
+        isDefault: true,
+      };
+      await schedulesService.createUserSchedule(teamUser.id, userSchedule);
+      await schedulesService.createUserSchedule(teamUser2.id, userSchedule);
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${teamUser.id}`,
+        username: teamUserEmail,
+        organization: {
+          connect: {
+            id: organization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: teamUser.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${teamUser2.id}`,
+        username: teamUserEmail2,
+        organization: {
+          connect: {
+            id: organization.id,
+          },
+        },
+        user: {
+          connect: {
+            id: teamUser2.id,
+          },
+        },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: teamUser.id } },
+        team: { connect: { id: team1.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: teamUser.id } },
+        team: { connect: { id: team2.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: teamUser2.id } },
+        team: { connect: { id: team2.id } },
+        accepted: true,
+      });
+
+      const team1EventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "COLLECTIVE",
+        team: {
+          connect: { id: team1.id },
+        },
+        title: "Collective Event Type",
+        slug: "collective-event-type",
+        length: 60,
+        assignAllTeamMembers: true,
+        bookingFields: [],
+        locations: [],
+      });
+
+      team1EventTypeId = team1EventType.id;
+
+      const team2EventType = await eventTypesRepositoryFixture.createTeamEventType({
+        schedulingType: "COLLECTIVE",
+        team: {
+          connect: { id: team2.id },
+        },
+        title: "Collective Event Type 2",
+        slug: "collective-event-type-2",
+        length: 60,
+        assignAllTeamMembers: true,
+        bookingFields: [],
+        locations: [],
+      });
+
+      team2EventTypeId = team2EventType.id;
+
+      await hostsRepositoryFixture.create({
+        isFixed: true,
+        user: {
+          connect: {
+            id: teamUser.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: team1EventType.id,
+          },
+        },
+      });
+
+      await hostsRepositoryFixture.create({
+        isFixed: true,
+        user: {
+          connect: {
+            id: teamUser.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: team2EventType.id,
+          },
+        },
+      });
+
+      await hostsRepositoryFixture.create({
+        isFixed: true,
+        user: {
+          connect: {
+            id: teamUser2.id,
+          },
+        },
+        eventType: {
+          connect: {
+            id: team2EventType.id,
+          },
+        },
+      });
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    describe("create team bookings", () => {
+      it("should create a team 1 booking", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
+          eventTypeId: team1EventTypeId,
+          attendee: {
+            name: "alice",
+            email: "alice@gmail.com",
+            timeZone: "Europe/Madrid",
+            language: "es",
+          },
+          meetingUrl: "https://meet.google.com/abc-def-ghi",
+        };
+
+        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(data.hosts.length).toEqual(1);
+              expect(data.hosts[0].id).toEqual(teamUser.id);
+              expect(data.status).toEqual("accepted");
+              expect(data.start).toEqual(body.start);
+              expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString());
+              expect(data.duration).toEqual(60);
+              expect(data.eventTypeId).toEqual(team1EventTypeId);
+              expect(data.attendees.length).toEqual(1);
+              expect(data.attendees[0]).toEqual({
+                name: body.attendee.name,
+                timeZone: body.attendee.timeZone,
+                language: body.attendee.language,
+                absent: false,
+              });
+              expect(data.meetingUrl).toEqual(body.meetingUrl);
+              expect(data.absentHost).toEqual(false);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+
+      it("should create a team 2 booking", async () => {
+        const body: CreateBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2030, 0, 8, 10, 0, 0)).toISOString(),
+          eventTypeId: team2EventTypeId,
+          attendee: {
+            name: "bob",
+            email: "bob@gmail.com",
+            timeZone: "Europe/Rome",
+            language: "it",
+          },
+          meetingUrl: "https://meet.google.com/abc-def-ghi",
+        };
+
+        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(data.hosts.length).toEqual(1);
+              expect(data.hosts[0].id).toEqual(teamUser.id);
+              expect(data.status).toEqual("accepted");
+              expect(data.start).toEqual(body.start);
+              expect(data.end).toEqual(new Date(Date.UTC(2030, 0, 8, 11, 0, 0)).toISOString());
+              expect(data.duration).toEqual(60);
+              expect(data.eventTypeId).toEqual(team2EventTypeId);
+              expect(data.attendees.length).toEqual(2);
+              expect(data.attendees[0]).toEqual({
+                name: body.attendee.name,
+                timeZone: body.attendee.timeZone,
+                language: body.attendee.language,
+                absent: false,
+              });
+              expect(data.attendees[1]).toEqual({
+                name: teamUser2.name,
+                timeZone: teamUser2.timeZone,
+                language: teamUser2.locale,
+                absent: false,
+              });
+              expect(data.meetingUrl).toEqual(body.meetingUrl);
+              expect(data.absentHost).toEqual(false);
+            } else {
+              throw new Error(
+                "Invalid response data - expected booking but received array of possibily recurring bookings"
+              );
+            }
+          });
+      });
+    });
+
+    describe("get team bookings", () => {
+      it("should should get bookings by teamId", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/bookings?teamId=${team1.id}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingsOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            expect(data.length).toEqual(1);
+            expect(data[0].eventTypeId).toEqual(team1EventTypeId);
+          });
+      });
+
+      it("should should get bookings by teamId", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/bookings?teamId=${team2.id}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingsOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            expect(data.length).toEqual(1);
+            expect(data[0].eventTypeId).toEqual(team2EventTypeId);
+          });
+      });
+
+      it("should should get bookings by teamIds", async () => {
+        return request(app.getHttpServer())
+          .get(`/v2/bookings?teamIds=${team1.id},${team2.id}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: GetBookingsOutput_2024_08_13 = response.body;
+            expect(responseBody.status).toEqual(SUCCESS_STATUS);
+            expect(responseBody.data).toBeDefined();
+            const data: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = responseBody.data;
+            expect(data.length).toEqual(2);
+            expect(data.find((booking) => booking.eventTypeId === team1EventTypeId)).toBeDefined();
+            expect(data.find((booking) => booking.eventTypeId === team2EventTypeId)).toBeDefined();
+          });
+      });
+    });
+
+    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;
+    }
+
+    function responseDataIsBooking(data: any): data is BookingOutput_2024_08_13 {
+      return !Array.isArray(data) && typeof data === "object" && data && "id" in data;
+    }
+
+    afterAll(async () => {
+      await oauthClientRepositoryFixture.delete(oAuthClient.id);
+      await teamRepositoryFixture.delete(organization.id);
+      await userRepositoryFixture.deleteByEmail(teamUser.email);
+      await bookingsRepositoryFixture.deleteAllBookings(teamUser.id, teamUser.email);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/ee/bookings/2024-08-13/guards/booking-uid.guard.ts

@@ -0,0 +1,16 @@
+import { Injectable, CanActivate, ExecutionContext, BadRequestException } from "@nestjs/common";
+
+@Injectable()
+export class BookingUidGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+
+    const bookingUid = request.params.bookingUid;
+
+    if (!bookingUid) {
+      throw new BadRequestException("Booking UID missing in the request path");
+    }
+
+    return true;
+  }
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/cancel-booking.output.ts

@@ -0,0 +1,26 @@
+import { ApiProperty, ApiExtraModels, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+
+@ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
+export class CancelBookingOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ValidateNested()
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(BookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
+      { type: "array", items: { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) } },
+    ],
+    description:
+      "Booking data, which can be either a BookingOutput object, a RecurringBookingOutput object, or an array of RecurringBookingOutput objects",
+  })
+  @Type(() => Object)
+  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13[];
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/create-booking.output.ts

@@ -0,0 +1,25 @@
+import { ApiProperty, ApiExtraModels, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+
+@ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
+export class CreateBookingOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ValidateNested()
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(BookingOutput_2024_08_13) },
+      { type: "array", items: { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) } },
+    ],
+    description:
+      "Booking data, which can be either a BookingOutput object or an array of RecurringBookingOutput objects",
+  })
+  @Type(() => Object)
+  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13[];
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/get-booking.output.ts

@@ -0,0 +1,26 @@
+import { ApiProperty, ApiExtraModels, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+
+@ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
+export class GetBookingOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ValidateNested()
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(BookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
+      { type: "array", items: { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) } },
+    ],
+    description:
+      "Booking data, which can be either a BookingOutput object, a RecurringBookingOutput object, or an array of RecurringBookingOutput objects",
+  })
+  @Type(() => Object)
+  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13[];
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/get-bookings.output.ts

@@ -0,0 +1,26 @@
+import { ApiProperty, ApiExtraModels, getSchemaPath } from "@nestjs/swagger";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+
+@ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
+export class GetBookingsOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({
+    type: "array",
+    items: {
+      oneOf: [
+        { $ref: getSchemaPath(BookingOutput_2024_08_13) },
+        { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
+      ],
+    },
+    description:
+      "Array of booking data, which can contain either BookingOutput objects or RecurringBookingOutput objects",
+  })
+  @ValidateNested({ each: true })
+  data!: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[];
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/mark-absent.output.ts

@@ -0,0 +1,25 @@
+import { ApiProperty, ApiExtraModels, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+
+@ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
+export class MarkAbsentBookingOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(BookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
+    ],
+    description:
+      "Booking data, which can be either a BookingOutput object or a RecurringBookingOutput object",
+  })
+  @ValidateNested()
+  @Type(() => Object)
+  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13;
+}

apps/api/v2/src/ee/bookings/2024-08-13/outputs/reschedule-booking.output.ts

@@ -0,0 +1,25 @@
+import { ApiProperty, ApiExtraModels, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, ValidateNested } from "class-validator";
+
+import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+
+@ApiExtraModels(BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13)
+export class RescheduleBookingOutput_2024_08_13 {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(BookingOutput_2024_08_13) },
+      { $ref: getSchemaPath(RecurringBookingOutput_2024_08_13) },
+    ],
+    description:
+      "Booking data, which can be either a BookingOutput object or a RecurringBookingOutput object",
+  })
+  @ValidateNested()
+  @Type(() => Object)
+  data!: BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13;
+}

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

@@ -0,0 +1,274 @@
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
+import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/input.service";
+import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
+import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { BillingService } from "@/modules/billing/services/billing.service";
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { Injectable, Logger, NotFoundException } from "@nestjs/common";
+import { BadRequestException } from "@nestjs/common";
+import { Request } from "express";
+
+import {
+  handleNewBooking,
+  handleNewRecurringBooking,
+  getAllUserBookings,
+  handleInstantMeeting,
+  handleCancelBooking,
+  handleMarkNoShow,
+} from "@calcom/platform-libraries";
+import {
+  CreateBookingInput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+  CreateBookingInput,
+  CreateRecurringBookingInput_2024_08_13,
+  GetBookingsInput_2024_08_13,
+  CreateInstantBookingInput_2024_08_13,
+  CancelBookingInput_2024_08_13,
+  MarkAbsentBookingInput_2024_08_13,
+  BookingOutput_2024_08_13,
+  RecurringBookingOutput_2024_08_13,
+} from "@calcom/platform-types";
+import { PrismaClient } from "@calcom/prisma";
+
+type CreatedBooking = {
+  hosts: { id: number }[];
+  uid: string;
+  start: string;
+};
+
+@Injectable()
+export class BookingsService_2024_08_13 {
+  private readonly logger = new Logger("BookingsService");
+  constructor(
+    private readonly inputService: InputBookingsService_2024_08_13,
+    private readonly outputService: OutputBookingsService_2024_08_13,
+    private readonly bookingsRepository: BookingsRepository_2024_08_13,
+    private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
+    private readonly prismaReadService: PrismaReadService,
+    private readonly billingService: BillingService
+  ) {}
+
+  async createBooking(request: Request, body: CreateBookingInput) {
+    try {
+      if ("instant" in body && body.instant) {
+        return await this.createInstantBooking(request, body);
+      }
+
+      if (await this.isRecurring(body)) {
+        return await this.createRecurringBooking(request, body);
+      }
+
+      return await this.createRegularBooking(request, body);
+    } 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;
+    }
+  }
+
+  async createInstantBooking(request: Request, body: CreateInstantBookingInput_2024_08_13) {
+    const bookingRequest = await this.inputService.createBookingRequest(request, body);
+    const booking = await handleInstantMeeting(bookingRequest);
+
+    const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUser(booking.bookingId);
+    if (!databaseBooking) {
+      throw new Error(`Booking with id=${booking.bookingId} was not found in the database`);
+    }
+
+    return this.outputService.getOutputBooking(databaseBooking);
+  }
+
+  async isRecurring(body: CreateBookingInput) {
+    const eventType = await this.eventTypesRepository.getEventTypeById(body.eventTypeId);
+    return !!eventType?.recurringEvent;
+  }
+
+  async createRecurringBooking(request: Request, body: CreateRecurringBookingInput_2024_08_13) {
+    const bookingRequest = await this.inputService.createRecurringBookingRequest(request, body);
+    const bookings = await handleNewRecurringBooking(bookingRequest);
+    const uid = bookings[0].recurringEventId;
+    if (!uid) {
+      throw new Error("Recurring booking was not created");
+    }
+
+    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUser(uid);
+    return this.outputService.getOutputRecurringBookings(recurringBooking);
+  }
+
+  async createRegularBooking(request: Request, body: CreateBookingInput_2024_08_13) {
+    const bookingRequest = await this.inputService.createBookingRequest(request, body);
+    const booking = await handleNewBooking(bookingRequest);
+
+    if (!booking.id) {
+      throw new Error("Booking was not created");
+    }
+
+    const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUser(booking.id);
+    if (!databaseBooking) {
+      throw new Error(`Booking with id=${booking.id} was not found in the database`);
+    }
+
+    return this.outputService.getOutputBooking(databaseBooking);
+  }
+
+  async getBooking(uid: string) {
+    const booking = await this.bookingsRepository.getByUidWithAttendeesAndUser(uid);
+
+    if (booking) {
+      const isRecurring = !!booking.recurringEventId;
+      if (isRecurring) {
+        return this.outputService.getOutputRecurringBooking(booking);
+      }
+      return this.outputService.getOutputBooking(booking);
+    }
+
+    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUser(uid);
+    if (!recurringBooking.length) {
+      throw new NotFoundException(`Booking with uid=${uid} was not found in the database`);
+    }
+
+    return this.outputService.getOutputRecurringBookings(recurringBooking);
+  }
+
+  async getBookings(queryParams: GetBookingsInput_2024_08_13, user: { email: string; id: number }) {
+    const fetchedBookings: { bookings: { id: number }[] } = await getAllUserBookings({
+      bookingListingByStatus: queryParams.status || [],
+      skip: queryParams.skip ?? 0,
+      // note(Lauris): we substract -1 because getAllUSerBookings child function adds +1 for some reason
+      take: queryParams.take ? queryParams.take - 1 : 100,
+      filters: this.inputService.transformGetBookingsFilters(queryParams),
+      ctx: {
+        user,
+        prisma: this.prismaReadService.prisma as unknown as PrismaClient,
+      },
+      sort: this.inputService.transformGetBookingsSort(queryParams),
+    });
+    // note(Lauris): fetchedBookings don't have attendees information and responses and i don't want to add them to the handler query,
+    // because its used elsewhere in code that does not need that information, so i get ids, fetch bookings and then return them formatted in same order as ids.
+    const ids = fetchedBookings.bookings.map((booking) => booking.id);
+    const bookings = await this.bookingsRepository.getByIdsWithAttendeesAndUser(ids);
+
+    const bookingMap = new Map(bookings.map((booking) => [booking.id, booking]));
+    const orderedBookings = ids.map((id) => bookingMap.get(id));
+
+    const formattedBookings: (BookingOutput_2024_08_13 | RecurringBookingOutput_2024_08_13)[] = [];
+    for (const booking of orderedBookings) {
+      if (!booking) {
+        continue;
+      }
+
+      const formatted = {
+        ...booking,
+        eventTypeId: booking.eventTypeId,
+        startTime: new Date(booking.startTime),
+        endTime: new Date(booking.endTime),
+        absentHost: !!booking.noShowHost,
+      };
+
+      const isRecurring = !!formatted.recurringEventId;
+      if (isRecurring) {
+        formattedBookings.push(this.outputService.getOutputRecurringBooking(formatted));
+      } else {
+        formattedBookings.push(this.outputService.getOutputBooking(formatted));
+      }
+    }
+
+    return formattedBookings;
+  }
+
+  async rescheduleBooking(request: Request, bookingUid: string, body: RescheduleBookingInput_2024_08_13) {
+    try {
+      const bookingRequest = await this.inputService.createRescheduleBookingRequest(
+        request,
+        bookingUid,
+        body
+      );
+      const booking = await handleNewBooking(bookingRequest);
+      if (!booking.id) {
+        throw new Error("Booking was not created");
+      }
+
+      const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUser(booking.id);
+      if (!databaseBooking) {
+        throw new Error(`Booking with id=${booking.id} was not found in the database`);
+      }
+
+      if (databaseBooking.recurringEventId) {
+        return this.outputService.getOutputRecurringBooking(databaseBooking);
+      }
+      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;
+    }
+  }
+
+  async cancelBooking(request: Request, bookingUid: string, body: CancelBookingInput_2024_08_13) {
+    const bookingRequest = await this.inputService.createCancelBookingRequest(request, bookingUid, body);
+    await handleCancelBooking(bookingRequest);
+    return this.getBooking(bookingUid);
+  }
+
+  async markAbsent(bookingUid: string, bookingOwnerId: number, body: MarkAbsentBookingInput_2024_08_13) {
+    const bodyTransformed = this.inputService.transformInputMarkAbsentBooking(body);
+
+    await handleMarkNoShow({
+      bookingUid,
+      attendees: bodyTransformed.attendees,
+      noShowHost: bodyTransformed.noShowHost,
+      userId: bookingOwnerId,
+    });
+
+    const booking = await this.bookingsRepository.getByUidWithAttendeesAndUser(bookingUid);
+
+    if (!booking) {
+      throw new Error(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const isRecurring = !!booking.recurringEventId;
+    if (isRecurring) {
+      return this.outputService.getOutputRecurringBooking(booking);
+    }
+    return this.outputService.getOutputBooking(booking);
+  }
+
+  async billBookings(bookings: CreatedBooking[]) {
+    for (const booking of bookings) {
+      await this.billBooking(booking);
+    }
+  }
+
+  async billBooking(booking: CreatedBooking) {
+    const hostId = booking.hosts[0].id;
+    if (!hostId) {
+      this.logger.error(`Booking with uid=${booking.uid} has no host`);
+      return;
+    }
+
+    await this.billingService.increaseUsageByUserId(hostId, {
+      uid: booking.uid,
+      startTime: new Date(booking.start),
+    });
+  }
+
+  async billRescheduledBooking(newBooking: CreatedBooking, oldBookingUid: string) {
+    const hostId = newBooking.hosts[0].id;
+    if (!hostId) {
+      this.logger.error(`Booking with uid=${newBooking.uid} has no host`);
+      return;
+    }
+
+    await this.billingService.increaseUsageByUserId(hostId, {
+      uid: newBooking.uid,
+      startTime: new Date(newBooking.start),
+      fromReschedule: oldBookingUid,
+    });
+  }
+}

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

@@ -0,0 +1,418 @@
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
+import { bookingResponsesSchema } from "@/ee/bookings/2024-08-13/services/output.service";
+import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
+import { ApiKeyRepository } from "@/modules/api-key/api-key-repository";
+import { OAuthClientRepository } from "@/modules/oauth-clients/oauth-client.repository";
+import { OAuthFlowService } from "@/modules/oauth-clients/services/oauth-flow.service";
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { Logger } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { Request } from "express";
+import { DateTime } from "luxon";
+import { NextApiRequest } from "next/types";
+import { v4 as uuidv4 } from "uuid";
+import { z } from "zod";
+
+import { X_CAL_CLIENT_ID } from "@calcom/platform-constants";
+import {
+  CancelBookingInput_2024_08_13,
+  CreateBookingInput_2024_08_13,
+  CreateInstantBookingInput_2024_08_13,
+  CreateRecurringBookingInput_2024_08_13,
+  GetBookingsInput_2024_08_13,
+  MarkAbsentBookingInput_2024_08_13,
+  RescheduleBookingInput_2024_08_13,
+} from "@calcom/platform-types";
+
+type BookingRequest = NextApiRequest & { userId: number | undefined } & OAuthRequestParams;
+
+const DEFAULT_PLATFORM_PARAMS = {
+  platformClientId: "",
+  platformCancelUrl: "",
+  platformRescheduleUrl: "",
+  platformBookingUrl: "",
+  arePlatformEmailsEnabled: false,
+  platformBookingLocation: undefined,
+};
+
+type OAuthRequestParams = {
+  platformClientId: string;
+  platformRescheduleUrl: string;
+  platformCancelUrl: string;
+  platformBookingUrl: string;
+  platformBookingLocation?: string;
+  arePlatformEmailsEnabled: boolean;
+};
+
+export enum Frequency {
+  "YEARLY",
+  "MONTHLY",
+  "WEEKLY",
+  "DAILY",
+  "HOURLY",
+  "MINUTELY",
+  "SECONDLY",
+}
+
+const recurringEventSchema = z.object({
+  dtstart: z.string().optional(),
+  interval: z.number().int().optional(),
+  count: z.number().int().optional(),
+  freq: z.nativeEnum(Frequency).optional(),
+  until: z.string().optional(),
+});
+
+@Injectable()
+export class InputBookingsService_2024_08_13 {
+  private readonly logger = new Logger("InputBookingsService_2024_08_13");
+
+  constructor(
+    private readonly oAuthFlowService: OAuthFlowService,
+    private readonly oAuthClientRepository: OAuthClientRepository,
+    private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
+    private readonly bookingsRepository: BookingsRepository_2024_08_13,
+    private readonly config: ConfigService,
+    private readonly apiKeyRepository: ApiKeyRepository
+  ) {}
+
+  async createBookingRequest(
+    request: Request,
+    body: CreateBookingInput_2024_08_13 | CreateInstantBookingInput_2024_08_13
+  ): Promise<BookingRequest> {
+    const bodyTransformed = await this.transformInputCreateBooking(body);
+    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+
+    const newRequest = { ...request };
+    const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
+    const oAuthParams = oAuthClientId
+      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
+      : DEFAULT_PLATFORM_PARAMS;
+
+    const location = request.body.meetingUrl;
+    Object.assign(newRequest, { userId, ...oAuthParams, platformBookingLocation: location });
+
+    newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+
+    return newRequest as unknown as BookingRequest;
+  }
+
+  async transformInputCreateBooking(inputBooking: CreateBookingInput_2024_08_13) {
+    const eventType = await this.eventTypesRepository.getEventTypeByIdWithOwnerAndTeam(
+      inputBooking.eventTypeId
+    );
+
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id=${inputBooking.eventTypeId} not found`);
+    }
+
+    const startTime = DateTime.fromISO(inputBooking.start, { zone: "utc" }).setZone(
+      inputBooking.attendee.timeZone
+    );
+    const endTime = startTime.plus({ minutes: eventType.length });
+
+    return {
+      start: startTime.toISO(),
+      end: endTime.toISO(),
+      eventTypeId: inputBooking.eventTypeId,
+      timeZone: inputBooking.attendee.timeZone,
+      language: inputBooking.attendee.language || "en",
+      // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
+      // metadata: inputBooking.metadata || {},
+      metadata: {},
+      hasHashedBookingLink: false,
+      guests: inputBooking.guests,
+      // note(Lauris): responses with name and email are required by the handleNewBooking
+      responses: inputBooking.bookingFieldsResponses
+        ? {
+            ...inputBooking.bookingFieldsResponses,
+            name: inputBooking.attendee.name,
+            email: inputBooking.attendee.email,
+          }
+        : { name: inputBooking.attendee.name, email: inputBooking.attendee.email },
+    };
+  }
+
+  async createRecurringBookingRequest(
+    request: Request,
+    body: CreateRecurringBookingInput_2024_08_13
+  ): Promise<BookingRequest> {
+    // note(Lauris): update to this.transformInputCreate when rescheduling is implemented
+    const bodyTransformed = await this.transformInputCreateRecurringBooking(body);
+    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+
+    const newRequest = { ...request };
+    const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
+    const oAuthParams = oAuthClientId
+      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
+      : DEFAULT_PLATFORM_PARAMS;
+
+    const location = request.body.meetingUrl;
+    Object.assign(newRequest, {
+      userId,
+      ...oAuthParams,
+      platformBookingLocation: location,
+      noEmail: !oAuthParams.arePlatformEmailsEnabled,
+    });
+
+    newRequest.body = bodyTransformed.map((event) => ({
+      ...event,
+    }));
+
+    return newRequest as unknown as BookingRequest;
+  }
+
+  async transformInputCreateRecurringBooking(inputBooking: CreateRecurringBookingInput_2024_08_13) {
+    const eventType = await this.eventTypesRepository.getEventTypeByIdWithOwnerAndTeam(
+      inputBooking.eventTypeId
+    );
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id=${inputBooking.eventTypeId} not found`);
+    }
+    if (!eventType.recurringEvent) {
+      throw new NotFoundException(`Event type with id=${inputBooking.eventTypeId} is not a recurring event`);
+    }
+
+    const occurrence = recurringEventSchema.parse(eventType.recurringEvent);
+    const repeatsEvery = occurrence.interval;
+    const repeatsTimes = occurrence.count;
+    // note(Lauris): timeBetween 0=yearly, 1=monthly and 2=weekly
+    const timeBetween = occurrence.freq;
+
+    if (!repeatsTimes) {
+      throw new Error("Repeats times is required");
+    }
+
+    const events = [];
+    const recurringEventId = uuidv4();
+
+    let startTime = DateTime.fromISO(inputBooking.start, { zone: "utc" }).setZone(
+      inputBooking.attendee.timeZone
+    );
+
+    for (let i = 0; i < repeatsTimes; i++) {
+      const endTime = startTime.plus({ minutes: eventType.length });
+
+      events.push({
+        start: startTime.toISO(),
+        end: endTime.toISO(),
+        eventTypeId: inputBooking.eventTypeId,
+        recurringEventId,
+        timeZone: inputBooking.attendee.timeZone,
+        language: inputBooking.attendee.language || "en",
+        // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
+        // metadata: inputBooking.metadata || {},
+        metadata: {},
+        hasHashedBookingLink: false,
+        guests: inputBooking.guests,
+        // note(Lauris): responses with name and email are required by the handleNewBooking
+        responses: inputBooking.bookingFieldsResponses
+          ? {
+              ...inputBooking.bookingFieldsResponses,
+              name: inputBooking.attendee.name,
+              email: inputBooking.attendee.email,
+            }
+          : { name: inputBooking.attendee.name, email: inputBooking.attendee.email },
+        schedulingType: eventType.schedulingType,
+      });
+
+      switch (timeBetween) {
+        case 0: // Yearly
+          startTime = startTime.plus({ years: repeatsEvery });
+          break;
+        case 1: // Monthly
+          startTime = startTime.plus({ months: repeatsEvery });
+          break;
+        case 2: // Weekly
+          startTime = startTime.plus({ weeks: repeatsEvery });
+          break;
+        default:
+          throw new Error("Unsupported timeBetween value");
+      }
+    }
+
+    return events;
+  }
+
+  async createRescheduleBookingRequest(
+    request: Request,
+    bookingUid: string,
+    body: RescheduleBookingInput_2024_08_13
+  ): Promise<BookingRequest> {
+    const bodyTransformed = await this.transformInputRescheduleBooking(bookingUid, body);
+    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+
+    const newRequest = { ...request };
+    const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
+    const oAuthParams = oAuthClientId
+      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
+      : DEFAULT_PLATFORM_PARAMS;
+
+    const location = await this.getRescheduleBookingLocation(bookingUid);
+    Object.assign(newRequest, { userId, ...oAuthParams, platformBookingLocation: location });
+
+    newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+
+    return newRequest as unknown as BookingRequest;
+  }
+
+  async transformInputRescheduleBooking(bookingUid: string, inputBooking: RescheduleBookingInput_2024_08_13) {
+    const booking = await this.bookingsRepository.getByUidWithAttendeesAndUser(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} not found`);
+    }
+    if (!booking.eventTypeId) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} is missing event type`);
+    }
+    const eventType = await this.eventTypesRepository.getEventTypeByIdWithOwnerAndTeam(booking.eventTypeId);
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id=${booking.eventTypeId} not found`);
+    }
+
+    const bookingResponses = bookingResponsesSchema.parse(booking.responses);
+    const attendee = booking.attendees.find((attendee) => attendee.email === bookingResponses.email);
+
+    if (!attendee) {
+      throw new NotFoundException(
+        `Attendee with e-mail ${bookingResponses.email} for booking with uid=${bookingUid} not found`
+      );
+    }
+
+    const startTime = DateTime.fromISO(inputBooking.start, { zone: "utc" }).setZone(attendee.timeZone);
+    const endTime = startTime.plus({ minutes: eventType.length });
+
+    return {
+      start: startTime.toISO(),
+      end: endTime.toISO(),
+      eventTypeId: eventType.id,
+      timeZone: attendee.timeZone,
+      language: attendee.locale,
+      // todo(Lauris): expose after refactoring metadata https://app.campsite.co/cal/posts/zysq8w9rwm9c
+      // metadata: booking.metadata || {},
+      metadata: {},
+      hasHashedBookingLink: false,
+      guests: bookingResponses.guests,
+      responses: { ...bookingResponses, rescheduledReason: inputBooking.reschedulingReason },
+      rescheduleUid: bookingUid,
+    };
+  }
+
+  async getRescheduleBookingLocation(rescheduleBookingUid: string) {
+    const booking = await this.bookingsRepository.getByUid(rescheduleBookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${rescheduleBookingUid} not found`);
+    }
+    return booking.location;
+  }
+
+  private async createBookingRequestOwnerId(req: Request): Promise<number | undefined> {
+    try {
+      const bearerToken = req.get("Authorization")?.replace("Bearer ", "");
+      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 keyData = await this.apiKeyRepository.getApiKeyFromHash(apiKeyHash);
+          return keyData?.userId;
+        } else {
+          // Access Token
+          return this.oAuthFlowService.getOwnerId(bearerToken);
+        }
+      }
+    } catch (err) {
+      this.logger.error(err);
+    }
+  }
+
+  private async createBookingRequestOAuthClientParams(clientId: string) {
+    const params = DEFAULT_PLATFORM_PARAMS;
+    try {
+      const client = await this.oAuthClientRepository.getOAuthClient(clientId);
+      if (client) {
+        params.platformClientId = clientId;
+        params.platformCancelUrl = client.bookingCancelRedirectUri ?? "";
+        params.platformRescheduleUrl = client.bookingRescheduleRedirectUri ?? "";
+        params.platformBookingUrl = client.bookingRedirectUri ?? "";
+        params.arePlatformEmailsEnabled = client.areEmailsEnabled ?? false;
+      }
+      return params;
+    } catch (err) {
+      this.logger.error(err);
+      return params;
+    }
+  }
+
+  transformGetBookingsFilters(queryParams: GetBookingsInput_2024_08_13) {
+    return {
+      attendeeEmail: queryParams.attendeeEmail,
+      attendeeName: queryParams.attendeeName,
+      afterStartDate: queryParams.afterStart,
+      beforeEndDate: queryParams.beforeEnd,
+      teamIds: queryParams.teamsIds || (queryParams.teamId ? [queryParams.teamId] : undefined),
+      eventTypeIds:
+        queryParams.eventTypeIds || (queryParams.eventTypeId ? [queryParams.eventTypeId] : undefined),
+    };
+  }
+
+  transformGetBookingsSort(queryParams: GetBookingsInput_2024_08_13) {
+    if (!queryParams.sortStart && !queryParams.sortEnd && !queryParams.sortCreated) {
+      return undefined;
+    }
+
+    return {
+      sortStart: queryParams.sortStart,
+      sortEnd: queryParams.sortEnd,
+      sortCreated: queryParams.sortCreated,
+    };
+  }
+
+  async createCancelBookingRequest(
+    request: Request,
+    bookingUid: string,
+    body: CancelBookingInput_2024_08_13
+  ): Promise<BookingRequest> {
+    const bodyTransformed = await this.transformInputCancelBooking(bookingUid, body);
+    const oAuthClientId = request.get(X_CAL_CLIENT_ID);
+
+    const newRequest = { ...request };
+    const userId = (await this.createBookingRequestOwnerId(request)) ?? undefined;
+    const oAuthParams = oAuthClientId
+      ? await this.createBookingRequestOAuthClientParams(oAuthClientId)
+      : DEFAULT_PLATFORM_PARAMS;
+
+    Object.assign(newRequest, { userId, ...oAuthParams });
+
+    newRequest.body = { ...bodyTransformed, noEmail: !oAuthParams.arePlatformEmailsEnabled };
+
+    return newRequest as unknown as BookingRequest;
+  }
+
+  async transformInputCancelBooking(bookingUid: string, inputBooking: CancelBookingInput_2024_08_13) {
+    let allRemainingBookings = false;
+    let uid = bookingUid;
+    const recurringBooking = await this.bookingsRepository.getRecurringByUidWithAttendeesAndUser(bookingUid);
+
+    if (recurringBooking.length) {
+      // note(Lauirs): this means that bookingUid is equal to recurringEventId on individual bookings of recurring one aka main recurring event
+      allRemainingBookings = true;
+      // note(Lauirs): we need to set uid as one of the individual recurring ids, not the main recurring event id
+      uid = recurringBooking[0].uid;
+    }
+
+    return {
+      uid,
+      cancellationReason: inputBooking.cancellationReason,
+      allRemainingBookings,
+    };
+  }
+
+  transformInputMarkAbsentBooking(inputBooking: MarkAbsentBookingInput_2024_08_13) {
+    return {
+      noShowHost: inputBooking.host,
+      attendees: inputBooking.attendees?.map((attendee) => ({
+        email: attendee.email,
+        noShow: attendee.absent,
+      })),
+    };
+  }
+}

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

@@ -0,0 +1,114 @@
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
+import { Injectable } from "@nestjs/common";
+import { plainToClass } from "class-transformer";
+import { DateTime } from "luxon";
+import { z } from "zod";
+
+import { BookingOutput_2024_08_13, RecurringBookingOutput_2024_08_13 } from "@calcom/platform-types";
+import { Booking } from "@calcom/prisma/client";
+
+export const bookingResponsesSchema = z.object({
+  email: z.string(),
+  name: z.string(),
+  guests: z.array(z.string()).optional(),
+  rescheduledReason: z.string().optional(),
+});
+
+type DatabaseBooking = Booking & {
+  attendees: {
+    name: string;
+    email: string;
+    timeZone: string;
+    locale: string | null;
+    noShow: boolean | null;
+  }[];
+} & { user: { id: number; name: string | null; email: string } | null };
+
+@Injectable()
+export class OutputBookingsService_2024_08_13 {
+  constructor(private readonly bookingsRepository: BookingsRepository_2024_08_13) {}
+
+  getOutputBooking(databaseBooking: DatabaseBooking) {
+    const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
+    const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
+    const duration = dateEnd.diff(dateStart, "minutes").minutes;
+
+    const bookingResponses = bookingResponsesSchema.parse(databaseBooking.responses);
+
+    const booking = {
+      id: databaseBooking.id,
+      uid: databaseBooking.uid,
+      hosts: [databaseBooking.user],
+      status: databaseBooking.status.toLowerCase(),
+      cancellationReason: databaseBooking.cancellationReason || undefined,
+      reschedulingReason: bookingResponses?.rescheduledReason,
+      rescheduledFromUid: databaseBooking.fromReschedule || undefined,
+      start: databaseBooking.startTime,
+      end: databaseBooking.endTime,
+      duration,
+      eventTypeId: databaseBooking.eventTypeId,
+      attendees: databaseBooking.attendees.map((attendee) => ({
+        name: attendee.name,
+        email: attendee.email,
+        timeZone: attendee.timeZone,
+        language: attendee.locale,
+        absent: !!attendee.noShow,
+      })),
+      guests: bookingResponses.guests,
+      meetingUrl: databaseBooking.location,
+      absentHost: !!databaseBooking.noShowHost,
+    };
+
+    return plainToClass(BookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
+  }
+
+  async getOutputRecurringBookings(databaseBookings: DatabaseBooking[]) {
+    const transformed = [];
+
+    for (const booking of databaseBookings) {
+      const databaseBooking = await this.bookingsRepository.getByIdWithAttendeesAndUser(booking.id);
+      if (!databaseBooking) {
+        throw new Error(`Booking with id=${booking.id} was not found in the database`);
+      }
+
+      transformed.push(this.getOutputRecurringBooking(databaseBooking));
+    }
+
+    return transformed.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime());
+  }
+
+  getOutputRecurringBooking(databaseBooking: DatabaseBooking) {
+    const dateStart = DateTime.fromISO(databaseBooking.startTime.toISOString());
+    const dateEnd = DateTime.fromISO(databaseBooking.endTime.toISOString());
+    const duration = dateEnd.diff(dateStart, "minutes").minutes;
+
+    const bookingResponses = bookingResponsesSchema.parse(databaseBooking.responses);
+
+    const booking = {
+      id: databaseBooking.id,
+      uid: databaseBooking.uid,
+      hosts: [databaseBooking.user],
+      status: databaseBooking.status.toLowerCase(),
+      cancellationReason: databaseBooking.cancellationReason || undefined,
+      reschedulingReason: bookingResponses?.rescheduledReason,
+      rescheduledFromUid: databaseBooking.fromReschedule || undefined,
+      start: databaseBooking.startTime,
+      end: databaseBooking.endTime,
+      duration,
+      eventTypeId: databaseBooking.eventTypeId,
+      attendees: databaseBooking.attendees.map((attendee) => ({
+        name: attendee.name,
+        email: attendee.email,
+        timeZone: attendee.timeZone,
+        language: attendee.locale,
+        absent: !!attendee.noShow,
+      })),
+      guests: bookingResponses.guests,
+      meetingUrl: databaseBooking.location,
+      recurringBookingUid: databaseBooking.recurringEventId,
+      absentHost: !!databaseBooking.noShowHost,
+    };
+
+    return plainToClass(RecurringBookingOutput_2024_08_13, booking, { strategy: "excludeAll" });
+  }
+}

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

@@ -1,3 +1,4 @@
+import { CreateIcsFeedOutputResponseDto } from "@/ee/calendars/input/create-ics.output";
 import { Request } from "express";
 
 import { ApiResponse } from "@calcom/platform-types";
@@ -12,6 +13,16 @@ export interface CredentialSyncCalendarApp {
   check(userId: number): Promise<ApiResponse>;
 }
 
+export interface ICSFeedCalendarApp {
+  save(
+    userId: number,
+    userEmail: string,
+    urls: string[],
+    readonly?: boolean
+  ): Promise<CreateIcsFeedOutputResponseDto>;
+  check(userId: number): Promise<ApiResponse>;
+}
+
 export interface OAuthCalendarApp extends CalendarApp {
   connect(authorization: string, req: Request): Promise<ApiResponse<{ authUrl: string }>>;
 }

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

@@ -3,6 +3,7 @@ import { CalendarsController } from "@/ee/calendars/controllers/calendars.contro
 import { AppleCalendarService } from "@/ee/calendars/services/apple-calendar.service";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { GoogleCalendarService } from "@/ee/calendars/services/gcal.service";
+import { IcsFeedService } from "@/ee/calendars/services/ics-feed.service";
 import { OutlookService } from "@/ee/calendars/services/outlook.service";
 import { AppsRepository } from "@/modules/apps/apps.repository";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
@@ -20,6 +21,7 @@ import { Module } from "@nestjs/common";
     OutlookService,
     GoogleCalendarService,
     AppleCalendarService,
+    IcsFeedService,
     SelectedCalendarsRepository,
     AppsRepository,
     CalendarsRepository,

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

@@ -1,5 +1,6 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
+import { CreateIcsFeedOutput, CreateIcsFeedOutputResponseDto } from "@/ee/calendars/input/create-ics.output";
 import { DeletedCalendarCredentialsOutputResponseDto } from "@/ee/calendars/outputs/delete-calendar-credentials.output";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { HttpExceptionFilter } from "@/filters/http-exception.filter";
@@ -18,6 +19,7 @@ import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.
 import { TokensRepositoryFixture } from "test/fixtures/repository/tokens.repository.fixture";
 import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
 import { CalendarsServiceMock } from "test/mocks/calendars-service-mock";
+import { IcsCalendarServiceMock } from "test/mocks/ics-calendar-service-mock";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import {
@@ -27,6 +29,8 @@ import {
   GOOGLE_CALENDAR_ID,
 } from "@calcom/platform-constants";
 import { OFFICE_365_CALENDAR_ID, OFFICE_365_CALENDAR_TYPE } from "@calcom/platform-constants";
+import { ICS_CALENDAR } from "@calcom/platform-constants/apps";
+import { IcsFeedCalendarService } from "@calcom/platform-libraries";
 
 const CLIENT_REDIRECT_URI = "http://localhost:5555";
 
@@ -45,6 +49,7 @@ describe("Platform Calendars Endpoints", () => {
   let googleCalendarCredentials: Credential;
   let accessTokenSecret: string;
   let refreshTokenSecret: string;
+  let icsCalendarCredentials: CreateIcsFeedOutput;
 
   beforeAll(async () => {
     const moduleRef = await Test.createTestingModule({
@@ -192,6 +197,52 @@ describe("Platform Calendars Endpoints", () => {
       .expect(200);
   });
 
+  it(`/POST/v2/calendars/${ICS_CALENDAR}/save with access token should fail to create a new ics feed calendar credentials with invalid urls`, async () => {
+    const body = {
+      urls: ["https://cal.com/ics/feed.ics", "https://not-an-ics-feed.com"],
+      readOnly: false,
+    };
+    await request(app.getHttpServer())
+      .post(`/v2/calendars/${ICS_CALENDAR}/save`)
+      .set("Authorization", `Bearer ${accessTokenSecret}`)
+      .set("Origin", CLIENT_REDIRECT_URI)
+      .send(body)
+      .expect(400);
+  });
+
+  it(`/POST/v2/calendars/${ICS_CALENDAR}/save with access token should create a new ics feed calendar credentials`, async () => {
+    const body = {
+      urls: ["https://cal.com/ics/feed.ics"],
+      readOnly: false,
+    };
+    jest
+      .spyOn(IcsFeedCalendarService.prototype, "listCalendars")
+      .mockImplementation(IcsCalendarServiceMock.prototype.listCalendars);
+    await request(app.getHttpServer())
+      .post(`/v2/calendars/${ICS_CALENDAR}/save`)
+      .set("Authorization", `Bearer ${accessTokenSecret}`)
+      .set("Origin", CLIENT_REDIRECT_URI)
+      .send(body)
+      .expect(201)
+      .then(async (response) => {
+        const responseBody: CreateIcsFeedOutputResponseDto = response.body;
+        expect(responseBody.status).toEqual(SUCCESS_STATUS);
+        expect(responseBody.data).toBeDefined();
+        expect(responseBody.data.userId).toBeDefined();
+        expect(responseBody.data.userId).toEqual(user.id);
+        expect(responseBody.data.id).toBeDefined();
+        icsCalendarCredentials = responseBody.data;
+      });
+  });
+
+  it(`/GET/v2/calendars/${ICS_CALENDAR}/check with access token`, async () => {
+    await request(app.getHttpServer())
+      .get(`/v2/calendars/${ICS_CALENDAR}/check`)
+      .set("Authorization", `Bearer ${accessTokenSecret}`)
+      .set("Origin", CLIENT_REDIRECT_URI)
+      .expect(200);
+  });
+
   it.skip(`/POST/v2/calendars/${OFFICE_365_CALENDAR}/disconnect: it should respond with a 201 returning back the user deleted calendar credentials`, async () => {
     const body = {
       id: 10,
@@ -217,6 +268,7 @@ describe("Platform Calendars Endpoints", () => {
     await teamRepositoryFixture.delete(organization.id);
     await credentialsRepositoryFixture.delete(office365Credentials.id);
     await credentialsRepositoryFixture.delete(googleCalendarCredentials.id);
+    await credentialsRepositoryFixture.delete(icsCalendarCredentials.id);
     await userRepositoryFixture.deleteByEmail(user.email);
     await app.close();
   });

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

@@ -1,4 +1,6 @@
 import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
+import { CreateIcsFeedInputDto } from "@/ee/calendars/input/create-ics.input";
+import { CreateIcsFeedOutputResponseDto } from "@/ee/calendars/input/create-ics.output";
 import { DeleteCalendarCredentialsInputBodyDto } from "@/ee/calendars/input/delete-calendar-credentials.input";
 import { GetBusyTimesOutput } from "@/ee/calendars/outputs/busy-times.output";
 import { ConnectedCalendarsOutput } from "@/ee/calendars/outputs/connected-calendars.output";
@@ -9,6 +11,7 @@ import {
 import { AppleCalendarService } from "@/ee/calendars/services/apple-calendar.service";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { GoogleCalendarService } from "@/ee/calendars/services/gcal.service";
+import { IcsFeedService } from "@/ee/calendars/services/ics-feed.service";
 import { OutlookService } from "@/ee/calendars/services/outlook.service";
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
@@ -31,7 +34,7 @@ import {
   Post,
   Body,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { User } from "@prisma/client";
 import { plainToClass } from "class-transformer";
 import { Request } from "express";
@@ -44,6 +47,7 @@ import {
   GOOGLE_CALENDAR,
   OFFICE_365_CALENDAR,
   APPLE_CALENDAR,
+  CREDENTIAL_CALENDARS,
 } from "@calcom/platform-constants";
 import { ApiResponse, CalendarBusyTimesInput } from "@calcom/platform-types";
 
@@ -58,11 +62,29 @@ export class CalendarsController {
     private readonly outlookService: OutlookService,
     private readonly googleCalendarService: GoogleCalendarService,
     private readonly appleCalendarService: AppleCalendarService,
+    private readonly icsFeedService: IcsFeedService,
     private readonly calendarsRepository: CalendarsRepository
   ) {}
 
+  @Post("/ics-feed/save")
+  @UseGuards(ApiAuthGuard)
+  async createIcsFeed(
+    @GetUser("id") userId: number,
+    @GetUser("email") userEmail: string,
+    @Body() body: CreateIcsFeedInputDto
+  ): Promise<CreateIcsFeedOutputResponseDto> {
+    return await this.icsFeedService.save(userId, userEmail, body.urls, body.readOnly);
+  }
+
+  @Get("/ics-feed/check")
+  @UseGuards(ApiAuthGuard)
+  async checkIcsFeed(@GetUser("id") userId: number): Promise<ApiResponse> {
+    return await this.icsFeedService.check(userId);
+  }
+
   @UseGuards(ApiAuthGuard)
   @Get("/busy-times")
+  @ApiOperation({ summary: "Get busy times" })
   async getBusyTimes(
     @Query() queryParams: CalendarBusyTimesInput,
     @GetUser() user: UserWithProfile
@@ -91,6 +113,7 @@ export class CalendarsController {
 
   @Get("/")
   @UseGuards(ApiAuthGuard)
+  @ApiOperation({ summary: "Get all calendars" })
   async getCalendars(@GetUser("id") userId: number): Promise<ConnectedCalendarsOutput> {
     const calendars = await this.calendarsService.getCalendars(userId);
 
@@ -103,6 +126,7 @@ export class CalendarsController {
   @UseGuards(ApiAuthGuard)
   @Get("/:calendar/connect")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get connect URL" })
   async redirect(
     @Req() req: Request,
     @Headers("Authorization") authorization: string,
@@ -125,6 +149,7 @@ export class CalendarsController {
   @Get("/:calendar/save")
   @HttpCode(HttpStatus.OK)
   @Redirect(undefined, 301)
+  @ApiOperation({ summary: "Save a calendar" })
   async save(
     @Query("state") state: string,
     @Query("code") code: string,
@@ -154,6 +179,7 @@ export class CalendarsController {
 
   @UseGuards(ApiAuthGuard)
   @Post("/:calendar/credentials")
+  @ApiOperation({ summary: "Sync credentials" })
   async syncCredentials(
     @GetUser() user: User,
     @Param("calendar") calendar: string,
@@ -167,7 +193,7 @@ export class CalendarsController {
       default:
         throw new BadRequestException(
           "Invalid calendar type, available calendars are: ",
-          CALENDARS.join(", ")
+          CREDENTIAL_CALENDARS.join(", ")
         );
     }
   }
@@ -176,6 +202,7 @@ export class CalendarsController {
   @HttpCode(HttpStatus.OK)
   @UseGuards(ApiAuthGuard, PermissionsGuard)
   @Permissions([APPS_READ])
+  @ApiOperation({ summary: "Check a calendar connection" })
   async check(@GetUser("id") userId: number, @Param("calendar") calendar: string): Promise<ApiResponse> {
     switch (calendar) {
       case OFFICE_365_CALENDAR:
@@ -195,6 +222,7 @@ export class CalendarsController {
   @UseGuards(ApiAuthGuard)
   @Post("/:calendar/disconnect")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Disconnect a calendar" })
   async deleteCalendarCredentials(
     @Param("calendar") calendar: string,
     @Body() body: DeleteCalendarCredentialsInputBodyDto,

apps/api/v2/src/ee/calendars/input/create-ics.input.ts

@@ -0,0 +1,62 @@
+import { ApiProperty } from "@nestjs/swagger";
+import {
+  ArrayNotEmpty,
+  IsBoolean,
+  IsOptional,
+  Validate,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from "class-validator";
+import { IsNotEmpty, IsArray } from "class-validator";
+
+// Custom constraint to validate ICS URLs
+@ValidatorConstraint({ async: false })
+export class IsICSUrlConstraint implements ValidatorConstraintInterface {
+  validate(url: unknown) {
+    if (typeof url !== "string") return false;
+
+    // Check if it's a valid URL and ends with .ics
+    try {
+      const urlObject = new URL(url);
+      return (
+        (urlObject.protocol === "http:" || urlObject.protocol === "https:") &&
+        urlObject.pathname.endsWith(".ics")
+      );
+    } catch (error) {
+      return false;
+    }
+  }
+
+  defaultMessage() {
+    return "The URL must be a valid ICS URL (ending with .ics)";
+  }
+}
+
+export class CreateIcsFeedInputDto {
+  @ApiProperty({
+    example: ["https://cal.com/ics/feed.ics", "http://cal.com/ics/feed.ics"],
+    description: "An array of ICS URLs",
+    type: "array",
+    items: {
+      type: "string",
+      example: "https://cal.com/ics/feed.ics",
+    },
+    required: true,
+  })
+  @IsArray()
+  @ArrayNotEmpty()
+  @IsNotEmpty({ each: true })
+  @Validate(IsICSUrlConstraint, { each: true }) // Apply the custom validator to each element in the array
+  urls!: string[];
+
+  @IsBoolean()
+  @ApiProperty({
+    example: false,
+    description: "Whether to allowing writing to the calendar or not",
+    type: "boolean",
+    required: false,
+    default: true,
+  })
+  @IsOptional()
+  readOnly?: boolean = true;
+}

apps/api/v2/src/ee/calendars/input/create-ics.output.ts

@@ -0,0 +1,57 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsString, ValidateNested, IsEnum, IsInt, IsBoolean } from "class-validator";
+
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
+
+export class CreateIcsFeedOutput {
+  @IsInt()
+  @Expose()
+  @ApiProperty({ example: 1234567890, description: "The id of the calendar credential" })
+  readonly id!: number;
+
+  @IsString()
+  @Expose()
+  @ApiProperty({ example: "ics-feed_calendar", description: "The type of the calendar" })
+  readonly type!: string;
+
+  @IsInt()
+  @Expose()
+  @ApiProperty({
+    example: 1234567890,
+    description: "The user id of the user that created the calendar",
+    type: "integer",
+  })
+  readonly userId!: number | null;
+
+  @IsInt()
+  @Expose()
+  @ApiProperty({
+    example: 1234567890,
+    nullable: true,
+    description: "The team id of the user that created the calendar",
+    type: "integer",
+  })
+  readonly teamId!: number | null;
+
+  @IsString()
+  @Expose()
+  @ApiProperty({ example: "ics-feed", description: "The slug of the calendar" })
+  readonly appId!: string | null;
+
+  @IsBoolean()
+  @Expose()
+  @ApiProperty({ example: false, description: "Whether the calendar credentials are valid or not" })
+  readonly invalid!: boolean | null;
+}
+
+export class CreateIcsFeedOutputResponseDto {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @Expose()
+  @ValidateNested()
+  @Type(() => CreateIcsFeedOutput)
+  data!: CreateIcsFeedOutput;
+}

apps/api/v2/src/ee/calendars/outputs/connected-calendars.output.ts

@@ -198,7 +198,7 @@ class DestinationCalendar {
   integrationTitle?: string;
 }
 
-class ConnectedCalendarsData {
+export class ConnectedCalendarsData {
   @ValidateNested({ each: true })
   @IsArray()
   connectedCalendars!: ConnectedCalendar[];

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

@@ -4,7 +4,6 @@ import {
   CredentialsRepository,
   CredentialsWithUserEmail,
 } from "@/modules/credentials/credentials.repository";
-import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
 import { UsersRepository } from "@/modules/users/users.repository";
@@ -14,7 +13,6 @@ import {
   UnauthorizedException,
   NotFoundException,
 } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
 import { User } from "@prisma/client";
 import { Prisma } from "@prisma/client";
 import { DateTime } from "luxon";
@@ -34,9 +32,7 @@ export class CalendarsService {
     private readonly credentialsRepository: CredentialsRepository,
     private readonly appsRepository: AppsRepository,
     private readonly calendarsRepository: CalendarsRepository,
-    private readonly dbRead: PrismaReadService,
     private readonly dbWrite: PrismaWriteService,
-    private readonly config: ConfigService,
     private readonly selectedCalendarsRepository: SelectedCalendarsRepository
   ) {}
 

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

@@ -42,7 +42,7 @@ export class GoogleCalendarService implements OAuthCalendarApp {
   ): Promise<{ status: typeof SUCCESS_STATUS; data: { authUrl: string } }> {
     const accessToken = authorization.replace("Bearer ", "");
     const origin = req.get("origin") ?? req.get("host");
-    const redirectUrl = await await this.getCalendarRedirectUrl(accessToken, origin ?? "", redir);
+    const redirectUrl = await this.getCalendarRedirectUrl(accessToken, origin ?? "", redir);
 
     return { status: SUCCESS_STATUS, data: { authUrl: redirectUrl } };
   }

apps/api/v2/src/ee/calendars/services/ics-feed.service.ts

@@ -0,0 +1,103 @@
+import { ICSFeedCalendarApp } from "@/ee/calendars/calendars.interface";
+import { CreateIcsFeedOutputResponseDto } from "@/ee/calendars/input/create-ics.output";
+import { CalendarsService } from "@/ee/calendars/services/calendars.service";
+import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
+import { BadRequestException, UnauthorizedException, Logger } from "@nestjs/common";
+import { Injectable } from "@nestjs/common";
+
+import { SUCCESS_STATUS, ICS_CALENDAR_TYPE, ICS_CALENDAR } from "@calcom/platform-constants";
+import { symmetricEncrypt, IcsFeedCalendarService } from "@calcom/platform-libraries";
+
+@Injectable()
+export class IcsFeedService implements ICSFeedCalendarApp {
+  constructor(
+    private readonly calendarsService: CalendarsService,
+    private readonly credentialRepository: CredentialsRepository
+  ) {}
+
+  private logger = new Logger("IcsFeedService");
+
+  async save(
+    userId: number,
+    userEmail: string,
+    urls: string[],
+    readonly = true
+  ): Promise<CreateIcsFeedOutputResponseDto> {
+    const data = {
+      type: ICS_CALENDAR_TYPE,
+      ICS_CALENDAR,
+      key: symmetricEncrypt(
+        JSON.stringify({ urls, skipWriting: readonly }),
+        process.env.CALENDSO_ENCRYPTION_KEY || ""
+      ),
+      userId: userId,
+      teamId: null,
+      appId: ICS_CALENDAR,
+      invalid: false,
+    };
+
+    try {
+      const dav = new IcsFeedCalendarService({
+        id: 0,
+        ...data,
+        user: { email: userEmail },
+      });
+
+      const listedCals = await dav.listCalendars();
+
+      if (listedCals.length !== urls.length) {
+        throw new BadRequestException(
+          `Listed cals and URLs mismatch: ${listedCals.length} vs. ${urls.length}`
+        );
+      }
+
+      const credential = await this.credentialRepository.upsertAppCredential(
+        ICS_CALENDAR_TYPE,
+        data.key,
+        userId
+      );
+      return {
+        status: SUCCESS_STATUS,
+        data: {
+          id: credential.id,
+          type: credential.type,
+          userId: credential.userId,
+          teamId: credential.teamId,
+          appId: credential.appId,
+          invalid: credential.invalid,
+        },
+      };
+    } catch (e) {
+      this.logger.error("Could not add ICS feeds", e);
+      throw new BadRequestException("Could not add ICS feeds, try using private ics feed.");
+    }
+  }
+
+  async check(userId: number): Promise<{ status: typeof SUCCESS_STATUS }> {
+    const icsFeedCredentials = await this.credentialRepository.getByTypeAndUserId(ICS_CALENDAR_TYPE, userId);
+
+    if (!icsFeedCredentials) {
+      throw new BadRequestException("Credentials for Ics Feed calendar not found.");
+    }
+
+    if (icsFeedCredentials.invalid) {
+      throw new BadRequestException("Invalid Ics Feed credentials.");
+    }
+
+    const { connectedCalendars } = await this.calendarsService.getCalendars(userId);
+    const icsCalendar = connectedCalendars.find(
+      (cal: { integration: { type: string } }) => cal.integration.type === ICS_CALENDAR_TYPE
+    );
+
+    if (!icsCalendar) {
+      throw new UnauthorizedException("Ics Feed not connected.");
+    }
+    if (icsCalendar.error?.message) {
+      throw new UnauthorizedException(icsCalendar.error?.message);
+    }
+
+    return {
+      status: SUCCESS_STATUS,
+    };
+  }
+}

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

@@ -1,16 +1,44 @@
-export const DEFAULT_EVENT_TYPES = {
-  thirtyMinutes: { length: 30, slug: "thirty-minutes", title: "30 Minutes" },
-  thirtyMinutesVideo: {
-    length: 30,
-    slug: "thirty-minutes-video",
-    title: "30 Minutes",
-    locations: [{ type: "integrations:daily" }],
-  },
-  sixtyMinutes: { length: 60, slug: "sixty-minutes", title: "60 Minutes" },
-  sixtyMinutesVideo: {
-    length: 60,
-    slug: "sixty-minutes-video",
-    title: "60 Minutes",
-    locations: [{ type: "integrations:daily" }],
-  },
+import { IntegrationLocation } from "@calcom/lib";
+
+type BaseEventType = {
+  length: number;
+  slug: string;
+  title: string;
+};
+
+type EventTypeWithLocation = BaseEventType & {
+  locations: IntegrationLocation[];
+};
+
+const thirtyMinutes: BaseEventType = {
+  length: 30,
+  slug: "thirty-minutes",
+  title: "30 Minutes",
+};
+
+const thirtyMinutesVideo: EventTypeWithLocation = {
+  length: 30,
+  slug: "thirty-minutes-video",
+  title: "30 Minutes",
+  locations: [{ type: "integrations:daily" }],
+};
+
+const sixtyMinutes: BaseEventType = {
+  length: 60,
+  slug: "sixty-minutes",
+  title: "60 Minutes",
+};
+
+const sixtyMinutesVideo: EventTypeWithLocation = {
+  length: 60,
+  slug: "sixty-minutes-video",
+  title: "60 Minutes",
+  locations: [{ type: "integrations:daily" }],
+};
+
+export const DEFAULT_EVENT_TYPES = {
+  thirtyMinutes,
+  thirtyMinutesVideo,
+  sixtyMinutes,
+  sixtyMinutesVideo,
 };

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

@@ -20,7 +20,13 @@ import { UserRepositoryFixture } from "test/fixtures/repository/users.repository
 import { withApiAuth } from "test/utils/withApiAuth";
 
 import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_06_14 } from "@calcom/platform-constants";
-import { BookingWindowPeriodInputTypeEnum_2024_06_14, FrequencyInput } from "@calcom/platform-enums";
+import {
+  BookingWindowPeriodInputTypeEnum_2024_06_14,
+  BookerLayoutsInputEnum_2024_06_14,
+  ConfirmationPolicyEnum,
+  NoticeThresholdUnitEnum,
+  FrequencyInput,
+} from "@calcom/platform-enums";
 import {
   ApiSuccessResponse,
   CreateEventTypeInput_2024_06_14,
@@ -230,11 +236,36 @@ describe("Event types Endpoints", () => {
           value: 30,
           rolling: true,
         },
+        bookerLayouts: {
+          enabledLayouts: [
+            BookerLayoutsInputEnum_2024_06_14.column,
+            BookerLayoutsInputEnum_2024_06_14.month,
+            BookerLayoutsInputEnum_2024_06_14.week,
+          ],
+          defaultLayout: BookerLayoutsInputEnum_2024_06_14.month,
+        },
+        confirmationPolicy: {
+          type: ConfirmationPolicyEnum.TIME,
+          noticeThreshold: {
+            count: 60,
+            unit: NoticeThresholdUnitEnum.MINUTES,
+          },
+          blockUnconfirmedBookingsInBooker: true,
+        },
         recurrence: {
           frequency: FrequencyInput.weekly,
           interval: 2,
           occurrences: 10,
+          disabled: false,
         },
+        requiresBookerEmailVerification: false,
+        hideCalendarNotes: false,
+        lockTimeZoneToggleOnBookingPage: true,
+        color: {
+          darkThemeHex: "#292929",
+          lightThemeHex: "#fafafa",
+        },
+        customName: `{Event type title} between {Organiser} and {Scheduler}`,
       };
 
       return request(app.getHttpServer())
@@ -257,7 +288,19 @@ describe("Event types Endpoints", () => {
           expect(createdEventType.bookingLimitsDuration).toEqual(body.bookingLimitsDuration);
           expect(createdEventType.offsetStart).toEqual(body.offsetStart);
           expect(createdEventType.bookingWindow).toEqual(body.bookingWindow);
+          expect(createdEventType.bookerLayouts).toEqual(body.bookerLayouts);
+          expect(createdEventType.confirmationPolicy).toEqual(body.confirmationPolicy);
           expect(createdEventType.recurrence).toEqual(body.recurrence);
+          expect(createdEventType.customName).toEqual(body.customName);
+          expect(createdEventType.requiresBookerEmailVerification).toEqual(
+            body.requiresBookerEmailVerification
+          );
+
+          expect(createdEventType.hideCalendarNotes).toEqual(body.hideCalendarNotes);
+          expect(createdEventType.lockTimeZoneToggleOnBookingPage).toEqual(
+            body.lockTimeZoneToggleOnBookingPage
+          );
+          expect(createdEventType.color).toEqual(body.color);
 
           const responseBookingFields = body.bookingFields || [];
           const expectedBookingFields = [
@@ -272,6 +315,317 @@ describe("Event types Endpoints", () => {
         });
     });
 
+    it(`/GET/even-types by username`, async () => {
+      const response = await request(app.getHttpServer())
+        .get(`/api/v2/event-types?username=${username}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        // note: bearer token value mocked using "withAccessTokenAuth" for user which id is used when creating event type above
+        .set("Authorization", `Bearer whatever`)
+        .expect(200);
+
+      const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14[]> = response.body;
+
+      expect(responseBody.status).toEqual(SUCCESS_STATUS);
+      expect(responseBody.data).toBeDefined();
+      expect(responseBody.data?.length).toEqual(1);
+
+      const fetchedEventType = responseBody.data?.[0];
+
+      expect(fetchedEventType?.id).toEqual(eventType.id);
+      expect(fetchedEventType?.title).toEqual(eventType.title);
+      expect(fetchedEventType?.description).toEqual(eventType.description);
+      expect(fetchedEventType?.lengthInMinutes).toEqual(eventType.lengthInMinutes);
+      expect(fetchedEventType?.locations).toEqual(eventType.locations);
+      expect(fetchedEventType?.bookingFields).toEqual(eventType.bookingFields);
+      expect(fetchedEventType?.ownerId).toEqual(user.id);
+      expect(fetchedEventType.bookingLimitsCount).toEqual(eventType.bookingLimitsCount);
+      expect(fetchedEventType.onlyShowFirstAvailableSlot).toEqual(eventType.onlyShowFirstAvailableSlot);
+      expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
+      expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
+      expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
+      expect(fetchedEventType.bookerLayouts).toEqual(eventType.bookerLayouts);
+      expect(fetchedEventType.confirmationPolicy).toEqual(eventType.confirmationPolicy);
+      expect(fetchedEventType.recurrence).toEqual(eventType.recurrence);
+      expect(fetchedEventType.customName).toEqual(eventType.customName);
+      expect(fetchedEventType.requiresBookerEmailVerification).toEqual(
+        eventType.requiresBookerEmailVerification
+      );
+      expect(fetchedEventType.hideCalendarNotes).toEqual(eventType.hideCalendarNotes);
+      expect(fetchedEventType.lockTimeZoneToggleOnBookingPage).toEqual(
+        eventType.lockTimeZoneToggleOnBookingPage
+      );
+      expect(fetchedEventType.color).toEqual(eventType.color);
+    });
+
+    it("should return an error when creating an event type with seats enabled and multiple locations", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 2",
+        slug: "coding-class-2",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+          {
+            type: "phone",
+            phone: "+37120993151",
+            public: true,
+          },
+        ],
+        scheduleId: firstSchedule.id,
+        seats: {
+          seatsPerTimeSlot: 4,
+          showAttendeeInfo: true,
+          showAvailabilityCount: true,
+        },
+      };
+
+      await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(400);
+    });
+
+    it("should return an error when trying to enable seats for an event type with multiple locations", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 3",
+        slug: "coding-class-3",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+          {
+            type: "phone",
+            phone: "+37120993151",
+            public: true,
+          },
+        ],
+        scheduleId: firstSchedule.id,
+      };
+
+      const createResponse = await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(201);
+
+      const createdEventType = createResponse.body.data;
+
+      expect(createdEventType).toMatchObject({
+        id: expect.any(Number),
+        title: body.title,
+        description: body.description,
+        lengthInMinutes: body.lengthInMinutes,
+        locations: body.locations,
+        scheduleId: firstSchedule.id,
+      });
+
+      return request(app.getHttpServer())
+        .patch(`/api/v2/event-types/${createdEventType.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send({
+          seats: {
+            seatsPerTimeSlot: 4,
+            showAttendeeInfo: true,
+            showAvailabilityCount: true,
+          },
+        })
+        .expect(400);
+    });
+
+    it("should return an error when creating an event type with seats enabled and confirmationPolicy enabled", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 4",
+        slug: "coding-class-4",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        scheduleId: firstSchedule.id,
+        confirmationPolicy: {
+          type: ConfirmationPolicyEnum.ALWAYS,
+          blockUnconfirmedBookingsInBooker: false,
+        },
+        seats: {
+          seatsPerTimeSlot: 4,
+          showAttendeeInfo: true,
+          showAvailabilityCount: true,
+        },
+      };
+
+      await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(400);
+    });
+
+    it("should return an error when trying to enable seats for an event type with confirmationPolicy enabled", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 5",
+        slug: "coding-class-5",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        confirmationPolicy: {
+          type: ConfirmationPolicyEnum.ALWAYS,
+          blockUnconfirmedBookingsInBooker: false,
+        },
+        scheduleId: firstSchedule.id,
+      };
+
+      const createResponse = await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(201);
+
+      const createdEventType = createResponse.body.data;
+      console.log("createdEventType: ", createdEventType);
+
+      expect(createdEventType).toMatchObject({
+        id: expect.any(Number),
+        title: body.title,
+        description: body.description,
+        lengthInMinutes: body.lengthInMinutes,
+        confirmationPolicy: body.confirmationPolicy,
+        scheduleId: firstSchedule.id,
+      });
+
+      return request(app.getHttpServer())
+        .patch(`/api/v2/event-types/${createdEventType.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send({
+          seats: {
+            seatsPerTimeSlot: 4,
+            showAttendeeInfo: true,
+            showAvailabilityCount: true,
+          },
+        })
+        .expect(400);
+    });
+
+    it("should return an error when trying to set multiple locations for an event type with seats enabled", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 6",
+        slug: "coding-class-6",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        scheduleId: firstSchedule.id,
+        seats: {
+          seatsPerTimeSlot: 4,
+          showAttendeeInfo: true,
+          showAvailabilityCount: true,
+        },
+      };
+
+      const createResponse = await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(201);
+
+      const createdEventType = createResponse.body.data;
+
+      expect(createdEventType).toMatchObject({
+        id: expect.any(Number),
+        title: body.title,
+        description: body.description,
+        lengthInMinutes: body.lengthInMinutes,
+        seats: body.seats,
+        scheduleId: firstSchedule.id,
+      });
+
+      return request(app.getHttpServer())
+        .patch(`/api/v2/event-types/${createdEventType.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send({
+          locations: [
+            {
+              type: "integration",
+              integration: "cal-video",
+            },
+            {
+              type: "phone",
+              phone: "+37120993151",
+              public: true,
+            },
+          ],
+        })
+        .expect(400);
+    });
+
+    it("should return an error when creating an event type with confirmationPolicy enabled and seats enabled", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 7",
+        slug: "coding-class-7",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        confirmationPolicy: {
+          type: ConfirmationPolicyEnum.ALWAYS,
+          blockUnconfirmedBookingsInBooker: false,
+        },
+        scheduleId: firstSchedule.id,
+        seats: {
+          seatsPerTimeSlot: 4,
+          showAttendeeInfo: true,
+          showAvailabilityCount: true,
+        },
+      };
+
+      await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(400);
+    });
+
+    it("should return an error when trying to enable confirmationPolicy for an event type with seats enabled", async () => {
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class 8",
+        slug: "coding-class-8",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        seats: {
+          seatsPerTimeSlot: 4,
+          showAttendeeInfo: true,
+          showAvailabilityCount: true,
+        },
+        scheduleId: firstSchedule.id,
+      };
+
+      const createResponse = await request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(201);
+
+      const createdEventType = createResponse.body.data;
+
+      expect(createdEventType).toMatchObject({
+        id: expect.any(Number),
+        title: body.title,
+        description: body.description,
+        lengthInMinutes: body.lengthInMinutes,
+        seats: body.seats,
+        scheduleId: firstSchedule.id,
+      });
+
+      return request(app.getHttpServer())
+        .patch(`/api/v2/event-types/${createdEventType.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send({
+          confirmationPolicy: {
+            type: ConfirmationPolicyEnum.ALWAYS,
+            blockUnconfirmedBookingsInBooker: false,
+          },
+        })
+        .expect(400);
+    });
+
     it("should update event type", async () => {
       const newTitle = "Coding class in Italian!";
 
@@ -293,11 +647,32 @@ describe("Event types Endpoints", () => {
           value: 40,
           rolling: false,
         },
+        bookerLayouts: {
+          enabledLayouts: [
+            BookerLayoutsInputEnum_2024_06_14.column,
+            BookerLayoutsInputEnum_2024_06_14.month,
+            BookerLayoutsInputEnum_2024_06_14.week,
+          ],
+          defaultLayout: BookerLayoutsInputEnum_2024_06_14.month,
+        },
+        confirmationPolicy: {
+          type: ConfirmationPolicyEnum.ALWAYS,
+          blockUnconfirmedBookingsInBooker: false,
+        },
         recurrence: {
           frequency: FrequencyInput.monthly,
           interval: 4,
           occurrences: 10,
+          disabled: false,
         },
+        requiresBookerEmailVerification: true,
+        hideCalendarNotes: true,
+        lockTimeZoneToggleOnBookingPage: true,
+        color: {
+          darkThemeHex: "#292929",
+          lightThemeHex: "#fafafa",
+        },
+        customName: `{Event type title} betweennnnnnnnnnn {Organiser} and {Scheduler}`,
       };
 
       return request(app.getHttpServer())
@@ -323,7 +698,18 @@ describe("Event types Endpoints", () => {
           expect(updatedEventType.bookingLimitsDuration).toEqual(body.bookingLimitsDuration);
           expect(updatedEventType.offsetStart).toEqual(body.offsetStart);
           expect(updatedEventType.bookingWindow).toEqual(body.bookingWindow);
+          expect(updatedEventType.bookerLayouts).toEqual(body.bookerLayouts);
+          expect(updatedEventType.confirmationPolicy).toEqual(body.confirmationPolicy);
           expect(updatedEventType.recurrence).toEqual(body.recurrence);
+          expect(updatedEventType.customName).toEqual(body.customName);
+          expect(updatedEventType.requiresBookerEmailVerification).toEqual(
+            body.requiresBookerEmailVerification
+          );
+          expect(updatedEventType.hideCalendarNotes).toEqual(body.hideCalendarNotes);
+          expect(updatedEventType.lockTimeZoneToggleOnBookingPage).toEqual(
+            body.lockTimeZoneToggleOnBookingPage
+          );
+          expect(updatedEventType.color).toEqual(body.color);
 
           eventType.title = newTitle;
           eventType.scheduleId = secondSchedule.id;
@@ -332,7 +718,14 @@ describe("Event types Endpoints", () => {
           eventType.bookingLimitsDuration = updatedEventType.bookingLimitsDuration;
           eventType.offsetStart = updatedEventType.offsetStart;
           eventType.bookingWindow = updatedEventType.bookingWindow;
+          eventType.bookerLayouts = updatedEventType.bookerLayouts;
+          eventType.confirmationPolicy = updatedEventType.confirmationPolicy;
           eventType.recurrence = updatedEventType.recurrence;
+          eventType.customName = updatedEventType.customName;
+          eventType.requiresBookerEmailVerification = updatedEventType.requiresBookerEmailVerification;
+          eventType.hideCalendarNotes = updatedEventType.hideCalendarNotes;
+          eventType.lockTimeZoneToggleOnBookingPage = updatedEventType.lockTimeZoneToggleOnBookingPage;
+          eventType.color = updatedEventType.color;
         });
     });
 
@@ -373,38 +766,18 @@ describe("Event types Endpoints", () => {
       expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
       expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
       expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
+      expect(fetchedEventType.bookerLayouts).toEqual(eventType.bookerLayouts);
+      expect(fetchedEventType.confirmationPolicy).toEqual(eventType.confirmationPolicy);
       expect(fetchedEventType.recurrence).toEqual(eventType.recurrence);
-    });
-
-    it(`/GET/even-types by username`, async () => {
-      const response = await request(app.getHttpServer())
-        .get(`/api/v2/event-types?username=${username}`)
-        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
-        // note: bearer token value mocked using "withAccessTokenAuth" for user which id is used when creating event type above
-        .set("Authorization", `Bearer whatever`)
-        .expect(200);
-
-      const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14[]> = response.body;
-
-      expect(responseBody.status).toEqual(SUCCESS_STATUS);
-      expect(responseBody.data).toBeDefined();
-      expect(responseBody.data?.length).toEqual(1);
-
-      const fetchedEventType = responseBody.data?.[0];
-
-      expect(fetchedEventType?.id).toEqual(eventType.id);
-      expect(fetchedEventType?.title).toEqual(eventType.title);
-      expect(fetchedEventType?.description).toEqual(eventType.description);
-      expect(fetchedEventType?.lengthInMinutes).toEqual(eventType.lengthInMinutes);
-      expect(fetchedEventType?.locations).toEqual(eventType.locations);
-      expect(fetchedEventType?.bookingFields).toEqual(eventType.bookingFields);
-      expect(fetchedEventType?.ownerId).toEqual(user.id);
-      expect(fetchedEventType.bookingLimitsCount).toEqual(eventType.bookingLimitsCount);
-      expect(fetchedEventType.onlyShowFirstAvailableSlot).toEqual(eventType.onlyShowFirstAvailableSlot);
-      expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
-      expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
-      expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
-      expect(fetchedEventType.recurrence).toEqual(eventType.recurrence);
+      expect(fetchedEventType.customName).toEqual(eventType.customName);
+      expect(fetchedEventType.requiresBookerEmailVerification).toEqual(
+        eventType.requiresBookerEmailVerification
+      );
+      expect(fetchedEventType.hideCalendarNotes).toEqual(eventType.hideCalendarNotes);
+      expect(fetchedEventType.lockTimeZoneToggleOnBookingPage).toEqual(
+        eventType.lockTimeZoneToggleOnBookingPage
+      );
+      expect(fetchedEventType.color).toEqual(eventType.color);
     });
 
     it(`/GET/event-types by username and eventSlug`, async () => {
@@ -430,7 +803,18 @@ describe("Event types Endpoints", () => {
       expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
       expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
       expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
+      expect(fetchedEventType.bookerLayouts).toEqual(eventType.bookerLayouts);
+      expect(fetchedEventType.confirmationPolicy).toEqual(eventType.confirmationPolicy);
       expect(fetchedEventType.recurrence).toEqual(eventType.recurrence);
+      expect(fetchedEventType.customName).toEqual(eventType.customName);
+      expect(fetchedEventType.requiresBookerEmailVerification).toEqual(
+        eventType.requiresBookerEmailVerification
+      );
+      expect(fetchedEventType.hideCalendarNotes).toEqual(eventType.hideCalendarNotes);
+      expect(fetchedEventType.lockTimeZoneToggleOnBookingPage).toEqual(
+        eventType.lockTimeZoneToggleOnBookingPage
+      );
+      expect(fetchedEventType.color).toEqual(eventType.color);
     });
 
     it(`/GET/:id not existing`, async () => {

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

@@ -3,7 +3,9 @@ import { DeleteEventTypeOutput_2024_06_14 } from "@/ee/event-types/event-types_2
 import { GetEventTypeOutput_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/outputs/get-event-type.output";
 import { GetEventTypesOutput_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/outputs/get-event-types.output";
 import { UpdateEventTypeOutput_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/outputs/update-event-type.output";
+import { EventTypeResponseTransformPipe } from "@/ee/event-types/event-types_2024_06_14/pipes/event-type-response.transformer";
 import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
+import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
 import { VERSION_2024_06_14_VALUE } from "@/lib/api-versions";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { Permissions } from "@/modules/auth/decorators/permissions/permissions.decorator";
@@ -23,14 +25,15 @@ import {
   HttpStatus,
   Delete,
   Query,
+  ParseIntPipe,
 } from "@nestjs/common";
-import { ApiHeader, ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiHeader, ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { EVENT_TYPE_READ, EVENT_TYPE_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
 import {
-  CreateEventTypeInput_2024_06_14,
   UpdateEventTypeInput_2024_06_14,
   GetEventTypesQuery_2024_06_14,
+  CreateEventTypeInput_2024_06_14,
 } from "@calcom/platform-types";
 
 @Controller({
@@ -38,14 +41,18 @@ import {
   version: VERSION_2024_06_14_VALUE,
 })
 @UseGuards(PermissionsGuard)
-@DocsTags("Event types")
+@DocsTags("Event Types")
 @ApiHeader({
   name: "cal-api-version",
   description: `Must be set to \`2024-06-14\``,
   required: true,
 })
 export class EventTypesController_2024_06_14 {
-  constructor(private readonly eventTypesService: EventTypesService_2024_06_14) {}
+  constructor(
+    private readonly eventTypesService: EventTypesService_2024_06_14,
+    private readonly inputEventTypesService: InputEventTypesService_2024_06_14,
+    private readonly eventTypeResponseTransformPipe: EventTypeResponseTransformPipe
+  ) {}
 
   @Post("/")
   @Permissions([EVENT_TYPE_WRITE])
@@ -56,15 +63,21 @@ export class EventTypesController_2024_06_14 {
       "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
     required: true,
   })
+  @ApiOperation({ summary: "Create an event type" })
   async createEventType(
     @Body() body: CreateEventTypeInput_2024_06_14,
     @GetUser() user: UserWithProfile
   ): Promise<CreateEventTypeOutput_2024_06_14> {
-    const eventType = await this.eventTypesService.createUserEventType(user, body);
+    const transformedBody = await this.inputEventTypesService.transformAndValidateCreateEventTypeInput(
+      user.id,
+      body
+    );
+
+    const eventType = await this.eventTypesService.createUserEventType(user, transformedBody);
 
     return {
       status: SUCCESS_STATUS,
-      data: eventType,
+      data: this.eventTypeResponseTransformPipe.transform(eventType),
     };
   }
 
@@ -77,6 +90,7 @@ export class EventTypesController_2024_06_14 {
       "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
     required: true,
   })
+  @ApiOperation({ summary: "Get an event type" })
   async getEventTypeById(
     @Param("eventTypeId") eventTypeId: string,
     @GetUser() user: UserWithProfile
@@ -89,11 +103,12 @@ export class EventTypesController_2024_06_14 {
 
     return {
       status: SUCCESS_STATUS,
-      data: eventType,
+      data: this.eventTypeResponseTransformPipe.transform(eventType),
     };
   }
 
   @Get("/")
+  @ApiOperation({ summary: "Get all event types" })
   async getEventTypes(
     @Query() queryParams: GetEventTypesQuery_2024_06_14
   ): Promise<GetEventTypesOutput_2024_06_14> {
@@ -101,7 +116,7 @@ export class EventTypesController_2024_06_14 {
 
     return {
       status: SUCCESS_STATUS,
-      data: eventTypes,
+      data: this.eventTypeResponseTransformPipe.transform(eventTypes),
     };
   }
 
@@ -115,16 +130,23 @@ export class EventTypesController_2024_06_14 {
     required: true,
   })
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Update an event type" })
   async updateEventType(
-    @Param("eventTypeId") eventTypeId: number,
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
     @Body() body: UpdateEventTypeInput_2024_06_14,
     @GetUser() user: UserWithProfile
   ): Promise<UpdateEventTypeOutput_2024_06_14> {
-    const eventType = await this.eventTypesService.updateEventType(eventTypeId, body, user);
+    const transformedBody = await this.inputEventTypesService.transformAndValidateUpdateEventTypeInput(
+      body,
+      user.id,
+      eventTypeId
+    );
+
+    const eventType = await this.eventTypesService.updateEventType(eventTypeId, transformedBody, user);
 
     return {
       status: SUCCESS_STATUS,
-      data: eventType,
+      data: this.eventTypeResponseTransformPipe.transform(eventType),
     };
   }
 
@@ -137,6 +159,7 @@ export class EventTypesController_2024_06_14 {
       "value must be `Bearer <token>` where `<token>` either managed user access token or api key prefixed with cal_",
     required: true,
   })
+  @ApiOperation({ summary: "Delete an event type" })
   async deleteEventType(
     @Param("eventTypeId") eventTypeId: number,
     @GetUser("id") userId: number

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

@@ -1,9 +1,14 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
+import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { EventTypesController_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/controllers/event-types.controller";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { EventTypeResponseTransformPipe } from "@/ee/event-types/event-types_2024_06_14/pipes/event-type-response.transformer";
 import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
 import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
 import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
 import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
+import { AppsRepository } from "@/modules/apps/apps.repository";
+import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { MembershipsModule } from "@/modules/memberships/memberships.module";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { SelectedCalendarsModule } from "@/modules/selected-calendars/selected-calendars.module";
@@ -22,6 +27,11 @@ import { Module } from "@nestjs/common";
     UsersRepository,
     UsersService,
     SchedulesRepository_2024_06_11,
+    EventTypeResponseTransformPipe,
+    CalendarsService,
+    CredentialsRepository,
+    AppsRepository,
+    CalendarsRepository,
   ],
   controllers: [EventTypesController_2024_06_14],
   exports: [

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

@@ -4,36 +4,10 @@ import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Injectable } from "@nestjs/common";
 
-import {
-  getEventTypeById,
-  transformBookingFieldsApiToInternal,
-  transformLocationsApiToInternal,
-} from "@calcom/platform-libraries";
-import { CreateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
+import { getEventTypeById } from "@calcom/platform-libraries";
+import { InputEventTransformed_2024_06_14 } from "@calcom/platform-types";
 import type { PrismaClient } from "@calcom/prisma";
 
-type InputEventTransformed = Omit<
-  CreateEventTypeInput_2024_06_14,
-  | "lengthInMinutes"
-  | "locations"
-  | "bookingFields"
-  | "bookingLimitsCount"
-  | "onlyShowFirstAvailableSlot"
-  | "bookingLimitsDuration"
-  | "offsetStart"
-  | "periodType"
-  | "periodDays"
-  | "periodCountCalendarDays"
-  | "periodStartDate"
-  | "periodEndDate"
-  | "recurrence"
-> & {
-  length: number;
-  slug: string;
-  locations?: ReturnType<typeof transformLocationsApiToInternal>;
-  bookingFields?: ReturnType<typeof transformBookingFieldsApiToInternal>;
-};
-
 @Injectable()
 export class EventTypesRepository_2024_06_14 {
   constructor(
@@ -42,7 +16,10 @@ export class EventTypesRepository_2024_06_14 {
     private usersService: UsersService
   ) {}
 
-  async createUserEventType(userId: number, body: InputEventTransformed) {
+  async createUserEventType(
+    userId: number,
+    body: Omit<InputEventTransformed_2024_06_14, "destinationCalendar">
+  ) {
     return this.dbWrite.prisma.eventType.create({
       data: {
         ...body,
@@ -57,7 +34,19 @@ export class EventTypesRepository_2024_06_14 {
   async getEventTypeWithSeats(eventTypeId: number) {
     return this.dbRead.prisma.eventType.findUnique({
       where: { id: eventTypeId },
-      select: { users: { select: { id: true } }, seatsPerTimeSlot: true },
+      select: {
+        users: { select: { id: true } },
+        seatsPerTimeSlot: true,
+        locations: true,
+        requiresConfirmation: true,
+      },
+    });
+  }
+
+  async getEventTypeWithMetaData(eventTypeId: number) {
+    return this.dbRead.prisma.eventType.findUnique({
+      where: { id: eventTypeId },
+      select: { metadata: true },
     });
   }
 
@@ -67,7 +56,7 @@ export class EventTypesRepository_2024_06_14 {
         id: eventTypeId,
         userId,
       },
-      include: { users: true, schedule: true },
+      include: { users: true, schedule: true, destinationCalendar: true },
     });
   }
 
@@ -76,7 +65,7 @@ export class EventTypesRepository_2024_06_14 {
       where: {
         userId,
       },
-      include: { users: true, schedule: true },
+      include: { users: true, schedule: true, destinationCalendar: true },
     });
   }
 
@@ -98,7 +87,14 @@ export class EventTypesRepository_2024_06_14 {
   async getEventTypeById(eventTypeId: number) {
     return this.dbRead.prisma.eventType.findUnique({
       where: { id: eventTypeId },
-      include: { users: true, schedule: true },
+      include: { users: true, schedule: true, destinationCalendar: true },
+    });
+  }
+
+  async getEventTypeByIdWithOwnerAndTeam(eventTypeId: number) {
+    return this.dbRead.prisma.eventType.findUnique({
+      where: { id: eventTypeId },
+      include: { owner: true, team: true },
     });
   }
 
@@ -110,7 +106,7 @@ export class EventTypesRepository_2024_06_14 {
           slug: slug,
         },
       },
-      include: { users: true, schedule: true },
+      include: { users: true, schedule: true, destinationCalendar: true },
     });
   }
 

apps/api/v2/src/ee/event-types/event-types_2024_06_14/pipes/event-type-response.transformer.ts

@@ -0,0 +1,39 @@
+import { Injectable, PipeTransform } from "@nestjs/common";
+import { plainToClass } from "class-transformer";
+
+import { EventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+import {
+  DatabaseEventType,
+  OutputEventTypesService_2024_06_14,
+} from "../services/output-event-types.service";
+
+type EventTypeResponse = DatabaseEventType & { ownerId: number };
+
+@Injectable()
+export class EventTypeResponseTransformPipe implements PipeTransform {
+  constructor(private readonly outputEventTypesService: OutputEventTypesService_2024_06_14) {}
+
+  private transformEventType(eventType: EventTypeResponse): EventTypeOutput_2024_06_14 {
+    return plainToClass(
+      EventTypeOutput_2024_06_14,
+      this.outputEventTypesService.getResponseEventType(eventType.ownerId, eventType),
+      { strategy: "exposeAll" }
+    );
+  }
+
+  // Implementing function overloading to ensure correct return types based on input type:
+  transform(value: EventTypeResponse[]): EventTypeOutput_2024_06_14[];
+
+  transform(value: EventTypeResponse): EventTypeOutput_2024_06_14;
+
+  transform(
+    value: EventTypeResponse | EventTypeResponse[]
+  ): EventTypeOutput_2024_06_14 | EventTypeOutput_2024_06_14[] {
+    if (Array.isArray(value)) {
+      return value.map((item) => this.transformEventType(item));
+    } else {
+      return this.transformEventType(value);
+    }
+  }
+}

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

@@ -1,7 +1,5 @@
 import { DEFAULT_EVENT_TYPES } from "@/ee/event-types/event-types_2024_06_14/constants/constants";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
-import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
-import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
 import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
@@ -13,20 +11,13 @@ import { BadRequestException, ForbiddenException, Injectable, NotFoundException
 import { createEventType, updateEventType } from "@calcom/platform-libraries";
 import { getEventTypesPublic, EventTypesPublic } from "@calcom/platform-libraries";
 import { dynamicEvent } from "@calcom/platform-libraries";
-import {
-  CreateEventTypeInput_2024_06_14,
-  UpdateEventTypeInput_2024_06_14,
-  GetEventTypesQuery_2024_06_14,
-  EventTypeOutput_2024_06_14,
-} from "@calcom/platform-types";
+import { GetEventTypesQuery_2024_06_14, InputEventTransformed_2024_06_14 } from "@calcom/platform-types";
 import { EventType } from "@calcom/prisma/client";
 
 @Injectable()
 export class EventTypesService_2024_06_14 {
   constructor(
     private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
-    private readonly inputEventTypesService: InputEventTypesService_2024_06_14,
-    private readonly outputEventTypesService: OutputEventTypesService_2024_06_14,
     private readonly membershipsRepository: MembershipsRepository,
     private readonly usersRepository: UsersRepository,
     private readonly usersService: UsersService,
@@ -35,22 +26,13 @@ export class EventTypesService_2024_06_14 {
     private readonly schedulesRepository: SchedulesRepository_2024_06_11
   ) {}
 
-  async createUserEventType(user: UserWithProfile, body: CreateEventTypeInput_2024_06_14) {
+  async createUserEventType(user: UserWithProfile, body: InputEventTransformed_2024_06_14) {
     await this.checkCanCreateEventType(user.id, body);
     const eventTypeUser = await this.getUserToCreateEvent(user);
-    const {
-      bookingLimits,
-      durationLimits,
-      periodType = undefined,
-      periodDays = undefined,
-      periodCountCalendarDays = undefined,
-      periodStartDate = undefined,
-      periodEndDate = undefined,
-      recurrence = undefined,
-      ...bodyTransformed
-    } = this.inputEventTypesService.transformInputCreateEventType(body);
+    const { destinationCalendar: _destinationCalendar, ...rest } = body;
+
     const { eventType: eventTypeCreated } = await createEventType({
-      input: bodyTransformed,
+      input: rest,
       ctx: {
         user: eventTypeUser,
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -62,15 +44,7 @@ export class EventTypesService_2024_06_14 {
     await updateEventType({
       input: {
         id: eventTypeCreated.id,
-        bookingLimits,
-        durationLimits,
-        periodType,
-        periodDays,
-        periodCountCalendarDays,
-        periodStartDate,
-        periodEndDate,
-        recurrence,
-        ...bodyTransformed,
+        ...body,
       },
       ctx: {
         user: eventTypeUser,
@@ -86,10 +60,13 @@ export class EventTypesService_2024_06_14 {
       throw new NotFoundException(`Event type with id ${eventTypeCreated.id} not found`);
     }
 
-    return this.outputEventTypesService.getResponseEventType(user.id, eventType);
+    return {
+      ownerId: user.id,
+      ...eventType,
+    };
   }
 
-  async checkCanCreateEventType(userId: number, body: CreateEventTypeInput_2024_06_14) {
+  async checkCanCreateEventType(userId: number, body: InputEventTransformed_2024_06_14) {
     const existsWithSlug = await this.eventTypesRepository.getUserEventTypeBySlug(userId, body.slug);
     if (existsWithSlug) {
       throw new BadRequestException("User already has an event type with this slug.");
@@ -109,7 +86,10 @@ export class EventTypesService_2024_06_14 {
       return null;
     }
 
-    return this.outputEventTypesService.getResponseEventType(user.id, eventType);
+    return {
+      ownerId: user.id,
+      ...eventType,
+    };
   }
 
   async getEventTypesByUsername(username: string) {
@@ -117,7 +97,7 @@ export class EventTypesService_2024_06_14 {
     if (!user) {
       return [];
     }
-    return this.getUserEventTypes(user.id);
+    return await this.getUserEventTypes(user.id);
   }
 
   async getUserToCreateEvent(user: UserWithProfile) {
@@ -147,17 +127,19 @@ export class EventTypesService_2024_06_14 {
     }
 
     this.checkUserOwnsEventType(userId, eventType);
-    return this.outputEventTypesService.getResponseEventType(userId, eventType);
+
+    return {
+      ownerId: userId,
+      ...eventType,
+    };
   }
 
   async getUserEventTypes(userId: number) {
     const eventTypes = await this.eventTypesRepository.getUserEventTypes(userId);
 
-    const eventTypePromises = eventTypes.map(async (eventType) => {
-      return await this.outputEventTypesService.getResponseEventType(userId, eventType);
+    return eventTypes.map((eventType) => {
+      return { ownerId: userId, ...eventType };
     });
-
-    return await Promise.all(eventTypePromises);
   }
 
   async getUserEventTypeForAtom(user: UserWithProfile, eventTypeId: number) {
@@ -190,7 +172,7 @@ export class EventTypesService_2024_06_14 {
     return await getEventTypesPublic(user.id);
   }
 
-  async getEventTypes(queryParams: GetEventTypesQuery_2024_06_14): Promise<EventTypeOutput_2024_06_14[]> {
+  async getEventTypes(queryParams: GetEventTypesQuery_2024_06_14) {
     const { username, eventSlug, usernames } = queryParams;
 
     if (username && eventSlug) {
@@ -218,12 +200,12 @@ export class EventTypesService_2024_06_14 {
         usersFiltered.push(user);
       }
     }
-
-    return this.outputEventTypesService.getResponseEventType(0, {
+    return {
+      ownerId: 0,
       ...dynamicEvent,
       users: usersFiltered,
       isInstantEvent: false,
-    });
+    };
   }
 
   async createUserDefaultEventTypes(userId: number) {
@@ -239,12 +221,12 @@ export class EventTypesService_2024_06_14 {
     return defaultEventTypes;
   }
 
-  async updateEventType(eventTypeId: number, body: UpdateEventTypeInput_2024_06_14, user: UserWithProfile) {
+  async updateEventType(eventTypeId: number, body: InputEventTransformed_2024_06_14, user: UserWithProfile) {
     await this.checkCanUpdateEventType(user.id, eventTypeId, body.scheduleId);
     const eventTypeUser = await this.getUserToUpdateEvent(user);
-    const bodyTransformed = this.inputEventTypesService.transformInputUpdateEventType(body);
+
     await updateEventType({
-      input: { id: eventTypeId, ...bodyTransformed },
+      input: { id: eventTypeId, ...body },
       ctx: {
         user: eventTypeUser,
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -259,7 +241,10 @@ export class EventTypesService_2024_06_14 {
       throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
     }
 
-    return this.outputEventTypesService.getResponseEventType(user.id, eventType);
+    return {
+      ownerId: user.id,
+      ...eventType,
+    };
   }
 
   async checkCanUpdateEventType(userId: number, eventTypeId: number, scheduleId: number | undefined) {

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

@@ -1,4 +1,8 @@
-import { Injectable } from "@nestjs/common";
+import { ConnectedCalendarsData } from "@/ee/calendars/outputs/connected-calendars.output";
+import { CalendarsService } from "@/ee/calendars/services/calendars.service";
+import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { Injectable, BadRequestException } from "@nestjs/common";
 
 import {
   transformBookingFieldsApiToInternal,
@@ -9,12 +13,85 @@ import {
   systemBeforeFieldName,
   systemBeforeFieldEmail,
   systemAfterFieldRescheduleReason,
+  EventTypeMetaDataSchema,
+  systemBeforeFieldLocation,
+  transformBookerLayoutsApiToInternal,
+  transformConfirmationPolicyApiToInternal,
+  transformEventColorsApiToInternal,
+  validateCustomEventName,
+  transformSeatsApiToInternal,
 } from "@calcom/platform-libraries";
-import { systemBeforeFieldLocation } from "@calcom/platform-libraries";
-import { CreateEventTypeInput_2024_06_14, UpdateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
+import {
+  CreateEventTypeInput_2024_06_14,
+  DestinationCalendar_2024_06_14,
+  InputEventTransformed_2024_06_14,
+  UpdateEventTypeInput_2024_06_14,
+} from "@calcom/platform-types";
+
+import { OutputEventTypesService_2024_06_14 } from "./output-event-types.service";
+
+interface ValidationContext {
+  eventTypeId?: number;
+  seatsPerTimeSlot?: number | null;
+  locations?: InputEventTransformed_2024_06_14["locations"];
+  requiresConfirmation?: boolean;
+  eventName?: string;
+}
 
 @Injectable()
 export class InputEventTypesService_2024_06_14 {
+  constructor(
+    private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
+    private readonly outputEventTypesService: OutputEventTypesService_2024_06_14,
+    private readonly calendarsService: CalendarsService
+  ) {}
+
+  async transformAndValidateCreateEventTypeInput(
+    userId: UserWithProfile["id"],
+    inputEventType: CreateEventTypeInput_2024_06_14
+  ) {
+    const transformedBody = this.transformInputCreateEventType(inputEventType);
+
+    await this.validateEventTypeInputs({
+      seatsPerTimeSlot: transformedBody.seatsPerTimeSlot,
+      locations: transformedBody.locations,
+      requiresConfirmation: transformedBody.requiresConfirmation,
+      eventName: transformedBody.eventName,
+    });
+
+    transformedBody.destinationCalendar &&
+      (await this.validateInputDestinationCalendar(userId, transformedBody.destinationCalendar));
+
+    transformedBody.useEventTypeDestinationCalendarEmail &&
+      (await this.validateInputUseDestinationCalendarEmail(userId));
+
+    return transformedBody;
+  }
+
+  async transformAndValidateUpdateEventTypeInput(
+    inputEventType: UpdateEventTypeInput_2024_06_14,
+    userId: UserWithProfile["id"],
+    eventTypeId: number
+  ) {
+    const transformedBody = await this.transformInputUpdateEventType(inputEventType, eventTypeId);
+
+    await this.validateEventTypeInputs({
+      eventTypeId: eventTypeId,
+      seatsPerTimeSlot: transformedBody.seatsPerTimeSlot,
+      locations: transformedBody.locations,
+      requiresConfirmation: transformedBody.requiresConfirmation,
+      eventName: transformedBody.eventName,
+    });
+
+    transformedBody.destinationCalendar &&
+      (await this.validateInputDestinationCalendar(userId, transformedBody.destinationCalendar));
+
+    transformedBody.useEventTypeDestinationCalendarEmail &&
+      (await this.validateInputUseDestinationCalendarEmail(userId));
+
+    return transformedBody;
+  }
+
   transformInputCreateEventType(inputEventType: CreateEventTypeInput_2024_06_14) {
     const defaultLocations: CreateEventTypeInput_2024_06_14["locations"] = [
       {
@@ -30,9 +107,16 @@ export class InputEventTypesService_2024_06_14 {
       bookingLimitsCount,
       bookingLimitsDuration,
       bookingWindow,
+      bookerLayouts,
+      confirmationPolicy,
+      color,
       recurrence,
+      seats,
+      customName,
+      useDestinationCalendarEmail,
       ...rest
     } = inputEventType;
+    const confirmationPolicyTransformed = this.transformInputConfirmationPolicy(confirmationPolicy);
 
     const hasMultipleLocations = (locations || defaultLocations).length > 1;
     const eventType = {
@@ -45,25 +129,47 @@ export class InputEventTypesService_2024_06_14 {
         ? this.transformInputIntervalLimits(bookingLimitsDuration)
         : undefined,
       ...this.transformInputBookingWindow(bookingWindow),
+      metadata: {
+        bookerLayouts: this.transformInputBookerLayouts(bookerLayouts),
+        requiresConfirmationThreshold:
+          confirmationPolicyTransformed?.requiresConfirmationThreshold ?? undefined,
+      },
+      requiresConfirmation: confirmationPolicyTransformed?.requiresConfirmation ?? undefined,
+      requiresConfirmationWillBlockSlot:
+        confirmationPolicyTransformed?.requiresConfirmationWillBlockSlot ?? undefined,
+      eventTypeColor: this.transformInputEventTypeColor(color),
       recurringEvent: recurrence ? this.transformInputRecurrignEvent(recurrence) : undefined,
+      ...this.transformInputSeatOptions(seats),
+      eventName: customName,
+      useEventTypeDestinationCalendarEmail: useDestinationCalendarEmail,
     };
 
     return eventType;
   }
 
-  transformInputUpdateEventType(inputEventType: UpdateEventTypeInput_2024_06_14) {
+  async transformInputUpdateEventType(inputEventType: UpdateEventTypeInput_2024_06_14, eventTypeId: number) {
     const {
       lengthInMinutes,
       locations,
       bookingFields,
-      scheduleId,
       bookingLimitsCount,
       bookingLimitsDuration,
       bookingWindow,
+      bookerLayouts,
+      confirmationPolicy,
+      color,
       recurrence,
+      seats,
+      customName,
+      useDestinationCalendarEmail,
       ...rest
     } = inputEventType;
+    const eventTypeDb = await this.eventTypesRepository.getEventTypeWithMetaData(eventTypeId);
+    const metadataTransformed = !!eventTypeDb?.metadata
+      ? EventTypeMetaDataSchema.parse(eventTypeDb.metadata)
+      : {};
 
+    const confirmationPolicyTransformed = this.transformInputConfirmationPolicy(confirmationPolicy);
     const hasMultipleLocations = !!(locations && locations?.length > 1);
 
     const eventType = {
@@ -73,13 +179,25 @@ export class InputEventTypesService_2024_06_14 {
       bookingFields: bookingFields
         ? this.transformInputBookingFields(bookingFields, hasMultipleLocations)
         : undefined,
-      schedule: scheduleId,
       bookingLimits: bookingLimitsCount ? this.transformInputIntervalLimits(bookingLimitsCount) : undefined,
       durationLimits: bookingLimitsDuration
         ? this.transformInputIntervalLimits(bookingLimitsDuration)
         : undefined,
       ...this.transformInputBookingWindow(bookingWindow),
+      metadata: {
+        ...metadataTransformed,
+        bookerLayouts: this.transformInputBookerLayouts(bookerLayouts),
+        requiresConfirmationThreshold:
+          confirmationPolicyTransformed?.requiresConfirmationThreshold ?? undefined,
+      },
       recurringEvent: recurrence ? this.transformInputRecurrignEvent(recurrence) : undefined,
+      requiresConfirmation: confirmationPolicyTransformed?.requiresConfirmation ?? undefined,
+      requiresConfirmationWillBlockSlot:
+        confirmationPolicyTransformed?.requiresConfirmationWillBlockSlot ?? undefined,
+      eventTypeColor: this.transformInputEventTypeColor(color),
+      ...this.transformInputSeatOptions(seats),
+      eventName: customName,
+      useEventTypeDestinationCalendarEmail: useDestinationCalendarEmail,
     };
 
     return eventType;
@@ -114,7 +232,142 @@ export class InputEventTypesService_2024_06_14 {
     return !!res ? res : {};
   }
 
+  transformInputBookerLayouts(inputBookerLayouts: CreateEventTypeInput_2024_06_14["bookerLayouts"]) {
+    return transformBookerLayoutsApiToInternal(inputBookerLayouts);
+  }
+
+  transformInputConfirmationPolicy(
+    requiresConfirmation: CreateEventTypeInput_2024_06_14["confirmationPolicy"]
+  ) {
+    return transformConfirmationPolicyApiToInternal(requiresConfirmation);
+  }
   transformInputRecurrignEvent(recurrence: CreateEventTypeInput_2024_06_14["recurrence"]) {
     return transformRecurrenceApiToInternal(recurrence);
   }
+
+  transformInputEventTypeColor(color: CreateEventTypeInput_2024_06_14["color"]) {
+    return transformEventColorsApiToInternal(color);
+  }
+
+  transformInputSeatOptions(seats: CreateEventTypeInput_2024_06_14["seats"]) {
+    return transformSeatsApiToInternal(seats);
+  }
+  async validateEventTypeInputs({
+    eventTypeId,
+    seatsPerTimeSlot,
+    locations,
+    requiresConfirmation,
+    eventName,
+  }: ValidationContext) {
+    let seatsPerTimeSlotDb: number | null = null;
+    let locationsDb: ReturnType<typeof this.transformInputLocations> = [];
+    let requiresConfirmationDb = false;
+
+    if (eventTypeId != null) {
+      const eventTypeDb = await this.eventTypesRepository.getEventTypeWithSeats(eventTypeId);
+      seatsPerTimeSlotDb = eventTypeDb?.seatsPerTimeSlot ?? null;
+      locationsDb = this.outputEventTypesService.transformLocations(eventTypeDb?.locations) ?? [];
+      requiresConfirmationDb = eventTypeDb?.requiresConfirmation ?? false;
+    }
+
+    const seatsPerTimeSlotFinal = seatsPerTimeSlot !== undefined ? seatsPerTimeSlot : seatsPerTimeSlotDb;
+    const seatsEnabledFinal = seatsPerTimeSlotFinal != null && seatsPerTimeSlotFinal > 0;
+
+    const locationsFinal = locations !== undefined ? locations : locationsDb;
+    const requiresConfirmationFinal =
+      requiresConfirmation !== undefined ? requiresConfirmation : requiresConfirmationDb;
+
+    this.validateSeatsSingleLocationRule(seatsEnabledFinal, locationsFinal);
+    this.validateSeatsRequiresConfirmationFalseRule(seatsEnabledFinal, requiresConfirmationFinal);
+    this.validateMultipleLocationsSeatsDisabledRule(locationsFinal, seatsEnabledFinal);
+    this.validateRequiresConfirmationSeatsDisabledRule(requiresConfirmationFinal, seatsEnabledFinal);
+
+    if (eventName) {
+      await this.validateCustomEventNameInput(eventName);
+    }
+  }
+  validateSeatsSingleLocationRule(
+    seatsEnabled: boolean,
+    locations: ReturnType<typeof this.transformInputLocations>
+  ) {
+    if (seatsEnabled && locations.length > 1) {
+      throw new BadRequestException(
+        "Seats Validation failed: Seats are enabled but more than one location provided."
+      );
+    }
+  }
+
+  validateSeatsRequiresConfirmationFalseRule(seatsEnabled: boolean, requiresConfirmation: boolean) {
+    if (seatsEnabled && requiresConfirmation) {
+      throw new BadRequestException(
+        "Seats Validation failed: Seats are enabled but requiresConfirmation is true."
+      );
+    }
+  }
+
+  validateMultipleLocationsSeatsDisabledRule(
+    locations: ReturnType<typeof this.transformInputLocations>,
+    seatsEnabled: boolean
+  ) {
+    if (locations.length > 1 && seatsEnabled) {
+      throw new BadRequestException("Locations Validation failed: Multiple locations but seats are enabled.");
+    }
+  }
+
+  validateRequiresConfirmationSeatsDisabledRule(requiresConfirmation: boolean, seatsEnabled: boolean) {
+    if (requiresConfirmation && seatsEnabled) {
+      throw new BadRequestException(
+        "RequiresConfirmation Validation failed: Seats are enabled but requiresConfirmation is true."
+      );
+    }
+  }
+
+  async validateCustomEventNameInput(value: string) {
+    const validationResult = validateCustomEventName(value);
+    if (validationResult !== true) {
+      throw new BadRequestException(`Invalid event name variables: ${validationResult}`);
+    }
+    return;
+  }
+
+  async validateInputDestinationCalendar(
+    userId: number,
+    destinationCalendar: DestinationCalendar_2024_06_14
+  ) {
+    const calendars: ConnectedCalendarsData = await this.calendarsService.getCalendars(userId);
+
+    const allCals = calendars.connectedCalendars.map((cal) => cal.calendars ?? []).flat();
+
+    const matchedCalendar = allCals.find(
+      (cal) =>
+        cal.externalId === destinationCalendar.externalId &&
+        cal.integration === destinationCalendar.integration
+    );
+
+    if (!matchedCalendar) {
+      throw new BadRequestException("Invalid destinationCalendarId: Calendar does not exist");
+    }
+
+    if (matchedCalendar.readOnly) {
+      throw new BadRequestException("Invalid destinationCalendarId: Calendar does not have write permission");
+    }
+
+    return;
+  }
+
+  async validateInputUseDestinationCalendarEmail(userId: number) {
+    const calendars: ConnectedCalendarsData = await this.calendarsService.getCalendars(userId);
+
+    const allCals = calendars.connectedCalendars.map((cal) => cal.calendars ?? []).flat();
+
+    const primaryCalendar = allCals.find((cal) => cal.primary);
+
+    if (!primaryCalendar) {
+      throw new BadRequestException(
+        "Validation failed: A primary connected calendar is required to set useDestinationCalendarEmail"
+      );
+    }
+
+    return;
+  }
 }

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

@@ -1,5 +1,5 @@
 import { Injectable } from "@nestjs/common";
-import type { EventType, User, Schedule } from "@prisma/client";
+import type { EventType, User, Schedule, DestinationCalendar } from "@prisma/client";
 
 import {
   EventTypeMetaDataSchema,
@@ -15,11 +15,25 @@ import {
   transformIntervalLimitsInternalToApi,
   transformFutureBookingLimitsInternalToApi,
   transformRecurrenceInternalToApi,
+  transformBookerLayoutsInternalToApi,
+  transformRequiresConfirmationInternalToApi,
+  transformEventTypeColorsInternalToApi,
+  parseEventTypeColor,
+  transformSeatsInternalToApi,
 } from "@calcom/platform-libraries";
-import { TransformFutureBookingsLimitSchema_2024_06_14 } from "@calcom/platform-types";
+import {
+  TransformFutureBookingsLimitSchema_2024_06_14,
+  BookerLayoutsTransformedSchema,
+  NoticeThresholdTransformedSchema,
+  EventTypeOutput_2024_06_14,
+} from "@calcom/platform-types";
 
-type EventTypeRelations = { users: User[]; schedule: Schedule | null };
-type DatabaseEventType = EventType & EventTypeRelations;
+type EventTypeRelations = {
+  users: User[];
+  schedule: Schedule | null;
+  destinationCalendar?: DestinationCalendar | null;
+};
+export type DatabaseEventType = EventType & EventTypeRelations;
 
 type Input = Pick<
   DatabaseEventType,
@@ -58,11 +72,19 @@ type Input = Pick<
   | "periodCountCalendarDays"
   | "periodStartDate"
   | "periodEndDate"
+  | "requiresBookerEmailVerification"
+  | "hideCalendarNotes"
+  | "eventTypeColor"
+  | "seatsShowAttendees"
+  | "requiresConfirmationWillBlockSlot"
+  | "eventName"
+  | "destinationCalendar"
+  | "useEventTypeDestinationCalendarEmail"
 >;
 
 @Injectable()
 export class OutputEventTypesService_2024_06_14 {
-  async getResponseEventType(ownerId: number, databaseEventType: Input) {
+  getResponseEventType(ownerId: number, databaseEventType: Input): EventTypeOutput_2024_06_14 {
     const {
       id,
       length,
@@ -74,8 +96,6 @@ export class OutputEventTypesService_2024_06_14 {
       beforeEventBuffer,
       afterEventBuffer,
       slug,
-      schedulingType,
-      requiresConfirmation,
       price,
       currency,
       lockTimeZoneToggleOnBookingPage,
@@ -87,17 +107,34 @@ export class OutputEventTypesService_2024_06_14 {
       scheduleId,
       onlyShowFirstAvailableSlot,
       offsetStart,
+      requiresBookerEmailVerification,
+      hideCalendarNotes,
+      seatsShowAttendees,
+      useEventTypeDestinationCalendarEmail,
     } = databaseEventType;
 
     const locations = this.transformLocations(databaseEventType.locations);
+    const customName = databaseEventType?.eventName ?? undefined;
     const bookingFields = databaseEventType.bookingFields
       ? this.transformBookingFields(BookingFieldsSchema.parse(databaseEventType.bookingFields))
       : [];
     const recurrence = this.transformRecurringEvent(databaseEventType.recurringEvent);
     const metadata = this.transformMetadata(databaseEventType.metadata) || {};
-    const users = this.transformUsers(databaseEventType.users);
+    const users = this.transformUsers(databaseEventType.users || []);
     const bookingLimitsCount = this.transformIntervalLimits(databaseEventType.bookingLimits);
     const bookingLimitsDuration = this.transformIntervalLimits(databaseEventType.durationLimits);
+    const color = this.transformEventTypeColor(databaseEventType.eventTypeColor);
+    const bookerLayouts = this.transformBookerLayouts(
+      metadata.bookerLayouts as unknown as BookerLayoutsTransformedSchema
+    );
+    const confirmationPolicy = this.transformRequiresConfirmation(
+      !!databaseEventType.requiresConfirmation,
+      !!databaseEventType.requiresConfirmationWillBlockSlot,
+      metadata.requiresConfirmationThreshold as NoticeThresholdTransformedSchema
+    );
+    delete metadata["bookerLayouts"];
+    delete metadata["requiresConfirmationThreshold"];
+    const seats = this.transformSeats(seatsPerTimeSlot, seatsShowAttendees, seatsShowAvailabilityCount);
     const bookingWindow = this.transformBookingWindow({
       periodType: databaseEventType.periodType,
       periodDays: databaseEventType.periodDays,
@@ -105,6 +142,7 @@ export class OutputEventTypesService_2024_06_14 {
       periodStartDate: databaseEventType.periodStartDate,
       periodEndDate: databaseEventType.periodEndDate,
     } as TransformFutureBookingsLimitSchema_2024_06_14);
+    const destinationCalendar = this.transformDestinationCalendar(databaseEventType.destinationCalendar);
 
     return {
       id,
@@ -121,16 +159,12 @@ export class OutputEventTypesService_2024_06_14 {
       minimumBookingNotice,
       beforeEventBuffer,
       afterEventBuffer,
-      schedulingType,
       metadata,
-      requiresConfirmation,
       price,
       currency,
       lockTimeZoneToggleOnBookingPage,
-      seatsPerTimeSlot,
       forwardParamsSuccessRedirect,
       successRedirectUrl,
-      seatsShowAvailabilityCount,
       isInstantEvent,
       users,
       scheduleId,
@@ -139,6 +173,15 @@ export class OutputEventTypesService_2024_06_14 {
       onlyShowFirstAvailableSlot,
       offsetStart,
       bookingWindow,
+      bookerLayouts,
+      confirmationPolicy,
+      requiresBookerEmailVerification,
+      hideCalendarNotes,
+      color,
+      seats,
+      customName,
+      destinationCalendar,
+      useDestinationCalendarEmail: useEventTypeDestinationCalendarEmail,
     };
   }
 
@@ -147,6 +190,14 @@ export class OutputEventTypesService_2024_06_14 {
     return transformLocationsInternalToApi(TransformedLocationsSchema.parse(locations));
   }
 
+  transformDestinationCalendar(destinationCalendar?: DestinationCalendar | null) {
+    if (!destinationCalendar) return undefined;
+    return {
+      integration: destinationCalendar.integration,
+      externalId: destinationCalendar.externalId,
+    };
+  }
+
   transformBookingFields(bookingFields: (SystemField | CustomField)[] | null) {
     if (!bookingFields) return [];
 
@@ -189,4 +240,39 @@ export class OutputEventTypesService_2024_06_14 {
   transformBookingWindow(bookingLimits: TransformFutureBookingsLimitSchema_2024_06_14) {
     return transformFutureBookingLimitsInternalToApi(bookingLimits);
   }
+
+  transformBookerLayouts(bookerLayouts: BookerLayoutsTransformedSchema) {
+    if (!bookerLayouts) return undefined;
+    return transformBookerLayoutsInternalToApi(bookerLayouts);
+  }
+
+  transformRequiresConfirmation(
+    requiresConfirmation: boolean,
+    requiresConfirmationWillBlockSlot: boolean,
+    requiresConfirmationThreshold?: NoticeThresholdTransformedSchema
+  ) {
+    return transformRequiresConfirmationInternalToApi(
+      requiresConfirmation,
+      requiresConfirmationWillBlockSlot,
+      requiresConfirmationThreshold
+    );
+  }
+
+  transformEventTypeColor(eventTypeColor: any) {
+    if (!eventTypeColor) return undefined;
+    const parsedeventTypeColor = parseEventTypeColor(eventTypeColor);
+    return transformEventTypeColorsInternalToApi(parsedeventTypeColor);
+  }
+
+  transformSeats(
+    seatsPerTimeSlot: number | null,
+    seatsShowAttendees: boolean | null,
+    seatsShowAvailabilityCount: boolean | null
+  ) {
+    return transformSeatsInternalToApi({
+      seatsPerTimeSlot,
+      seatsShowAttendees: !!seatsShowAttendees,
+      seatsShowAvailabilityCount: !!seatsShowAvailabilityCount,
+    });
+  }
 }

apps/api/v2/src/ee/gcal/gcal.controller.ts

@@ -26,7 +26,7 @@ import {
   Headers,
 } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { Prisma } from "@prisma/client";
 import { Request } from "express";
 import { google } from "googleapis";
@@ -44,7 +44,7 @@ const CALENDAR_SCOPES = [
   path: "/v2/gcal",
   version: API_VERSIONS_VALUES,
 })
-@DocsTags("Google Calendar")
+@DocsTags("Platform / Google Calendar")
 export class GcalController {
   private readonly logger = new Logger("Platform Gcal Provider");
 
@@ -62,6 +62,7 @@ export class GcalController {
   @Get("/oauth/auth-url")
   @HttpCode(HttpStatus.OK)
   @UseGuards(ApiAuthGuard)
+  @ApiOperation({ summary: "Get auth URL" })
   async redirect(
     @Headers("Authorization") authorization: string,
     @Req() req: Request
@@ -81,6 +82,7 @@ export class GcalController {
   @Get("/oauth/save")
   @Redirect(undefined, 301)
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Connect a calendar" })
   async save(@Query("state") state: string, @Query("code") code: string): Promise<GcalSaveRedirectOutput> {
     const url = new URL(this.config.get("api.url") + "/calendars/google/save");
     url.searchParams.append("code", code);
@@ -92,6 +94,7 @@ export class GcalController {
   @HttpCode(HttpStatus.OK)
   @UseGuards(ApiAuthGuard, PermissionsGuard)
   @Permissions([APPS_READ])
+  @ApiOperation({ summary: "Check a calendar connection status" })
   async check(@GetUser("id") userId: number): Promise<GcalCheckOutput> {
     const gcalCredentials = await this.credentialRepository.getByTypeAndUserId("google_calendar", userId);
 

apps/api/v2/src/ee/me/me.controller.ts

@@ -10,7 +10,7 @@ import { UpdateManagedUserInput } from "@/modules/users/inputs/update-managed-us
 import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile, UsersRepository } from "@/modules/users/users.repository";
 import { Controller, UseGuards, Get, Patch, Body } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { PROFILE_READ, PROFILE_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
 import { userSchemaResponse } from "@calcom/platform-types";
@@ -30,6 +30,7 @@ export class MeController {
 
   @Get("/")
   @Permissions([PROFILE_READ])
+  @ApiOperation({ summary: "Get my profile" })
   async getMe(@GetUser() user: UserWithProfile): Promise<GetMeOutput> {
     const organization = this.usersService.getUserMainProfile(user)?.organization;
     const me = userSchemaResponse.parse(
@@ -52,6 +53,7 @@ export class MeController {
 
   @Patch("/")
   @Permissions([PROFILE_WRITE])
+  @ApiOperation({ summary: "Update my profile" })
   async updateMe(
     @GetUser() user: UserWithProfile,
     @Body() bodySchedule: UpdateManagedUserInput

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

@@ -1,4 +1,5 @@
-import { BookingsModule } from "@/ee/bookings/bookings.module";
+import { BookingsModule_2024_04_15 } from "@/ee/bookings/2024-04-15/bookings.module";
+import { BookingsModule_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.module";
 import { CalendarsModule } from "@/ee/calendars/calendars.module";
 import { EventTypesModule_2024_04_15 } from "@/ee/event-types/event-types_2024_04_15/event-types.module";
 import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
@@ -21,7 +22,8 @@ import { Module } from "@nestjs/common";
     EventTypesModule_2024_04_15,
     EventTypesModule_2024_06_14,
     CalendarsModule,
-    BookingsModule,
+    BookingsModule_2024_04_15,
+    BookingsModule_2024_08_13,
     SlotsModule,
   ],
 })

apps/api/v2/src/ee/provider/provider.controller.ts

@@ -16,7 +16,7 @@ import {
   UnauthorizedException,
   UseGuards,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 
@@ -24,12 +24,13 @@ import { SUCCESS_STATUS } from "@calcom/platform-constants";
   path: "/v2/provider",
   version: API_VERSIONS_VALUES,
 })
-@DocsTags("Cal provider")
+@DocsTags("Platform / Cal Provider")
 export class CalProviderController {
   constructor(private readonly oauthClientRepository: OAuthClientRepository) {}
 
   @Get("/:clientId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get a provider" })
   async verifyClientId(@Param("clientId") clientId: string): Promise<ProviderVerifyClientOutput> {
     if (!clientId) {
       throw new NotFoundException();
@@ -51,6 +52,7 @@ export class CalProviderController {
   @Get("/:clientId/access-token")
   @HttpCode(HttpStatus.OK)
   @UseGuards(ApiAuthGuard)
+  @ApiOperation({ summary: "Verify an access token" })
   async verifyAccessToken(
     @Param("clientId") clientId: string,
     @GetUser() user: UserWithProfile

apps/api/v2/src/ee/schedules/schedules_2024_06_11/controllers/schedules.controller.ts

@@ -89,6 +89,7 @@ export class SchedulesController_2024_06_11 {
     description: "Returns the default schedule of the authenticated user",
     type: GetDefaultScheduleOutput_2024_06_11,
   })
+  @ApiOperation({ summary: "Get default schedule (of the authenticated user)" })
   async getDefaultSchedule(@GetUser() user: UserWithProfile): Promise<GetScheduleOutput_2024_06_11> {
     const schedule = await this.schedulesService.getUserScheduleDefault(user.id);
 
@@ -101,6 +102,7 @@ export class SchedulesController_2024_06_11 {
   @Get("/:scheduleId")
   @Permissions([SCHEDULE_READ])
   @Throttle({ default: { limit: 10, ttl: 60000 } }) // allow 10 requests per minute (for :scheduleId)
+  @ApiOperation({ summary: "Get a schedule" })
   async getSchedule(
     @GetUser() user: UserWithProfile,
     @Param("scheduleId") scheduleId: number
@@ -115,9 +117,7 @@ export class SchedulesController_2024_06_11 {
 
   @Get("/")
   @Permissions([SCHEDULE_READ])
-  @ApiOperation({
-    description: "Returns all schedules of the authenticated user",
-  })
+  @ApiOperation({ summary: "Get all schedules (of the authenticated user)" })
   async getSchedules(@GetUser() user: UserWithProfile): Promise<GetSchedulesOutput_2024_06_11> {
     const schedules = await this.schedulesService.getUserSchedules(user.id);
 
@@ -129,6 +129,7 @@ export class SchedulesController_2024_06_11 {
 
   @Patch("/:scheduleId")
   @Permissions([SCHEDULE_WRITE])
+  @ApiOperation({ summary: "Update a schedule" })
   async updateSchedule(
     @GetUser() user: UserWithProfile,
     @Body() bodySchedule: UpdateScheduleInput_2024_06_11,
@@ -149,6 +150,7 @@ export class SchedulesController_2024_06_11 {
   @Delete("/:scheduleId")
   @HttpCode(HttpStatus.OK)
   @Permissions([SCHEDULE_WRITE])
+  @ApiOperation({ summary: "Delete a schedule" })
   async deleteSchedule(
     @GetUser("id") userId: number,
     @Param("scheduleId") scheduleId: number

apps/api/v2/src/lib/api-versions.ts

@@ -5,13 +5,16 @@ import {
   VERSION_2024_04_15,
   VERSION_2024_06_11,
   VERSION_2024_06_14,
+  VERSION_2024_08_13,
 } from "@calcom/platform-constants";
 
 export const API_VERSIONS_VALUES: VersionValue = API_VERSIONS as unknown as VersionValue;
 export const VERSION_2024_06_14_VALUE: VersionValue = VERSION_2024_06_14 as unknown as VersionValue;
 export const VERSION_2024_06_11_VALUE: VersionValue = VERSION_2024_06_11 as unknown as VersionValue;
 export const VERSION_2024_04_15_VALUE: VersionValue = VERSION_2024_04_15 as unknown as VersionValue;
+export const VERSION_2024_08_13_VALUE: VersionValue = VERSION_2024_08_13 as unknown as VersionValue;
 
 export { VERSION_2024_04_15 };
 export { VERSION_2024_06_11 };
 export { VERSION_2024_06_14 };
+export { VERSION_2024_08_13 };

apps/api/v2/src/main.ts

@@ -4,6 +4,12 @@ import { ConfigService } from "@nestjs/config";
 import { NestFactory } from "@nestjs/core";
 import type { NestExpressApplication } from "@nestjs/platform-express";
 import { SwaggerModule, DocumentBuilder } from "@nestjs/swagger";
+import {
+  PathItemObject,
+  PathsObject,
+  OperationObject,
+  TagObject,
+} from "@nestjs/swagger/dist/interfaces/open-api-spec.interface";
 import "dotenv/config";
 import * as fs from "fs";
 import { Server } from "http";
@@ -13,6 +19,8 @@ import { bootstrap } from "./app";
 import { AppModule } from "./app.module";
 import { loggerConfig } from "./lib/logger";
 
+const HttpMethods: (keyof PathItemObject)[] = ["get", "post", "put", "delete", "patch", "options", "head"];
+
 const run = async () => {
   const app = await NestFactory.create<NestExpressApplication>(AppModule, {
     logger: WinstonModule.createLogger(loggerConfig()),
@@ -35,13 +43,69 @@ const run = async () => {
   }
 };
 
+function customTagSort(a: string, b: string): number {
+  const platformPrefix = "Platform";
+  const orgsPrefix = "Orgs";
+
+  if (a.startsWith(platformPrefix) && !b.startsWith(platformPrefix)) {
+    return -1;
+  }
+  if (!a.startsWith(platformPrefix) && b.startsWith(platformPrefix)) {
+    return 1;
+  }
+
+  if (a.startsWith(orgsPrefix) && !b.startsWith(orgsPrefix)) {
+    return -1;
+  }
+  if (!a.startsWith(orgsPrefix) && b.startsWith(orgsPrefix)) {
+    return 1;
+  }
+
+  return a.localeCompare(b);
+}
+
+function isOperationObject(obj: any): obj is OperationObject {
+  return obj && typeof obj === "object" && "tags" in obj;
+}
+
+function groupAndSortPathsByFirstTag(paths: PathsObject): PathsObject {
+  const groupedPaths: { [key: string]: PathsObject } = {};
+
+  Object.keys(paths).forEach((pathKey) => {
+    const pathItem = paths[pathKey];
+
+    HttpMethods.forEach((method) => {
+      const operation = pathItem[method];
+
+      if (isOperationObject(operation) && operation.tags && operation.tags.length > 0) {
+        const firstTag = operation.tags[0];
+
+        if (!groupedPaths[firstTag]) {
+          groupedPaths[firstTag] = {};
+        }
+
+        groupedPaths[firstTag][pathKey] = pathItem;
+      }
+    });
+  });
+
+  const sortedTags = Object.keys(groupedPaths).sort(customTagSort);
+  const sortedPaths: PathsObject = {};
+
+  sortedTags.forEach((tag) => {
+    Object.assign(sortedPaths, groupedPaths[tag]);
+  });
+
+  return sortedPaths;
+}
+
 async function generateSwagger(app: NestExpressApplication<Server>) {
   const logger = new Logger("App");
   logger.log(`Generating Swagger documentation...\n`);
 
-  const config = new DocumentBuilder().setTitle("Cal.com v2 API").build();
-
+  const config = new DocumentBuilder().setTitle("Cal.com API v2").build();
   const document = SwaggerModule.createDocument(app, config);
+  document.paths = groupAndSortPathsByFirstTag(document.paths);
 
   const outputFile = "./swagger/documentation.json";
 

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

@@ -19,7 +19,7 @@ export class BillingRepository {
     billingStart: number,
     billingEnd: number,
     plan: PlatformPlan,
-    subscription?: string
+    subscriptionId?: string
   ) {
     return this.dbWrite.prisma.platformBilling.update({
       where: {
@@ -28,7 +28,7 @@ export class BillingRepository {
       data: {
         billingCycleStart: billingStart,
         billingCycleEnd: billingEnd,
-        subscriptionId: subscription,
+        subscriptionId,
         plan: plan.toString(),
       },
     });

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

@@ -7,9 +7,8 @@ import { SubscribeToPlanInput } from "@/modules/billing/controllers/inputs/subsc
 import { CheckPlatformBillingResponseDto } from "@/modules/billing/controllers/outputs/CheckPlatformBillingResponse.dto";
 import { SubscribeTeamToBillingResponseDto } from "@/modules/billing/controllers/outputs/SubscribeTeamToBillingResponse.dto";
 import { BillingService } from "@/modules/billing/services/billing.service";
-import { PlatformPlan } from "@/modules/billing/types";
+import { StripeService } from "@/modules/stripe/stripe.service";
 import {
-  BadRequestException,
   Body,
   Controller,
   Get,
@@ -25,7 +24,6 @@ import {
 import { ConfigService } from "@nestjs/config";
 import { ApiExcludeController } from "@nestjs/swagger";
 import { Request } from "express";
-import { Stripe } from "stripe";
 
 import { ApiResponse } from "@calcom/platform-types";
 
@@ -40,6 +38,7 @@ export class BillingController {
 
   constructor(
     private readonly billingService: BillingService,
+    public readonly stripeService: StripeService,
     private readonly configService: ConfigService<AppConfig>
   ) {
     this.stripeWhSecret = configService.get("stripe.webhookSecret", { infer: true }) ?? "";
@@ -69,13 +68,32 @@ export class BillingController {
     @Param("teamId") teamId: number,
     @Body() input: SubscribeToPlanInput
   ): Promise<ApiResponse<SubscribeTeamToBillingResponseDto | undefined>> {
-    const { status } = await this.billingService.getBillingData(teamId);
+    const { action, url } = await this.billingService.createSubscriptionForTeam(teamId, input.plan);
 
-    if (status === "valid") {
-      throw new BadRequestException("This team is already subscribed to a plan.");
+    if (action === "redirect") {
+      return {
+        status: "success",
+        data: {
+          action: "redirect",
+          url,
+        },
+      };
     }
 
-    const { action, url } = await this.billingService.createSubscriptionForTeam(teamId, input.plan);
+    return {
+      status: "success",
+    };
+  }
+
+  @Post("/:teamId/upgrade")
+  @UseGuards(NextAuthGuard, OrganizationRolesGuard)
+  @MembershipRoles(["OWNER", "ADMIN"])
+  async upgradeTeamBillingInStripe(
+    @Param("teamId") teamId: number,
+    @Body() input: SubscribeToPlanInput
+  ): Promise<ApiResponse<SubscribeTeamToBillingResponseDto | undefined>> {
+    const { action, url } = await this.billingService.updateSubscriptionForTeam(teamId, input.plan);
+
     if (action === "redirect") {
       return {
         status: "success",
@@ -103,33 +121,7 @@ export class BillingController {
       this.stripeWhSecret
     );
 
-    if (event.type === "customer.subscription.created" || event.type === "customer.subscription.updated") {
-      const subscription = event.data.object as Stripe.Subscription;
-      if (!subscription.metadata?.teamId) {
-        return {
-          status: "success",
-        };
-      }
-
-      const teamId = Number.parseInt(subscription.metadata.teamId);
-      const plan = subscription.metadata.plan;
-      if (!plan || !teamId) {
-        this.logger.log("Webhook received but not pertaining to Platform, discarding.");
-        return {
-          status: "success",
-        };
-      }
-
-      await this.billingService.setSubscriptionForTeam(
-        teamId,
-        subscription,
-        PlatformPlan[plan.toUpperCase() as keyof typeof PlatformPlan]
-      );
-
-      return {
-        status: "success",
-      };
-    }
+    await this.billingService.createOrUpdateStripeSubscription(event);
 
     return {
       status: "success",

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

@@ -6,7 +6,13 @@ import { PlatformPlan } from "@/modules/billing/types";
 import { OrganizationsRepository } from "@/modules/organizations/organizations.repository";
 import { StripeService } from "@/modules/stripe/stripe.service";
 import { InjectQueue } from "@nestjs/bull";
-import { Injectable, InternalServerErrorException, Logger, OnModuleDestroy } from "@nestjs/common";
+import {
+  Injectable,
+  InternalServerErrorException,
+  Logger,
+  NotFoundException,
+  OnModuleDestroy,
+} from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { Queue } from "bull";
 import { DateTime } from "luxon";
@@ -43,12 +49,9 @@ export class BillingService implements OnModuleDestroy {
 
   async createSubscriptionForTeam(teamId: number, plan: PlatformPlan) {
     const teamWithBilling = await this.teamsRepository.findByIdIncludeBilling(teamId);
-    let brandNewBilling = false;
-
     let customerId = teamWithBilling?.platformBilling?.customerId;
 
     if (!teamWithBilling?.platformBilling) {
-      brandNewBilling = true;
       customerId = await this.teamsRepository.createNewBillingRelation(teamId);
 
       this.logger.log("Team had no Stripe Customer ID, created one for them.", {
@@ -57,43 +60,61 @@ export class BillingService implements OnModuleDestroy {
       });
     }
 
-    if (brandNewBilling || !teamWithBilling?.platformBilling?.subscriptionId) {
-      const { url } = await this.stripeService.stripe.checkout.sessions.create({
-        customer: customerId,
-        line_items: [
-          {
-            price: this.billingConfigService.get(plan)?.overage,
-          },
-          {
-            price: this.billingConfigService.get(plan)?.base,
-            quantity: 1,
-          },
-        ],
-        success_url: `${this.webAppUrl}/settings/platform/`,
-        cancel_url: `${this.webAppUrl}/settings/platform/`,
-        mode: "subscription",
+    const { url } = await this.stripeService.stripe.checkout.sessions.create({
+      customer: customerId,
+      line_items: [
+        {
+          price: this.billingConfigService.get(plan)?.base,
+          quantity: 1,
+        },
+        {
+          price: this.billingConfigService.get(plan)?.overage,
+        },
+      ],
+      success_url: `${this.webAppUrl}/settings/platform/`,
+      cancel_url: `${this.webAppUrl}/settings/platform/`,
+      mode: "subscription",
+      metadata: {
+        teamId: teamId.toString(),
+        plan: plan.toString(),
+      },
+      currency: "usd",
+      subscription_data: {
         metadata: {
           teamId: teamId.toString(),
           plan: plan.toString(),
         },
-        subscription_data: {
-          metadata: {
-            teamId: teamId.toString(),
-            plan: plan.toString(),
-          },
-        },
-        allow_promotion_codes: true,
-      });
+      },
+      allow_promotion_codes: true,
+    });
 
-      if (!url) throw new InternalServerErrorException("Failed to create Stripe session.");
+    if (!url) throw new InternalServerErrorException("Failed to create Stripe session.");
 
-      return { action: "redirect", url };
-    }
-
-    return { action: "none" };
+    return { action: "redirect", url };
   }
 
-  async setSubscriptionForTeam(teamId: number, subscription: Stripe.Subscription, plan: PlatformPlan) {
+  async updateSubscriptionForTeam(teamId: number, plan: PlatformPlan) {
+    const teamWithBilling = await this.teamsRepository.findByIdIncludeBilling(teamId);
+    const customerId = teamWithBilling?.platformBilling?.customerId;
+
+    const { url } = await this.stripeService.stripe.checkout.sessions.create({
+      customer: customerId,
+      success_url: `${this.webAppUrl}/settings/platform/`,
+      cancel_url: `${this.webAppUrl}/settings/platform/plans`,
+      mode: "setup",
+      metadata: {
+        teamId: teamId.toString(),
+        plan: plan.toString(),
+      },
+      currency: "usd",
+    });
+
+    if (!url) throw new InternalServerErrorException("Failed to create Stripe session.");
+
+    return { action: "redirect", url };
+  }
+
+  async setSubscriptionForTeam(teamId: number, subscriptionId: string, plan: PlatformPlan) {
     const billingCycleStart = DateTime.now().get("day");
     const billingCycleEnd = DateTime.now().plus({ month: 1 }).get("day");
 
@@ -102,10 +123,94 @@ export class BillingService implements OnModuleDestroy {
       billingCycleStart,
       billingCycleEnd,
       plan,
-      subscription.id
+      subscriptionId
     );
   }
 
+  async createOrUpdateStripeSubscription(event: Stripe.Event) {
+    if (event.type === "checkout.session.completed") {
+      const subscription = event.data.object as Stripe.Checkout.Session;
+
+      if (!subscription.metadata?.teamId) {
+        return {
+          status: "success",
+        };
+      }
+
+      const teamId = Number.parseInt(subscription.metadata.teamId);
+      const plan = subscription.metadata.plan;
+      if (!plan || !teamId) {
+        this.logger.log("Webhook received but not pertaining to Platform, discarding.");
+        return {
+          status: "success",
+        };
+      }
+
+      if (subscription.mode === "subscription") {
+        await this.setSubscriptionForTeam(
+          teamId,
+          subscription.subscription as string,
+          PlatformPlan[plan.toUpperCase() as keyof typeof PlatformPlan]
+        );
+      }
+
+      if (subscription.mode === "setup") {
+        await this.updateStripeSubscriptionForTeam(teamId, plan as PlatformPlan);
+      }
+
+      return {
+        status: "success",
+      };
+    }
+  }
+
+  async updateStripeSubscriptionForTeam(teamId: number, plan: PlatformPlan) {
+    const teamWithBilling = await this.teamsRepository.findByIdIncludeBilling(teamId);
+
+    if (!teamWithBilling?.platformBilling || !teamWithBilling?.platformBilling.subscriptionId) {
+      throw new NotFoundException("Team plan not found");
+    }
+
+    const existingUserSubscription = await this.stripeService.stripe.subscriptions.retrieve(
+      teamWithBilling?.platformBilling?.subscriptionId
+    );
+    const currentLicensedItem = existingUserSubscription.items.data.find(
+      (item) => item.price?.recurring?.usage_type === "licensed"
+    );
+    const currentOverageItem = existingUserSubscription.items.data.find(
+      (item) => item.price?.recurring?.usage_type === "metered"
+    );
+
+    if (!currentLicensedItem) {
+      throw new NotFoundException("There is no licensed item present in the subscription");
+    }
+
+    if (!currentOverageItem) {
+      throw new NotFoundException("There is no overage item present in the subscription");
+    }
+
+    await this.stripeService.stripe.subscriptions.update(teamWithBilling?.platformBilling?.subscriptionId, {
+      items: [
+        {
+          id: currentLicensedItem.id,
+          price: this.billingConfigService.get(plan)?.base,
+        },
+        {
+          id: currentOverageItem.id,
+          price: this.billingConfigService.get(plan)?.overage,
+          clear_usage: false,
+        },
+      ],
+      billing_cycle_anchor: "now",
+      proration_behavior: "create_prorations",
+    });
+
+    await this.setSubscriptionForTeam(
+      teamId,
+      teamWithBilling?.platformBilling?.subscriptionId,
+      PlatformPlan[plan.toUpperCase() as keyof typeof PlatformPlan]
+    );
+  }
   /**
    *
    * Adds a job to the queue to increment usage of a stripe subscription.

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

@@ -98,6 +98,7 @@ describe("Platform Destination Calendar Endpoints", () => {
             error: { message: "" },
           },
         ],
+        destinationCalendar: null,
       })
     );
     app = moduleRef.createNestApplication();

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

@@ -9,7 +9,7 @@ import {
 import { DestinationCalendarsService } from "@/modules/destination-calendars/services/destination-calendars.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Body, Controller, Put, UseGuards } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { plainToClass } from "class-transformer";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -18,13 +18,13 @@ import { SUCCESS_STATUS } from "@calcom/platform-constants";
   path: "/v2/destination-calendars",
   version: API_VERSIONS_VALUES,
 })
-@DocsTags("Destination-Calendars")
+@DocsTags("Destination Calendars")
 export class DestinationCalendarsController {
   constructor(private readonly destinationCalendarsService: DestinationCalendarsService) {}
 
   @Put("/")
   @UseGuards(ApiAuthGuard)
-  @DocsTags("Select a third party destination calendar where events will be created")
+  @ApiOperation({ summary: "Update destination calendars" })
   async updateDestinationCalendars(
     @Body() input: DestinationCalendarsInputBodyDto,
     @GetUser() user: UserWithProfile

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

@@ -25,7 +25,7 @@ import {
   Patch,
   ParseIntPipe,
 } from "@nestjs/common";
-import { ApiOperation, ApiTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { Webhook } from "@prisma/client";
 import { plainToClass } from "class-transformer";
 
@@ -37,7 +37,7 @@ import { SkipTakePagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsUserEventTypeWebhookGuard)
-@ApiTags("Users' EventTypes Webhooks")
+@DocsTags("Event Types / Webhooks")
 export class EventTypeWebhooksController {
   constructor(
     private readonly webhooksService: WebhooksService,
@@ -45,7 +45,7 @@ export class EventTypeWebhooksController {
   ) {}
 
   @Post("/")
-  @ApiOperation({ summary: "Create a webhook for an event-type" })
+  @ApiOperation({ summary: "Create a webhook" })
   async createEventTypeWebhook(
     @Body() body: CreateWebhookInputDto,
     @Param("eventTypeId", ParseIntPipe) eventTypeId: number
@@ -63,7 +63,7 @@ export class EventTypeWebhooksController {
   }
 
   @Patch("/:webhookId")
-  @ApiOperation({ summary: "Update a webhook of an event-type" })
+  @ApiOperation({ summary: "Update a webhook" })
   async updateEventTypeWebhook(
     @Body() body: UpdateWebhookInputDto,
     @Param("webhookId") webhookId: string
@@ -81,7 +81,7 @@ export class EventTypeWebhooksController {
   }
 
   @Get("/:webhookId")
-  @ApiOperation({ summary: "Get a webhook of an event-type" })
+  @ApiOperation({ summary: "Get a webhook" })
   async getEventTypeWebhook(@GetWebhook() webhook: Webhook): Promise<EventTypeWebhookOutputResponseDto> {
     return {
       status: SUCCESS_STATUS,
@@ -92,7 +92,7 @@ export class EventTypeWebhooksController {
   }
 
   @Get("/")
-  @ApiOperation({ summary: "Get all webhooks of an event-type" })
+  @ApiOperation({ summary: "Get all webhooks" })
   async getEventTypeWebhooks(
     @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
     @Query() pagination: SkipTakePagination
@@ -113,7 +113,7 @@ export class EventTypeWebhooksController {
   }
 
   @Delete("/:webhookId")
-  @ApiOperation({ summary: "Delete a webhook of an event-type" })
+  @ApiOperation({ summary: "Delete a webhook" })
   async deleteEventTypeWebhook(@GetWebhook() webhook: Webhook): Promise<EventTypeWebhookOutputResponseDto> {
     await this.webhooksService.deleteWebhook(webhook.id);
     return {
@@ -125,7 +125,7 @@ export class EventTypeWebhooksController {
   }
 
   @Delete("/")
-  @ApiOperation({ summary: "Delete all webhooks of an event-type" })
+  @ApiOperation({ summary: "Delete all webhooks" })
   async deleteAllEventTypeWebhooks(
     @Param("eventTypeId", ParseIntPipe) eventTypeId: number
   ): Promise<DeleteManyWebhooksOutputResponseDto> {

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

@@ -4,10 +4,9 @@ import { DEFAULT_EVENT_TYPES } from "@/ee/event-types/event-types_2024_04_15/con
 import { HttpExceptionFilter } from "@/filters/http-exception.filter";
 import { PrismaExceptionFilter } from "@/filters/prisma-exception.filter";
 import { Locales } from "@/lib/enums/locales";
-import {
-  CreateUserResponse,
-  UserReturned,
-} from "@/modules/oauth-clients/controllers/oauth-client-users/oauth-client-users.controller";
+import { CreateManagedUserOutput } from "@/modules/oauth-clients/controllers/oauth-client-users/outputs/create-managed-user.output";
+import { GetManagedUserOutput } from "@/modules/oauth-clients/controllers/oauth-client-users/outputs/get-managed-user.output";
+import { GetManagedUsersOutput } from "@/modules/oauth-clients/controllers/oauth-client-users/outputs/get-managed-users.output";
 import { CreateManagedUserInput } from "@/modules/users/inputs/create-managed-user.input";
 import { UpdateManagedUserInput } from "@/modules/users/inputs/update-managed-user.input";
 import { UsersModule } from "@/modules/users/users.module";
@@ -81,7 +80,7 @@ describe("OAuth Client Users Endpoints", () => {
     let schedulesRepositoryFixture: SchedulesRepositoryFixture;
     let profilesRepositoryFixture: ProfileRepositoryFixture;
 
-    let postResponseData: CreateUserResponse;
+    let postResponseData: CreateManagedUserOutput["data"];
 
     const platformAdminEmail = "platform-sensei@mail.com";
     let platformAdmin: User;
@@ -150,6 +149,22 @@ describe("OAuth Client Users Endpoints", () => {
       const requestBody: CreateManagedUserInput = {
         email: userEmail,
         timeZone: "incorrect-time-zone",
+        name: "Alice Smith",
+      };
+
+      await request(app.getHttpServer())
+        .post(`/api/v2/oauth-clients/${oAuthClient.id}/users`)
+        .set("x-cal-secret-key", oAuthClient.secret)
+        .send(requestBody)
+        .expect(400);
+    });
+
+    it(`should fail /POST with incorrect timeFormat`, async () => {
+      const requestBody = {
+        email: userEmail,
+        timeZone: userTimeZone,
+        name: "Alice Smith",
+        timeFormat: 100,
       };
 
       await request(app.getHttpServer())
@@ -166,6 +181,7 @@ describe("OAuth Client Users Endpoints", () => {
         weekStart: "Monday",
         timeFormat: 24,
         locale: Locales.FR,
+        name: "Alice Smith",
       };
 
       const response = await request(app.getHttpServer())
@@ -174,11 +190,7 @@ describe("OAuth Client Users Endpoints", () => {
         .send(requestBody)
         .expect(201);
 
-      const responseBody: ApiSuccessResponse<{
-        user: Omit<User, "password">;
-        accessToken: string;
-        refreshToken: string;
-      }> = response.body;
+      const responseBody: CreateManagedUserOutput = response.body;
 
       postResponseData = responseBody.data;
 
@@ -186,6 +198,7 @@ describe("OAuth Client Users Endpoints", () => {
       expect(responseBody.data).toBeDefined();
       expect(responseBody.data.user.email).toEqual(getOAuthUserEmail(oAuthClient.id, requestBody.email));
       expect(responseBody.data.user.timeZone).toEqual(requestBody.timeZone);
+      expect(responseBody.data.user.name).toEqual(requestBody.name);
       expect(responseBody.data.user.weekStart).toEqual(requestBody.weekStart);
       expect(responseBody.data.user.timeFormat).toEqual(requestBody.timeFormat);
       expect(responseBody.data.user.locale).toEqual(requestBody.locale);
@@ -242,12 +255,13 @@ describe("OAuth Client Users Endpoints", () => {
         .set("Origin", `${CLIENT_REDIRECT_URI}`)
         .expect(200);
 
-      const responseBody: ApiSuccessResponse<UserReturned[]> = response.body;
+      const responseBody: GetManagedUsersOutput = response.body;
 
       expect(responseBody.status).toEqual(SUCCESS_STATUS);
       expect(responseBody.data).toBeDefined();
       expect(responseBody.data?.length).toBeGreaterThan(0);
       expect(responseBody.data[0].email).toEqual(postResponseData.user.email);
+      expect(responseBody.data[0].name).toEqual(postResponseData.user.name);
     });
 
     it(`/GET/:id`, async () => {
@@ -257,7 +271,7 @@ describe("OAuth Client Users Endpoints", () => {
         .set("Origin", `${CLIENT_REDIRECT_URI}`)
         .expect(200);
 
-      const responseBody: ApiSuccessResponse<UserReturned> = response.body;
+      const responseBody: GetManagedUserOutput = response.body;
 
       expect(responseBody.status).toEqual(SUCCESS_STATUS);
       expect(responseBody.data).toBeDefined();
@@ -333,7 +347,7 @@ describe("OAuth Client Users Endpoints", () => {
     let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
     let profileRepositoryFixture: ProfileRepositoryFixture;
 
-    let postResponseData: CreateUserResponse;
+    let postResponseData: CreateManagedUserOutput["data"];
 
     const userEmail = "oauth-client-users-user@gmail.com";
     const userTimeZone = "Europe/Rome";
@@ -479,6 +493,7 @@ describe("OAuth Client Users Endpoints", () => {
         weekStart: "Monday",
         timeFormat: 24,
         locale: Locales.FR,
+        name: "Alice Smith",
       };
 
       const response = await request(app.getHttpServer())
@@ -487,12 +502,7 @@ describe("OAuth Client Users Endpoints", () => {
         .send(requestBody)
         .expect(201);
 
-      const responseBody: ApiSuccessResponse<{
-        user: Omit<User, "password">;
-        accessToken: string;
-        refreshToken: string;
-      }> = response.body;
-
+      const responseBody: CreateManagedUserOutput = response.body;
       postResponseData = responseBody.data;
 
       expect(responseBody.status).toEqual(SUCCESS_STATUS);
@@ -500,6 +510,7 @@ describe("OAuth Client Users Endpoints", () => {
 
       await userHasCorrectEventTypes(responseBody.data.user.id);
       await teamHasCorrectEventTypes(team1.id);
+      expect(responseBody.data.user.name).toEqual(requestBody.name);
     });
 
     async function userHasCorrectEventTypes(userId: number) {

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

@@ -28,7 +28,7 @@ import {
   Query,
   NotFoundException,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { User } from "@prisma/client";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -39,7 +39,7 @@ import { Pagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, OAuthClientGuard)
-@DocsTags("Managed users")
+@DocsTags("Platform / Managed Users")
 export class OAuthClientUsersController {
   private readonly logger = new Logger("UserController");
 
@@ -51,6 +51,7 @@ export class OAuthClientUsersController {
   ) {}
 
   @Get("/")
+  @ApiOperation({ summary: "Get all managed users" })
   async getManagedUsers(
     @Param("clientId") oAuthClientId: string,
     @Query() queryParams: Pagination
@@ -71,6 +72,7 @@ export class OAuthClientUsersController {
   }
 
   @Post("/")
+  @ApiOperation({ summary: "Create a managed user" })
   async createUser(
     @Param("clientId") oAuthClientId: string,
     @Body() body: CreateManagedUserInput
@@ -101,6 +103,7 @@ export class OAuthClientUsersController {
 
   @Get("/:userId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get a managed user" })
   async getUserById(
     @Param("clientId") clientId: string,
     @Param("userId") userId: number
@@ -115,6 +118,7 @@ export class OAuthClientUsersController {
 
   @Patch("/:userId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Update a managed user" })
   async updateUser(
     @Param("clientId") clientId: string,
     @Param("userId") userId: number,
@@ -133,6 +137,7 @@ export class OAuthClientUsersController {
 
   @Delete("/:userId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Delete a managed user" })
   async deleteUser(
     @Param("clientId") clientId: string,
     @Param("userId") userId: number
@@ -150,6 +155,7 @@ export class OAuthClientUsersController {
 
   @Post("/:userId/force-refresh")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Force refresh tokens" })
   async forceRefresh(
     @Param("userId") userId: number,
     @Param("clientId") oAuthClientId: string
@@ -188,6 +194,7 @@ export class OAuthClientUsersController {
       id: user.id,
       email: user.email,
       username: user.username,
+      name: user.name,
       timeZone: user.timeZone,
       weekStart: user.weekStart,
       createdDate: user.createdDate,
@@ -197,7 +204,3 @@ export class OAuthClientUsersController {
     };
   }
 }
-
-export type UserReturned = Pick<User, "id" | "email" | "username">;
-
-export type CreateUserResponse = { user: UserReturned; accessToken: string; refreshToken: string };

apps/api/v2/src/modules/oauth-clients/controllers/oauth-client-users/outputs/managed-user.output.ts

@@ -13,6 +13,9 @@ export class ManagedUserOutput {
   @ApiProperty({ example: "alice" })
   username!: string | null;
 
+  @ApiProperty({ example: "alice" })
+  name!: string | null;
+
   @ApiProperty({ example: "America/New_York" })
   timeZone!: string;
 

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

@@ -16,7 +16,7 @@ import { WebhookOutputPipe } from "@/modules/webhooks/pipes/WebhookOutputPipe";
 import { OAuthClientWebhooksService } from "@/modules/webhooks/services/oauth-clients-webhooks.service";
 import { WebhooksService } from "@/modules/webhooks/services/webhooks.service";
 import { Controller, Post, Body, UseGuards, Get, Param, Query, Delete, Patch } from "@nestjs/common";
-import { ApiOperation, ApiTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { Webhook, MembershipRole } from "@prisma/client";
 import { plainToClass } from "class-transformer";
 
@@ -30,7 +30,7 @@ import { OAuthClientGuard } from "../../guards/oauth-client-guard";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(NextAuthGuard, OrganizationRolesGuard, OAuthClientGuard)
-@ApiTags("OAuthClients Webhooks")
+@DocsTags("Platform / Webhooks")
 export class OAuthClientWebhooksController {
   constructor(
     private readonly webhooksService: WebhooksService,
@@ -39,7 +39,7 @@ export class OAuthClientWebhooksController {
 
   @Post("/")
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
-  @ApiOperation({ summary: "Create a webhook for an oAuthClient" })
+  @ApiOperation({ summary: "Create a webhook" })
   async createOAuthClientWebhook(
     @Body() body: CreateWebhookInputDto,
     @Param("clientId") oAuthClientId: string
@@ -59,7 +59,7 @@ export class OAuthClientWebhooksController {
 
   @Patch("/:webhookId")
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
-  @ApiOperation({ summary: "Update a webhook of an oAuthClient" })
+  @ApiOperation({ summary: "Update a webhook" })
   @UseGuards(IsOAuthClientWebhookGuard)
   async updateOAuthClientWebhook(
     @Body() body: UpdateWebhookInputDto,
@@ -79,7 +79,7 @@ export class OAuthClientWebhooksController {
 
   @Get("/:webhookId")
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER, MembershipRole.MEMBER])
-  @ApiOperation({ summary: "Get a webhook of an oAuthClient" })
+  @ApiOperation({ summary: "Get a webhook" })
   @UseGuards(IsOAuthClientWebhookGuard)
   async getOAuthClientWebhook(@GetWebhook() webhook: Webhook): Promise<OAuthClientWebhookOutputResponseDto> {
     return {
@@ -92,7 +92,7 @@ export class OAuthClientWebhooksController {
 
   @Get("/")
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER, MembershipRole.MEMBER])
-  @ApiOperation({ summary: "Get all webhooks of an oAuthClient" })
+  @ApiOperation({ summary: "Get all webhooks" })
   async getOAuthClientWebhooks(
     @Param("clientId") oAuthClientId: string,
     @Query() pagination: SkipTakePagination
@@ -114,7 +114,7 @@ export class OAuthClientWebhooksController {
 
   @Delete("/:webhookId")
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
-  @ApiOperation({ summary: "Delete a webhook of an oAuthClient" })
+  @ApiOperation({ summary: "Delete a webhook" })
   @UseGuards(IsOAuthClientWebhookGuard)
   async deleteOAuthClientWebhook(
     @GetWebhook() webhook: Webhook
@@ -130,7 +130,7 @@ export class OAuthClientWebhooksController {
 
   @Delete("/")
   @MembershipRoles([MembershipRole.ADMIN, MembershipRole.OWNER])
-  @ApiOperation({ summary: "Delete all webhooks of an oAuthClient" })
+  @ApiOperation({ summary: "Delete all webhooks" })
   async deleteAllOAuthClientWebhooks(
     @Param("clientId") oAuthClientId: string
   ): Promise<DeleteManyWebhooksOutputResponseDto> {

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

@@ -172,6 +172,7 @@ export class OAuthClientsController {
       id: user.id,
       email: user.email,
       username: user.username,
+      name: user.name,
       timeZone: user.timeZone,
       weekStart: user.weekStart,
       createdDate: user.createdDate,

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

@@ -62,10 +62,11 @@ export class OAuthClientUsersService {
       )[0];
       await this.userRepository.addToOAuthClient(user.id, oAuthClientId);
       const updatedUser = await this.userRepository.update(user.id, {
-        name: body.name ?? user.username ?? undefined,
+        name: body.name,
         locale: body.locale,
       });
       user.locale = updatedUser.locale;
+      user.name = updatedUser.name;
     }
 
     const { accessToken, refreshToken, accessTokenExpiresAt } = await this.tokensRepository.createOAuthTokens(

apps/api/v2/src/modules/organizations/controllers/attributes/organizations-attributes-options.controller.ts

@@ -20,6 +20,7 @@ import { GetAllAttributeOptionOutput } from "@/modules/organizations/outputs/att
 import { UpdateAttributeOptionOutput } from "@/modules/organizations/outputs/attributes/options/update-option.output";
 import { OrganizationAttributeOptionService } from "@/modules/organizations/services/attributes/organization-attributes-option.service";
 import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post, UseGuards } from "@nestjs/common";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 
@@ -28,13 +29,14 @@ import { SUCCESS_STATUS } from "@calcom/platform-constants";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+@DocsTags("Orgs / Attributes / Options")
 export class OrganizationsOptionsAttributesController {
   constructor(private readonly organizationsAttributesOptionsService: OrganizationAttributeOptionService) {}
 
-  // Creates an attribute option for an attribute
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Post("/attributes/:attributeId/options")
+  @ApiOperation({ summary: "Create an attribute option" })
   async createOrganizationAttributeOption(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string,
@@ -52,10 +54,10 @@ export class OrganizationsOptionsAttributesController {
     };
   }
 
-  // Deletes an attribute option for an attribute
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Delete("/attributes/:attributeId/options/:optionId")
+  @ApiOperation({ summary: "Delete an attribute option" })
   async deleteOrganizationAttributeOption(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string,
@@ -73,10 +75,10 @@ export class OrganizationsOptionsAttributesController {
     };
   }
 
-  // Updates an attribute option for an attribute
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Patch("/attributes/:attributeId/options/:optionId")
+  @ApiOperation({ summary: "Update an attribute option" })
   async updateOrganizationAttributeOption(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string,
@@ -96,10 +98,10 @@ export class OrganizationsOptionsAttributesController {
     };
   }
 
-  // Gets all attribute options for an attribute
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   @Get("/attributes/:attributeId/options")
+  @ApiOperation({ summary: "Get all attribute options" })
   async getOrganizationAttributeOptions(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string
@@ -114,10 +116,10 @@ export class OrganizationsOptionsAttributesController {
     };
   }
 
-  // Assign attribute option to user
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Post("/attributes/options/:userId")
+  @ApiOperation({ summary: "Assign an attribute to a user" })
   async assignOrganizationAttributeOptionToUser(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("userId", ParseIntPipe) userId: number,
@@ -135,10 +137,10 @@ export class OrganizationsOptionsAttributesController {
     };
   }
 
-  // Unassign attribute option from user
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   @Delete("/attributes/options/:userId/:attributeOptionId")
+  @ApiOperation({ summary: "Unassign an attribute from a user" })
   async unassignOrganizationAttributeOptionFromUser(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("userId", ParseIntPipe) userId: number,
@@ -159,6 +161,7 @@ export class OrganizationsOptionsAttributesController {
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   @Get("/attributes/options/:userId")
+  @ApiOperation({ summary: "Get all attribute options for a user" })
   async getOrganizationAttributeOptionsForUser(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("userId", ParseIntPipe) userId: number

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

@@ -28,6 +28,7 @@ import {
   Query,
   UseGuards,
 } from "@nestjs/common";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import { SkipTakePagination } from "@calcom/platform-types";
@@ -37,12 +38,14 @@ import { SkipTakePagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
+@DocsTags("Orgs / Attributes")
 export class OrganizationsAttributesController {
   constructor(private readonly organizationsAttributesService: OrganizationAttributesService) {}
   // Gets all attributes for an organization
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   @Get("/attributes")
+  @ApiOperation({ summary: "Get all attributes" })
   async getOrganizationAttributes(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Query() queryParams: SkipTakePagination
@@ -60,6 +63,7 @@ export class OrganizationsAttributesController {
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   @Get("/attributes/:attributeId")
+  @ApiOperation({ summary: "Get an attribute" })
   async getOrganizationAttribute(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string
@@ -75,6 +79,7 @@ export class OrganizationsAttributesController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Post("/attributes")
+  @ApiOperation({ summary: "Create an attribute" })
   async createOrganizationAttribute(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Body() bodyAttribute: CreateOrganizationAttributeInput
@@ -93,6 +98,7 @@ export class OrganizationsAttributesController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Patch("/attributes/:attributeId")
+  @ApiOperation({ summary: "Update an attribute" })
   async updateOrganizationAttribute(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string,
@@ -113,6 +119,7 @@ export class OrganizationsAttributesController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Delete("/attributes/:attributeId")
+  @ApiOperation({ summary: "Delete an attribute" })
   async deleteOrganizationAttribute(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("attributeId") attributeId: string

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

@@ -1,5 +1,6 @@
 import { CreatePhoneCallInput } from "@/ee/event-types/event-types_2024_06_14/inputs/create-phone-call.input";
 import { CreatePhoneCallOutput } from "@/ee/event-types/event-types_2024_06_14/outputs/create-phone-call.output";
+import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
 import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
@@ -15,7 +16,10 @@ import { DeleteTeamEventTypeOutput } from "@/modules/organizations/controllers/e
 import { GetTeamEventTypeOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/get-team-event-type.output";
 import { GetTeamEventTypesOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/get-team-event-types.output";
 import { UpdateTeamEventTypeOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/update-team-event-type.output";
+import { OutputTeamEventTypesResponsePipe } from "@/modules/organizations/controllers/pipes/event-types/team-event-types-response.transformer";
+import { InputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/input.service";
 import { OrganizationsEventTypesService } from "@/modules/organizations/services/event-types/organizations-event-types.service";
+import { DatabaseTeamEventType } from "@/modules/organizations/services/event-types/output.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import {
   Controller,
@@ -32,45 +36,63 @@ import {
   NotFoundException,
   Query,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
-import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
 import { handleCreatePhoneCall } from "@calcom/platform-libraries";
 import {
   CreateTeamEventTypeInput_2024_06_14,
   GetTeamEventTypesQuery_2024_06_14,
   SkipTakePagination,
+  TeamEventTypeOutput_2024_06_14,
   UpdateTeamEventTypeInput_2024_06_14,
 } from "@calcom/platform-types";
 
+export type EventTypeHandlerResponse = {
+  data: DatabaseTeamEventType[] | DatabaseTeamEventType;
+  status: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+};
+
 @Controller({
   path: "/v2/organizations/:orgId",
   version: API_VERSIONS_VALUES,
 })
-@DocsTags("Organizations Event Types")
+@DocsTags("Orgs / Event Types")
 export class OrganizationsEventTypesController {
-  constructor(private readonly organizationsEventTypesService: OrganizationsEventTypesService) {}
+  constructor(
+    private readonly organizationsEventTypesService: OrganizationsEventTypesService,
+    private readonly inputService: InputOrganizationsEventTypesService,
+    private readonly inputUserEventTypesService: InputEventTypesService_2024_06_14,
+    private readonly outputTeamEventTypesResponsePipe: OutputTeamEventTypesResponsePipe
+  ) {}
 
   @Roles("TEAM_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
   @Post("/teams/:teamId/event-types")
+  @ApiOperation({ summary: "Create an event type" })
   async createTeamEventType(
     @GetUser() user: UserWithProfile,
     @Param("teamId", ParseIntPipe) teamId: number,
     @Param("orgId", ParseIntPipe) orgId: number,
     @Body() bodyEventType: CreateTeamEventTypeInput_2024_06_14
   ): Promise<CreateTeamEventTypeOutput> {
+    const transformedBody = await this.inputService.transformAndValidateCreateTeamEventTypeInput(
+      user.id,
+      teamId,
+      bodyEventType
+    );
+
     const eventType = await this.organizationsEventTypesService.createTeamEventType(
       user,
       teamId,
       orgId,
-      bodyEventType
+      transformedBody
     );
 
     return {
       status: SUCCESS_STATUS,
-      data: eventType,
+      data: await this.outputTeamEventTypesResponsePipe.transform(eventType),
     };
   }
 
@@ -78,6 +100,7 @@ export class OrganizationsEventTypesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
   @Get("/teams/:teamId/event-types/:eventTypeId")
+  @ApiOperation({ summary: "Get an event type" })
   async getTeamEventType(
     @Param("teamId", ParseIntPipe) teamId: number,
     @Param("eventTypeId") eventTypeId: number
@@ -90,13 +113,16 @@ export class OrganizationsEventTypesController {
 
     return {
       status: SUCCESS_STATUS,
-      data: eventType,
+      data: (await this.outputTeamEventTypesResponsePipe.transform(
+        eventType
+      )) as TeamEventTypeOutput_2024_06_14,
     };
   }
 
   @Roles("TEAM_ADMIN")
   @Post("/teams/:teamId/event-types/:eventTypeId/create-phone-call")
   @UseGuards(ApiAuthGuard, IsOrgGuard, IsTeamInOrg, RolesGuard)
+  @ApiOperation({ summary: "Create a phone call" })
   async createPhoneCall(
     @Param("eventTypeId") eventTypeId: number,
     @Param("orgId", ParseIntPipe) orgId: number,
@@ -120,17 +146,19 @@ export class OrganizationsEventTypesController {
 
   @UseGuards(IsOrgGuard, IsTeamInOrg, IsAdminAPIEnabledGuard)
   @Get("/teams/:teamId/event-types")
+  @ApiOperation({ summary: "Get a team event type" })
   async getTeamEventTypes(
     @Param("teamId", ParseIntPipe) teamId: number,
     @Query() queryParams: GetTeamEventTypesQuery_2024_06_14
   ): Promise<GetTeamEventTypesOutput> {
     const { eventSlug } = queryParams;
+
     if (eventSlug) {
       const eventType = await this.organizationsEventTypesService.getTeamEventTypeBySlug(teamId, eventSlug);
 
       return {
         status: SUCCESS_STATUS,
-        data: eventType ? [eventType] : [],
+        data: await this.outputTeamEventTypesResponsePipe.transform(eventType ? [eventType] : []),
       };
     }
 
@@ -138,7 +166,7 @@ export class OrganizationsEventTypesController {
 
     return {
       status: SUCCESS_STATUS,
-      data: eventTypes,
+      data: await this.outputTeamEventTypesResponsePipe.transform(eventTypes),
     };
   }
 
@@ -146,6 +174,7 @@ export class OrganizationsEventTypesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
   @Get("/teams/event-types")
+  @ApiOperation({ summary: "Get all team event types" })
   async getTeamsEventTypes(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Query() queryParams: SkipTakePagination
@@ -155,7 +184,7 @@ export class OrganizationsEventTypesController {
 
     return {
       status: SUCCESS_STATUS,
-      data: eventTypes,
+      data: await this.outputTeamEventTypesResponsePipe.transform(eventTypes),
     };
   }
 
@@ -163,22 +192,30 @@ export class OrganizationsEventTypesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
   @Patch("/teams/:teamId/event-types/:eventTypeId")
+  @ApiOperation({ summary: "Update a team event type" })
   async updateTeamEventType(
     @Param("teamId", ParseIntPipe) teamId: number,
     @Param("eventTypeId", ParseIntPipe) eventTypeId: number,
     @GetUser() user: UserWithProfile,
     @Body() bodyEventType: UpdateTeamEventTypeInput_2024_06_14
   ): Promise<UpdateTeamEventTypeOutput> {
+    const transformedBody = await this.inputService.transformAndValidateUpdateTeamEventTypeInput(
+      user.id,
+      eventTypeId,
+      teamId,
+      bodyEventType
+    );
+
     const eventType = await this.organizationsEventTypesService.updateTeamEventType(
       eventTypeId,
       teamId,
-      bodyEventType,
+      transformedBody,
       user
     );
 
     return {
       status: SUCCESS_STATUS,
-      data: eventType,
+      data: await this.outputTeamEventTypesResponsePipe.transform(eventType),
     };
   }
 
@@ -187,9 +224,10 @@ export class OrganizationsEventTypesController {
   @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
   @Delete("/teams/:teamId/event-types/:eventTypeId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Delete a team event type" })
   async deleteTeamEventType(
     @Param("teamId", ParseIntPipe) teamId: number,
-    @Param("eventTypeId") eventTypeId: number
+    @Param("eventTypeId", ParseIntPipe) eventTypeId: number
   ): Promise<DeleteTeamEventTypeOutput> {
     const eventType = await this.organizationsEventTypesService.deleteTeamEventType(teamId, eventTypeId);
 

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

@@ -17,7 +17,12 @@ import { UserRepositoryFixture } from "test/fixtures/repository/users.repository
 import { withApiAuth } from "test/utils/withApiAuth";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
-import { BookingWindowPeriodInputTypeEnum_2024_06_14 } from "@calcom/platform-enums";
+import {
+  BookingWindowPeriodInputTypeEnum_2024_06_14,
+  BookerLayoutsInputEnum_2024_06_14,
+  ConfirmationPolicyEnum,
+  NoticeThresholdUnitEnum,
+} from "@calcom/platform-enums";
 import {
   ApiSuccessResponse,
   CreateTeamEventTypeInput_2024_06_14,
@@ -276,6 +281,30 @@ describe("Organizations Event Types Endpoints", () => {
           value: 30,
           rolling: true,
         },
+        bookerLayouts: {
+          enabledLayouts: [
+            BookerLayoutsInputEnum_2024_06_14.column,
+            BookerLayoutsInputEnum_2024_06_14.month,
+            BookerLayoutsInputEnum_2024_06_14.week,
+          ],
+          defaultLayout: BookerLayoutsInputEnum_2024_06_14.month,
+        },
+
+        confirmationPolicy: {
+          type: ConfirmationPolicyEnum.TIME,
+          noticeThreshold: {
+            count: 60,
+            unit: NoticeThresholdUnitEnum.MINUTES,
+          },
+          blockUnconfirmedBookingsInBooker: true,
+        },
+        requiresBookerEmailVerification: true,
+        hideCalendarNotes: true,
+        lockTimeZoneToggleOnBookingPage: true,
+        color: {
+          darkThemeHex: "#292929",
+          lightThemeHex: "#fafafa",
+        },
       };
 
       return request(app.getHttpServer())
@@ -297,6 +326,12 @@ describe("Organizations Event Types Endpoints", () => {
           expect(data.bookingLimitsDuration).toEqual(body.bookingLimitsDuration);
           expect(data.offsetStart).toEqual(body.offsetStart);
           expect(data.bookingWindow).toEqual(body.bookingWindow);
+          expect(data.bookerLayouts).toEqual(body.bookerLayouts);
+          expect(data.confirmationPolicy).toEqual(body.confirmationPolicy);
+          expect(data.requiresBookerEmailVerification).toEqual(body.requiresBookerEmailVerification);
+          expect(data.hideCalendarNotes).toEqual(body.hideCalendarNotes);
+          expect(data.lockTimeZoneToggleOnBookingPage).toEqual(body.lockTimeZoneToggleOnBookingPage);
+          expect(data.color).toEqual(body.color);
 
           collectiveEventType = responseBody.data;
         });
@@ -444,7 +479,7 @@ describe("Organizations Event Types Endpoints", () => {
       return request(app.getHttpServer())
         .patch(`/v2/organizations/${org.id}/teams/${team.id}/event-types/999999`)
         .send(body)
-        .expect(404);
+        .expect(400);
     });
 
     it("should update collective event-type", async () => {

apps/api/v2/src/modules/organizations/controllers/memberships/organizations-membership.controller.ts

@@ -30,7 +30,7 @@ import {
   HttpCode,
   HttpStatus,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { plainToClass } from "class-transformer";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -41,7 +41,7 @@ import { SkipTakePagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-@DocsTags("Organizations Memberships")
+@DocsTags("Orgs / Memberships")
 export class OrganizationsMembershipsController {
   constructor(private organizationsMembershipService: OrganizationsMembershipService) {}
 
@@ -49,6 +49,7 @@ export class OrganizationsMembershipsController {
   @PlatformPlan("ESSENTIALS")
   @Get("/")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get all memberships" })
   async getAllMemberships(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Query() queryParams: SkipTakePagination
@@ -71,6 +72,7 @@ export class OrganizationsMembershipsController {
   @PlatformPlan("ESSENTIALS")
   @Post("/")
   @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: "Create a membership" })
   async createMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Body() body: CreateOrgMembershipDto
@@ -87,6 +89,7 @@ export class OrganizationsMembershipsController {
   @UseGuards(IsMembershipInOrg)
   @Get("/:membershipId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get a membership" })
   async getOrgMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("membershipId", ParseIntPipe) membershipId: number
@@ -103,6 +106,7 @@ export class OrganizationsMembershipsController {
   @UseGuards(IsMembershipInOrg)
   @Delete("/:membershipId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Delete a membership" })
   async deleteMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("membershipId", ParseIntPipe) membershipId: number
@@ -119,6 +123,7 @@ export class OrganizationsMembershipsController {
   @PlatformPlan("ESSENTIALS")
   @Patch("/:membershipId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Update a membership" })
   async updateMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("membershipId", ParseIntPipe) membershipId: number,

apps/api/v2/src/modules/organizations/controllers/pipes/event-types/team-event-types-response.transformer.ts

@@ -0,0 +1,38 @@
+import { OutputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/output.service";
+import { DatabaseTeamEventType } from "@/modules/organizations/services/event-types/output.service";
+import { Injectable, PipeTransform } from "@nestjs/common";
+import { plainToClass } from "class-transformer";
+
+import { TeamEventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+@Injectable()
+export class OutputTeamEventTypesResponsePipe implements PipeTransform {
+  constructor(private readonly outputOrganizationsEventTypesService: OutputOrganizationsEventTypesService) {}
+
+  private async transformEventType(item: DatabaseTeamEventType): Promise<TeamEventTypeOutput_2024_06_14> {
+    return plainToClass(
+      TeamEventTypeOutput_2024_06_14,
+      await this.outputOrganizationsEventTypesService.getResponseTeamEventType(item),
+      { strategy: "exposeAll" }
+    );
+  }
+
+  // Implementing function overloading to ensure correct return types based on input type:
+  async transform(value: DatabaseTeamEventType[]): Promise<TeamEventTypeOutput_2024_06_14[]>;
+
+  async transform(value: DatabaseTeamEventType): Promise<TeamEventTypeOutput_2024_06_14>;
+
+  async transform(
+    value: DatabaseTeamEventType | DatabaseTeamEventType[]
+  ): Promise<TeamEventTypeOutput_2024_06_14 | TeamEventTypeOutput_2024_06_14[]>;
+
+  async transform(
+    value: DatabaseTeamEventType | DatabaseTeamEventType[]
+  ): Promise<TeamEventTypeOutput_2024_06_14 | TeamEventTypeOutput_2024_06_14[]> {
+    if (Array.isArray(value)) {
+      return await Promise.all(value.map((item) => this.transformEventType(item)));
+    } else {
+      return await this.transformEventType(value);
+    }
+  }
+}

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

@@ -23,7 +23,7 @@ import {
   HttpStatus,
   Query,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import {
@@ -42,7 +42,7 @@ import { SkipTakePagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-@DocsTags("Organizations Schedules")
+@DocsTags("Orgs / Schedules")
 export class OrganizationsSchedulesController {
   constructor(
     private schedulesService: SchedulesService_2024_06_11,
@@ -52,6 +52,7 @@ export class OrganizationsSchedulesController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Get("/schedules")
+  @ApiOperation({ summary: "Get all schedules" })
   async getOrganizationSchedules(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Query() queryParams: SkipTakePagination
@@ -70,6 +71,8 @@ export class OrganizationsSchedulesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(IsUserInOrg)
   @Post("/users/:userId/schedules")
+  @DocsTags("Orgs / Users / Schedules")
+  @ApiOperation({ summary: "Create a schedule" })
   async createUserSchedule(
     @Param("userId", ParseIntPipe) userId: number,
     @Body() bodySchedule: CreateScheduleInput_2024_06_11
@@ -86,6 +89,8 @@ export class OrganizationsSchedulesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(IsUserInOrg)
   @Get("/users/:userId/schedules/:scheduleId")
+  @DocsTags("Orgs / Users / Schedules")
+  @ApiOperation({ summary: "Get a schedule" })
   async getUserSchedule(
     @Param("userId", ParseIntPipe) userId: number,
     @Param("scheduleId") scheduleId: number
@@ -102,6 +107,8 @@ export class OrganizationsSchedulesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(IsUserInOrg)
   @Get("/users/:userId/schedules")
+  @DocsTags("Orgs / Users / Schedules")
+  @ApiOperation({ summary: "Get all schedules" })
   async getUserSchedules(
     @Param("userId", ParseIntPipe) userId: number
   ): Promise<GetSchedulesOutput_2024_06_11> {
@@ -117,6 +124,8 @@ export class OrganizationsSchedulesController {
   @PlatformPlan("ESSENTIALS")
   @UseGuards(IsUserInOrg)
   @Patch("/users/:userId/schedules/:scheduleId")
+  @DocsTags("Orgs / Users / Schedules")
+  @ApiOperation({ summary: "Update a schedule" })
   async updateUserSchedule(
     @Param("userId", ParseIntPipe) userId: number,
     @Param("scheduleId", ParseIntPipe) scheduleId: number,
@@ -135,6 +144,8 @@ export class OrganizationsSchedulesController {
   @UseGuards(IsUserInOrg)
   @Delete("/users/:userId/schedules/:scheduleId")
   @HttpCode(HttpStatus.OK)
+  @DocsTags("Orgs / Users / Schedules")
+  @ApiOperation({ summary: "Delete a schedule" })
   async deleteUserSchedule(
     @Param("userId", ParseIntPipe) userId: number,
     @Param("scheduleId", ParseIntPipe) scheduleId: number

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

@@ -42,7 +42,7 @@ import { SkipTakePagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-@DocsTags("Organizations Teams")
+@DocsTags("Orgs / Teams / Memberships")
 export class OrganizationsTeamsMembershipsController {
   constructor(
     private organizationsTeamsMembershipsService: OrganizationsTeamsMembershipsService,
@@ -50,7 +50,7 @@ export class OrganizationsTeamsMembershipsController {
   ) {}
 
   @Get("/")
-  @ApiOperation({ summary: "Get all the memberships of a team of an organization." })
+  @ApiOperation({ summary: "Get all memberships" })
   @UseGuards()
   @Roles("TEAM_ADMIN")
   @PlatformPlan("ESSENTIALS")
@@ -76,7 +76,7 @@ export class OrganizationsTeamsMembershipsController {
   }
 
   @Get("/:membershipId")
-  @ApiOperation({ summary: "Get the membership of an organization's team by ID" })
+  @ApiOperation({ summary: "Get a membership" })
   @UseGuards()
   @Roles("TEAM_ADMIN")
   @PlatformPlan("ESSENTIALS")
@@ -101,7 +101,7 @@ export class OrganizationsTeamsMembershipsController {
   @PlatformPlan("ESSENTIALS")
   @Delete("/:membershipId")
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: "Delete the membership of an organization's team by ID" })
+  @ApiOperation({ summary: "Delete a membership" })
   async deleteOrgTeamMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("teamId", ParseIntPipe) teamId: number,
@@ -122,7 +122,7 @@ export class OrganizationsTeamsMembershipsController {
   @PlatformPlan("ESSENTIALS")
   @Patch("/:membershipId")
   @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: "Update the membership of an organization's team by ID" })
+  @ApiOperation({ summary: "Update a membership" })
   async updateOrgTeamMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("teamId", ParseIntPipe) teamId: number,
@@ -145,7 +145,7 @@ export class OrganizationsTeamsMembershipsController {
   @PlatformPlan("ESSENTIALS")
   @Post("/")
   @HttpCode(HttpStatus.CREATED)
-  @ApiOperation({ summary: "Create a membership of an organization's team" })
+  @ApiOperation({ summary: "Create a membership" })
   async createOrgTeamMembership(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("teamId", ParseIntPipe) teamId: number,

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

@@ -45,12 +45,13 @@ import { Team } from "@calcom/prisma/client";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-@DocsTags("Organizations Teams")
+@DocsTags("Orgs / Teams")
 export class OrganizationsTeamsController {
   constructor(private organizationsTeamsService: OrganizationsTeamsService) {}
 
   @Get()
-  @ApiOperation({ summary: "Get all the teams of an organization." })
+  @DocsTags("Teams")
+  @ApiOperation({ summary: "Get all teams" })
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   async getAllTeams(
@@ -66,7 +67,7 @@ export class OrganizationsTeamsController {
   }
 
   @Get("/me")
-  @ApiOperation({ summary: "Get the organization's teams user is a member of" })
+  @ApiOperation({ summary: "Get team membership for user" })
   @Roles("ORG_MEMBER")
   @PlatformPlan("ESSENTIALS")
   async getMyTeams(
@@ -97,7 +98,7 @@ export class OrganizationsTeamsController {
   @Roles("TEAM_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Get("/:teamId")
-  @ApiOperation({ summary: "Get a team of the organization by ID." })
+  @ApiOperation({ summary: "Get a team" })
   async getTeam(@GetTeam() team: Team): Promise<OrgTeamOutputResponseDto> {
     return {
       status: SUCCESS_STATUS,
@@ -109,7 +110,7 @@ export class OrganizationsTeamsController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Delete("/:teamId")
-  @ApiOperation({ summary: "Delete a team of the organization by ID." })
+  @ApiOperation({ summary: "Delete a team" })
   async deleteTeam(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("teamId", ParseIntPipe) teamId: number
@@ -125,7 +126,7 @@ export class OrganizationsTeamsController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @Patch("/:teamId")
-  @ApiOperation({ summary: "Update a team of the organization by ID." })
+  @ApiOperation({ summary: "Update a team" })
   async updateTeam(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("teamId", ParseIntPipe) teamId: number,
@@ -141,7 +142,7 @@ export class OrganizationsTeamsController {
   @Post()
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
-  @ApiOperation({ summary: "Create a team for an organization." })
+  @ApiOperation({ summary: "Create a team" })
   async createTeam(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Body() body: CreateOrgTeamDto,

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

@@ -31,7 +31,7 @@ import {
   Query,
 } from "@nestjs/common";
 import { ClassSerializerInterceptor } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { plainToInstance } from "class-transformer";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -44,13 +44,14 @@ import { Team } from "@calcom/prisma/client";
 @UseInterceptors(ClassSerializerInterceptor)
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
 @UseGuards(IsOrgGuard)
-@DocsTags("Organizations Users")
+@DocsTags("Orgs / Users")
 export class OrganizationsUsersController {
   constructor(private readonly organizationsUsersService: OrganizationsUsersService) {}
 
   @Get()
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
+  @ApiOperation({ summary: "Get all users" })
   async getOrganizationsUsers(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Query() query: GetOrganizationsUsersInput
@@ -71,6 +72,7 @@ export class OrganizationsUsersController {
   @Post()
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
+  @ApiOperation({ summary: "Create a user" })
   async createOrganizationUser(
     @Param("orgId", ParseIntPipe) orgId: number,
     @GetOrg() org: Team,
@@ -92,6 +94,7 @@ export class OrganizationsUsersController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @UseGuards(IsUserInOrg)
+  @ApiOperation({ summary: "Update a user" })
   async updateOrganizationUser(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("userId", ParseIntPipe) userId: number,
@@ -109,6 +112,7 @@ export class OrganizationsUsersController {
   @Roles("ORG_ADMIN")
   @PlatformPlan("ESSENTIALS")
   @UseGuards(IsUserInOrg)
+  @ApiOperation({ summary: "Delete a user" })
   async deleteOrganizationUser(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Param("userId", ParseIntPipe) userId: number

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

@@ -32,7 +32,7 @@ import {
   HttpCode,
   HttpStatus,
 } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { plainToClass } from "class-transformer";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -43,7 +43,7 @@ import { SkipTakePagination } from "@calcom/platform-types";
   version: API_VERSIONS_VALUES,
 })
 @UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, PlatformPlanGuard, IsAdminAPIEnabledGuard)
-@DocsTags("Organizations Webhooks")
+@DocsTags("Orgs / Webhooks")
 export class OrganizationsWebhooksController {
   constructor(
     private organizationsWebhooksService: OrganizationsWebhooksService,
@@ -54,6 +54,7 @@ export class OrganizationsWebhooksController {
   @PlatformPlan("ESSENTIALS")
   @Get("/")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get all webhooks" })
   async getAllOrganizationWebhooks(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Query() queryParams: SkipTakePagination
@@ -78,6 +79,7 @@ export class OrganizationsWebhooksController {
   @PlatformPlan("ESSENTIALS")
   @Post("/")
   @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: "Create a webhook" })
   async createOrganizationWebhook(
     @Param("orgId", ParseIntPipe) orgId: number,
     @Body() body: CreateWebhookInputDto
@@ -99,6 +101,7 @@ export class OrganizationsWebhooksController {
   @UseGuards(IsWebhookInOrg)
   @Get("/:webhookId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Get a webhook" })
   async getOrganizationWebhook(@Param("webhookId") webhookId: string): Promise<OrgWebhookOutputResponseDto> {
     const webhook = await this.organizationsWebhooksService.getWebhook(webhookId);
     return {
@@ -114,6 +117,7 @@ export class OrganizationsWebhooksController {
   @UseGuards(IsWebhookInOrg)
   @Delete("/:webhookId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Delete a webhook" })
   async deleteWebhook(@Param("webhookId") webhookId: string): Promise<OrgWebhookOutputResponseDto> {
     const webhook = await this.webhooksService.deleteWebhook(webhookId);
     return {
@@ -129,6 +133,7 @@ export class OrganizationsWebhooksController {
   @UseGuards(IsWebhookInOrg)
   @Patch("/:webhookId")
   @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Update a webhook" })
   async updateOrgWebhook(
     @Param("webhookId") webhookId: string,
     @Body() body: UpdateWebhookInputDto

apps/api/v2/src/modules/organizations/inputs/update-organization-team.input.ts

@@ -72,4 +72,8 @@ export class UpdateOrgTeamDto {
   @IsOptional()
   @IsString()
   readonly weekStart?: string = "Sunday";
+
+  @IsOptional()
+  @IsString()
+  readonly bookingLimits?: string;
 }

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

@@ -7,6 +7,7 @@ import { OrganizationsOptionsAttributesController } from "@/modules/organization
 import { OrganizationsAttributesController } from "@/modules/organizations/controllers/attributes/organizations-attributes.controller";
 import { OrganizationsEventTypesController } from "@/modules/organizations/controllers/event-types/organizations-event-types.controller";
 import { OrganizationsMembershipsController } from "@/modules/organizations/controllers/memberships/organizations-membership.controller";
+import { OutputTeamEventTypesResponsePipe } from "@/modules/organizations/controllers/pipes/event-types/team-event-types-response.transformer";
 import { OrganizationsSchedulesController } from "@/modules/organizations/controllers/schedules/organizations-schedules.controller";
 import { OrganizationsTeamsMembershipsController } from "@/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller";
 import { OrganizationsTeamsController } from "@/modules/organizations/controllers/teams/organizations-teams.controller";
@@ -79,6 +80,7 @@ import { Module } from "@nestjs/common";
     OrganizationsWebhooksService,
     WebhooksRepository,
     WebhooksService,
+    OutputTeamEventTypesResponsePipe,
   ],
   exports: [
     OrganizationsService,

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

@@ -12,7 +12,7 @@ export class OrganizationsEventTypesRepository {
         id: eventTypeId,
         teamId,
       },
-      include: { users: true, schedule: true, hosts: true },
+      include: { users: true, schedule: true, hosts: true, destinationCalendar: true },
     });
   }
 
@@ -24,7 +24,7 @@ export class OrganizationsEventTypesRepository {
           slug: eventTypeSlug,
         },
       },
-      include: { users: true, schedule: true, hosts: true },
+      include: { users: true, schedule: true, hosts: true, destinationCalendar: true },
     });
   }
 
@@ -33,21 +33,21 @@ export class OrganizationsEventTypesRepository {
       where: {
         teamId,
       },
-      include: { users: true, schedule: true, hosts: true },
+      include: { users: true, schedule: true, hosts: true, destinationCalendar: true },
     });
   }
 
   async getEventTypeById(eventTypeId: number) {
     return this.dbRead.prisma.eventType.findUnique({
       where: { id: eventTypeId },
-      include: { users: true, schedule: true, hosts: true },
+      include: { users: true, schedule: true, hosts: true, destinationCalendar: true },
     });
   }
 
   async getEventTypeChildren(eventTypeId: number) {
     return this.dbRead.prisma.eventType.findMany({
       where: { parentId: eventTypeId },
-      include: { users: true, schedule: true, hosts: true },
+      include: { users: true, schedule: true, hosts: true, destinationCalendar: true },
     });
   }
 
@@ -60,7 +60,7 @@ export class OrganizationsEventTypesRepository {
       },
       skip,
       take,
-      include: { users: true, schedule: true, hosts: true },
+      include: { users: true, schedule: true, hosts: true, destinationCalendar: true },
     });
   }
 

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

@@ -18,6 +18,14 @@ export class OrganizationsTeamsRepository {
     });
   }
 
+  async findTeamById(teamId: number) {
+    return this.dbRead.prisma.team.findUnique({
+      where: {
+        id: teamId,
+      },
+    });
+  }
+
   async findOrgTeams(organizationId: number) {
     return this.dbRead.prisma.team.findMany({
       where: {

apps/api/v2/src/modules/organizations/services/event-types/input.service.ts

@@ -2,7 +2,7 @@ import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_
 import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
 import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
 import { UsersRepository } from "@/modules/users/users.repository";
-import { BadRequestException, Injectable } from "@nestjs/common";
+import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
 
 import {
   CreateTeamEventTypeInput_2024_06_14,
@@ -19,37 +19,89 @@ export class InputOrganizationsEventTypesService {
     private readonly usersRepository: UsersRepository,
     private readonly orgEventTypesRepository: OrganizationsEventTypesRepository
   ) {}
+  async transformAndValidateCreateTeamEventTypeInput(
+    userId: number,
+    teamId: number,
+    inputEventType: CreateTeamEventTypeInput_2024_06_14
+  ) {
+    await this.validateHosts(teamId, inputEventType.hosts);
+
+    const transformedBody = await this.transformInputCreateTeamEventType(teamId, inputEventType);
+
+    await this.inputEventTypesService.validateEventTypeInputs({
+      seatsPerTimeSlot: transformedBody.seatsPerTimeSlot,
+      locations: transformedBody.locations,
+      requiresConfirmation: transformedBody.requiresConfirmation,
+      eventName: transformedBody.eventName,
+    });
+
+    transformedBody.destinationCalendar &&
+      (await this.inputEventTypesService.validateInputDestinationCalendar(
+        userId,
+        transformedBody.destinationCalendar
+      ));
+
+    transformedBody.useEventTypeDestinationCalendarEmail &&
+      (await this.inputEventTypesService.validateInputUseDestinationCalendarEmail(userId));
+
+    return transformedBody;
+  }
+
+  async transformAndValidateUpdateTeamEventTypeInput(
+    userId: number,
+    eventTypeId: number,
+    teamId: number,
+    inputEventType: UpdateTeamEventTypeInput_2024_06_14
+  ) {
+    await this.validateHosts(teamId, inputEventType.hosts);
+
+    const transformedBody = await this.transformInputUpdateTeamEventType(eventTypeId, teamId, inputEventType);
+
+    await this.inputEventTypesService.validateEventTypeInputs({
+      eventTypeId: eventTypeId,
+      seatsPerTimeSlot: transformedBody.seatsPerTimeSlot,
+      locations: transformedBody.locations,
+      requiresConfirmation: transformedBody.requiresConfirmation,
+      eventName: transformedBody.eventName,
+    });
+
+    transformedBody.destinationCalendar &&
+      (await this.inputEventTypesService.validateInputDestinationCalendar(
+        userId,
+        transformedBody.destinationCalendar
+      ));
+
+    transformedBody.useEventTypeDestinationCalendarEmail &&
+      (await this.inputEventTypesService.validateInputUseDestinationCalendarEmail(userId));
+
+    return transformedBody;
+  }
+
   async transformInputCreateTeamEventType(
     teamId: number,
     inputEventType: CreateTeamEventTypeInput_2024_06_14
   ) {
-    const {
-      hosts,
-      assignAllTeamMembers,
-      bookingLimitsCount,
-      bookingLimitsDuration,
-      bookingWindow,
-      bookingFields,
-      recurrence,
-      ...rest
-    } = inputEventType;
+    const { hosts, assignAllTeamMembers, ...rest } = inputEventType;
 
     const eventType = this.inputEventTypesService.transformInputCreateEventType(rest);
+    const children = await this.getChildEventTypesForManagedEventType(null, inputEventType, teamId);
 
-    const metadata = rest.schedulingType === "MANAGED" ? { managedEventConfig: {} } : undefined;
+    const metadata =
+      rest.schedulingType === "MANAGED"
+        ? { managedEventConfig: {}, ...eventType.metadata }
+        : eventType.metadata;
 
     const teamEventType = {
       ...eventType,
-      hosts: assignAllTeamMembers
-        ? await this.getAllTeamMembers(teamId, inputEventType.schedulingType)
-        : this.transformInputHosts(hosts, inputEventType.schedulingType),
+      // note(Lauris): we don't populate hosts for managed event-types because they are handled by the children
+      hosts: !(rest.schedulingType === "MANAGED")
+        ? assignAllTeamMembers
+          ? await this.getAllTeamMembers(teamId, inputEventType.schedulingType)
+          : this.transformInputHosts(hosts, inputEventType.schedulingType)
+        : undefined,
       assignAllTeamMembers,
-      bookingLimitsCount,
-      bookingLimitsDuration,
-      bookingWindow,
-      bookingFields,
-      recurrence,
       metadata,
+      children,
     };
 
     return teamEventType;
@@ -62,7 +114,7 @@ export class InputOrganizationsEventTypesService {
   ) {
     const { hosts, assignAllTeamMembers, ...rest } = inputEventType;
 
-    const eventType = this.inputEventTypesService.transformInputUpdateEventType(rest);
+    const eventType = await this.inputEventTypesService.transformInputUpdateEventType(rest, eventTypeId);
     const dbEventType = await this.orgEventTypesRepository.getTeamEventType(teamId, eventTypeId);
 
     if (!dbEventType) {
@@ -86,14 +138,16 @@ export class InputOrganizationsEventTypesService {
   }
 
   async getChildEventTypesForManagedEventType(
-    eventTypeId: number,
+    eventTypeId: number | null,
     inputEventType: UpdateTeamEventTypeInput_2024_06_14,
     teamId: number
   ) {
-    const eventType = await this.orgEventTypesRepository.getEventTypeByIdWithChildren(eventTypeId);
-
-    if (!eventType || eventType.schedulingType !== "MANAGED") {
-      return undefined;
+    let eventType = null;
+    if (eventTypeId) {
+      eventType = await this.orgEventTypesRepository.getEventTypeByIdWithChildren(eventTypeId);
+      if (!eventType || eventType.schedulingType !== "MANAGED") {
+        return undefined;
+      }
     }
 
     const ownersIds = await this.getOwnersIdsForManagedEventType(teamId, inputEventType, eventType);
@@ -110,7 +164,7 @@ export class InputOrganizationsEventTypesService {
   async getOwnersIdsForManagedEventType(
     teamId: number,
     inputEventType: UpdateTeamEventTypeInput_2024_06_14,
-    eventType: { children: { userId: number | null }[] }
+    eventType: { children: { userId: number | null }[] } | null
   ) {
     if (inputEventType.assignAllTeamMembers) {
       return await this.organizationsTeamsRepository.getTeamMembersIds(teamId);
@@ -122,7 +176,7 @@ export class InputOrganizationsEventTypesService {
     }
 
     // note(Lauris): when API user DOES NOT update managed event type users, but we still need existing managed event type users to know which event-types to update
-    return eventType.children.map((child) => child.userId).filter((id) => !!id) as number[];
+    return eventType?.children.map((child) => child.userId).filter((id) => !!id) as number[];
   }
 
   async getOwnersForManagedEventType(userIds: number[]) {
@@ -170,6 +224,16 @@ export class InputOrganizationsEventTypesService {
       ),
     }));
   }
+
+  async validateHosts(teamId: number, hosts: CreateTeamEventTypeInput_2024_06_14["hosts"] | undefined) {
+    if (hosts && hosts.length) {
+      const membersIds = await this.organizationsTeamsRepository.getTeamMembersIds(teamId);
+      const invalidHosts = hosts.filter((host) => !membersIds.includes(host.userId));
+      if (invalidHosts.length) {
+        throw new NotFoundException(`Invalid hosts: ${invalidHosts.join(", ")}`);
+      }
+    }
+  }
 }
 
 function getPriorityValue(priority: keyof typeof HostPriority): number {

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

@@ -2,31 +2,23 @@ import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_20
 import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
-import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
-import { InputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/input.service";
-import { OutputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/output.service";
+import { DatabaseTeamEventType } from "@/modules/organizations/services/event-types/output.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Injectable, NotFoundException } from "@nestjs/common";
 
 import { createEventType, updateEventType } from "@calcom/platform-libraries";
-import {
-  CreateTeamEventTypeInput_2024_06_14,
-  UpdateTeamEventTypeInput_2024_06_14,
-} from "@calcom/platform-types";
+import { InputTeamEventTransformed_2024_06_14 } from "@calcom/platform-types";
 
 @Injectable()
 export class OrganizationsEventTypesService {
   constructor(
-    private readonly inputService: InputOrganizationsEventTypesService,
     private readonly eventTypesService: EventTypesService_2024_06_14,
     private readonly dbWrite: PrismaWriteService,
     private readonly organizationEventTypesRepository: OrganizationsEventTypesRepository,
     private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
-    private readonly outputService: OutputOrganizationsEventTypesService,
     private readonly membershipsRepository: MembershipsRepository,
-    private readonly organizationsTeamsRepository: OrganizationsTeamsRepository,
     private readonly usersService: UsersService
   ) {}
 
@@ -34,24 +26,14 @@ export class OrganizationsEventTypesService {
     user: UserWithProfile,
     teamId: number,
     orgId: number,
-    body: CreateTeamEventTypeInput_2024_06_14
-  ) {
-    await this.validateHosts(teamId, body.hosts);
+    body: InputTeamEventTransformed_2024_06_14
+  ): Promise<DatabaseTeamEventType | DatabaseTeamEventType[]> {
     const eventTypeUser = await this.getUserToCreateTeamEvent(user, orgId);
-    const {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      hosts,
-      assignAllTeamMembers,
-      locations,
-      bookingLimitsCount,
-      bookingLimitsDuration,
-      bookingWindow,
-      bookingFields,
-      recurrence,
-      ...rest
-    } = await this.inputService.transformInputCreateTeamEventType(teamId, body);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { hosts, children, destinationCalendar, ...rest } = body;
+
     const { eventType: eventTypeCreated } = await createEventType({
-      input: { teamId: teamId, locations, ...rest },
+      input: { teamId: teamId, ...rest },
       ctx: {
         user: eventTypeUser,
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -60,31 +42,7 @@ export class OrganizationsEventTypesService {
       },
     });
 
-    return await this.updateTeamEventType(
-      eventTypeCreated.id,
-      teamId,
-      {
-        hosts: body.hosts,
-        assignAllTeamMembers,
-        bookingLimitsCount,
-        bookingLimitsDuration,
-        bookingWindow,
-        bookingFields,
-        recurrence,
-        ...rest,
-      },
-      user
-    );
-  }
-
-  async validateHosts(teamId: number, hosts: CreateTeamEventTypeInput_2024_06_14["hosts"] | undefined) {
-    if (hosts && hosts.length) {
-      const membersIds = await this.organizationsTeamsRepository.getTeamMembersIds(teamId);
-      const invalidHosts = hosts.filter((host) => !membersIds.includes(host.userId));
-      if (invalidHosts.length) {
-        throw new NotFoundException(`Invalid hosts: ${invalidHosts.join(", ")}`);
-      }
-    }
+    return this.updateTeamEventType(eventTypeCreated.id, teamId, body, user);
   }
 
   async validateEventTypeExists(teamId: number, eventTypeId: number) {
@@ -105,22 +63,22 @@ export class OrganizationsEventTypesService {
       role: user.role,
       organizationId: user.organizationId,
       organization: { isOrgAdmin },
-      profile: { id: profileId },
+      profile: { id: profileId || null },
       metadata: user.metadata,
     };
   }
 
-  async getTeamEventType(teamId: number, eventTypeId: number) {
+  async getTeamEventType(teamId: number, eventTypeId: number): Promise<DatabaseTeamEventType | null> {
     const eventType = await this.organizationEventTypesRepository.getTeamEventType(teamId, eventTypeId);
 
     if (!eventType) {
       return null;
     }
 
-    return this.outputService.getResponseTeamEventType(eventType);
+    return eventType;
   }
 
-  async getTeamEventTypeBySlug(teamId: number, eventTypeSlug: string) {
+  async getTeamEventTypeBySlug(teamId: number, eventTypeSlug: string): Promise<DatabaseTeamEventType | null> {
     const eventType = await this.organizationEventTypesRepository.getTeamEventTypeBySlug(
       teamId,
       eventTypeSlug
@@ -130,46 +88,28 @@ export class OrganizationsEventTypesService {
       return null;
     }
 
-    return this.outputService.getResponseTeamEventType(eventType);
+    return eventType;
   }
 
-  async getTeamEventTypes(teamId: number) {
-    const eventTypes = await this.organizationEventTypesRepository.getTeamEventTypes(teamId);
-
-    const eventTypePromises = eventTypes.map(async (eventType) => {
-      return await this.outputService.getResponseTeamEventType(eventType);
-    });
-
-    return await Promise.all(eventTypePromises);
+  async getTeamEventTypes(teamId: number): Promise<DatabaseTeamEventType[]> {
+    return await this.organizationEventTypesRepository.getTeamEventTypes(teamId);
   }
 
-  async getTeamsEventTypes(orgId: number, skip = 0, take = 250) {
-    const eventTypes = await this.organizationEventTypesRepository.getTeamsEventTypes(orgId, skip, take);
-
-    const eventTypePromises = eventTypes.map(async (eventType) => {
-      return await this.outputService.getResponseTeamEventType(eventType);
-    });
-
-    return await Promise.all(eventTypePromises);
+  async getTeamsEventTypes(orgId: number, skip = 0, take = 250): Promise<DatabaseTeamEventType[]> {
+    return await this.organizationEventTypesRepository.getTeamsEventTypes(orgId, skip, take);
   }
 
   async updateTeamEventType(
     eventTypeId: number,
     teamId: number,
-    body: UpdateTeamEventTypeInput_2024_06_14,
+    body: InputTeamEventTransformed_2024_06_14,
     user: UserWithProfile
-  ) {
+  ): Promise<DatabaseTeamEventType | DatabaseTeamEventType[]> {
     await this.validateEventTypeExists(teamId, eventTypeId);
-    await this.validateHosts(teamId, body.hosts);
     const eventTypeUser = await this.eventTypesService.getUserToUpdateEvent(user);
-    const bodyTransformed = await this.inputService.transformInputUpdateTeamEventType(
-      eventTypeId,
-      teamId,
-      body
-    );
 
     await updateEventType({
-      input: { id: eventTypeId, ...bodyTransformed },
+      input: { id: eventTypeId, ...body },
       ctx: {
         user: eventTypeUser,
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -185,18 +125,12 @@ export class OrganizationsEventTypesService {
     }
 
     if (eventType.schedulingType !== "MANAGED") {
-      return this.outputService.getResponseTeamEventType(eventType);
+      return eventType;
     }
 
-    const children = await this.organizationEventTypesRepository.getEventTypeChildren(eventType.id);
+    const childrenEventTypes = await this.organizationEventTypesRepository.getEventTypeChildren(eventType.id);
 
-    const eventTypes = [eventType, ...children];
-
-    const eventTypePromises = eventTypes.map(async (e) => {
-      return await this.outputService.getResponseTeamEventType(e);
-    });
-
-    return await Promise.all(eventTypePromises);
+    return [eventType, ...childrenEventTypes];
   }
 
   async deleteTeamEventType(teamId: number, eventTypeId: number) {

apps/api/v2/src/modules/organizations/services/event-types/output.service.ts

@@ -2,16 +2,21 @@ import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types
 import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
 import { UsersRepository } from "@/modules/users/users.repository";
 import { Injectable } from "@nestjs/common";
-import type { EventType, User, Schedule, Host } from "@prisma/client";
+import type { EventType, User, Schedule, Host, DestinationCalendar } from "@prisma/client";
 import { SchedulingType } from "@prisma/client";
 
 import { HostPriority, TeamEventTypeResponseHost } from "@calcom/platform-types";
 
-type EventTypeRelations = { users: User[]; schedule: Schedule | null; hosts: Host[] };
-type DatabaseEventType = EventType & EventTypeRelations;
+type EventTypeRelations = {
+  users: User[];
+  schedule: Schedule | null;
+  hosts: Host[];
+  destinationCalendar?: DestinationCalendar | null;
+};
+export type DatabaseTeamEventType = EventType & EventTypeRelations;
 
 type Input = Pick<
-  DatabaseEventType,
+  DatabaseTeamEventType,
   | "id"
   | "length"
   | "title"
@@ -52,6 +57,14 @@ type Input = Pick<
   | "periodCountCalendarDays"
   | "periodStartDate"
   | "periodEndDate"
+  | "requiresBookerEmailVerification"
+  | "hideCalendarNotes"
+  | "lockTimeZoneToggleOnBookingPage"
+  | "eventTypeColor"
+  | "seatsShowAttendees"
+  | "requiresConfirmationWillBlockSlot"
+  | "eventName"
+  | "useEventTypeDestinationCalendarEmail"
 >;
 
 @Injectable()
@@ -65,7 +78,7 @@ export class OutputOrganizationsEventTypesService {
   async getResponseTeamEventType(databaseEventType: Input) {
     const { teamId, userId, parentId, assignAllTeamMembers } = databaseEventType;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { ownerId, users, ...rest } = await this.outputEventTypesService.getResponseEventType(
+    const { ownerId, users, ...rest } = this.outputEventTypesService.getResponseEventType(
       0,
       databaseEventType
     );
@@ -80,6 +93,7 @@ export class OutputOrganizationsEventTypesService {
       teamId,
       ownerId: userId,
       parentEventTypeId: parentId,
+      schedulingType: databaseEventType.schedulingType,
       assignAllTeamMembers: teamId ? assignAllTeamMembers : undefined,
     };
   }

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

@@ -14,7 +14,7 @@ import {
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Body, Controller, Post, UseGuards, Delete, Query } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { plainToClass } from "class-transformer";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -23,7 +23,7 @@ import { SUCCESS_STATUS } from "@calcom/platform-constants";
   path: "/v2/selected-calendars",
   version: API_VERSIONS_VALUES,
 })
-@DocsTags("Selected-Calendars")
+@DocsTags("Selected Calendars")
 export class SelectedCalendarsController {
   constructor(
     private readonly calendarsRepository: CalendarsRepository,
@@ -33,6 +33,7 @@ export class SelectedCalendarsController {
 
   @Post("/")
   @UseGuards(ApiAuthGuard)
+  @ApiOperation({ summary: "Add a selected calendar" })
   async addSelectedCalendar(
     @Body() input: SelectedCalendarsInputDto,
     @GetUser() user: UserWithProfile
@@ -55,6 +56,7 @@ export class SelectedCalendarsController {
 
   @Delete("/")
   @UseGuards(ApiAuthGuard)
+  @ApiOperation({ summary: "Delete a selected calendar" })
   async removeSelectedCalendar(
     @Query() queryParams: SelectedCalendarsQueryParamsInputDto,
     @GetUser() user: UserWithProfile

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

@@ -1,7 +1,7 @@
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
 import { SlotsService } from "@/modules/slots/services/slots.service";
 import { Query, Body, Controller, Get, Delete, Post, Req, Res } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 import { Response as ExpressResponse, Request as ExpressRequest } from "express";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
@@ -19,6 +19,7 @@ export class SlotsController {
   constructor(private readonly slotsService: SlotsService) {}
 
   @Post("/reserve")
+  @ApiOperation({ summary: "Reserve a slot" })
   async reserveSlot(
     @Body() body: ReserveSlotInput,
     @Res({ passthrough: true }) res: ExpressResponse,
@@ -34,6 +35,7 @@ export class SlotsController {
   }
 
   @Delete("/selected-slot")
+  @ApiOperation({ summary: "Delete a selected slot" })
   async deleteSelectedSlot(
     @Query() params: RemoveSelectedSlotInput,
     @Req() req: ExpressRequest
@@ -48,6 +50,7 @@ export class SlotsController {
   }
 
   @Get("/available")
+  @ApiOperation({ summary: "Get available slots" })
   async getAvailableSlots(
     @Query() query: GetAvailableSlotsInput,
     @Req() req: ExpressRequest

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

@@ -1,7 +1,7 @@
 import { API_VERSIONS_VALUES } from "@/lib/api-versions";
 import { TimezonesService } from "@/modules/timezones/services/timezones.service";
 import { Controller, Get } from "@nestjs/common";
-import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import type { CityTimezones } from "@calcom/platform-libraries";
@@ -16,6 +16,7 @@ export class TimezonesController {
   constructor(private readonly timezonesService: TimezonesService) {}
 
   @Get("/")
+  @ApiOperation({ summary: "Get all timezones" })
   async getTimeZones(): Promise<ApiResponse<CityTimezones>> {
     const timeZones = await this.timezonesService.getCityTimeZones();
 

apps/api/v2/src/modules/users/inputs/create-managed-user.input.ts

@@ -1,7 +1,7 @@
 import { Locales } from "@/lib/enums/locales";
 import { CapitalizeTimeZone } from "@/lib/inputs/capitalize-timezone";
 import { ApiProperty } from "@nestjs/swagger";
-import { IsOptional, IsTimeZone, IsString, IsEnum } from "class-validator";
+import { IsOptional, IsTimeZone, IsString, IsEnum, IsIn } from "class-validator";
 
 export type WeekDay = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
 export type TimeFormat = 12 | 24;
@@ -11,11 +11,12 @@ export class CreateManagedUserInput {
   email!: string;
 
   @IsString()
-  @IsOptional()
-  name?: string;
+  @ApiProperty({ example: "Alice Smith", description: "Managed user's name is used in emails" })
+  name!: string;
 
   @IsOptional()
-  @ApiProperty({ example: 12, enum: [12, 24], description: "Must be 12 or 24" })
+  @IsIn([12, 24], { message: "timeFormat must be a number either 12 or 24" })
+  @ApiProperty({ example: 12, enum: [12, 24], description: "Must be a number 12 or 24" })
   timeFormat?: TimeFormat;
 
   @IsOptional()