refactor: convert checkBookingLimits to class service with dependency injection (calcom#22768)

* refactor: convert checkBookingLimits to class service with dependency injection

- Create CheckBookingLimitsService class following AvailableSlotsService pattern
- Add countBookingsByEventTypeAndDateRange method to BookingRepository
- Move direct prisma calls from service to repository layer
- Implement dependency injection with proper DI tokens and modules
- Update all usage points to use the new service through DI
- Maintain backward compatibility with error-throwing wrapper functions
- Update tests to use the new service pattern
- Resolve TODO comment in AvailableSlotsService for DI integration

Co-Authored-By: morgan@cal.com <morgan@cal.com>

* chore: DI CheckBookingLimitsService in v2 slots service

* chore: bump libraries

* chore: create getCheckBookingLimitsService

* refactor: convert checkBookingAndDurationLimits to service class with DI

- Create CheckBookingAndDurationLimitsService class following DI pattern
- Add DI tokens and module for the new service
- Update booking-limits container to provide the new service
- Refactor handleNewBooking.ts to use service through DI
- Maintain backward compatibility with deprecated function export
- Preserve all existing functionality while improving code organization

Co-Authored-By: morgan@cal.com <morgan@cal.com>

* chore: CheckBookingAndDurationLimitsService

* chore: bump platform libs

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: morgan@cal.com <morgan@cal.com>
Co-authored-by: Morgan <33722304+ThyMinimalDev@users.noreply.github.com>

Author: devin-ai-integration[bot]

apps/api/v2/package.json

@@ -38,7 +38,7 @@
     "@axiomhq/winston": "^1.2.0",
     "@calcom/platform-constants": "*",
     "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.268",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.271",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",
     "@calcom/prisma": "*",

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

@@ -7,6 +7,7 @@ import { PrismaSelectedSlotRepository } from "@/lib/repositories/prisma-selected
 import { PrismaTeamRepository } from "@/lib/repositories/prisma-team.repository";
 import { PrismaUserRepository } from "@/lib/repositories/prisma-user.repository";
 import { AvailableSlotsService } from "@/lib/services/available-slots.service";
+import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.service";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { Module } from "@nestjs/common";
 
@@ -21,6 +22,7 @@ import { Module } from "@nestjs/common";
     PrismaEventTypeRepository,
     PrismaRoutingFormResponseRepository,
     PrismaTeamRepository,
+    CheckBookingLimitsService,
     AvailableSlotsService,
   ],
   exports: [AvailableSlotsService],

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

@@ -6,6 +6,7 @@ import { PrismaScheduleRepository } from "@/lib/repositories/prisma-schedule.rep
 import { PrismaSelectedSlotRepository } from "@/lib/repositories/prisma-selected-slot.repository";
 import { PrismaTeamRepository } from "@/lib/repositories/prisma-team.repository";
 import { PrismaUserRepository } from "@/lib/repositories/prisma-user.repository";
+import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.service";
 import { Injectable } from "@nestjs/common";
 
 import { AvailableSlotsService as BaseAvailableSlotsService } from "@calcom/platform-libraries/slots";
@@ -31,6 +32,7 @@ export class AvailableSlotsService extends BaseAvailableSlotsService {
       selectedSlotRepo: selectedSlotRepository,
       eventTypeRepo: eventTypeRepository,
       userRepo: userRepository,
+      checkBookingLimitsService: new CheckBookingLimitsService(bookingRepository),
     });
   }
 }

apps/api/v2/src/lib/services/check-booking-and-duration-limits.service.ts

@@ -0,0 +1,13 @@
+import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.service";
+import { Injectable } from "@nestjs/common";
+
+import { CheckBookingAndDurationLimitsService as BaseCheckBookingAndDurationLimitsService } from "@calcom/platform-libraries/bookings";
+
+@Injectable()
+export class CheckBookingAndDurationLimitsService extends BaseCheckBookingAndDurationLimitsService {
+  constructor(checkBookingLimitsService: CheckBookingLimitsService) {
+    super({
+      checkBookingLimitsService: checkBookingLimitsService,
+    });
+  }
+}

apps/api/v2/src/lib/services/check-booking-limits.service.ts

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

apps/api/v2/tsconfig.json

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

apps/web/test/lib/checkBookingLimits.test.ts

@@ -3,8 +3,8 @@ import prismaMock from "../../../../tests/libs/__mocks__/prismaMock";
 import { describe, expect, it } from "vitest";
 
 import dayjs from "@calcom/dayjs";
+import { getCheckBookingLimitsService } from "@calcom/lib/di/containers/booking-limits";
 import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSchema";
