refactor: implement DI in team billing service and team billing data repository factory (calcom#24803)

* Move TeamBillingRepositories

* WIP refactor team internal billing service

* Remove duplicate billing repository files

* Remove logic check in repository for billing is enabled

* Rename repository to `TeamBillingData`

* Use repository factory in main service

* Fix new import paths

* Rename  to

* Ensure `IS_TEAM_BILLING_ENABLED` is of type boolean

* Rename classes to TeamBillingService and TeamBillingServiceFactory

* Implement DI in `BookingServiceFactory`

* `TeamBillingService` use repository in `getOrgIfNeeded`

* DI `isTeamBillingEnabled` to `TeamBillingServiceFactory`

* Rename files for consistency

* Return stub BillingRepository if billing is not enabled

* Move Stripe billing service to service folder

* Rename file

* `StripeBillingService.getSubscriptionStatus` return `SubscriptionStatus`

* Type fices in StripeBillingService

* Type fix in `stubTeamBillingService`

* DI the `BillingProviderService` into the `TeamBillingService`

* Implement DI in `skipTeamTrials.handler`

* Implement DI for team billing in `inviteMember.handler`

* `skipTeamTrials.handler` use `team.isOrganization`

* Implement DI for billing in `hasActiveTeamPlan.handler`

* Type fixes

* Implement DI in `bulkDeleteUsers.handler`

* Implement `BillingProviderServiceFactory` in `updateProfile.handler`

* Implment `BillingProviderServiceFactory` in `buyCredits.handler`

* Fix import in `stripeCustomer.handler`

* Add a constructor to `teamBillingServiceFactory`

* Add DI to `PrismaTeamBillingRepository`

* Add DI to `StripeBillingService`

* Implement singleton in `BillingProviderServiceFactory`

* Add DI folder and contents to billing folder

* Use `getTeamBillingServiceFactory` in `inviteMember.handler`

* Add `saveTeamBilling` method to `ITeamBillingService`

* Implement DI in new team route

* Implement DI in `teamService`

* Implement DI in `OrganizationPaymentService`

* Implement DI in `credit-service`

* In `StripeBillingService` remove `static` from status methods

* Implemnt DI in `_invoice.paid.org`

* Refactor `hasActiveTeamPlan` to use `getTeamBillingFactory`

* Refactor `skipTeamTrials` to use `getTeamBillingFactory`

* Refactor `skipTeamTrials` to use `getTeamBillingServiceFactory`

* `stripeCustomer.handler` to use `getBillingProviderService`

* Remove old factories

* Type fix

* Remove unused factory

* Refactor `updateProfile.handler` to use `getBillingProviderService`

* Change name to `TeamBillingDataRepositoryFactory`

* Type Prisma return in `prisma.module`

* Type fix

* Refactor `buyCredits.handler` to use `getBillingProviderService`

* Refactor `credit-service` to use billing DI containers

* Type fix

* Add `getTeamBillingDataRepository`

* Refactor `_invoice.paid.org` to use DI container

* Refactor `_customer.subscription.deleted.team-plan` to use DI container

* Refactor `calcomHandler` to use DI container

* Refactor `getCustomerAndCheckoutSession` to use DI container

* Refactor `verify-email` to use DI containers

* Refactor `api/create/route` to use DI container

* Refactor downgradeUsers to use DI container

* Type fix

* Clean up console.logs

* Add await to `this.billingRepository.create` in `saveTeamBilling`

Co-authored-by: cubic-dev-ai[bot] <191113872+cubic-dev-ai[bot]@users.noreply.github.com>

* Fix type errors

* Address comments

* fix: update tests to work with new DI pattern

- Update teamBillingService.test.ts to properly inject DI dependencies
- Remove unused billingModule import and mock
- Fix import naming in teamService.integration-test.ts (remove unused rename)
- Fix import path for TeamBillingPublishResponseStatus

All tests now properly mock IBillingProviderService, ITeamBillingDataRepository,
and IBillingRepository instead of using the old BillingRepositoryFactory pattern.

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* fix: add compatibility layer and env setup for unit tests

- Add STRIPE_PRIVATE_KEY dummy value to vitest.config.ts to prevent DI module errors
- Fix import paths in credit-service.test.ts (StripeBillingService, TeamBillingService)
- Create compatibility barrel at packages/features/ee/billing/teams/index.ts for test mocking

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* fix: update unit tests to mock DI container properly

- Update teamService.test.ts to mock getTeamBillingServiceFactory() instead of TeamBilling.findAndInit
- Update teamService.alternative.test.ts to mock DI container
- Update credit-service.test.ts to mock getBillingProviderService() and use SubscriptionStatus enum values
- Update OrganizationPaymentService.test.ts to mock DI container instead of direct StripeBillingService import
- Remove all 'as any' type casting to comply with Cal.com coding standards
- Fix unused variable warnings by prefixing with underscore

All 53 tests now passing (16 + 1 + 30 + 6)

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* fix: update remaining unit tests to use DI pattern

- Fix StripeBillingService.test.ts to inject mock Stripe client directly
- Fix teamBillingFactory.test.ts to mock getTeamBillingServiceFactory() from DI container
- Fix skipTeamTrials.test.ts to mock DI container and use SubscriptionStatus enum

All 11 previously failing tests now pass (5 + 5 + 1)

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* Undo changes made to Prisma module

* fix: address test-related PR comments

- Fix OrganizationPaymentService.test.ts mock path from @calcom/ee to @calcom/features/ee
- Refactor teamBillingFactory.test.ts to test real factory logic instead of mocking container
- Remove duplicate teamBillingService.test..ts file with incorrect double-dot filename

All three test files now pass successfully with proper DI patterns.

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* Address feedback

* fix: update teamService integration test to mock new DI factory pattern

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* refactor: remove duplicate imports in credit-service.test.ts

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* Remove unused index file

* `getBySubscriptionId` to return team or null

* Address feedback

* Merge fix

* Refactor file names

* fix: correct mockStripe variable name to stripeMock in StripeBillingService.test.ts

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* refactor: update internal-team-billing.test.ts to use new DI structure with TeamBillingService

- Replace InternalTeamBilling with TeamBillingService
- Use constructor injection with mock dependencies instead of factory pattern
- Remove BillingRepositoryFactory mock and import
- Update all test cases to use mockBillingProviderService, mockTeamBillingDataRepository, and mockBillingRepository
- Simplify saveTeamBilling tests to focus on repository.create calls
- All 11 tests now pass with the new DI structure

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

* fix: update createWithPaymentIntent.handler.test.ts to mock DI container's getBillingProviderService

- OrganizationPaymentService now uses getBillingProviderService() from DI container
- Test was mocking @calcom/features/ee/payments/server/stripe directly, which no longer works
- Added mock for @calcom/features/ee/billing/di/containers/Billing module
- Mock returns fake billing provider that delegates to mockSharedStripe
- Preserves all existing test assertions and helpers
- Fixed lint error by prefixing unused lastCreatedSessionId with underscore
- All 11 tests now pass (1 skipped as expected)

Co-Authored-By: joe@cal.com <j.auyeung419@gmail.com>

---------

Co-authored-by: cubic-dev-ai[bot] <191113872+cubic-dev-ai[bot]@users.noreply.github.com>
Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: Syed Ali Shahbaz <52925846+alishaz-polymath@users.noreply.github.com>

Author: 4 people

apps/web/app/api/cron/downgradeUsers/route.ts

@@ -3,7 +3,7 @@ import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
 import { z } from "zod";
 
-import { TeamBilling } from "@calcom/ee/billing/teams";
+import { getTeamBillingServiceFactory } from "@calcom/features/ee/billing/di/containers/Billing";
 import prisma from "@calcom/prisma";
 
 const querySchema = z.object({
@@ -17,7 +17,6 @@ async function postHandler(request: NextRequest) {
     return NextResponse.json({ message: "Not authenticated" }, { status: 401 });
   }
 
-  const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
   const pageSize = 90; // Adjust this value based on the total number of teams and the available processing time
 
   let { page: pageNumber } = querySchema.parse(Object.fromEntries(request.nextUrl.searchParams));
@@ -43,7 +42,8 @@ async function postHandler(request: NextRequest) {
       break;
     }
 
-    const teamsBilling = TeamBilling.initMany(teams);
+    const teamBillingFactory = getTeamBillingServiceFactory();
+    const teamsBilling = teamBillingFactory.initMany(teams);
     const teamBillingPromises = teamsBilling.map((teamBilling) => teamBilling.updateQuantity());
     await Promise.allSettled(teamBillingPromises);
 

apps/web/app/api/teams/api/create/route.ts

@@ -4,9 +4,9 @@ import { NextResponse } from "next/server";
 import type Stripe from "stripe";
 import { z } from "zod";
 
-import { Plan, SubscriptionStatus } from "@calcom/features/ee/billing/repository/IBillingRepository";
-import { StripeBillingService } from "@calcom/features/ee/billing/stripe-billing-service";
-import { InternalTeamBilling } from "@calcom/features/ee/billing/teams/internal-team-billing";
+import { getBillingProviderService } from "@calcom/ee/billing/di/containers/Billing";
+import { getTeamBillingServiceFactory } from "@calcom/ee/billing/di/containers/Billing";
+import { Plan, SubscriptionStatus } from "@calcom/features/ee/billing/repository/billing/IBillingRepository";
 import stripe from "@calcom/features/ee/payments/server/stripe";
 import { HttpError } from "@calcom/lib/http-error";
 import { prisma } from "@calcom/prisma";
@@ -58,11 +58,12 @@ async function handler(request: NextRequest) {
     });
 
     if (checkoutSessionSubscription) {
-      const { subscriptionStart } =
-        StripeBillingService.extractSubscriptionDates(checkoutSessionSubscription);
+      const billingService = getBillingProviderService();
+      const { subscriptionStart } = billingService.extractSubscriptionDates(checkoutSessionSubscription);
 
-      const internalBillingService = new InternalTeamBilling(finalizedTeam);
-      await internalBillingService.saveTeamBilling({
+      const teamBillingServiceFactory = getTeamBillingServiceFactory();
+      const teamBillingService = teamBillingServiceFactory.init(finalizedTeam);
+      await teamBillingService.saveTeamBilling({
         teamId: finalizedTeam.id,
         subscriptionId: checkoutSessionSubscription.id,
         subscriptionItemId: checkoutSessionSubscription.items.data[0].id,

apps/web/app/api/teams/create/route.ts

@@ -4,9 +4,11 @@ import { NextResponse } from "next/server";
 import type Stripe from "stripe";
 import { z } from "zod";
 
-import { Plan, SubscriptionStatus } from "@calcom/features/ee/billing/repository/IBillingRepository";
-import { StripeBillingService } from "@calcom/features/ee/billing/stripe-billing-service";
-import { InternalTeamBilling } from "@calcom/features/ee/billing/teams/internal-team-billing";
+import {
+  getBillingProviderService,
+  getTeamBillingServiceFactory,
+} from "@calcom/features/ee/billing/di/containers/Billing";
+import { Plan, SubscriptionStatus } from "@calcom/features/ee/billing/repository/billing/IBillingRepository";
 import stripe from "@calcom/features/ee/payments/server/stripe";
 import { WEBAPP_URL } from "@calcom/lib/constants";
 import { HttpError } from "@calcom/lib/http-error";
@@ -91,9 +93,11 @@ async function getHandler(req: NextRequest) {
   });
 
   if (checkoutSession && subscription) {
-    const { subscriptionStart } = StripeBillingService.extractSubscriptionDates(subscription);
-    const internalBillingService = new InternalTeamBilling(team);
-    await internalBillingService.saveTeamBilling({
+    const billingProviderService = getBillingProviderService();
+    const { subscriptionStart } = billingProviderService.extractSubscriptionDates(subscription);
+    const teamBillingServiceFactory = getTeamBillingServiceFactory();
+    const teamBillingService = teamBillingServiceFactory.init(team);
+    await teamBillingService.saveTeamBilling({
       teamId: team.id,
       subscriptionId: subscription.id,
       subscriptionItemId: subscription.items.data[0].id,

apps/web/lib/pages/auth/verify-email.ts

@@ -2,7 +2,7 @@ import type { NextApiRequest, NextApiResponse } from "next";
 import { z } from "zod";
 
 import dayjs from "@calcom/dayjs";
-import { StripeBillingService } from "@calcom/features/ee/billing/stripe-billing-service";
+import { getBillingProviderService } from "@calcom/features/ee/billing/di/containers/Billing";
 import { getOrganizationRepository } from "@calcom/features/ee/organizations/di/OrganizationRepository.container";
 import { OnboardingPathService } from "@calcom/features/onboarding/lib/onboarding-path.service";
 import { WEBAPP_URL } from "@calcom/lib/constants";
@@ -45,7 +45,6 @@ export async function moveUserToMatchingOrg({ email }: { email: string }) {
 
 export async function handler(req: NextApiRequest, res: NextApiResponse) {
   const { token } = verifySchema.parse(req.query);
-  const billingService = new StripeBillingService();
 
   const foundToken = await prisma.verificationToken.findFirst({
     where: {
@@ -133,6 +132,7 @@ export async function handler(req: NextApiRequest, res: NextApiResponse) {
     });
 
     if (IS_STRIPE_ENABLED && userMetadataParsed.stripeCustomerId) {
+      const billingService = getBillingProviderService();
       await billingService.updateCustomer({
         customerId: userMetadataParsed.stripeCustomerId,
         email: updatedEmail,

packages/app-store/stripepayment/lib/getCustomerAndCheckoutSession.ts

@@ -1,7 +1,7 @@
-import { StripeBillingService } from "@calcom/features/ee/billing/stripe-billing-service";
+import { getBillingProviderService } from "@calcom/features/ee/billing/di/containers/Billing";
 
 export async function getCustomerAndCheckoutSession(checkoutSessionId: string) {
-  const billingService = new StripeBillingService();
+  const billingService = getBillingProviderService();
   const checkoutSession = await billingService.getCheckoutSession(checkoutSessionId);
   const customerOrCustomerId = checkoutSession.customer;
   let customerId = null;

packages/features/auth/signup/handlers/calcomHandler.ts

@@ -7,7 +7,7 @@ import { sendEmailVerification } from "@calcom/features/auth/lib/verifyEmail";
 import { createOrUpdateMemberships } from "@calcom/features/auth/signup/utils/createOrUpdateMemberships";
 import { prefillAvatar } from "@calcom/features/auth/signup/utils/prefillAvatar";
 import { validateAndGetCorrectedUsernameAndEmail } from "@calcom/features/auth/signup/utils/validateUsername";
-import { StripeBillingService } from "@calcom/features/ee/billing/stripe-billing-service";
+import { getBillingProviderService } from "@calcom/features/ee/billing/di/containers/Billing";
 import { sentrySpan } from "@calcom/features/watchlist/lib/telemetry";
 import { checkIfEmailIsBlockedInWatchlistController } from "@calcom/features/watchlist/operations/check-if-email-in-watchlist.controller";
 import { hashPassword } from "@calcom/lib/auth/hashPassword";
@@ -44,7 +44,7 @@ const handler: CustomNextApiHandler = async (body, usernameStatus) => {
     })
     .parse(body);
 
-  const billingService = new StripeBillingService();
+  const billingService = getBillingProviderService();
 
   const shouldLockByDefault = await checkIfEmailIsBlockedInWatchlistController({
     email: _email,

packages/features/di/di.ts

@@ -1,4 +1,4 @@
-import type { Container, Module } from "@evyweb/ioctopus";
+import type { Container, Module, ResolveFunction } from "@evyweb/ioctopus";
 import { createContainer, createModule } from "@evyweb/ioctopus";
 
 export type ModuleLoader = { token: string | symbol; loadModule: (container: Container) => void };
@@ -111,4 +111,4 @@ export function bindModuleToClassOnToken<TClass extends new (deps: any) => any>(
     }
   };
 }
-export { createContainer, createModule, type Container, type Module };
+export { createContainer, createModule, type Container, type Module, type ResolveFunction };

packages/features/ee/billing/api/webhook/_customer.subscription.deleted.team-plan.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
 
-import { TeamBilling } from "../../teams";
+import logger from "@calcom/lib/logger";
+
+import { getTeamBillingDataRepository, getTeamBillingServiceFactory } from "../../di/containers/Billing";
 import type { SWHMap } from "./__handler";
 
 const metadataSchema = z.object({
@@ -9,15 +11,25 @@ const metadataSchema = z.object({
 
 const handler = async (data: SWHMap["customer.subscription.deleted"]["data"]) => {
   const subscription = data.object;
+  const teamBillingFactory = getTeamBillingServiceFactory();
+  const log = logger.getSubLogger({
+    prefix: [`[customer.subscription.deleted.team-plan]: subscriptionId: ${subscription.id}`],
+  });
+
   try {
     const { teamId } = metadataSchema.parse(subscription.metadata);
-    const teamBilling = await TeamBilling.findAndInit(teamId);
-    await teamBilling.downgrade();
+    const teamBillingService = await teamBillingFactory.findAndInit(teamId);
+    await teamBillingService.downgrade();
     return { success: true };
-  } catch (error) {
+  } catch {
+    const teamBillingDataRepository = getTeamBillingDataRepository();
     // If stripe metadata is missing teamId, we attempt to find by sub ID.
-    const team = await TeamBilling.repo.findBySubscriptionId(subscription.id);
-    const teamBilling = TeamBilling.init(team);
+    const team = await teamBillingDataRepository.findBySubscriptionId(subscription.id);
+    if (!team) {
+      log.warn("No team found with subscriptionId");
+      return { success: false };
+    }
+    const teamBilling = teamBillingFactory.init(team);
     await teamBilling.downgrade();
     return { success: true };
   }

packages/features/ee/billing/api/webhook/_invoice.paid.org.ts

@@ -1,8 +1,7 @@
 import { z } from "zod";
 
-import { Plan, SubscriptionStatus } from "@calcom/features/ee/billing/repository/IBillingRepository";
-import { StripeBillingService } from "@calcom/features/ee/billing/stripe-billing-service";
-import { InternalTeamBilling } from "@calcom/features/ee/billing/teams/internal-team-billing";
+import { getBillingProviderService } from "@calcom/ee/billing/di/containers/Billing";
+import { Plan, SubscriptionStatus } from "@calcom/features/ee/billing/repository/billing/IBillingRepository";
 import { BillingEnabledOrgOnboardingService } from "@calcom/features/ee/organizations/lib/service/onboarding/BillingEnabledOrgOnboardingService";
 import stripe from "@calcom/features/ee/payments/server/stripe";
 import { UserRepository } from "@calcom/features/users/repositories/UserRepository";
@@ -11,6 +10,7 @@ import { safeStringify } from "@calcom/lib/safeStringify";
 import { OrganizationOnboardingRepository } from "@calcom/lib/server/repository/organizationOnboarding";
 import { prisma } from "@calcom/prisma";
 
+import { getTeamBillingServiceFactory } from "../../di/containers/Billing";
 import type { SWHMap } from "./__handler";
 
 const invoicePaidSchema = z.object({
@@ -123,10 +123,12 @@ const handler = async (data: SWHMap["invoice.paid"]["data"]) => {
 
     // Get the Stripe subscription object
     const stripeSubscription = await stripe.subscriptions.retrieve(paymentSubscriptionId);
-    const { subscriptionStart } = StripeBillingService.extractSubscriptionDates(stripeSubscription);
+    const billingService = getBillingProviderService();
+    const { subscriptionStart } = billingService.extractSubscriptionDates(stripeSubscription);
 
-    const internalTeamBillingService = new InternalTeamBilling(organization);
-    await internalTeamBillingService.saveTeamBilling({
+    const teamBillingServiceFactory = getTeamBillingServiceFactory();
+    const teamBillingService = teamBillingServiceFactory.init(organization);
+    await teamBillingService.saveTeamBilling({
       teamId: organization.id,
       subscriptionId: paymentSubscriptionId,
       subscriptionItemId: paymentSubscriptionItemId,

packages/features/ee/billing/credit-service.test.ts

@@ -9,7 +9,7 @@ import { CreditsRepository } from "@calcom/lib/server/repository/credits";
 import { CreditType } from "@calcom/prisma/enums";
 
 import { CreditService } from "./credit-service";
-import { InternalTeamBilling } from "./teams/internal-team-billing";
+import { SubscriptionStatus } from "./repository/billing/IBillingRepository";
 
 const MOCK_TX = {
   team: {
@@ -102,6 +102,12 @@ vi.mock("@calcom/lib/getOrgIdFromMemberOrTeamId", () => ({
   default: vi.fn().mockResolvedValue(null),
 }));
 
+vi.mock("@calcom/ee/billing/di/containers/Billing", () => ({
+  getBillingProviderService: vi.fn(),
+  getTeamBillingServiceFactory: vi.fn(),
+  getTeamBillingDataRepository: vi.fn(),
+}));
+
 const creditService = new CreditService();
 
 vi.spyOn(creditService, "_getAllCreditsForTeam").mockResolvedValue({
@@ -126,7 +132,7 @@ CreditsRepository.findCreditBalance.mockResolvedValueOnce({
 describe("CreditService", () => {
   let creditService: CreditService;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.restoreAllMocks();
 
     mockStripe.prices.retrieve.mockResolvedValue({ id: "price_123", unit_amount: 1000 });
@@ -135,6 +141,25 @@ describe("CreditService", () => {
     creditService = new CreditService();
 
     vi.mocked(CreditsRepository.findCreditExpenseLogByExternalRef).mockResolvedValue(null);
+
+    const { getBillingProviderService, getTeamBillingServiceFactory } = await import(
+      "@calcom/ee/billing/di/containers/Billing"
+    );
+
+    const mockBillingProviderService = {
+      getPrice: vi.fn().mockResolvedValue({ unit_amount: 1500 }),
+    };
+    vi.mocked(getBillingProviderService).mockReturnValue(mockBillingProviderService);
+
+    const mockTeamBillingService = {
+      getSubscriptionStatus: vi.fn().mockResolvedValue("active"),
+    };
+    const mockTeamBillingServiceFactory = {
+      init: vi.fn().mockReturnValue(mockTeamBillingService),
+      findAndInit: vi.fn().mockResolvedValue(mockTeamBillingService),
+      findAndInitMany: vi.fn().mockResolvedValue([mockTeamBillingService]),
+    };
+    vi.mocked(getTeamBillingServiceFactory).mockReturnValue(mockTeamBillingServiceFactory);
   });
 
   describe("Team credits", () => {
@@ -450,11 +475,14 @@ describe("CreditService", () => {
         vi.mocked(TeamRepository).mockImplementation(() => mockTeamRepo as unknown as TeamRepository);
 
         const mockTeamBillingService = {
-          getSubscriptionStatus: vi.fn().mockResolvedValue("trialing"),
+          getSubscriptionStatus: vi.fn().mockResolvedValue(SubscriptionStatus.TRIALING),
         };
-        vi.spyOn(InternalTeamBilling.prototype, "getSubscriptionStatus").mockImplementation(
-          mockTeamBillingService.getSubscriptionStatus
-        );
+        const { getTeamBillingServiceFactory } = await import("@calcom/ee/billing/di/containers/Billing");
+        vi.mocked(getTeamBillingServiceFactory).mockReturnValue({
+          init: vi.fn().mockReturnValue(mockTeamBillingService),
+          findAndInit: vi.fn().mockResolvedValue(mockTeamBillingService),
+          findAndInitMany: vi.fn().mockResolvedValue([mockTeamBillingService]),
+        });
 
         const result = await creditService.getMonthlyCredits(1);
         expect(result).toBe(0);
@@ -471,13 +499,20 @@ describe("CreditService", () => {
         vi.mocked(TeamRepository).mockImplementation(() => mockTeamRepo as unknown as TeamRepository);
 
         const mockTeamBillingService = {
-          getSubscriptionStatus: vi.fn().mockResolvedValue("active"),
+          getSubscriptionStatus: vi.fn().mockResolvedValue(SubscriptionStatus.ACTIVE),
+        };
+        const mockBillingProviderService = {
+          getPrice: vi.fn().mockResolvedValue({ unit_amount: 1000 }),
         };
-        vi.spyOn(InternalTeamBilling.prototype, "getSubscriptionStatus").mockImplementation(
-          mockTeamBillingService.getSubscriptionStatus
+        const { getBillingProviderService, getTeamBillingServiceFactory } = await import(
+          "@calcom/ee/billing/di/containers/Billing"
         );
-
-        mockStripe.prices.retrieve.mockResolvedValue({ id: "price_123", unit_amount: 1000 });
+        vi.mocked(getBillingProviderService).mockReturnValue(mockBillingProviderService);
+        vi.mocked(getTeamBillingServiceFactory).mockReturnValue({
+          init: vi.fn().mockReturnValue(mockTeamBillingService),
+          findAndInit: vi.fn().mockResolvedValue(mockTeamBillingService),
+          findAndInitMany: vi.fn().mockResolvedValue([mockTeamBillingService]),
+        });
 
         const result = await creditService.getMonthlyCredits(1);
         expect(result).toBe(1500); // (3 members * 1000 price) / 2
@@ -495,18 +530,20 @@ describe("CreditService", () => {
         vi.mocked(TeamRepository).mockImplementation(() => mockTeamRepo as unknown as TeamRepository);
 
         const mockTeamBillingService = {
-          getSubscriptionStatus: vi.fn().mockResolvedValue("active"),
+          getSubscriptionStatus: vi.fn().mockResolvedValue(SubscriptionStatus.ACTIVE),
         };
-        vi.spyOn(InternalTeamBilling.prototype, "getSubscriptionStatus").mockImplementation(
-          mockTeamBillingService.getSubscriptionStatus
-        );
+        const { getTeamBillingServiceFactory } = await import("@calcom/ee/billing/di/containers/Billing");
+        vi.mocked(getTeamBillingServiceFactory).mockReturnValue({
+          init: vi.fn().mockReturnValue(mockTeamBillingService),
+          findAndInit: vi.fn().mockResolvedValue(mockTeamBillingService),
+          findAndInitMany: vi.fn().mockResolvedValue([mockTeamBillingService]),
+        });
 
         const result = await creditService.getMonthlyCredits(1);
         expect(result).toBe(3000); // 2 members * 1500 credits per seat
       });
 
       it("should calculate credits for organizations with default 1000 credits per seat", async () => {
-        // Clear ORG_MONTHLY_CREDITS to test default behavior
         vi.stubEnv("ORG_MONTHLY_CREDITS", undefined);
         const mockTeamRepo = {
           findTeamWithMembers: vi.fn().mockResolvedValue({
@@ -518,11 +555,14 @@ describe("CreditService", () => {
         vi.mocked(TeamRepository).mockImplementation(() => mockTeamRepo as unknown as TeamRepository);
 
         const mockTeamBillingService = {
-          getSubscriptionStatus: vi.fn().mockResolvedValue("active"),
+          getSubscriptionStatus: vi.fn().mockResolvedValue(SubscriptionStatus.ACTIVE),
         };
-        vi.spyOn(InternalTeamBilling.prototype, "getSubscriptionStatus").mockImplementation(
-          mockTeamBillingService.getSubscriptionStatus
-        );
+        const { getTeamBillingServiceFactory } = await import("@calcom/ee/billing/di/containers/Billing");
+        vi.mocked(getTeamBillingServiceFactory).mockReturnValue({
+          init: vi.fn().mockReturnValue(mockTeamBillingService),
+          findAndInit: vi.fn().mockResolvedValue(mockTeamBillingService),
+          findAndInitMany: vi.fn().mockResolvedValue([mockTeamBillingService]),
+        });
 
         const result = await creditService.getMonthlyCredits(1);
         expect(result).toBe(3000); // 3 members * 1000 credits per seat (default)