chore: release v5.5.11

* refactor: getUserAvailability into service with DI

* chore: bump platform libs

* disable bull queue in e2e for bookings

* chore: bump platform libs

* chore: bump platform libs

* fix: should update event type bookingFields test

---------

Co-authored-by: Alex van Andel <me@alexvanandel.com>

.yarn/versions/5cae75a1.yml

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

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

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

apps/api/v2/package.json

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

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

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

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

@@ -12,6 +12,7 @@ import { CacheService } from "@/lib/services/cache.service";
 import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.service";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { Module } from "@nestjs/common";
+import { UserAvailabilityService } from "@/lib/services/user-availability.service";
 
 @Module({
   imports: [PrismaModule],
@@ -28,6 +29,7 @@ import { Module } from "@nestjs/common";
     CheckBookingLimitsService,
     CacheService,
     AvailableSlotsService,
+    UserAvailabilityService
   ],
   exports: [AvailableSlotsService],
 })

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

@@ -12,6 +12,7 @@ import { CheckBookingLimitsService } from "@/lib/services/check-booking-limits.s
 import { Injectable } from "@nestjs/common";
 
 import { AvailableSlotsService as BaseAvailableSlotsService } from "@calcom/platform-libraries/slots";
+import { UserAvailabilityService } from "./user-availability.service";
 
 @Injectable()
 export class AvailableSlotsService extends BaseAvailableSlotsService {
@@ -37,6 +38,7 @@ export class AvailableSlotsService extends BaseAvailableSlotsService {
       userRepo: userRepository,
       checkBookingLimitsService: new CheckBookingLimitsService(bookingRepository) as any,
       cacheService: new CacheService(featuresRepository),
+      userAvailabilityService: new UserAvailabilityService(oooRepoDependency, bookingRepository, eventTypeRepository)
     });
   }
 }

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

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

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

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

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

@@ -6,7 +6,7 @@ import { checkForConflicts } from "@calcom/features/bookings/lib/conflictChecker
 import { buildDateRanges } from "@calcom/lib/date-ranges";
 import { ErrorCode } from "@calcom/lib/errorCodes";
 import { getBusyTimesForLimitChecks } from "@calcom/lib/getBusyTimes";
-import { getUsersAvailability } from "@calcom/lib/getUserAvailability";
+import { getUserAvailabilityService } from "@calcom/lib/di/containers/get-user-availability";
 import { parseBookingLimit } from "@calcom/lib/intervalLimits/isBookingLimits";
 import { parseDurationLimit } from "@calcom/lib/intervalLimits/isDurationLimits";
 import { getPiiFreeUser } from "@calcom/lib/piiFreeData";
@@ -62,6 +62,7 @@ const _ensureAvailableUsers = async (
   shouldServeCache?: boolean
   // ReturnType hint of at least one IsFixedAwareUser, as it's made sure at least one entry exists
 ): Promise<[IsFixedAwareUser, ...IsFixedAwareUser[]]> => {
+  const userAvailabilityService = getUserAvailabilityService()
   const availableUsers: IsFixedAwareUser[] = [];
 
   const startDateTimeUtc = getDateTimeInUtc(input.dateFrom, input.timeZone);
@@ -86,7 +87,7 @@ const _ensureAvailableUsers = async (
         })
       : [];
 
