refactor: create team service (#22036)

* refactor: create team service

* refactor: finish

* tests: add unit test for team service

* Add alternative approach to testing

---------

Co-authored-by: Hariom <[email protected]>
Co-authored-by: Benny Joo <[email protected]>
This commit is contained in:
authored and GitHub committed 2025-07-04 07:45:44 +00:00
1 parent f40a1c92ef
commit 0cdd7c9605
12 files changed
+421 -176

No files matched your search

@@ -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;
@@ -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);
};
@@ -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,7 +36,7 @@ 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);
});
@@ -62,75 +44,94 @@ describe("TeamRepository", () => {
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);
});
});
});
-95
View File
@@ -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 },
+2 -1
View File
@@ -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: {
@@ -0,0 +1,114 @@
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { TeamBilling } from "@calcom/features/ee/billing/teams";
import { deleteDomain } from "@calcom/lib/domainManager/organization";
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { WorkflowService } from "@calcom/lib/server/service/workflows";
import { TeamService } from "./team";
vi.mock("@calcom/features/ee/billing/teams");
vi.mock("@calcom/lib/server/repository/team");
vi.mock("@calcom/lib/server/service/workflows");
vi.mock("@calcom/lib/domainManager/organization");
vi.mock("@calcom/features/ee/teams/lib/removeMember");
class Database {
teams = new Map();
domains = new Set();
billings = new Map();
workflowReminders = new Map();
clear() {
this.teams.clear();
this.domains.clear();
this.billings.clear();
this.workflowReminders.clear();
}
}
// In-memory database for testing
const database = new Database();
const mockTeamBilling = {
cancel: vi.fn(),
updateQuantity: vi.fn(),
publish: vi.fn(),
downgrade: vi.fn(),
};
// Mock implementations that modify the in-memory database
vi.mocked(TeamRepository.deleteById).mockImplementation(async ({ id }) => {
const team = database.teams.get(id);
if (team) {
database.teams.delete(id);
return team;
}
throw new Error(`Team with id ${id} not found`);
});
vi.mocked(deleteDomain).mockImplementation(async (slug) => {
database.domains.delete(slug);
});
vi.mocked(WorkflowService.deleteWorkflowRemindersOfRemovedTeam).mockImplementation(async (teamId) => {
database.workflowReminders.delete(teamId);
});
vi.mocked(TeamBilling.findAndInit).mockImplementation(async (teamId) => {
// Create a team-specific billing mock
const teamSpecificBilling = {
...mockTeamBilling,
teamId,
cancel: vi.fn().mockImplementation(() => {
const billing = database.billings.get(teamId);
if (billing) {
billing.cancelled = true;
}
}),
};
return teamSpecificBilling;
});
describe("TeamService", () => {
beforeEach(() => {
database.clear();
database.teams.set(1, {
id: 1,
name: "Deleted Team",
isOrganization: true,
slug: "deleted-team",
});
database.domains.add("deleted-team");
database.billings.set(1, { teamId: 1, cancelled: false });
database.workflowReminders.set(1, ["reminder1", "reminder2"]);
});
afterEach(() => {
vi.clearAllMocks();
});
describe("delete", () => {
it("should delete team, cancel billing, and clean up", async () => {
const result = await TeamService.delete({ id: 1 });
// Verify the team was deleted from the database
expect(database.teams.has(1)).toBe(false);
// Verify the domain was deleted
expect(database.domains.has("deleted-team")).toBe(false);
// Verify billing was cancelled
expect(database.billings.get(1)?.cancelled).toBe(true);
// Verify workflow reminders were deleted
expect(database.workflowReminders.has(1)).toBe(false);
// Verify the returned team data
expect(result).toEqual({
id: 1,
name: "Deleted Team",
isOrganization: true,
slug: "deleted-team",
});
});
});
});
@@ -0,0 +1,105 @@
import prismaMock from "../../../../tests/libs/__mocks__/prismaMock";
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { TeamBilling } from "@calcom/features/ee/billing/teams";
import { deleteDomain } from "@calcom/lib/domainManager/organization";
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { WorkflowService } from "@calcom/lib/server/service/workflows";
import { MembershipRole } from "@calcom/prisma/enums";
import { TRPCError } from "@trpc/server";
import { TeamService } from "./team";
vi.mock("@calcom/features/ee/billing/teams");
vi.mock("@calcom/lib/server/repository/team");
vi.mock("@calcom/lib/server/service/workflows");
vi.mock("@calcom/lib/domainManager/organization");
vi.mock("@calcom/features/ee/teams/lib/removeMember");
const mockTeamBilling = {
cancel: vi.fn(),
updateQuantity: vi.fn(),
publish: vi.fn(),
downgrade: vi.fn(),
};
vi.mocked(TeamBilling.findAndInit).mockResolvedValue(mockTeamBilling);
describe("TeamService", () => {
beforeEach(() => {
vi.resetAllMocks();
vi.mocked(TeamBilling.findAndInit).mockResolvedValue(mockTeamBilling);
});
afterEach(() => {
vi.clearAllMocks();
});
describe("delete", () => {
it("should delete team, cancel billing, and clean up", async () => {
const mockDeletedTeam = {
id: 1,
name: "Deleted Team",
isOrganization: true,
slug: "deleted-team",
};
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
vi.mocked(TeamRepository.deleteById).mockResolvedValue(mockDeletedTeam);
const result = await TeamService.delete({ id: 1 });
expect(TeamBilling.findAndInit).toHaveBeenCalledWith(1);
expect(mockTeamBilling.cancel).toHaveBeenCalled();
expect(WorkflowService.deleteWorkflowRemindersOfRemovedTeam).toHaveBeenCalledWith(1);
expect(TeamRepository.deleteById).toHaveBeenCalledWith({ id: 1 });
expect(deleteDomain).toHaveBeenCalledWith("deleted-team");
expect(result).toEqual(mockDeletedTeam);
});
});
describe("inviteMemberByToken", () => {
it("should throw error if verification token is not found", async () => {
prismaMock.verificationToken.findFirst.mockResolvedValue(null);
await expect(TeamService.inviteMemberByToken("invalid-token", 1)).rejects.toThrow(TRPCError);
});
it("should create membership and update billing", async () => {
const mockToken = {
teamId: 1,
team: { name: "Test Team" },
expiresInDays: null,
expires: new Date(Date.now() + 86400000),
token: "valid-token",
identifier: "valid-token",
id: "1",
};
prismaMock.verificationToken.findFirst.mockResolvedValue(mockToken);
const result = await TeamService.inviteMemberByToken("valid-token", 1);
expect(prismaMock.membership.create).toHaveBeenCalledWith({
data: {
accepted: false,
createdAt: expect.any(Date),
role: MembershipRole.MEMBER,
teamId: 1,
userId: 1,
},
});
expect(mockTeamBilling.updateQuantity).toHaveBeenCalled();
expect(result).toBe("Test Team");
});
});
describe("publish", () => {
it("should call publish on TeamBilling", async () => {
await TeamService.publish(1);
expect(TeamBilling.findAndInit).toHaveBeenCalledWith(1);
expect(mockTeamBilling.publish).toHaveBeenCalled();
});
});
});
+123
View File
@@ -0,0 +1,123 @@
import { Prisma } from "@prisma/client";
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 { TeamRepository } from "@calcom/lib/server/repository/team";
import { WorkflowService } from "@calcom/lib/server/service/workflows";
import prisma from "@calcom/prisma";
import { MembershipRole } from "@calcom/prisma/enums";
import { TRPCError } from "@trpc/server";
export class TeamService {
/**
* Deletes a team and all its associated data in a safe, transactional order.
* External, critical services like billing are handled first to prevent data inconsistencies.
*/
static async delete({ id }: { id: number }) {
// Step 1: Cancel the external billing subscription first.
// If this fails, the entire operation aborts, leaving the team and its data intact.
// This prevents a state where the user is billed for a deleted team.
const teamBilling = await TeamBilling.findAndInit(id);
await teamBilling.cancel();
// Step 2: Clean up internal, related data like workflow reminders.
try {
await WorkflowService.deleteWorkflowRemindersOfRemovedTeam(id);
} catch (e) {
// Log the error, but don't abort the deletion.
// It's better to have a deleted team with orphaned reminders than to halt the process
// after the subscription has already been canceled.
logger.error(`Failed to delete workflow reminders for team ${id}`, e);
}
// Step 3: Delete the team from the database. This is the core "commit" point.
const deletedTeam = await TeamRepository.deleteById({ id });
// Step 4: Clean up any final, non-critical external state.
if (deletedTeam && deletedTeam.isOrganization && deletedTeam.slug) {
deleteDomain(deletedTeam.slug);
}
return deletedTeam;
}
static async removeMembers(teamIds: number[], memberIds: number[], isOrg = false) {
const deleteMembershipPromises = [];
for (const memberId of memberIds) {
for (const teamId of teamIds) {
deleteMembershipPromises.push(
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);
}
// 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();
}
}
@@ -1,5 +1,5 @@
import { isTeamOwner } from "@calcom/lib/server/queries/teams";
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { TeamService } from "@calcom/lib/server/service/team";
import { TRPCError } from "@trpc/server";
@@ -16,7 +16,7 @@ type DeleteOptions = {
export const deleteHandler = async ({ ctx, input }: DeleteOptions) => {
if (!(await isTeamOwner(ctx.user?.id, input.teamId))) throw new TRPCError({ code: "UNAUTHORIZED" });
return await TeamRepository.deleteById({ id: input.teamId });
return await TeamService.delete({ id: input.teamId });
};
export default deleteHandler;
@@ -1,4 +1,4 @@
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { TeamService } from "@calcom/lib/server/service/team";
import type { TrpcSessionUser } from "@calcom/trpc/server/types";
import type { TInviteMemberByTokenSchemaInputSchema } from "./inviteMemberByToken.schema";
@@ -13,7 +13,7 @@ type InviteMemberByTokenOptions = {
export const inviteMemberByTokenHandler = async ({ ctx, input }: InviteMemberByTokenOptions) => {
const { token } = input;
return TeamRepository.inviteMemberByToken(token, ctx.user.id);
return TeamService.inviteMemberByToken(token, ctx.user.id);
};
export default inviteMemberByTokenHandler;
@@ -5,7 +5,7 @@ import { IS_TEAM_BILLING_ENABLED, WEBAPP_URL } from "@calcom/lib/constants";
import { Redirect } from "@calcom/lib/redirect";
import { isOrganisationAdmin } from "@calcom/lib/server/queries/organisations";
import { isTeamAdmin } from "@calcom/lib/server/queries/teams";
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { TeamService } from "@calcom/lib/server/service/team";
import { teamMetadataSchema } from "@calcom/prisma/zod-utils";
import { TRPCError } from "@trpc/server";
@@ -66,7 +66,7 @@ export const publishHandler = async ({ ctx, input }: PublishOptions) => {
await checkPermissions({ ctx, input });
try {
const { redirectUrl, status } = await TeamRepository.publish(teamId);
const { redirectUrl, status } = await TeamService.publish(teamId);
if (redirectUrl) return { url: redirectUrl, status };
} catch (error) {
/** We return the url for client redirect if needed */
@@ -1,7 +1,7 @@
import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";
import logger from "@calcom/lib/logger";
import { isTeamAdmin, isTeamOwner } from "@calcom/lib/server/queries/teams";
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { TeamService } from "@calcom/lib/server/service/team";
import type { TrpcSessionUser } from "@calcom/trpc/server/types";
import { TRPCError } from "@trpc/server";
@@ -61,7 +61,7 @@ export const removeMemberHandler = async ({ ctx, input }: RemoveMemberOptions) =
message: "You can not remove yourself from a team you own.",
});
await TeamRepository.removeMembers(teamIds, memberIds, isOrg);
await TeamService.removeMembers(teamIds, memberIds, isOrg);
};
export default removeMemberHandler;