refactor: create team service (calcom#22036)

* refactor: create team service

* refactor: finish

* tests: add unit test for team service

* Add alternative approach to testing

---------

Co-authored-by: Hariom <hariombalhara@gmail.com>
Co-authored-by: Benny Joo <sldisek783@gmail.com>

Author: 3 people

apps/web/app/(use-page-wrapper)/(main-nav)/teams/server-page.tsx

@@ -5,6 +5,7 @@ import { unstable_cache } from "next/cache";
 
 import { TeamsListing } from "@calcom/features/ee/teams/components/TeamsListing";
 import { TeamRepository } from "@calcom/lib/server/repository/team";
+import { TeamService } from "@calcom/lib/server/service/team";
 import { meRouter } from "@calcom/trpc/server/routers/viewer/me/_router";
 
 import { TRPCError } from "@trpc/server";
@@ -37,7 +38,7 @@ export const ServerTeamsListing = async ({
 
   if (token) {
     try {
-      teamNameFromInvite = await TeamRepository.inviteMemberByToken(token, userId);
+      teamNameFromInvite = await TeamService.inviteMemberByToken(token, userId);
     } catch (e) {
       errorMsgFromInvite = "Error while fetching teams";
       if (e instanceof TRPCError) errorMsgFromInvite = e.message;

packages/features/ee/workflows/lib/reminders/whatsappReminderManager.ts

@@ -16,7 +16,6 @@ import {
 } from "../reminders/templates/whatsapp/ContentSidMapping";
 import { scheduleSmsOrFallbackEmail, sendSmsOrFallbackEmail } from "./messageDispatcher";
 import type { ScheduleTextReminderArgs, timeUnitLowerCase } from "./smsReminderManager";
-import { deleteScheduledSMSReminder } from "./smsReminderManager";
 import {
   whatsappEventCancelledTemplate,
   whatsappEventCompletedTemplate,
@@ -268,7 +267,3 @@ export const scheduleWhatsappReminder = async (args: ScheduleTextReminderArgs) =
     }
   }
 };
-
-export const deleteScheduledWhatsappReminder = async (reminderId: number, referenceId: string | null) => {
-  return await deleteScheduledSMSReminder(reminderId, referenceId);
-};

packages/lib/server/repository/TeamRepository.test.ts

@@ -1,28 +1,10 @@
 import prismaMock from "../../../../tests/libs/__mocks__/prismaMock";
 
+import type { Team } from "@prisma/client";
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 
-import { TeamBilling } from "@calcom/features/ee/billing/teams";
-
-import { TRPCError } from "@trpc/server";
-
 import { TeamRepository } from "./team";
 
-vi.mock("@calcom/features/ee/billing/teams", () => ({
-  TeamBilling: {
-    findAndInit: vi.fn(),
-    findAndInitMany: vi.fn(),
-  },
-}));
-
-vi.mock("@calcom/lib/domainManager/organization", () => ({
-  deleteDomain: vi.fn(),
-}));
-
-vi.mock("@calcom/features/ee/teams/lib/removeMember", () => ({
-  default: vi.fn(),
-}));
-
 describe("TeamRepository", () => {
   beforeEach(() => {
     vi.resetAllMocks();
@@ -54,83 +36,102 @@ describe("TeamRepository", () => {
         isPlatform: true,
         requestedSlug: null,
       };
-      prismaMock.team.findUnique.mockResolvedValue(mockTeam);
+      prismaMock.team.findUnique.mockResolvedValue(mockTeam as unknown as Team);
       const result = await TeamRepository.findById({ id: 1 });
       expect(result).toEqual(mockTeam);
     });
   });
 
   describe("deleteById", () => {
     it("should delete team and related data", async () => {
-      const mockDeletedTeam = { id: 1, name: "Deleted Team", isOrganization: true, slug: "deleted-team" };
-      prismaMock.team.delete.mockResolvedValue(mockDeletedTeam);
-
-      const mockTeamBilling = { cancel: vi.fn() };
-      TeamBilling.findAndInit.mockResolvedValue(mockTeamBilling);
-
-      // Mock the Prisma transaction
-      const mockTransaction = {
-        eventType: { deleteMany: vi.fn() },
-        membership: { deleteMany: vi.fn() },
-        team: { delete: vi.fn().mockResolvedValue(mockDeletedTeam) },
-      };
-
-      //   Mock the transaction calls so we can spy on it
-      prismaMock.$transaction.mockImplementation((callback) => callback(mockTransaction));
+      const mockDeletedTeam = { id: 1, name: "Deleted Team" };
+      const deleteManyEventTypeMock = vi.fn();
+      const deleteManyMembershipMock = vi.fn();
+      const deleteTeamMock = vi.fn().mockResolvedValue(mockDeletedTeam as unknown as Team);
+      prismaMock.$transaction.mockImplementation(async (callback) => {
+        const mockTx = {
+          ...prismaMock,
+          eventType: {
+            ...prismaMock.eventType,
+            deleteMany: deleteManyEventTypeMock,
+          },
+          membership: {
+            ...prismaMock.membership,
+            deleteMany: deleteManyMembershipMock,
+          },
+          team: {
+            ...prismaMock.team,
+            delete: deleteTeamMock,
+          },
+        };
+        return callback(mockTx);
+      });
 
       const result = await TeamRepository.deleteById({ id: 1 });
 
-      expect(mockTransaction.eventType.deleteMany).toHaveBeenCalledWith({
+      expect(deleteManyEventTypeMock).toHaveBeenCalledWith({
         where: {
           teamId: 1,
           schedulingType: "MANAGED",
         },
       });
-      expect(mockTransaction.membership.deleteMany).toHaveBeenCalledWith({
+      expect(deleteManyMembershipMock).toHaveBeenCalledWith({
         where: {
           teamId: 1,
         },
       });
-      expect(mockTransaction.team.delete).toHaveBeenCalledWith({
+      expect(deleteTeamMock).toHaveBeenCalledWith({
         where: {
           id: 1,
         },
       });
-
-      expect(mockTeamBilling.cancel).toHaveBeenCalled();
       expect(result).toEqual(mockDeletedTeam);
     });
   });
 
-  describe("inviteMemberByToken", () => {
-    it("should throw error if verification token is not found", async () => {
-      prismaMock.verificationToken.findFirst.mockResolvedValue(null);
-      await expect(TeamRepository.inviteMemberByToken("invalid-token", 1)).rejects.toThrow(TRPCError);
-    });
-
-    it("should create membership and update billing", async () => {
-      const mockToken = { teamId: 1, team: { name: "Test Team" } };
-      prismaMock.verificationToken.findFirst.mockResolvedValue(mockToken);
-
-      const mockTeamBilling = { updateQuantity: vi.fn() };
-      TeamBilling.findAndInit.mockResolvedValue(mockTeamBilling);
-
-      const result = await TeamRepository.inviteMemberByToken("valid-token", 1);
-
-      expect(prismaMock.membership.create).toHaveBeenCalled();
-      expect(mockTeamBilling.updateQuantity).toHaveBeenCalled();
-      expect(result).toBe("Test Team");
+  describe("findAllByParentId", () => {
+    it("should return all teams with given parentId", async () => {
+      const mockTeams = [{ id: 1 }, { id: 2 }];
+      prismaMock.team.findMany.mockResolvedValue(mockTeams as unknown as Team[]);
+      const result = await TeamRepository.findAllByParentId({ parentId: 1 });
+      expect(prismaMock.team.findMany).toHaveBeenCalledWith({
+        where: { parentId: 1 },
+        select: {
+          id: true,
+          name: true,
+          slug: true,
+          logoUrl: true,
+          parentId: true,
+          metadata: true,
+          isOrganization: true,
+          organizationSettings: true,
+          isPlatform: true,
+        },
+      });
+      expect(result).toEqual(mockTeams);
     });
   });
 
-  describe("publish", () => {
-    it("should call publish on TeamBilling", async () => {
-      const mockTeamBilling = { publish: vi.fn() };
-      TeamBilling.findAndInit.mockResolvedValue(mockTeamBilling);
-
-      await TeamRepository.publish(1);
-
-      expect(mockTeamBilling.publish).toHaveBeenCalled();
+  describe("findTeamWithMembers", () => {
+    it("should return team with its members", async () => {
+      const mockTeam = { id: 1, members: [] };
+      prismaMock.team.findUnique.mockResolvedValue(mockTeam as unknown as Team & { members: [] });
+      const result = await TeamRepository.findTeamWithMembers(1);
+      expect(prismaMock.team.findUnique).toHaveBeenCalledWith({
+        where: { id: 1 },
+        select: {
+          members: {
+            select: {
+              accepted: true,
+            },
+          },
+          id: true,
+          metadata: true,
+          parentId: true,
+          isOrganization: true,
+        },
+      });
+      expect(result).toEqual(mockTeam);
     });
   });
 });

packages/lib/server/repository/team.ts

@@ -2,17 +2,10 @@ import { Prisma } from "@prisma/client";
 import type { z } from "zod";
 
 import { whereClauseForOrgWithSlugOrRequestedSlug } from "@calcom/ee/organizations/lib/orgDomains";
-import { TeamBilling } from "@calcom/features/ee/billing/teams";
-import removeMember from "@calcom/features/ee/teams/lib/removeMember";
-import { deleteDomain } from "@calcom/lib/domainManager/organization";
 import logger from "@calcom/lib/logger";
 import prisma from "@calcom/prisma";
-import { MembershipRole } from "@calcom/prisma/enums";
 import { teamMetadataSchema } from "@calcom/prisma/zod-utils";
 
-import { TRPCError } from "@trpc/server";
-
-import { WorkflowService } from "../service/workflows";
 import { getParsedTeam } from "./teamUtils";
 
 type TeamGetPayloadWithParsedMetadata<TeamSelect extends Prisma.TeamSelect> =
@@ -220,12 +213,6 @@ export class TeamRepository {
   }
 
   static async deleteById({ id }: { id: number }) {
-    try {
-      await WorkflowService.deleteWorkflowRemindersOfRemovedTeam(id);
-    } catch (e) {
-      console.error(e);
-    }
-
     const deletedTeam = await prisma.$transaction(async (tx) => {
       await tx.eventType.deleteMany({
         where: {
@@ -247,94 +234,12 @@ export class TeamRepository {
         },
       });
 
-      const teamBilling = await TeamBilling.findAndInit(id);
-      await teamBilling.cancel();
       return deletedTeam;
     });
 
-    if (deletedTeam?.isOrganization && deletedTeam.slug) deleteDomain(deletedTeam.slug);
-
     return deletedTeam;
   }
 
-  // TODO: Move errors away from TRPC error to make it more generic
-  static async inviteMemberByToken(token: string, userId: number) {
-    const verificationToken = await prisma.verificationToken.findFirst({
-      where: {
-        token,
-        OR: [{ expiresInDays: null }, { expires: { gte: new Date() } }],
-      },
-      include: {
-        team: {
-          select: {
-            name: true,
-          },
-        },
-      },
-    });
-
-    if (!verificationToken) throw new TRPCError({ code: "NOT_FOUND", message: "Invite not found" });
-    if (!verificationToken.teamId || !verificationToken.team)
-      throw new TRPCError({
-        code: "NOT_FOUND",
-        message: "Invite token is not associated with any team",
-      });
-
-    try {
-      await prisma.membership.create({
-        data: {
-          createdAt: new Date(),
-          teamId: verificationToken.teamId,
-          userId: userId,
-          role: MembershipRole.MEMBER,
-          accepted: false,
-        },
-      });
-    } catch (e) {
-      if (e instanceof Prisma.PrismaClientKnownRequestError) {
-        if (e.code === "P2002") {
-          throw new TRPCError({
-            code: "FORBIDDEN",
-            message: "This user is a member of this team / has a pending invitation.",
-          });
-        }
-      } else throw e;
-    }
-
-    const teamBilling = await TeamBilling.findAndInit(verificationToken.teamId);
-    await teamBilling.updateQuantity();
-
-    return verificationToken.team.name;
-  }
-
-  static async publish(teamId: number) {
-    const teamBilling = await TeamBilling.findAndInit(teamId);
-    return teamBilling.publish();
-  }
-
-  static async removeMembers(teamIds: number[], memberIds: number[], isOrg = false) {
-    const deleteMembershipPromises = [];
-
-    for (const memberId of memberIds) {
-      for (const teamId of teamIds) {
-        deleteMembershipPromises.push(
-          // This removeMember function is from @calcom/features/ee/teams/lib/removeMember.ts we should probably move it to this repository.
-          removeMember({
-            teamId,
-            memberId,
-            isOrg,
-          })
-        );
-      }
-    }
-
-    await Promise.all(deleteMembershipPromises);
-
-    const teamsBilling = await TeamBilling.findAndInitMany(teamIds);
-    const teamBillingPromises = teamsBilling.map((teamBilling) => teamBilling.updateQuantity());
-    await Promise.allSettled(teamBillingPromises);
-  }
-
   static async findTeamWithMembers(teamId: number) {
     return await prisma.team.findUnique({
       where: { id: teamId },

packages/lib/server/repository/workflow.ts

@@ -3,7 +3,6 @@ import { z } from "zod";
 import type { WorkflowType } from "@calcom/ee/workflows/components/WorkflowListPage";
 import { deleteScheduledEmailReminder } from "@calcom/ee/workflows/lib/reminders/emailReminderManager";
 import { deleteScheduledSMSReminder } from "@calcom/ee/workflows/lib/reminders/smsReminderManager";
-import { deleteScheduledWhatsappReminder } from "@calcom/ee/workflows/lib/reminders/whatsappReminderManager";
 import type { WorkflowStep } from "@calcom/ee/workflows/lib/types";
 import { hasFilter } from "@calcom/features/filters/lib/hasFilter";
 import prisma from "@calcom/prisma";
@@ -22,6 +21,8 @@ export const ZGetInputSchema = z.object({
 
 export type TGetInputSchema = z.infer<typeof ZGetInputSchema>;
 
+const deleteScheduledWhatsappReminder = deleteScheduledSMSReminder;
+
 const { include: includedFields } = Prisma.validator<Prisma.WorkflowDefaultArgs>()({
   include: {
     activeOn: {