-import { checkBookingLimits, checkBookingLimit } from "@calcom/lib/intervalLimits/server/checkBookingLimits";
 import { validateIntervalLimitOrder } from "@calcom/lib/intervalLimits/validateIntervalLimitOrder";
 
 type Mockdata = {
@@ -21,25 +21,27 @@ const MOCK_DATA: Mockdata = {
   },
 };
 
+const checkBookingLimitsService = getCheckBookingLimitsService();
+
 describe("Check Booking Limits Tests", () => {
   it("Should return no errors", async () => {
     prismaMock.booking.count.mockResolvedValue(0);
     expect(
-      checkBookingLimits(MOCK_DATA.bookingLimits, MOCK_DATA.startDate, MOCK_DATA.id)
+      checkBookingLimitsService.checkBookingLimits(MOCK_DATA.bookingLimits, MOCK_DATA.startDate, MOCK_DATA.id)
     ).resolves.toBeTruthy();
   });
   it("Should throw an error", async () => {
     // Mock there being two a day
     prismaMock.booking.count.mockResolvedValue(2);
     expect(
-      checkBookingLimits(MOCK_DATA.bookingLimits, MOCK_DATA.startDate, MOCK_DATA.id)
+      checkBookingLimitsService.checkBookingLimits(MOCK_DATA.bookingLimits, MOCK_DATA.startDate, MOCK_DATA.id)
     ).rejects.toThrowError();
   });
 
   it("Should pass with multiple booking limits", async () => {
     prismaMock.booking.count.mockResolvedValue(0);
     expect(
-      checkBookingLimits(
+      checkBookingLimitsService.checkBookingLimits(
         {
           PER_DAY: 1,
           PER_WEEK: 2,
@@ -51,8 +53,9 @@ describe("Check Booking Limits Tests", () => {
   });
   it("Should pass with multiple booking limits with one undefined", async () => {
     prismaMock.booking.count.mockResolvedValue(0);
+
     expect(
-      checkBookingLimits(
+      checkBookingLimitsService.checkBookingLimits(
         {
           PER_DAY: 1,
           PER_WEEK: undefined,
@@ -65,7 +68,7 @@ describe("Check Booking Limits Tests", () => {
   it("Should handle multiple limits correctly", async () => {
     prismaMock.booking.count.mockResolvedValue(1);
     expect(
-      checkBookingLimit({
+      checkBookingLimitsService.checkBookingLimit({
         key: "PER_DAY",
         limitingNumber: 2,
         eventStartDate: MOCK_DATA.startDate,
@@ -74,7 +77,7 @@ describe("Check Booking Limits Tests", () => {
     ).resolves.not.toThrow();
     prismaMock.booking.count.mockResolvedValue(3);
     expect(
-      checkBookingLimit({
+      checkBookingLimitsService.checkBookingLimit({
         key: "PER_WEEK",
         limitingNumber: 2,
         eventStartDate: MOCK_DATA.startDate,

packages/features/bookings/lib/handleNewBooking.ts

@@ -51,6 +51,7 @@ import {
   enrichHostsWithDelegationCredentials,
   getFirstDelegationConferencingCredentialAppLocation,
 } from "@calcom/lib/delegationCredential/server";
+import { getCheckBookingAndDurationLimitsService } from "@calcom/lib/di/containers/booking-limits";
 import { ErrorCode } from "@calcom/lib/errorCodes";
 import { getErrorFromUnknown } from "@calcom/lib/errors";
 import { getEventName, updateHostInEventName } from "@calcom/lib/event";
@@ -90,7 +91,6 @@ import { refreshCredentials } from "./getAllCredentialsForUsersOnEvent/refreshCr
 import getBookingDataSchema from "./getBookingDataSchema";
 import { addVideoCallDataToEvent } from "./handleNewBooking/addVideoCallDataToEvent";
 import { checkActiveBookingsLimitForBooker } from "./handleNewBooking/checkActiveBookingsLimitForBooker";
-import { checkBookingAndDurationLimits } from "./handleNewBooking/checkBookingAndDurationLimits";
 import { checkIfBookerEmailIsBlocked } from "./handleNewBooking/checkIfBookerEmailIsBlocked";
 import { createBooking } from "./handleNewBooking/createBooking";
 import type { Booking } from "./handleNewBooking/createBooking";
@@ -650,7 +650,8 @@ async function handler(
     location,
   });
 
-  await checkBookingAndDurationLimits({
+  const checkBookingAndDurationLimitsService = getCheckBookingAndDurationLimitsService();
+  await checkBookingAndDurationLimitsService.checkBookingAndDurationLimits({
     eventType,
     reqBodyStart: reqBody.start,
     reqBodyRescheduleUid: reqBody.rescheduleUid,

packages/features/bookings/lib/handleNewBooking/checkBookingAndDurationLimits.ts

@@ -1,6 +1,6 @@
 import dayjs from "@calcom/dayjs";
 import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSchema";
-import { checkBookingLimits } from "@calcom/lib/intervalLimits/server/checkBookingLimits";
+import type { CheckBookingLimitsService } from "@calcom/lib/intervalLimits/server/checkBookingLimits";
 import { checkDurationLimits } from "@calcom/lib/intervalLimits/server/checkDurationLimits";
 import { withReporting } from "@calcom/lib/sentryWrapper";
 
@@ -14,37 +14,41 @@ type InputProps = {
   reqBodyRescheduleUid?: string;
 };
 
-const _checkBookingAndDurationLimits = async ({
-  eventType,
-  reqBodyStart,
-  reqBodyRescheduleUid,
-}: InputProps) => {
-  if (
-    Object.prototype.hasOwnProperty.call(eventType, "bookingLimits") ||
-    Object.prototype.hasOwnProperty.call(eventType, "durationLimits")
-  ) {
-    const startAsDate = dayjs(reqBodyStart).toDate();
-    if (eventType.bookingLimits && Object.keys(eventType.bookingLimits).length > 0) {
-      await checkBookingLimits(
-        eventType.bookingLimits as IntervalLimit,
-        startAsDate,
-        eventType.id,
-        reqBodyRescheduleUid,
-        eventType.schedule?.timeZone
-      );
-    }
-    if (eventType.durationLimits) {
-      await checkDurationLimits(
-        eventType.durationLimits as IntervalLimit,
-        startAsDate,
-        eventType.id,
-        reqBodyRescheduleUid
-      );
+export interface ICheckBookingAndDurationLimitsService {
+  checkBookingLimitsService: CheckBookingLimitsService;
+}
+
+export class CheckBookingAndDurationLimitsService {
+  constructor(private readonly dependencies: ICheckBookingAndDurationLimitsService) {}
+
+  checkBookingAndDurationLimits = withReporting(
+    this._checkBookingAndDurationLimits.bind(this),
+    "checkBookingAndDurationLimits"
+  );
+
+  async _checkBookingAndDurationLimits({ eventType, reqBodyStart, reqBodyRescheduleUid }: InputProps) {
+    if (
+      Object.prototype.hasOwnProperty.call(eventType, "bookingLimits") ||
+      Object.prototype.hasOwnProperty.call(eventType, "durationLimits")
+    ) {
+      const startAsDate = dayjs(reqBodyStart).toDate();
+      if (eventType.bookingLimits && Object.keys(eventType.bookingLimits).length > 0) {
+        await this.dependencies.checkBookingLimitsService.checkBookingLimits(
+          eventType.bookingLimits as IntervalLimit,
+          startAsDate,
+          eventType.id,
+          reqBodyRescheduleUid,
+          eventType.schedule?.timeZone
+        );
+      }
+      if (eventType.durationLimits) {
+        await checkDurationLimits(
+          eventType.durationLimits as IntervalLimit,
+          startAsDate,
+          eventType.id,
+          reqBodyRescheduleUid
+        );
+      }
     }
   }
-};
-
-export const checkBookingAndDurationLimits = withReporting(
-  _checkBookingAndDurationLimits,
-  "checkBookingAndDurationLimits"
-);
+}

packages/lib/di/containers/available-slots.ts

@@ -6,6 +6,7 @@ import type { AvailableSlotsService } from "@calcom/trpc/server/routers/viewer/s
 
 import { availableSlotsModule } from "../modules/available-slots";
 import { bookingRepositoryModule } from "../modules/booking";
+import { checkBookingLimitsModule } from "../modules/check-booking-limits";
 import { eventTypeRepositoryModule } from "../modules/eventType";
 import { oooRepositoryModule } from "../modules/ooo";
 import { routingFormResponseRepositoryModule } from "../modules/routingFormResponse";
@@ -24,6 +25,7 @@ container.load(DI_TOKENS.USER_REPOSITORY_MODULE, userRepositoryModule);
 container.load(DI_TOKENS.BOOKING_REPOSITORY_MODULE, bookingRepositoryModule);
 container.load(DI_TOKENS.EVENT_TYPE_REPOSITORY_MODULE, eventTypeRepositoryModule);
 container.load(DI_TOKENS.ROUTING_FORM_RESPONSE_REPOSITORY_MODULE, routingFormResponseRepositoryModule);
+container.load(DI_TOKENS.CHECK_BOOKING_LIMITS_SERVICE_MODULE, checkBookingLimitsModule);
 container.load(DI_TOKENS.AVAILABLE_SLOTS_SERVICE_MODULE, availableSlotsModule);
 
 export function getAvailableSlotsService() {