-  const usersAvailability = await getUsersAvailability({
+  const usersAvailability = await userAvailabilityService.getUsersAvailability({
     users: eventType.users,
     query: {
       ...input,

packages/features/insights/HOW_TO_ADD_BOOKING_CHARTS.md

@@ -103,7 +103,7 @@ export default function InsightsPage() {
 
 ## Step 4: Create tRPC Handler
 
-Add the tRPC endpoint in the insights router using the `createInsightsBookingService()` helper:
+Add the tRPC endpoint in the insights router using the `getInsightsBookingService()` DI container function:
 
 ```typescript
 // packages/features/insights/server/trpc-router.ts
@@ -118,6 +118,7 @@ export const insightsRouter = router({
   myNewChartData: userBelongsToTeamProcedure
     .input(bookingRepositoryBaseInputSchema)
     .query(async ({ ctx, input }) => {
+      // `createInsightsBookingService` is defined at the root level in this file
       const insightsBookingService = createInsightsBookingService(ctx, input);
 
       try {
@@ -129,13 +130,13 @@ export const insightsRouter = router({
 });
 ```
 
-## Step 5: Add Service Method to InsightsBookingService
+## Step 5: Add Service Method to InsightsBookingBaseService
 
-Add your new method to the `InsightsBookingService` class:
+Add your new method to the `InsightsBookingBaseService` class:
 
 ```typescript
-// packages/lib/server/service/insightsBooking.ts
+// packages/lib/server/service/InsightsBookingBaseService.ts
-export class InsightsBookingService {
+export class InsightsBookingBaseService {
   // ... existing methods
 
   async getMyNewChartData() {
@@ -168,7 +169,7 @@ export class InsightsBookingService {
 
 ## Best Practices
 
-1. **Use `createInsightsBookingService()`**: Always use the helper function for consistent service creation
+1. **Use `getInsightsBookingService()`**: Always use the DI container function for consistent service creation
 2. **Raw SQL for Performance**: Use `$queryRaw` for complex aggregations and better performance
 3. **Base Conditions**: Always use `await this.getBaseConditions()` for proper filtering and permissions
 4. **Error Handling**: Wrap service calls in try-catch blocks with `TRPCError`

packages/features/insights/server/trpc-router.ts

@@ -9,8 +9,8 @@ import {
   routingRepositoryBaseInputSchema,
   bookingRepositoryBaseInputSchema,
 } from "@calcom/features/insights/server/raw-data.schema";
+import { getInsightsBookingService } from "@calcom/lib/di/containers/insights-booking";
 import { getInsightsRoutingService } from "@calcom/lib/di/containers/insights-routing";
-import { InsightsBookingService } from "@calcom/lib/server/service/insightsBooking";
 import type { readonlyPrisma } from "@calcom/prisma";
 import { BookingStatus } from "@calcom/prisma/enums";
 import authedProcedure from "@calcom/trpc/server/procedures/authedProcedure";
@@ -316,14 +316,13 @@ const BATCH_SIZE = 1000; // Adjust based on your needs
  * Helper function to create InsightsBookingService with standardized parameters
  */
 function createInsightsBookingService(
-  ctx: { insightsDb: typeof readonlyPrisma; user: { id: number; organizationId: number | null } },
+  ctx: { user: { id: number; organizationId: number | null } },
   input: z.infer<typeof bookingRepositoryBaseInputSchema>,
   dateTarget: "createdAt" | "startTime" = "createdAt"
 ) {
   const { scope, selectedTeamId, startDate, endDate, columnFilters } = input;
 
-  return new InsightsBookingService({
+  return getInsightsBookingService({
-    prisma: ctx.insightsDb,
     options: {
       scope,
       userId: ctx.user.id,

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

@@ -16,6 +16,7 @@ import { scheduleRepositoryModule } from "../modules/schedule";
 import { selectedSlotsRepositoryModule } from "../modules/selectedSlots";
 import { teamRepositoryModule } from "../modules/team";
 import { userRepositoryModule } from "../modules/user";
+import { getUserAvailabilityModule } from "../modules/get-user-availability";
 
 const container = createContainer();
 container.load(DI_TOKENS.PRISMA_MODULE, prismaModule);
@@ -31,7 +32,7 @@ container.load(DI_TOKENS.FEATURES_REPOSITORY_MODULE, featuresRepositoryModule);
 container.load(DI_TOKENS.CACHE_SERVICE_MODULE, cacheModule);
 container.load(DI_TOKENS.CHECK_BOOKING_LIMITS_SERVICE_MODULE, checkBookingLimitsModule);
 container.load(DI_TOKENS.AVAILABLE_SLOTS_SERVICE_MODULE, availableSlotsModule);
-
+container.load(DI_TOKENS.GET_USER_AVAILABILITY_SERVICE_MODULE, getUserAvailabilityModule)
 export function getAvailableSlotsService() {
   return container.get<AvailableSlotsService>(DI_TOKENS.AVAILABLE_SLOTS_SERVICE);
 }

packages/lib/di/containers/get-user-availability.ts

@@ -0,0 +1,23 @@
+import { createContainer } from "@evyweb/ioctopus";
+
+import { DI_TOKENS } from "@calcom/lib/di/tokens";
+import { prismaModule } from "@calcom/prisma/prisma.module";
+
+import { getUserAvailabilityModule } from "../modules/get-user-availability";
+import { bookingRepositoryModule } from "../modules/booking";
+
+import { eventTypeRepositoryModule } from "../modules/eventType";
+
+import { oooRepositoryModule } from "../modules/ooo";
+import { UserAvailabilityService } from "../../getUserAvailability";
+
+const container = createContainer();
+container.load(DI_TOKENS.PRISMA_MODULE, prismaModule);
+container.load(DI_TOKENS.OOO_REPOSITORY_MODULE, oooRepositoryModule);
+container.load(DI_TOKENS.BOOKING_REPOSITORY_MODULE, bookingRepositoryModule);
+container.load(DI_TOKENS.EVENT_TYPE_REPOSITORY_MODULE, eventTypeRepositoryModule);
+container.load(DI_TOKENS.GET_USER_AVAILABILITY_SERVICE_MODULE, getUserAvailabilityModule);
+
+export function getUserAvailabilityService() {
+  return container.get<UserAvailabilityService>(DI_TOKENS.GET_USER_AVAILABILITY_SERVICE);
+}

packages/lib/di/containers/insights-booking.ts

@@ -0,0 +1,27 @@
+import { createContainer } from "@evyweb/ioctopus";
+
+import { DI_TOKENS } from "@calcom/lib/di/tokens";
+import type {
+  InsightsBookingServicePublicOptions,
+  InsightsBookingServiceFilterOptions,
+  InsightsBookingBaseService,
+} from "@calcom/lib/server/service/InsightsBookingBaseService";
+import type { InsightsBookingService } from "@calcom/lib/server/service/InsightsBookingDIService";
+import { prismaModule } from "@calcom/prisma/prisma.module";
+
+import { insightsBookingModule } from "../modules/insights-booking";
+
+export function getInsightsBookingService({
+  options,
+  filters,
+}: {
+  options: InsightsBookingServicePublicOptions;
+  filters?: InsightsBookingServiceFilterOptions;
+}): InsightsBookingBaseService {
+  const container = createContainer();
+  container.load(DI_TOKENS.READ_ONLY_PRISMA_CLIENT, prismaModule);
+  container.load(DI_TOKENS.INSIGHTS_BOOKING_SERVICE_MODULE, insightsBookingModule);
+
+  const diService = container.get<InsightsBookingService>(DI_TOKENS.INSIGHTS_BOOKING_SERVICE);
+  return diService.create({ options, filters });
+}

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

@@ -17,4 +17,5 @@ availableSlotsModule.bind(DI_TOKENS.AVAILABLE_SLOTS_SERVICE).toClass(AvailableSl
   routingFormResponseRepo: DI_TOKENS.ROUTING_FORM_RESPONSE_REPOSITORY,
   cacheService: DI_TOKENS.CACHE_SERVICE,
   checkBookingLimitsService: DI_TOKENS.CHECK_BOOKING_LIMITS_SERVICE,
+  userAvailabilityService: DI_TOKENS.GET_USER_AVAILABILITY_SERVICE
 } satisfies Record<keyof IAvailableSlotsService, symbol>);

packages/lib/di/modules/get-user-availability.ts

@@ -0,0 +1,11 @@
+import { createModule } from "@evyweb/ioctopus";
+
+import { DI_TOKENS } from "../tokens";
+import { IUserAvailabilityService, UserAvailabilityService } from "../../getUserAvailability";
+
+export const getUserAvailabilityModule = createModule();
+getUserAvailabilityModule.bind(DI_TOKENS.GET_USER_AVAILABILITY_SERVICE).toClass(UserAvailabilityService, {
+  oooRepo: DI_TOKENS.OOO_REPOSITORY,
+  bookingRepo: DI_TOKENS.BOOKING_REPOSITORY,
+  eventTypeRepo: DI_TOKENS.EVENT_TYPE_REPOSITORY,
+} satisfies Record<keyof IUserAvailabilityService, symbol>);

packages/lib/di/modules/insights-booking.ts

@@ -0,0 +1,11 @@
+import { createModule } from "@evyweb/ioctopus";
+
+import type { IInsightsBookingService } from "@calcom/lib/server/service/InsightsBookingDIService";
+import { InsightsBookingService } from "@calcom/lib/server/service/InsightsBookingDIService";
+
+import { DI_TOKENS } from "../tokens";
+
+export const insightsBookingModule = createModule();
+insightsBookingModule.bind(DI_TOKENS.INSIGHTS_BOOKING_SERVICE).toClass(InsightsBookingService, {
+  prisma: DI_TOKENS.READ_ONLY_PRISMA_CLIENT,
+} satisfies Record<keyof IInsightsBookingService, symbol>);

packages/lib/di/tokens.ts

@@ -22,6 +22,8 @@ export const DI_TOKENS = {
   AVAILABLE_SLOTS_SERVICE_MODULE: Symbol("AvailableSlotsModule"),
   INSIGHTS_ROUTING_SERVICE: Symbol("InsightsRoutingService"),
   INSIGHTS_ROUTING_SERVICE_MODULE: Symbol("InsightsRoutingServiceModule"),
+  INSIGHTS_BOOKING_SERVICE: Symbol("InsightsBookingService"),
+  INSIGHTS_BOOKING_SERVICE_MODULE: Symbol("InsightsBookingServiceModule"),
   FEATURES_REPOSITORY: Symbol("FeaturesRepository"),
   FEATURES_REPOSITORY_MODULE: Symbol("FeaturesRepositoryModule"),
   CACHE_SERVICE: Symbol("CacheService"),
@@ -30,4 +32,6 @@ export const DI_TOKENS = {
   CHECK_BOOKING_LIMITS_SERVICE_MODULE: Symbol("CheckBookingLimitsServiceModule"),
   CHECK_BOOKING_AND_DURATION_LIMITS_SERVICE: Symbol("CheckBookingAndDurationLimitsService"),
   CHECK_BOOKING_AND_DURATION_LIMITS_SERVICE_MODULE: Symbol("CheckBookingAndDurationLimitsServiceModule"),
+  GET_USER_AVAILABILITY_SERVICE: Symbol("GetUserAvailabilityService"),
+  GET_USER_AVAILABILITY_SERVICE_MODULE: Symbol("GetUserAvailabilityModule"),
 };

packages/lib/getUserAvailability.ts

@@ -8,6 +8,7 @@ import type {
 } from "@prisma/client";
 import * as Sentry from "@sentry/nextjs";
 import { z } from "zod";
+import type { BookingRepository } from "@calcom/lib/server/repository/booking";
 
 import type { Dayjs } from "@calcom/dayjs";
 import dayjs from "@calcom/dayjs";
@@ -27,15 +28,14 @@ import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import { findUsersForAvailabilityCheck } from "@calcom/lib/server/findUsersForAvailabilityCheck";
 import { EventTypeRepository } from "@calcom/lib/server/repository/eventTypeRepository";
-import prisma from "@calcom/prisma";
 import { SchedulingType } from "@calcom/prisma/enums";
-import { BookingStatus } from "@calcom/prisma/enums";
 import { EventTypeMetaDataSchema } from "@calcom/prisma/zod-utils";
 import type { EventBusyDetails, IntervalLimitUnit } from "@calcom/types/Calendar";
 import type { TimeRange } from "@calcom/types/schedule";
 
 import { getBusyTimes } from "./getBusyTimes";
 import { withReporting } from "./sentryWrapper";
+import type { PrismaOOORepository } from "@calcom/lib/server/repository/ooo";
 
 const log = logger.getSubLogger({ prefix: ["getUserAvailability"] });
 const availabilitySchema = z
@@ -55,106 +55,11 @@ const availabilitySchema = z
   })
   .refine((data) => !!data.username || !!data.userId, "Either username or userId should be filled in.");
 
-const _getEventType = async (id: number) => {
+export type EventType = Awaited<
-  const eventType = await prisma.eventType.findUnique({
+  ReturnType<(typeof UserAvailabilityService)["prototype"]["_getEventType"]>
-    where: { id },
+>;
-    select: {
-      id: true,
-      seatsPerTimeSlot: true,
-      bookingLimits: true,
-      useEventLevelSelectedCalendars: true,
-      parent: {
-        select: {
-          team: {
-            select: {
-              id: true,
-              bookingLimits: true,
-              includeManagedEventsInLimits: true,
-            },
-          },
-        },
-      },
-      team: {
-        select: {
-          id: true,
-          bookingLimits: true,
-          includeManagedEventsInLimits: true,
-        },
-      },
-      hosts: {
-        select: {
-          user: {
-            select: {
-              email: true,
-              id: true,
-            },
-          },
-          schedule: {
-            select: {
-              availability: {
-                select: {
-                  date: true,
-                  startTime: true,
-                  endTime: true,
-                  days: true,
-                },
-              },
-              timeZone: true,
-              id: true,
-            },
-          },
-        },
-      },
-      durationLimits: true,
-      assignAllTeamMembers: true,
-      schedulingType: true,
-      timeZone: true,
-      length: true,
-      metadata: true,
-      schedule: {
-        select: {
-          id: true,
-          availability: {
-            select: {
-              days: true,
-              date: true,
-              startTime: true,
-              endTime: true,
-            },
-          },
-          timeZone: true,
-        },
-      },
-      availability: {
-        select: {
-          startTime: true,
-          endTime: true,
-          days: true,
-          date: true,
-        },
-      },
-    },
-  });
-  if (!eventType) {
-    return eventType;
-  }
-  return {
-    ...eventType,
-    metadata: EventTypeMetaDataSchema.parse(eventType.metadata),
-  };
-};
 
-export type EventType = Awaited<ReturnType<typeof _getEventType>>;
+type GetUser = Awaited<ReturnType<(typeof UserAvailabilityService)["prototype"]["_getUser"]>>;
-
-export const getEventType = withReporting(_getEventType, "getEventType");
-
-const _getUser = async (where: Prisma.UserWhereInput) => {
-  return findUsersForAvailabilityCheck({ where });
-};
-
-type GetUser = Awaited<ReturnType<typeof _getUser>>;
-
-const getUser = withReporting(_getUser, "getUser");
 
 export type GetUserAvailabilityInitialData = {
   user?: GetUser;
@@ -207,7 +112,76 @@ type GetUserAvailabilityQuery = {
   shouldServeCache?: boolean;
 };
 
-const _getCurrentSeats = async (
+export type CurrentSeats = Awaited<
+  ReturnType<(typeof UserAvailabilityService)["prototype"]["_getCurrentSeats"]>
+>;
+
+export type GetUserAvailabilityResult = Awaited<
+  ReturnType<(typeof UserAvailabilityService)["prototype"]["_getUserAvailability"]>
+>;
+
+interface GetUserAvailabilityParamsDTO {
+  availability: (DateOverride | WorkingHours)[];
+}
+
+export interface IFromUser {
+  id: number;
+  displayName: string | null;
+}
+
+export interface IToUser {
+  id: number;
+  username: string | null;
+  displayName: string | null;
+}
+
+export interface IOutOfOfficeData {
+  [key: string]: {
+    fromUser: IFromUser | null;
+    toUser?: IToUser | null;
+    reason?: string | null;
+    emoji?: string | null;
+  };
+}
+
+type GetUsersAvailabilityProps = {
+  users: (GetAvailabilityUser & {
+    currentBookings?: GetUserAvailabilityInitialData["currentBookings"];
+    outOfOfficeDays?: GetUserAvailabilityInitialData["outOfOfficeDays"];
+  })[];
+  query: Omit<GetUserAvailabilityQuery, "userId" | "username">;
+  initialData?: Omit<GetUserAvailabilityInitialData, "user">;
+};
+
+export interface IUserAvailabilityService {
+    eventTypeRepo: EventTypeRepository;
+  oooRepo: PrismaOOORepository;
+  bookingRepo: BookingRepository;
+
+}
+
+export class UserAvailabilityService {
+  constructor(public readonly dependencies: IUserAvailabilityService) {}
+
+  async _getEventType(id: number) {
+    const eventType = await this.dependencies.eventTypeRepo.findByIdForUserAvailability({id})
+    if (!eventType) {
+      return eventType;
+    }
+    return {
+      ...eventType,
+      metadata: EventTypeMetaDataSchema.parse(eventType.metadata),
+    };
+  }
+
+  getEventType = withReporting(this._getEventType.bind(this), "getEventType");
+
+  async _getUser(where: Prisma.UserWhereInput) {
+    return findUsersForAvailabilityCheck({ where });
+  }
+  getUser = withReporting(this._getUser.bind(this), "getUser");
+
+  async _getCurrentSeats(
     eventType: {
       id?: number;
       schedulingType?: SchedulingType | null;
@@ -219,7 +193,7 @@ const _getCurrentSeats = async (
     },
     dateFrom: Dayjs,
     dateTo: Dayjs
-) => {
+  ) {
     const { schedulingType, hosts, id } = eventType;
     const hostEmails = hosts?.map((host) => host.user.email);
     const isTeamEvent =
@@ -227,25 +201,9 @@ const _getCurrentSeats = async (
       schedulingType === SchedulingType.ROUND_ROBIN ||
       schedulingType === SchedulingType.COLLECTIVE;
 
-  const bookings = await prisma.booking.findMany({
+    const bookings = await this.dependencies.bookingRepo.findAcceptedBookingByEventTypeId({eventTypeId: id, dateFrom: dateFrom.format(), dateTo: dateTo.format()})
-    where: {
+    
-      eventTypeId: id,
+  
-      startTime: {
-        gte: dateFrom.format(),
-        lte: dateTo.format(),
-      },
-      status: BookingStatus.ACCEPTED,
-    },
-    select: {
-      uid: true,
-      startTime: true,
-      attendees: {
-        select: {
-          email: true,
-        },
-      },
-    },
-  });
 
     return bookings.map((booking) => {
       const attendees = isTeamEvent
@@ -260,19 +218,12 @@ const _getCurrentSeats = async (
         },
       };
     });
-};
+  }
 
-export type CurrentSeats = Awaited<ReturnType<typeof _getCurrentSeats>>;
+  getCurrentSeats = withReporting(this._getCurrentSeats.bind(this), "getCurrentSeats");
-
-export const getCurrentSeats = withReporting(_getCurrentSeats, "getCurrentSeats");
-
-export type GetUserAvailabilityResult = Awaited<ReturnType<typeof _getUserAvailability>>;
 
   /** This should be called getUsersWorkingHoursAndBusySlots (...and remaining seats, and final timezone) */
-const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseAndEverythingElse(
+  async _getUserAvailability(query: GetUserAvailabilityQuery, initialData?: GetUserAvailabilityInitialData) {
-  query: GetUserAvailabilityQuery,
-  initialData?: GetUserAvailabilityInitialData
-) {
     const {
       username,
       userId,
@@ -301,20 +252,20 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
     if (username) where.username = username;
     if (userId) where.id = userId;
 
-  const user = initialData?.user || (await getUser(where));
+    const user = initialData?.user || (await this.getUser(where));
 
     if (!user) {
       throw new HttpError({ statusCode: 404, message: "No user found in getUserAvailability" });
     }
 
     let eventType: EventType | null = initialData?.eventType || null;
-  if (!eventType && eventTypeId) eventType = await getEventType(eventTypeId);
+    if (!eventType && eventTypeId) eventType = await this.getEventType(eventTypeId);
 
     /* Current logic is if a booking is in a time slot mark it as busy, but seats can have more than one attendee so grab
     current bookings with a seats event type and display them on the calendar, even if they are full */
     let currentSeats: CurrentSeats | null = initialData?.currentSeats || null;
     if (!currentSeats && eventType?.seatsPerTimeSlot) {
-    currentSeats = await getCurrentSeats(eventType, dateFrom, dateTo);
+      currentSeats = await this.getCurrentSeats(eventType, dateFrom, dateTo);
     }
 
     const userSchedule = user.schedules.filter(
@@ -469,7 +420,10 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
     );
 
     if (
-    !(schedule?.availability || (eventType?.availability.length ? eventType.availability : user.availability))
+      !(
+        schedule?.availability ||
+        (eventType?.availability.length ? eventType.availability : user.availability)
+      )
     ) {
       throw new HttpError({ statusCode: 400, message: ErrorCode.AvailabilityNotFoundInSchedule });
     }
@@ -513,72 +467,9 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
 
     const outOfOfficeDays =
       initialData?.outOfOfficeDays ??
-    (await prisma.outOfOfficeEntry.findMany({
+      (await this.dependencies.oooRepo.findUserOOODays({userId: user.id, dateFrom: dateFrom.toISOString(), dateTo: dateTo.toISOString()}));
-      where: {
-        userId: user.id,
-        OR: [
-          // outside of range
-          // (start <= 'dateTo' AND end >= 'dateFrom')
-          {
-            start: {
-              lte: dateTo.toISOString(),
-            },
-            end: {
-              gte: dateFrom.toISOString(),
-            },
-          },
-          // start is between dateFrom and dateTo but end is outside of range
-          // (start <= 'dateTo' AND end >= 'dateTo')
-          {
-            start: {
-              lte: dateTo.toISOString(),
-            },
 
-            end: {
+    const datesOutOfOffice: IOutOfOfficeData = this.calculateOutOfOfficeRanges(outOfOfficeDays, availability);
-              gte: dateTo.toISOString(),
-            },
-          },
-          // end is between dateFrom and dateTo but start is outside of range
-          // (start <= 'dateFrom' OR end <= 'dateTo')
-          {
-            start: {
-              lte: dateFrom.toISOString(),
-            },
-
-            end: {
-              lte: dateTo.toISOString(),
-            },
-          },
-        ],
-      },
-      select: {
-        id: true,
-        start: true,
-        end: true,
-        user: {
-          select: {
-            id: true,
-            name: true,
-          },
-        },
-        toUser: {
-          select: {
-            id: true,
-            username: true,
-            name: true,
-          },
-        },
-        reason: {
-          select: {
-            id: true,
-            emoji: true,
-            reason: true,
-          },
-        },
-      },
-    }));
-
-  const datesOutOfOffice: IOutOfOfficeData = calculateOutOfOfficeRanges(outOfOfficeDays, availability);
 
     const { dateRanges, oooExcludedDateRanges } = buildDateRanges({
       dateFrom,
@@ -621,16 +512,16 @@ const _getUserAvailability = async function getUsersWorkingHoursLifeTheUniverseA
     );
 
     return result;
-};
+  }
 
-export const getUserAvailability = withReporting(_getUserAvailability, "getUserAvailability");
+  getUserAvailability = withReporting(this._getUserAvailability.bind(this), "getUserAvailability");
 
-const _getPeriodStartDatesBetween = (
+  _getPeriodStartDatesBetween(
     dateFrom: Dayjs,
     dateTo: Dayjs,
     period: IntervalLimitUnit,
     timeZone?: string
-): Dayjs[] => {
+  ): Dayjs[] {
     const dates = [];
     let startDate = timeZone ? dayjs(dateFrom).tz(timeZone).startOf(period) : dayjs(dateFrom).startOf(period);
     const endDate = timeZone ? dayjs(dateTo).tz(timeZone).endOf(period) : dayjs(dateTo).endOf(period);
@@ -640,41 +531,17 @@ const _getPeriodStartDatesBetween = (
       startDate = startDate.add(1, period);
     }
     return dates;
-};
+  }
 
-export const getPeriodStartDatesBetween = withReporting(
+  getPeriodStartDatesBetween = withReporting(
-  _getPeriodStartDatesBetween,
+    this._getPeriodStartDatesBetween.bind(this),
     "getPeriodStartDatesBetween"
   );
 
-interface GetUserAvailabilityParamsDTO {
+  calculateOutOfOfficeRanges(
-  availability: (DateOverride | WorkingHours)[];
-}
-
-export interface IFromUser {
-  id: number;
-  displayName: string | null;
-}
-
-export interface IToUser {
-  id: number;
-  username: string | null;
-  displayName: string | null;
-}
-
-export interface IOutOfOfficeData {
-  [key: string]: {
-    fromUser: IFromUser | null;
-    toUser?: IToUser | null;
-    reason?: string | null;
-    emoji?: string | null;
-  };
-}
-
-const calculateOutOfOfficeRanges = (
     outOfOfficeDays: GetUserAvailabilityInitialData["outOfOfficeDays"],
     availability: GetUserAvailabilityParamsDTO["availability"]
-): IOutOfOfficeData => {
+  ): IOutOfOfficeData {
     if (!outOfOfficeDays || outOfOfficeDays.length === 0) {
       return {};
     }
@@ -713,18 +580,9 @@ const calculateOutOfOfficeRanges = (
 
       return acc;
     }, {});
-};
+  }
 
-type GetUsersAvailabilityProps = {
+  async _getUsersAvailability({ users, query, initialData }: GetUsersAvailabilityProps) {
-  users: (GetAvailabilityUser & {
-    currentBookings?: GetUserAvailabilityInitialData["currentBookings"];
-    outOfOfficeDays?: GetUserAvailabilityInitialData["outOfOfficeDays"];
-  })[];
-  query: Omit<GetUserAvailabilityQuery, "userId" | "username">;
-  initialData?: Omit<GetUserAvailabilityInitialData, "user">;
-};
-
-const _getUsersAvailability = async ({ users, query, initialData }: GetUsersAvailabilityProps) => {
     if (users.length >= 50) {
       const userIds = users.map(({ id }) => id).join(", ");
       log.warn(
@@ -733,7 +591,7 @@ const _getUsersAvailability = async ({ users, query, initialData }: GetUsersAvai
     }
     return await Promise.all(
       users.map((user) =>
-      _getUserAvailability(
+        this._getUserAvailability(
           {
             ...query,
             userId: user.id,
@@ -750,6 +608,7 @@ const _getUsersAvailability = async ({ users, query, initialData }: GetUsersAvai
         )
       )
     );
-};
+  }
 
-export const getUsersAvailability = withReporting(_getUsersAvailability, "getUsersAvailability");
+  getUsersAvailability = withReporting(this._getUsersAvailability.bind(this), "getUsersAvailability");
+}

packages/lib/intervalLimits/server/getBusyTimesFromLimits.ts

@@ -1,9 +1,9 @@
 import type { Dayjs } from "@calcom/dayjs";
 import dayjs from "@calcom/dayjs";
 import { getCheckBookingLimitsService } from "@calcom/lib/di/containers/booking-limits";
+import { getUserAvailabilityService } from "@calcom/lib/di/containers/get-user-availability";
 import { getStartEndDateforLimitCheck } from "@calcom/lib/getBusyTimes";
 import type { EventType } from "@calcom/lib/getUserAvailability";
-import { getPeriodStartDatesBetween } from "@calcom/lib/getUserAvailability";
 import { withReporting } from "@calcom/lib/sentryWrapper";
 import { performance } from "@calcom/lib/server/perfObserver";
 import { getTotalBookingDuration } from "@calcom/lib/server/queries/booking";
@@ -86,6 +86,7 @@ const _getBusyTimesFromBookingLimits = async (params: {
   includeManagedEvents?: boolean;
   timeZone?: string | null;
 }) => {
+  const userAvailabilityService = getUserAvailabilityService();
   const {
     bookings,
     bookingLimits,
@@ -105,7 +106,7 @@ const _getBusyTimesFromBookingLimits = async (params: {
     if (!limit) continue;
 
     const unit = intervalLimitKeyToUnit(key);
-    const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit);
+    const periodStartDates = userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit);
 
     for (const periodStart of periodStartDates) {
       if (limitManager.isAlreadyBusy(periodStart, unit)) continue;
@@ -162,12 +163,14 @@ const _getBusyTimesFromDurationLimits = async (
   timeZone: string,
   rescheduleUid?: string
 ) => {
+  const userAvailabilityService = getUserAvailabilityService();
+
   for (const key of descendingLimitKeys) {
     const limit = durationLimits?.[key];
     if (!limit) continue;
 
     const unit = intervalLimitKeyToUnit(key);
-    const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit);
+    const periodStartDates = userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit);
 
     for (const periodStart of periodStartDates) {
       if (limitManager.isAlreadyBusy(periodStart, unit)) continue;

packages/lib/server/i18n.ts

@@ -1,12 +1,13 @@
 import { createInstance } from "i18next";
 
-/* eslint-disable @typescript-eslint/no-var-requires */
-const { i18n } = require("@calcom/config/next-i18next.config");
 import { WEBAPP_URL } from "@calcom/lib/constants";
 
 import { fetchWithTimeout } from "../fetchWithTimeout";
 import logger from "../logger";
 
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { i18n } = require("@calcom/config/next-i18next.config");
+
 const translationCache = new Map<string, Record<string, string>>();
 const i18nInstanceCache = new Map<string, any>();
 const SUPPORTED_NAMESPACES = ["common"];
@@ -28,6 +29,7 @@ export async function loadTranslations(_locale: string, _ns: string) {
   }
 
   const url = `${WEBAPP_URL}/static/locales/${locale}/${ns}.json`;
+  try {
     const response = await fetchWithTimeout(
       url,
       {
@@ -44,6 +46,11 @@ export async function loadTranslations(_locale: string, _ns: string) {
     const translations = await response.json();
     translationCache.set(cacheKey, translations);
     return translations;
+  } catch (err) {
+    console.error("loadTranslations Error:", err);
+
+    return {};
+  }
 }
 
 /**

packages/lib/server/repository/booking.ts

@@ -869,4 +869,26 @@ export class BookingRepository {
       },
     });
   }
+
+  async findAcceptedBookingByEventTypeId({eventTypeId, dateFrom, dateTo}: {eventTypeId?: number, dateFrom: string, dateTo: string}) {
+    return  this.prismaClient.booking.findMany({
+          where: {
+            eventTypeId,
+            startTime: {
+              gte: dateFrom,
+              lte: dateTo,
+            },
+            status: BookingStatus.ACCEPTED,
+          },
+          select: {
+            uid: true,
+            startTime: true,
+            attendees: {
+              select: {
+                email: true,
+              },
+            },
+          },
+        });
+  }
 }

packages/lib/server/repository/eventTypeRepository.ts

@@ -1299,4 +1299,93 @@ export class EventTypeRepository {
   }) {
     return user.allSelectedCalendars.filter((calendar) => calendar.eventTypeId === eventTypeId);
   }
+
+  async findByIdForUserAvailability({ id }: { id: number }) {
+    const eventType = await this.prismaClient.eventType.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        seatsPerTimeSlot: true,
+        bookingLimits: true,
+        useEventLevelSelectedCalendars: true,
+        parent: {
+          select: {
+            team: {
+              select: {
+                id: true,
+                bookingLimits: true,
+                includeManagedEventsInLimits: true,
+              },
+            },
+          },
+        },
+        team: {
+          select: {
+            id: true,
+            bookingLimits: true,
+            includeManagedEventsInLimits: true,
+          },
+        },
+        hosts: {
+          select: {
+            user: {
+              select: {
+                email: true,
+                id: true,
+              },
+            },
+            schedule: {
+              select: {
+                availability: {
+                  select: {
+                    date: true,
+                    startTime: true,
+                    endTime: true,
+                    days: true,
+                  },
+                },
+                timeZone: true,
+                id: true,
+              },
+            },
+          },
+        },
+        durationLimits: true,
+        assignAllTeamMembers: true,
+        schedulingType: true,
+        timeZone: true,
+        length: true,
+        metadata: true,
+        schedule: {
+          select: {
+            id: true,
+            availability: {
+              select: {
+                days: true,
+                date: true,
+                startTime: true,
+                endTime: true,
+              },
+            },
+            timeZone: true,
+          },
+        },
+        availability: {
+          select: {
+            startTime: true,
+            endTime: true,
+            days: true,
+            date: true,
+          },
+        },
+      },
+    });
+    if (!eventType) {
+      return eventType;
+    }
+    return {
+      ...eventType,
+      metadata: EventTypeMetaDataSchema.parse(eventType.metadata),
+    };
+  }
 }

packages/lib/server/repository/ooo.ts

@@ -79,4 +79,71 @@ export class PrismaOOORepository {
       },
     });
   }
+
+  async findUserOOODays({userId, dateTo, dateFrom}: {userId: number, dateTo: string, dateFrom: string}) {
+    return this.prismaClient.outOfOfficeEntry.findMany({
+            where: {
+              userId,
+              OR: [
+                // outside of range
+                // (start <= 'dateTo' AND end >= 'dateFrom')
+                {
+                  start: {
+                    lte: dateTo,
+                  },
+                  end: {
+                    gte: dateFrom,
+                  },
+                },
+                // start is between dateFrom and dateTo but end is outside of range
+                // (start <= 'dateTo' AND end >= 'dateTo')
+                {
+                  start: {
+                    lte: dateTo,
+                  },
+    
+                  end: {
+                    gte: dateTo,
+                  },
+                },
+                // end is between dateFrom and dateTo but start is outside of range
+                // (start <= 'dateFrom' OR end <= 'dateTo')
+                {
+                  start: {
+                    lte: dateFrom,
+                  },
+    
+                  end: {
+                    lte: dateTo,
+                  },
+                },
+              ],
+            },
+            select: {
+              id: true,
+              start: true,
+              end: true,
+              user: {
+                select: {
+                  id: true,
+                  name: true,
+                },
+              },
+              toUser: {
+                select: {
+                  id: true,
+                  username: true,
+                  name: true,
+                },
+              },
+              reason: {
+                select: {
+                  id: true,
+                  emoji: true,
+                  reason: true,
+                },
+              },
+            },
+          });
+  }
 }

packages/lib/server/service/InsightsBookingBaseService.ts

@@ -135,7 +135,7 @@ const NOTHING_CONDITION = Prisma.sql`1=0`;
 
 const bookingDataKeys = new Set(Object.keys(bookingDataSchema.shape));
 
-export class InsightsBookingService {
+export class InsightsBookingBaseService {
   private prisma: typeof readonlyPrisma;
   private options: InsightsBookingServiceOptions | null;
   private filters: InsightsBookingServiceFilterOptions | null;

packages/lib/server/service/InsightsBookingDIService.ts

@@ -0,0 +1,29 @@
+import type { readonlyPrisma } from "@calcom/prisma";
+
+import {
+  InsightsBookingBaseService,
+  type InsightsBookingServicePublicOptions,
+  type InsightsBookingServiceFilterOptions,
+} from "./InsightsBookingBaseService";
+
+export interface IInsightsBookingService {
+  prisma: typeof readonlyPrisma;
+}
+
+export class InsightsBookingService {
+  constructor(private readonly dependencies: IInsightsBookingService) {}
+
+  create({
+    options,
+    filters,
+  }: {
+    options: InsightsBookingServicePublicOptions;
+    filters?: InsightsBookingServiceFilterOptions;
+  }): InsightsBookingBaseService {
+    return new InsightsBookingBaseService({
+      prisma: this.dependencies.prisma,
+      options,
+      filters,
+    });
+  }
+}

packages/lib/server/service/__tests__/InsightsBookingService.integration-test.ts

@@ -6,7 +6,7 @@ import { ColumnFilterType } from "@calcom/features/data-table/lib/types";
 import prisma from "@calcom/prisma";
 import { BookingStatus, MembershipRole } from "@calcom/prisma/enums";
 
-import { InsightsBookingService } from "../../service/insightsBooking";
+import { InsightsBookingBaseService as InsightsBookingService } from "../InsightsBookingBaseService";
 
 const NOTHING_CONDITION = Prisma.sql`1=0`;
 

packages/platform/libraries/schedules.ts

@@ -4,3 +4,4 @@ export {
 } from "@calcom/lib/server/repository/schedule";
 
 export { updateSchedule, type UpdateScheduleResponse } from "@calcom/lib/schedules/updateSchedule";
+export {UserAvailabilityService} from "@calcom/lib/getUserAvailability"

packages/trpc/server/routers/viewer/availability/user.handler.ts

@@ -1,4 +1,4 @@
-import { getUserAvailability } from "@calcom/lib/getUserAvailability";
+import { getUserAvailabilityService } from "@calcom/lib/di/containers/get-user-availability";
 
 import type { TrpcSessionUser } from "../../../types";
 import type { TUserInputSchema } from "./user.schema";
@@ -11,7 +11,8 @@ type UserOptions = {
 };
 
 export const userHandler = async ({ input }: UserOptions) => {
-  return getUserAvailability(
+  const userAvailabilityService = getUserAvailabilityService()
+  return userAvailabilityService.getUserAvailability(
     { returnDateOverrides: true, bypassBusyCalendarTimes: false, ...input },
     undefined
   );

packages/trpc/server/routers/viewer/slots/util.ts

@@ -20,10 +20,10 @@ import type {
   CurrentSeats,
   EventType,
   GetAvailabilityUser,
+  UserAvailabilityService,
   IFromUser,
   IToUser,
 } from "@calcom/lib/getUserAvailability";
-import { getPeriodStartDatesBetween, getUsersAvailability } from "@calcom/lib/getUserAvailability";
 import { descendingLimitKeys, intervalLimitKeyToUnit } from "@calcom/lib/intervalLimits/intervalLimit";
 import type { IntervalLimit } from "@calcom/lib/intervalLimits/intervalLimitSchema";
 import { parseBookingLimit } from "@calcom/lib/intervalLimits/isBookingLimits";
@@ -101,6 +101,7 @@ export interface IAvailableSlotsService {
   routingFormResponseRepo: RoutingFormResponseRepository;
   cacheService: CacheService;
   checkBookingLimitsService: CheckBookingLimitsService;
+  userAvailabilityService: UserAvailabilityService
 }
 
 export class AvailableSlotsService {
@@ -357,7 +358,7 @@ export class AvailableSlotsService {
         if (!limit) continue;
 
         const unit = intervalLimitKeyToUnit(key);
-        const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
+        const periodStartDates = this.dependencies.userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
 
         for (const periodStart of periodStartDates) {
           if (globalLimitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;
@@ -392,7 +393,7 @@ export class AvailableSlotsService {
           if (!limit) continue;
 
           const unit = intervalLimitKeyToUnit(key);
-          const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
+          const periodStartDates = this.dependencies.userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
 
           for (const periodStart of periodStartDates) {
             if (limitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;
@@ -443,7 +444,7 @@ export class AvailableSlotsService {
           if (!limit) continue;
 
           const unit = intervalLimitKeyToUnit(key);
-          const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
+          const periodStartDates = this.dependencies.userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
 
           for (const periodStart of periodStartDates) {
             if (limitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;
@@ -543,7 +544,7 @@ export class AvailableSlotsService {
       if (!limit) continue;
 
       const unit = intervalLimitKeyToUnit(key);
-      const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
+      const periodStartDates = this.dependencies.userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
 
       for (const periodStart of periodStartDates) {
         if (globalLimitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;
@@ -591,7 +592,7 @@ export class AvailableSlotsService {
         if (!limit) continue;
 
         const unit = intervalLimitKeyToUnit(key);
-        const periodStartDates = getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
+        const periodStartDates = this.dependencies.userAvailabilityService.getPeriodStartDatesBetween(dateFrom, dateTo, unit, timeZone);
 
         for (const periodStart of periodStartDates) {
           if (limitManager.isAlreadyBusy(periodStart, unit, timeZone)) continue;
@@ -818,7 +819,7 @@ export class AvailableSlotsService {
     const users = enrichUsersWithData();
 
     // TODO: DI getUsersAvailability
-    const premappedUsersAvailability = await getUsersAvailability({
+    const premappedUsersAvailability = await this.dependencies.userAvailabilityService.getUsersAvailability({
       users,
       query: {
         dateFrom: startTime.format(),

packages/trpc/server/routers/viewer/teams/getMemberAvailability.handler.ts

@@ -1,5 +1,5 @@
 import { enrichUserWithDelegationCredentialsIncludeServiceAccountKey } from "@calcom/lib/delegationCredential/server";
-import { getUserAvailability } from "@calcom/lib/getUserAvailability";
+import { getUserAvailabilityService } from "@calcom/lib/di/containers/get-user-availability";
 import { isTeamMember } from "@calcom/lib/server/queries/teams";
 import { MembershipRepository } from "@calcom/lib/server/repository/membership";
 import type { TrpcSessionUser } from "@calcom/trpc/server/types";
@@ -16,6 +16,7 @@ type GetMemberAvailabilityOptions = {
 };
 
 export const getMemberAvailabilityHandler = async ({ ctx, input }: GetMemberAvailabilityOptions) => {
+  const userAvailabilityService = getUserAvailabilityService()
   const team = await isTeamMember(ctx.user?.id, input.teamId);
   if (!team) throw new TRPCError({ code: "UNAUTHORIZED" });
 
@@ -32,7 +33,7 @@ export const getMemberAvailabilityHandler = async ({ ctx, input }: GetMemberAvai
   });
 
   // get availability for this member
-  return await getUserAvailability(
+  return await userAvailabilityService.getUserAvailability(
     {
       username: username,
       dateFrom: input.dateFrom,

yarn.lock

@@ -2500,7 +2500,7 @@ __metadata:
     "@axiomhq/winston": ^1.2.0
     "@calcom/platform-constants": "*"
     "@calcom/platform-enums": "*"
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.276"
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.283"
     "@calcom/platform-types": "*"
     "@calcom/platform-utils": "*"
     "@calcom/prisma": "*"
@@ -3556,13 +3556,13 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@calcom/platform-libraries@npm:@calcom/platform-libraries@0.0.276":
+"@calcom/platform-libraries@npm:@calcom/platform-libraries@0.0.283":
-  version: 0.0.276
+  version: 0.0.283
-  resolution: "@calcom/platform-libraries@npm:0.0.276"
+  resolution: "@calcom/platform-libraries@npm:0.0.283"
   dependencies:
     "@calcom/features": "*"
     "@calcom/lib": "*"
-  checksum: 4effc186c0301ec35496ebffbe32280f26261667b60057d18207b30636b038cdcc3783b95390eecc8460f3203d0cfe5d732e3b3f89031ff064b1a556321779a8
+  checksum: 7d741bd13ac050f8552855658b2348cba0999529c12ca6741e5f802a7bc9ce4e29c9ac69a17306c42beb392f17acb7b5f8a0554b8d2ea9b5fc6d963950d0fca8
   languageName: node
   linkType: hard