Skip to content

Scheduling infrastructure for absolutely everyone.

fix: Consistently remove a member from organization/sub-team/team - through all the APIs and webapp actions (#22806)

Hariom Balhara88bbab216e46
diff --git a/apps/api/v2/package.json b/apps/api/v2/package.json
index 462678e01f0..a2e52710621 100644
--- a/apps/api/v2/package.json
+++ b/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/[email protected]",
+ "@calcom/platform-libraries": "npm:@calcom/[email protected]",
"@calcom/platform-types": "*",
"@calcom/platform-utils": "*",
"@calcom/prisma": "*",
diff --git a/apps/api/v2/src/modules/organizations/memberships/services/organizations-membership.service.ts b/apps/api/v2/src/modules/organizations/memberships/services/organizations-membership.service.ts
index 2e5e818cfd6..feda629b039 100644
--- a/apps/api/v2/src/modules/organizations/memberships/services/organizations-membership.service.ts
+++ b/apps/api/v2/src/modules/organizations/memberships/services/organizations-membership.service.ts
@@ -2,6 +2,8 @@ import { CreateOrgMembershipDto } from "@/modules/organizations/memberships/inpu
import { OrganizationsMembershipRepository } from "@/modules/organizations/memberships/organizations-membership.repository";
import { Injectable, NotFoundException } from "@nestjs/common";
+import { TeamService } from "@calcom/platform-libraries";
+
import { UpdateOrgMembershipDto } from "../inputs/update-organization-membership.input";
import { OrganizationsMembershipOutputService } from "./organizations-membership-output.service";
@@ -62,10 +64,24 @@ export class OrganizationsMembershipService {
}
async deleteOrgMembership(organizationId: number, membershipId: number) {
- const membership = await this.organizationsMembershipRepository.deleteOrgMembership(
+ // Get the membership first to get the userId
+ const membership = await this.organizationsMembershipRepository.findOrgMembership(
organizationId,
membershipId
);
+
+ if (!membership) {
+ throw new NotFoundException(
+ `Membership with id ${membershipId} within organization id ${organizationId} not found`
+ );
+ }
+
+ await TeamService.removeMembers({
+ teamIds: [organizationId],
+ userIds: [membership.userId],
+ isOrg: true,
+ });
+
return this.organizationsMembershipOutputService.getOrgMembershipOutput(membership);
}
diff --git a/apps/api/v2/src/modules/organizations/teams/memberships/organizations-teams-memberships.controller.ts b/apps/api/v2/src/modules/organizations/teams/memberships/organizations-teams-memberships.controller.ts
index 3ca7b6fe8ef..8b9a77366d8 100644
--- a/apps/api/v2/src/modules/organizations/teams/memberships/organizations-teams-memberships.controller.ts
+++ b/apps/api/v2/src/modules/organizations/teams/memberships/organizations-teams-memberships.controller.ts
@@ -20,7 +20,6 @@ import {
OrgTeamMembershipOutputResponseDto,
} from "@/modules/organizations/teams/memberships/outputs/organization-teams-memberships.output";
import { OrganizationsTeamsMembershipsService } from "@/modules/organizations/teams/memberships/services/organizations-teams-memberships.service";
-import { TeamsEventTypesService } from "@/modules/teams/event-types/services/teams-event-types.service";
import { TeamMembershipOutput } from "@/modules/teams/memberships/outputs/team-membership.output";
import {
Controller,
@@ -59,7 +58,6 @@ export class OrganizationsTeamsMembershipsController {
constructor(
private organizationsTeamsMembershipsService: OrganizationsTeamsMembershipsService,
- private teamsEventTypesService: TeamsEventTypesService,
private readonly organizationsRepository: OrganizationsRepository
) {}
@@ -127,8 +125,6 @@ export class OrganizationsTeamsMembershipsController {
membershipId
);
- await this.teamsEventTypesService.deleteUserTeamEventTypesAndHosts(membership.userId, teamId);
-
return {
status: SUCCESS_STATUS,
data: plainToClass(TeamMembershipOutput, membership, { strategy: "excludeAll" }),
diff --git a/apps/api/v2/src/modules/organizations/teams/memberships/services/organizations-teams-memberships.service.ts b/apps/api/v2/src/modules/organizations/teams/memberships/services/organizations-teams-memberships.service.ts
index 08319ec593c..d5e84d5341c 100644
--- a/apps/api/v2/src/modules/organizations/teams/memberships/services/organizations-teams-memberships.service.ts
+++ b/apps/api/v2/src/modules/organizations/teams/memberships/services/organizations-teams-memberships.service.ts
@@ -3,6 +3,8 @@ import { UpdateOrgTeamMembershipDto } from "@/modules/organizations/teams/member
import { OrganizationsTeamsMembershipsRepository } from "@/modules/organizations/teams/memberships/organizations-teams-memberships.repository";
import { Injectable, NotFoundException } from "@nestjs/common";
+import { TeamService } from "@calcom/platform-libraries";
+
@Injectable()
export class OrganizationsTeamsMembershipsService {
constructor(
@@ -58,11 +60,21 @@ export class OrganizationsTeamsMembershipsService {
}
async deleteOrgTeamMembership(organizationId: number, teamId: number, membershipId: number) {
- const teamMembership = await this.organizationsTeamsMembershipsRepository.deleteOrgTeamMembershipById(
+ // First get the membership to get the userId
+ const teamMembership = await this.organizationsTeamsMembershipsRepository.findOrgTeamMembership(
organizationId,
teamId,
membershipId
);
+
+ if (!teamMembership) {
+ throw new NotFoundException(
+ `Membership with id ${membershipId} not found in team ${teamId} of organization ${organizationId}`
+ );
+ }
+
+ await TeamService.removeMembers({ teamIds: [teamId], userIds: [teamMembership.userId], isOrg: false });
+
return teamMembership;
}
}
diff --git a/apps/api/v2/src/modules/teams/event-types/services/teams-event-types.service.ts b/apps/api/v2/src/modules/teams/event-types/services/teams-event-types.service.ts
index d0b2473894e..a1e2003520d 100644
--- a/apps/api/v2/src/modules/teams/event-types/services/teams-event-types.service.ts
+++ b/apps/api/v2/src/modules/teams/event-types/services/teams-event-types.service.ts
@@ -156,17 +156,4 @@ export class TeamsEventTypesService {
return this.eventTypesRepository.deleteEventType(eventTypeId);
}
-
- async deleteUserTeamEventTypesAndHosts(userId: number, teamId: number) {
- try {
- await this.teamsEventTypesRepository.deleteUserManagedTeamEventTypes(userId, teamId);
- await this.teamsEventTypesRepository.removeUserFromTeamEventTypesHosts(userId, teamId);
- } catch (err) {
- this.logger.error("Could not remove user from all team event-types.", {
- error: err,
- userId,
- teamId,
- });
- }
- }
}
diff --git a/apps/api/v2/src/modules/teams/memberships/controllers/teams-memberships.controller.ts b/apps/api/v2/src/modules/teams/memberships/controllers/teams-memberships.controller.ts
index 1d2db3be296..ab3fd1b61d7 100644
--- a/apps/api/v2/src/modules/teams/memberships/controllers/teams-memberships.controller.ts
+++ b/apps/api/v2/src/modules/teams/memberships/controllers/teams-memberships.controller.ts
@@ -3,7 +3,6 @@ import { API_KEY_HEADER } from "@/lib/docs/headers";
import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
-import { TeamsEventTypesService } from "@/modules/teams/event-types/services/teams-event-types.service";
import { CreateTeamMembershipInput } from "@/modules/teams/memberships/inputs/create-team-membership.input";
import { UpdateTeamMembershipInput } from "@/modules/teams/memberships/inputs/update-team-membership.input";
import { CreateTeamMembershipOutput } from "@/modules/teams/memberships/outputs/create-team-membership.output";
@@ -45,10 +44,7 @@ import { SkipTakePagination } from "@calcom/platform-types";
export class TeamsMembershipsController {
private logger = new Logger("TeamsMembershipsController");
- constructor(
- private teamsMembershipsService: TeamsMembershipsService,
- private teamsEventTypesService: TeamsEventTypesService
- ) {}
+ constructor(private teamsMembershipsService: TeamsMembershipsService) {}
@Roles("TEAM_ADMIN")
@Post("/")
@@ -127,7 +123,6 @@ export class TeamsMembershipsController {
membershipId,
body
);
-
if (!currentMembership.accepted && updatedMembership.accepted) {
try {
await updateNewTeamMemberEventTypes(updatedMembership.userId, teamId);
@@ -151,8 +146,6 @@ export class TeamsMembershipsController {
): Promise<DeleteTeamMembershipOutput> {
const membership = await this.teamsMembershipsService.deleteTeamMembership(teamId, membershipId);
- await this.teamsEventTypesService.deleteUserTeamEventTypesAndHosts(membership.userId, teamId);
-
return {
status: SUCCESS_STATUS,
data: plainToClass(TeamMembershipOutput, membership, { strategy: "excludeAll" }),
diff --git a/apps/api/v2/src/modules/teams/memberships/services/teams-memberships.service.ts b/apps/api/v2/src/modules/teams/memberships/services/teams-memberships.service.ts
index 328ac615178..ef96a9180fc 100644
--- a/apps/api/v2/src/modules/teams/memberships/services/teams-memberships.service.ts
+++ b/apps/api/v2/src/modules/teams/memberships/services/teams-memberships.service.ts
@@ -3,6 +3,8 @@ import { UpdateTeamMembershipInput } from "@/modules/teams/memberships/inputs/up
import { TeamsMembershipsRepository } from "@/modules/teams/memberships/teams-memberships.repository";
import { Injectable, NotFoundException } from "@nestjs/common";
+import { TeamService } from "@calcom/platform-libraries";
+
@Injectable()
export class TeamsMembershipsService {
constructor(private readonly teamsMembershipsRepository: TeamsMembershipsRepository) {}
@@ -41,10 +43,15 @@ export class TeamsMembershipsService {
}
async deleteTeamMembership(teamId: number, membershipId: number) {
- const teamMembership = await this.teamsMembershipsRepository.deleteTeamMembershipById(
- teamId,
- membershipId
- );
+ // First get the membership to get the userId
+ const teamMembership = await this.teamsMembershipsRepository.findTeamMembership(teamId, membershipId);
+
+ if (!teamMembership) {
+ throw new NotFoundException(`Membership with id ${membershipId} not found in team ${teamId}`);
+ }
+
+ await TeamService.removeMembers({ teamIds: [teamId], userIds: [teamMembership.userId], isOrg: false });
+
return teamMembership;
}
}
diff --git a/apps/api/v2/test/fixtures/repository/event-types.repository.fixture.ts b/apps/api/v2/test/fixtures/repository/event-types.repository.fixture.ts
index 9dad174ca20..d820808983a 100644
--- a/apps/api/v2/test/fixtures/repository/event-types.repository.fixture.ts
+++ b/apps/api/v2/test/fixtures/repository/event-types.repository.fixture.ts
@@ -59,4 +59,8 @@ export class EventTypesRepositoryFixture {
async delete(eventTypeId: EventType["id"]) {
return this.prismaWriteClient.eventType.delete({ where: { id: eventTypeId } });
}
+
+ async findById(eventTypeId: EventType["id"]) {
+ return this.prismaReadClient.eventType.findUnique({ where: { id: eventTypeId } });
+ }
}
diff --git a/apps/api/v2/test/fixtures/repository/membership.repository.fixture.ts b/apps/api/v2/test/fixtures/repository/membership.repository.fixture.ts
index 74f86ed0204..7613a67119b 100644
--- a/apps/api/v2/test/fixtures/repository/membership.repository.fixture.ts
+++ b/apps/api/v2/test/fixtures/repository/membership.repository.fixture.ts
@@ -35,4 +35,8 @@ export class MembershipRepositoryFixture {
await this.prismaWriteClient.user.update({ where: { id: user.id }, data: { organizationId: org.id } });
return membership;
}
+
+ async findById(membershipId: Membership["id"]) {
+ return this.prismaReadClient.membership.findUnique({ where: { id: membershipId } });
+ }
}
diff --git a/apps/web/app/(use-page-wrapper)/settings/organizations/new/layout.tsx b/apps/web/app/(use-page-wrapper)/settings/organizations/new/layout.tsx
index 136f262d95e..c2c1f0dbeb0 100644
--- a/apps/web/app/(use-page-wrapper)/settings/organizations/new/layout.tsx
+++ b/apps/web/app/(use-page-wrapper)/settings/organizations/new/layout.tsx
@@ -1,4 +1,3 @@
-import { _generateMetadata } from "app/_utils";
import { notFound } from "next/navigation";
import { FeaturesRepository } from "@calcom/features/flags/features.repository";
diff --git a/packages/features/bookings/Booker/components/EventMeta.tsx b/packages/features/bookings/Booker/components/EventMeta.tsx
index 99298dca26d..4caf9ddc616 100644
--- a/packages/features/bookings/Booker/components/EventMeta.tsx
+++ b/packages/features/bookings/Booker/components/EventMeta.tsx
@@ -55,7 +55,7 @@ export const EventMeta = ({
timeZones,
children,
selectedTimeslot,
- roundRobinHideOrgAndTeam
+ roundRobinHideOrgAndTeam,
}: {
event?: Pick<
BookerEvent,
diff --git a/packages/features/ee/dsync/lib/removeUserFromOrg.ts b/packages/features/ee/dsync/lib/removeUserFromOrg.ts
index 006330e0377..cc26ee88692 100644
--- a/packages/features/ee/dsync/lib/removeUserFromOrg.ts
+++ b/packages/features/ee/dsync/lib/removeUserFromOrg.ts
@@ -1,11 +1,7 @@
-import removeMember from "@calcom/features/ee/teams/lib/removeMember";
+import { TeamService } from "@calcom/lib/server/service/teamService";
const removeUserFromOrg = async ({ userId, orgId }: { userId: number; orgId: number }) => {
- return removeMember({
- memberId: userId,
- teamId: orgId,
- isOrg: true,
- });
+ return TeamService.removeMembers({ teamIds: [orgId], userIds: [userId], isOrg: true });
};
export default removeUserFromOrg;
diff --git a/packages/features/ee/teams/lib/removeMember.ts b/packages/features/ee/teams/lib/removeMember.ts
deleted file mode 100644
index 13cc5ffe746..00000000000
--- a/packages/features/ee/teams/lib/removeMember.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import logger from "@calcom/lib/logger";
-import { ProfileRepository } from "@calcom/lib/server/repository/profile";
-import prisma from "@calcom/prisma";
-
-import { TRPCError } from "@trpc/server";
-
-import { deleteWorkfowRemindersOfRemovedMember } from "./deleteWorkflowRemindersOfRemovedMember";
-
-const log = logger.getSubLogger({ prefix: ["removeMember"] });
-
-const removeMember = async ({
- memberId,
- teamId,
- isOrg,
-}: {
- memberId: number;
- teamId: number;
- isOrg: boolean;
-}) => {
- const [membership] = await prisma.$transaction([
- prisma.membership.delete({
- where: {
- userId_teamId: { userId: memberId, teamId: teamId },
- },
- include: {
- user: true,
- team: true,
- },
- }),
- // remove user as host from team events associated with this membership
- prisma.host.deleteMany({
- where: {
- userId: memberId,
- eventType: {
- teamId: teamId,
- },
- },
- }),
- ]);
-
- const team = await prisma.team.findUnique({
- where: { id: teamId },
- select: {
- isOrganization: true,
- organizationSettings: true,
- id: true,
- metadata: true,
- activeOrgWorkflows: true,
- parentId: true,
- },
- });
-
- const foundUser = await prisma.user.findUnique({
- where: { id: memberId },
- select: {
- id: true,
- movedToProfileId: true,
- email: true,
- username: true,
- completedOnboarding: true,
- teams: {
- select: {
- team: {
- select: {
- id: true,
- parentId: true,
- },
- },
- },
- },
- },
- });
-
- if (!team || !foundUser) throw new TRPCError({ code: "NOT_FOUND" });
-
- if (isOrg) {
- log.debug("Removing a member from the organization");
- // Deleting membership from all child teams
- // Delete all sub-team memberships where this team is the organization
- await prisma.membership.deleteMany({
- where: {
- team: {
- parentId: teamId,
- },
- userId: membership.userId,
- },
- });
-
- const userToDeleteMembershipOf = foundUser;
-
- const profileToDelete = await ProfileRepository.findByUserIdAndOrgId({
- userId: userToDeleteMembershipOf.id,
- organizationId: team.id,
- });
-
- if (
- userToDeleteMembershipOf.username &&
- userToDeleteMembershipOf.movedToProfileId === profileToDelete?.id
- ) {
- log.debug("Cleaning up tempOrgRedirect for user", userToDeleteMembershipOf.username);
-
- await prisma.tempOrgRedirect.deleteMany({
- where: {
- from: userToDeleteMembershipOf.username,
- },
- });
- }
-
- await prisma.$transaction([
- prisma.user.update({
- where: { id: membership.userId },
- data: { organizationId: null },
- }),
- ProfileRepository.delete({
- userId: membership.userId,
- organizationId: team.id,
- }),
- prisma.host.deleteMany({
- where: {
- userId: memberId,
- eventType: {
- team: {
- parentId: teamId,
- },
- },
- },
- }),
- ]);
- }
-
- // Deleted managed event types from this team from this member
- await prisma.eventType.deleteMany({
- where: { parent: { teamId: teamId }, userId: membership.userId },
- });
-
- await deleteWorkfowRemindersOfRemovedMember(team, memberId, isOrg);
-
- return { membership };
-};
-
-export default removeMember;
diff --git a/packages/lib/server/service/__tests__/teamService.integration-test.ts b/packages/lib/server/service/__tests__/teamService.integration-test.ts
new file mode 100644
index 00000000000..8ee11501da1
--- /dev/null
+++ b/packages/lib/server/service/__tests__/teamService.integration-test.ts
@@ -0,0 +1,1017 @@
+import type { Team, User } from "@prisma/client";
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+import prisma from "@calcom/prisma";
+import { MembershipRole } from "@calcom/prisma/enums";
+
+import { TeamService } from "../teamService";
+
+vi.mock("@calcom/features/ee/billing/teams", () => {
+ const mockUpdateQuantity = vi.fn().mockResolvedValue(undefined);
+ const mockTeamBilling = {
+ updateQuantity: mockUpdateQuantity,
+ };
+
+ return {
+ TeamBilling: {
+ findAndInitMany: vi.fn().mockResolvedValue([mockTeamBilling]),
+ },
+ };
+});
+
+const createTestUser = async (overrides?: {
+ email?: string;
+ username?: string | null;
+ organizationId?: number | null;
+}) => {
+ const timestamp = Date.now();
+ const randomSuffix = Math.random().toString(36).substring(7);
+
+ return prisma.user.create({
+ data: {
+ email: overrides?.email ?? `test-user-${timestamp}-${randomSuffix}@example.com`,
+ username:
+ overrides?.username === null ? null : overrides?.username ?? `testuser-${timestamp}-${randomSuffix}`,
+ name: "Test User",
+ organizationId: overrides?.organizationId ?? undefined,
+ },
+ });
+};
+
+const createTestTeam = async (overrides?: {
+ name?: string;
+ slug?: string;
+ isOrganization?: boolean;
+ parentId?: number | null;
+}) => {
+ const timestamp = Date.now();
+ const randomSuffix = Math.random().toString(36).substring(7);
+
+ return prisma.team.create({
+ data: {
+ name: overrides?.name ?? `Test Team ${timestamp}-${randomSuffix}`,
+ slug: overrides?.slug ?? `test-team-${timestamp}-${randomSuffix}`,
+ isOrganization: overrides?.isOrganization ?? false,
+ parentId: overrides?.parentId ?? undefined,
+ },
+ });
+};
+
+const createTestMembership = async (
+ userId: number,
+ teamId: number,
+ overrides?: {
+ role?: MembershipRole;
+ accepted?: boolean;
+ }
+) => {
+ return prisma.membership.create({
+ data: {
+ userId,
+ teamId,
+ role: overrides?.role ?? MembershipRole.MEMBER,
+ accepted: overrides?.accepted ?? true,
+ },
+ });
+};
+
+const createTestEventType = async (
+ teamId: number,
+ overrides?: {
+ title?: string;
+ slug?: string;
+ length?: number;
+ parentId?: number;
+ userId?: number;
+ }
+) => {
+ const timestamp = Date.now();
+
+ return prisma.eventType.create({
+ data: {
+ title: overrides?.title ?? `Test Event ${timestamp}`,
+ slug: overrides?.slug ?? `test-event-${timestamp}`,
+ teamId,
+ length: overrides?.length ?? 30,
+ parentId: overrides?.parentId,
+ userId: overrides?.userId,
+ },
+ });
+};
+
+const createTestHost = async (
+ userId: number,
+ eventTypeId: number,
+ overrides?: {
+ isFixed?: boolean;
+ }
+) => {
+ return prisma.host.create({
+ data: {
+ userId,
+ eventTypeId,
+ isFixed: overrides?.isFixed ?? false,
+ },
+ });
+};
+
+const expectMembershipExists = async (userId: number, teamId: number) => {
+ const membership = await prisma.membership.findUnique({
+ where: {
+ userId_teamId: { userId, teamId },
+ },
+ });
+ expect(membership).not.toBeNull();
+};
+
+const expectMembershipNotExists = async (userId: number, teamId: number) => {
+ const membership = await prisma.membership.findUnique({
+ where: {
+ userId_teamId: { userId, teamId },
+ },
+ });
+ expect(membership).toBeNull();
+};
+
+const expectMembershipCount = async (teamId: number, expectedCount: number) => {
+ const count = await prisma.membership.count({
+ where: { teamId },
+ });
+ expect(count).toBe(expectedCount);
+};
+
+const expectUserOrganization = async (userId: number, expectedOrgId: number | null) => {
+ const user = await prisma.user.findUnique({
+ where: { id: userId },
+ select: { organizationId: true },
+ });
+ expect(user?.organizationId).toBe(expectedOrgId);
+};
+
+const expectUserUsername = async (userId: number, expectedUsername: string) => {
+ const user = await prisma.user.findUnique({
+ where: { id: userId },
+ select: { username: true },
+ });
+ expect(user?.username).toBe(expectedUsername);
+};
+
+const cleanupTestData = async (teamIds: number[], userIds: number[]) => {
+ await prisma.host.deleteMany({
+ where: {
+ eventType: {
+ teamId: { in: teamIds },
+ },
+ },
+ });
+
+ await prisma.eventType.deleteMany({
+ where: {
+ teamId: { in: teamIds },
+ },
+ });
+
+ await prisma.membership.deleteMany({
+ where: {
+ OR: teamIds.map((teamId) => ({ teamId })),
+ },
+ });
+
+ await prisma.user.deleteMany({
+ where: {
+ id: { in: userIds },
+ },
+ });
+
+ await prisma.team.deleteMany({
+ where: {
+ id: { in: teamIds },
+ },
+ });
+};
+
+describe("TeamService.removeMembers Integration Tests", () => {
+ let orgTestData: {
+ team: Team;
+ teams: Array<{
+ team: Team;
+ members: User[];
+ }>;
+ members: User[];
+ };
+ let regularTeamTestData: {
+ team: Team;
+ members: User[];
+ };
+ let userWithoutOrg: User;
+
+ beforeEach(async () => {
+ // Create organization structure
+ const orgTeam = await createTestTeam({ isOrganization: true });
+ const subTeam = await createTestTeam({ parentId: orgTeam.id });
+
+ // Create users
+ const orgUser1 = await createTestUser({ organizationId: orgTeam.id });
+ const orgUser2 = await createTestUser({ organizationId: orgTeam.id });
+ const nonOrgUser = await createTestUser();
+
+ // Create regular team
+ const regularTeamEntity = await createTestTeam();
+
+ // Set up memberships
+ await createTestMembership(orgUser1.id, orgTeam.id);
+ await createTestMembership(orgUser2.id, orgTeam.id);
+ await createTestMembership(orgUser1.id, regularTeamEntity.id);
+ await createTestMembership(orgUser2.id, regularTeamEntity.id);
+ await createTestMembership(orgUser1.id, subTeam.id);
+ await createTestMembership(orgUser2.id, subTeam.id);
+ await createTestMembership(nonOrgUser.id, regularTeamEntity.id);
+ await createTestMembership(nonOrgUser.id, subTeam.id);
+
+ // Structure the test data
+ orgTestData = {
+ team: orgTeam,
+ teams: [{
+ team: subTeam,
+ members: [orgUser1, orgUser2]
+ }],
+ members: [orgUser1, orgUser2]
+ };
+
+ regularTeamTestData = {
+ team: regularTeamEntity,
+ members: [orgUser1, orgUser2, nonOrgUser]
+ };
+
+ userWithoutOrg = nonOrgUser;
+ });
+
+ afterEach(async () => {
+ const teamIds = [
+ orgTestData.team.id,
+ ...orgTestData.teams.map(t => t.team.id),
+ regularTeamTestData.team.id
+ ];
+ const userIds = [
+ ...orgTestData.members.map(u => u.id),
+ userWithoutOrg.id
+ ];
+
+ await cleanupTestData(teamIds, userIds);
+ vi.clearAllMocks();
+ });
+
+ describe("Team Removal - Sub-Team/Regular Team", () => {
+ it("should remove members from a single team", async () => {
+ const [orgUser1, orgUser2] = orgTestData.members;
+
+ await TeamService.removeMembers({
+ teamIds: [regularTeamTestData.team.id],
+ userIds: [orgUser1.id, orgUser2.id]
+ });
+
+ await expectMembershipNotExists(orgUser1.id, regularTeamTestData.team.id);
+ await expectMembershipNotExists(orgUser2.id, regularTeamTestData.team.id);
+ await expectMembershipExists(userWithoutOrg.id, regularTeamTestData.team.id);
+
+ await expectMembershipCount(regularTeamTestData.team.id, 1);
+
+ await expectMembershipExists(orgUser1.id, orgTestData.team.id);
+ await expectMembershipExists(orgUser2.id, orgTestData.team.id);
+ });
+
+ it("should remove members from multiple teams", async () => {
+ const [orgUser1] = orgTestData.members;
+ const subTeam = orgTestData.teams[0].team;
+
+ await TeamService.removeMembers({
+ teamIds: [regularTeamTestData.team.id, subTeam.id],
+ userIds: [orgUser1.id]
+ });
+
+ await expectMembershipNotExists(orgUser1.id, regularTeamTestData.team.id);
+ await expectMembershipNotExists(orgUser1.id, subTeam.id);
+
+ await expectMembershipExists(orgTestData.members[1].id, regularTeamTestData.team.id);
+ await expectMembershipExists(userWithoutOrg.id, regularTeamTestData.team.id);
+ await expectMembershipCount(regularTeamTestData.team.id, 2);
+ });
+
+ it("should remove hosts from team events when removing team member", async () => {
+ // Create a team member
+ const teamMember = await createTestUser();
+ await createTestMembership(teamMember.id, regularTeamTestData.team.id);
+
+ // Create multiple event types for the team
+ const teamEvent1 = await createTestEventType(regularTeamTestData.team.id, {
+ title: "Team Event 1",
+ slug: "team-event-1",
+ });
+
+ const teamEvent2 = await createTestEventType(regularTeamTestData.team.id, {
+ title: "Team Event 2",
+ slug: "team-event-2",
+ });
+
+ // Create an event type for another team (should not be affected)
+ const otherTeam = await createTestTeam({ name: "Other Team" });
+ const otherTeamEvent = await createTestEventType(otherTeam.id, {
+ title: "Other Team Event",
+ slug: "other-team-event",
+ });
+
+ // Add the user as host to all events
+ await createTestHost(teamMember.id, teamEvent1.id);
+ await createTestHost(teamMember.id, teamEvent2.id);
+ await createTestHost(teamMember.id, otherTeamEvent.id);
+
+ // Also add another user as host to teamEvent1 (should not be affected)
+ const anotherUser = await createTestUser();
+ await createTestMembership(anotherUser.id, regularTeamTestData.team.id);
+ await createTestHost(anotherUser.id, teamEvent1.id);
+
+ // Verify hosts exist before removal
+ const hostsBefore = await prisma.host.findMany({
+ where: { userId: teamMember.id },
+ });
+ expect(hostsBefore).toHaveLength(3);
+
+ // Remove member from team (not org)
+ await TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [teamMember.id], isOrg: false });
+
+ // Verify hosts for team events were removed
+ const hostsAfterForTeamEvents = await prisma.host.findMany({
+ where: {
+ userId: teamMember.id,
+ eventTypeId: { in: [teamEvent1.id, teamEvent2.id] },
+ },
+ });
+ expect(hostsAfterForTeamEvents).toHaveLength(0);
+
+ // Verify host for other team event still exists
+ const hostsAfterForOtherTeam = await prisma.host.findMany({
+ where: {
+ userId: teamMember.id,
+ eventTypeId: otherTeamEvent.id,
+ },
+ });
+ expect(hostsAfterForOtherTeam).toHaveLength(1);
+
+ // Verify other user's host assignment was not affected
+ const otherUserHosts = await prisma.host.findMany({
+ where: { userId: anotherUser.id },
+ });
+ expect(otherUserHosts).toHaveLength(1);
+ expect(otherUserHosts[0].eventTypeId).toBe(teamEvent1.id);
+
+ // Verify membership was deleted
+ await expectMembershipNotExists(teamMember.id, regularTeamTestData.team.id);
+
+ // Clean up
+ await prisma.eventType.deleteMany({
+ where: { id: { in: [teamEvent1.id, teamEvent2.id, otherTeamEvent.id] } },
+ });
+ await cleanupTestData([otherTeam.id], [teamMember.id, anotherUser.id]);
+ });
+
+ it("should delete managed event types when removing from team", async () => {
+ // Create parent event types
+ const parentEventType1 = await createTestEventType(regularTeamTestData.team.id, {
+ title: "Parent Team Event 1",
+ slug: "parent-team-event-1",
+ });
+
+ const parentEventType2 = await createTestEventType(regularTeamTestData.team.id, {
+ title: "Parent Team Event 2",
+ slug: "parent-team-event-2",
+ });
+
+ // Create managed event types for the user (one per parent)
+ const managedEventType1 = await createTestEventType(regularTeamTestData.team.id, {
+ userId: orgTestData.members[0].id,
+ parentId: parentEventType1.id,
+ title: "Managed Event 1",
+ slug: "managed-event-1",
+ });
+
+ const managedEventType2 = await createTestEventType(regularTeamTestData.team.id, {
+ userId: orgTestData.members[0].id,
+ parentId: parentEventType2.id,
+ title: "Managed Event 2",
+ slug: "managed-event-2",
+ });
+
+ // Create a managed event type for another user (should not be affected)
+ const otherUserManagedEvent = await createTestEventType(regularTeamTestData.team.id, {
+ userId: orgTestData.members[1].id,
+ parentId: parentEventType1.id,
+ title: "Other User Managed Event",
+ slug: "other-user-managed-event",
+ });
+
+ // Remove orgTestData.members[0] from team
+ await TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [orgTestData.members[0].id], isOrg: false });
+
+ // Verify orgTestData.members[0]'s managed event types were deleted
+ const deletedEventType1 = await prisma.eventType.findUnique({
+ where: { id: managedEventType1.id },
+ });
+ expect(deletedEventType1).toBeNull();
+
+ const deletedEventType2 = await prisma.eventType.findUnique({
+ where: { id: managedEventType2.id },
+ });
+ expect(deletedEventType2).toBeNull();
+
+ // Verify parent event types still exist
+ const parentStillExists1 = await prisma.eventType.findUnique({
+ where: { id: parentEventType1.id },
+ });
+ expect(parentStillExists1).not.toBeNull();
+
+ const parentStillExists2 = await prisma.eventType.findUnique({
+ where: { id: parentEventType2.id },
+ });
+ expect(parentStillExists2).not.toBeNull();
+
+ // Verify other user's managed event still exists
+ const otherUserEventStillExists = await prisma.eventType.findUnique({
+ where: { id: otherUserManagedEvent.id },
+ });
+ expect(otherUserEventStillExists).not.toBeNull();
+
+ // Clean up
+ await prisma.eventType.deleteMany({
+ where: { id: { in: [parentEventType1.id, parentEventType2.id, otherUserManagedEvent.id] } },
+ });
+ });
+
+ it("should not modify user organization data when removing from sub-team", async () => {
+ await TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [orgTestData.members[0].id], isOrg: false });
+
+ await expectMembershipNotExists(orgTestData.members[0].id, regularTeamTestData.team.id);
+
+ const user = await prisma.user.findUnique({
+ where: { id: orgTestData.members[0].id },
+ });
+ // When isOrg is false for regular teams, it should not update organizationId or modify username
+ expect(user?.organizationId).toBe(orgTestData.team.id);
+ expect(user?.username).toBe(orgTestData.members[0].username);
+ });
+ });
+
+ describe("Organization Removal", () => {
+ it("should remove members from organization and all sub-teams", async () => {
+ const originalUsername = orgTestData.members[0].username || "";
+
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [orgTestData.members[0].id], isOrg: true });
+
+ await expectMembershipNotExists(orgTestData.members[0].id, orgTestData.team.id);
+ await expectMembershipExists(orgTestData.members[0].id, regularTeamTestData.team.id);
+ await expectMembershipNotExists(orgTestData.members[0].id, orgTestData.teams[0].team.id);
+
+ await expectUserOrganization(orgTestData.members[0].id, null);
+ await expectUserUsername(orgTestData.members[0].id, `${originalUsername}-${orgTestData.members[0].id}`);
+ });
+
+ it("should remove multiple members from organization", async () => {
+ await TeamService.removeMembers({
+ teamIds: [orgTestData.team.id],
+ userIds: [orgTestData.members[0].id, orgTestData.members[1].id],
+ isOrg: true,
+ });
+
+ await expectMembershipNotExists(orgTestData.members[0].id, orgTestData.team.id);
+ await expectMembershipNotExists(orgTestData.members[1].id, orgTestData.team.id);
+ await expectMembershipNotExists(orgTestData.members[0].id, orgTestData.teams[0].team.id);
+ await expectMembershipNotExists(orgTestData.members[1].id, orgTestData.teams[0].team.id);
+
+ await expectMembershipExists(userWithoutOrg.id, orgTestData.teams[0].team.id);
+ });
+
+ it("should delete host assignments when removing from organization", async () => {
+ const eventType = await createTestEventType(orgTestData.teams[0].team.id);
+ await createTestHost(orgTestData.members[0].id, eventType.id);
+
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [orgTestData.members[0].id], isOrg: true });
+
+ const hosts = await prisma.host.findMany({
+ where: {
+ userId: orgTestData.members[0].id,
+ eventTypeId: eventType.id,
+ },
+ });
+ expect(hosts).toHaveLength(0);
+
+ await prisma.eventType.delete({
+ where: { id: eventType.id },
+ });
+ });
+
+ it("should prevent username conflicts when removing from organization", async () => {
+ const sharedUsername = `sharedusername-${Date.now()}`;
+
+ const userInOrg = await createTestUser({
+ username: sharedUsername,
+ organizationId: orgTestData.team.id,
+ });
+ await createTestMembership(userInOrg.id, orgTestData.team.id);
+
+ const userOutsideOrg = await createTestUser({
+ username: sharedUsername,
+ organizationId: null,
+ });
+
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [userInOrg.id], isOrg: true });
+
+ const updatedUser = await prisma.user.findUnique({
+ where: { id: userInOrg.id },
+ });
+ expect(updatedUser?.username).toBe(`${sharedUsername}-${userInOrg.id}`);
+ expect(updatedUser?.organizationId).toBeNull();
+
+ const unchangedUser = await prisma.user.findUnique({
+ where: { id: userOutsideOrg.id },
+ });
+ expect(unchangedUser?.username).toBe(sharedUsername);
+
+ await cleanupTestData([], [userInOrg.id, userOutsideOrg.id]);
+ });
+
+ it("should preserve null username when removing from organization", async () => {
+ const userWithNullUsername = await createTestUser({
+ username: null,
+ organizationId: orgTestData.team.id,
+ });
+ await createTestMembership(userWithNullUsername.id, orgTestData.team.id);
+
+ await TeamService.removeMembers({
+ teamIds: [orgTestData.team.id],
+ userIds: [userWithNullUsername.id],
+ isOrg: true,
+ });
+
+ const updatedUser = await prisma.user.findUnique({
+ where: { id: userWithNullUsername.id },
+ });
+ expect(updatedUser?.username).toBeNull();
+ expect(updatedUser?.organizationId).toBeNull();
+
+ await cleanupTestData([], [userWithNullUsername.id]);
+ });
+
+ it("should delete profile when removing from organization", async () => {
+ const profileUser = await createTestUser({ organizationId: orgTestData.team.id });
+ await createTestMembership(profileUser.id, orgTestData.team.id);
+
+ const profile = await prisma.profile.create({
+ data: {
+ uid: `profile-${Date.now()}`,
+ userId: profileUser.id,
+ organizationId: orgTestData.team.id,
+ username: profileUser.username || "",
+ },
+ });
+
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [profileUser.id], isOrg: true });
+
+ const deletedProfile = await prisma.profile.findUnique({
+ where: { id: profile.id },
+ });
+ expect(deletedProfile).toBeNull();
+
+ await cleanupTestData([], [profileUser.id]);
+ });
+
+ it("should successfully remove member without profile from organization", async () => {
+ const userWithoutProfile = await createTestUser({ organizationId: orgTestData.team.id });
+ await createTestMembership(userWithoutProfile.id, orgTestData.team.id);
+
+ await expect(
+ TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [userWithoutProfile.id], isOrg: true })
+ ).resolves.not.toThrow();
+
+ await expectMembershipNotExists(userWithoutProfile.id, orgTestData.team.id);
+ await cleanupTestData([], [userWithoutProfile.id]);
+ });
+
+ it("should clean up tempOrgRedirect when user movedToProfileId matches", async () => {
+ const userWithProfile = await createTestUser({ organizationId: orgTestData.team.id });
+ await createTestMembership(userWithProfile.id, orgTestData.team.id);
+
+ const profile = await prisma.profile.create({
+ data: {
+ uid: `profile-temp-${Date.now()}`,
+ userId: userWithProfile.id,
+ organizationId: orgTestData.team.id,
+ username: userWithProfile.username || "",
+ },
+ });
+
+ await prisma.user.update({
+ where: { id: userWithProfile.id },
+ data: { movedToProfileId: profile.id },
+ });
+
+ await prisma.tempOrgRedirect.create({
+ data: {
+ type: "User",
+ enabled: true,
+ from: userWithProfile.username || "",
+ fromOrgId: orgTestData.team.id,
+ toUrl: "https://example.com",
+ },
+ });
+
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [userWithProfile.id], isOrg: true });
+
+ const redirects = await prisma.tempOrgRedirect.findMany({
+ where: { from: userWithProfile.username || "" },
+ });
+ expect(redirects).toHaveLength(0);
+
+ await cleanupTestData([], [userWithProfile.id]);
+ });
+
+ it("should append userId to username when removing from organization", async () => {
+ const userWithUsername = await prisma.user.create({
+ data: {
+ email: `member8-acme-${Date.now()}@example.com`,
+ username: "member8-acme",
+ organizationId: orgTestData.team.id,
+ },
+ });
+ await createTestMembership(userWithUsername.id, orgTestData.team.id);
+
+ // Create a profile to match real-world scenario
+ const profile = await prisma.profile.create({
+ data: {
+ uid: `profile-${Date.now()}`,
+ userId: userWithUsername.id,
+ organizationId: orgTestData.team.id,
+ username: "member8-acme", // Profile has same username
+ },
+ });
+
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [userWithUsername.id], isOrg: true });
+
+ const updatedUser = await prisma.user.findUnique({
+ where: { id: userWithUsername.id },
+ });
+
+ // Should append userId to existing username
+ expect(updatedUser?.username).toBe(`member8-acme-${userWithUsername.id}`);
+ expect(updatedUser?.organizationId).toBeNull();
+
+ // Profile should be deleted
+ const deletedProfile = await prisma.profile.findUnique({
+ where: { id: profile.id },
+ });
+ expect(deletedProfile).toBeNull();
+
+ await cleanupTestData([], [userWithUsername.id]);
+ });
+
+ it("should preserve null username even when profile has username", async () => {
+ const userWithNullUsername = await prisma.user.create({
+ data: {
+ email: `null-username-user-${Date.now()}@example.com`,
+ username: null, // User has null username
+ organizationId: orgTestData.team.id,
+ },
+ });
+ await createTestMembership(userWithNullUsername.id, orgTestData.team.id);
+
+ // Create a profile with username
+ const profile = await prisma.profile.create({
+ data: {
+ uid: `profile-null-user-${Date.now()}`,
+ userId: userWithNullUsername.id,
+ organizationId: orgTestData.team.id,
+ username: "member8-acme", // Profile has username
+ },
+ });
+
+ await TeamService.removeMembers({
+ teamIds: [orgTestData.team.id],
+ userIds: [userWithNullUsername.id],
+ isOrg: true,
+ });
+
+ const updatedUser = await prisma.user.findUnique({
+ where: { id: userWithNullUsername.id },
+ });
+
+ // User username remains null because foundUser.username was null
+ expect(updatedUser?.username).toBeNull();
+ expect(updatedUser?.organizationId).toBeNull();
+
+ // Profile should be deleted
+ const deletedProfile = await prisma.profile.findUnique({
+ where: { id: profile.id },
+ });
+ expect(deletedProfile).toBeNull();
+
+ await cleanupTestData([], [userWithNullUsername.id]);
+ });
+
+ it("should append userId to empty username when removing from organization", async () => {
+ const userWithEmptyUsername = await prisma.user.create({
+ data: {
+ email: `empty-username-${Date.now()}@example.com`,
+ username: "", // Empty string, not null
+ organizationId: orgTestData.team.id,
+ },
+ });
+ await createTestMembership(userWithEmptyUsername.id, orgTestData.team.id);
+
+ await TeamService.removeMembers({
+ teamIds: [orgTestData.team.id],
+ userIds: [userWithEmptyUsername.id],
+ isOrg: true,
+ });
+
+ const updatedUser = await prisma.user.findUnique({
+ where: { id: userWithEmptyUsername.id },
+ });
+
+ // Fixed: Empty string usernames should be appended with userId
+ expect(updatedUser?.username).toBe(`-${userWithEmptyUsername.id}`);
+ expect(updatedUser?.organizationId).toBeNull();
+
+ await cleanupTestData([], [userWithEmptyUsername.id]);
+ });
+
+ it("should correctly remove user from organization with sub-team hosts and profile", async () => {
+ // This test simulates exactly what happens in API v2 deletion
+ const apiUser = await prisma.user.create({
+ data: {
+ email: `api-test-${Date.now()}@example.com`,
+ username: "member8-acme", // Using the exact username from the issue
+ organizationId: orgTestData.team.id,
+ },
+ });
+
+ // Create membership in org
+ await createTestMembership(apiUser.id, orgTestData.team.id);
+
+ // Create a sub-team (like in API v2 test)
+ const apiSubTeam = await createTestTeam({
+ parentId: orgTestData.team.id,
+ name: "API Sub Team",
+ });
+
+ // Create membership in sub-team
+ await createTestMembership(apiUser.id, apiSubTeam.id);
+
+ // Create event type in sub-team
+ const apiEventType = await createTestEventType(apiSubTeam.id, {
+ title: "API Team Event",
+ });
+
+ // Add user as host (like in API v2 test)
+ await createTestHost(apiUser.id, apiEventType.id);
+
+ // Create profile (which exists in real scenario)
+ const profile = await prisma.profile.create({
+ data: {
+ uid: `profile-api-${Date.now()}`,
+ userId: apiUser.id,
+ organizationId: orgTestData.team.id,
+ username: "member8-acme",
+ },
+ });
+
+ // Now remove from organization (what API v2 does)
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [apiUser.id], isOrg: true });
+
+ // Check final state
+ const finalUser = await prisma.user.findUnique({
+ where: { id: apiUser.id },
+ select: { id: true, username: true, organizationId: true },
+ });
+
+ // Username should be appended with userId, not null
+ expect(finalUser?.username).toBe(`member8-acme-${apiUser.id}`);
+ expect(finalUser?.organizationId).toBeNull();
+
+ // Verify profile was deleted
+ const deletedProfile = await prisma.profile.findUnique({
+ where: { id: profile.id },
+ });
+ expect(deletedProfile).toBeNull();
+
+ // Verify host was removed
+ const hosts = await prisma.host.findMany({
+ where: { userId: apiUser.id },
+ });
+ expect(hosts).toHaveLength(0);
+
+ await cleanupTestData([apiSubTeam.id], [apiUser.id]);
+ });
+
+ it("should delete managed event types in sub-teams when removing from organization", async () => {
+ // Create another sub-team under the org
+ const secondSubTeam = await createTestTeam({
+ parentId: orgTestData.team.id,
+ name: "Second Sub Team",
+ });
+
+ // Add user to the second sub-team
+ await createTestMembership(orgTestData.members[0].id, secondSubTeam.id);
+
+ // Create parent event types in both sub-teams
+ const parentEventInTeam1 = await createTestEventType(orgTestData.teams[0].team.id, {
+ title: "Parent Event Team 1",
+ slug: "parent-event-team-1",
+ });
+
+ const parentEventInTeam2 = await createTestEventType(secondSubTeam.id, {
+ title: "Parent Event Team 2",
+ slug: "parent-event-team-2",
+ });
+
+ // Create managed events for orgTestData.members[0] in both sub-teams
+ const managedEventTeam1 = await createTestEventType(orgTestData.teams[0].team.id, {
+ userId: orgTestData.members[0].id,
+ parentId: parentEventInTeam1.id,
+ title: "User1 Managed Event Team 1",
+ slug: "user1-managed-event-team-1",
+ });
+
+ const managedEventTeam2 = await createTestEventType(secondSubTeam.id, {
+ userId: orgTestData.members[0].id,
+ parentId: parentEventInTeam2.id,
+ title: "User1 Managed Event Team 2",
+ slug: "user1-managed-event-team-2",
+ });
+
+ // Create managed event for orgTestData.members[1] (should not be affected)
+ const managedEventUser2 = await createTestEventType(orgTestData.teams[0].team.id, {
+ userId: orgTestData.members[1].id,
+ parentId: parentEventInTeam1.id,
+ title: "User2 Managed Event",
+ slug: "user2-managed-event",
+ });
+
+ // Verify managed events exist before removal
+ const eventsBeforeRemoval = await prisma.eventType.findMany({
+ where: {
+ id: { in: [managedEventTeam1.id, managedEventTeam2.id, managedEventUser2.id] },
+ },
+ });
+ expect(eventsBeforeRemoval).toHaveLength(3);
+
+ // Remove orgTestData.members[0] from organization
+ await TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [orgTestData.members[0].id], isOrg: true });
+
+ // Verify orgTestData.members[0]'s managed events in all sub-teams were deleted
+ const deletedEvent1 = await prisma.eventType.findUnique({
+ where: { id: managedEventTeam1.id },
+ });
+ expect(deletedEvent1).toBeNull();
+
+ const deletedEvent2 = await prisma.eventType.findUnique({
+ where: { id: managedEventTeam2.id },
+ });
+ expect(deletedEvent2).toBeNull();
+
+ // Verify parent events still exist
+ const parentEvent1Still = await prisma.eventType.findUnique({
+ where: { id: parentEventInTeam1.id },
+ });
+ expect(parentEvent1Still).not.toBeNull();
+
+ const parentEvent2Still = await prisma.eventType.findUnique({
+ where: { id: parentEventInTeam2.id },
+ });
+ expect(parentEvent2Still).not.toBeNull();
+
+ // Verify orgTestData.members[1]'s managed event was not affected
+ const user2EventStill = await prisma.eventType.findUnique({
+ where: { id: managedEventUser2.id },
+ });
+ expect(user2EventStill).not.toBeNull();
+
+ // Verify memberships were removed from org and all sub-teams
+ await expectMembershipNotExists(orgTestData.members[0].id, orgTestData.team.id);
+ await expectMembershipNotExists(orgTestData.members[0].id, orgTestData.teams[0].team.id);
+ await expectMembershipNotExists(orgTestData.members[0].id, secondSubTeam.id);
+
+ // Clean up
+ await prisma.eventType.deleteMany({
+ where: {
+ id: { in: [parentEventInTeam1.id, parentEventInTeam2.id, managedEventUser2.id] },
+ },
+ });
+ await cleanupTestData([secondSubTeam.id], []);
+ });
+ });
+
+ describe("Common Behaviors and Edge Cases", () => {
+ it("should call TeamBilling.updateQuantity for each team", async () => {
+ const { TeamBilling } = await import("@calcom/features/ee/billing/teams");
+
+ await TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [orgTestData.members[0].id, orgTestData.members[1].id] });
+
+ expect(TeamBilling.findAndInitMany).toHaveBeenCalledWith([regularTeamTestData.team.id]);
+ const mockInstances = await TeamBilling.findAndInitMany([regularTeamTestData.team.id]);
+ expect(mockInstances[0].updateQuantity).toHaveBeenCalled();
+ });
+
+ it("should throw error when membership doesn't exist", async () => {
+ const nonExistentUserId = 999999;
+
+ await expect(
+ TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [nonExistentUserId] })
+ ).rejects.toThrow("Membership not found");
+ });
+
+ it("should gracefully skip when given empty arrays", async () => {
+ await expect(TeamService.removeMembers({ teamIds: [], userIds: [orgTestData.members[0].id] })).resolves.not.toThrow();
+ await expect(TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [] })).resolves.not.toThrow();
+ await expect(TeamService.removeMembers({ teamIds: [], userIds: [] })).resolves.not.toThrow();
+ });
+
+ it("should throw error on second removal attempt of same member", async () => {
+ await TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [orgTestData.members[0].id] });
+
+ await expect(
+ TeamService.removeMembers({ teamIds: [regularTeamTestData.team.id], userIds: [orgTestData.members[0].id] })
+ ).rejects.toThrow("Membership not found");
+ });
+
+ it("should rollback all changes if any operation in transaction fails", async () => {
+ // Create a user and membership for this test
+ const rollbackTestUser = await createTestUser({
+ username: "rollback-test-user",
+ organizationId: orgTestData.team.id,
+ });
+ await createTestMembership(rollbackTestUser.id, orgTestData.team.id);
+
+ // Create sub-team membership
+ const subTeamForRollback = await createTestTeam({
+ parentId: orgTestData.team.id,
+ name: "Rollback Test Sub Team",
+ });
+ await createTestMembership(rollbackTestUser.id, subTeamForRollback.id);
+
+ // Create event type and host
+ const eventType = await createTestEventType(subTeamForRollback.id);
+ await createTestHost(rollbackTestUser.id, eventType.id);
+
+ // Create profile
+ await prisma.profile.create({
+ data: {
+ uid: `profile-rollback-${Date.now()}`,
+ userId: rollbackTestUser.id,
+ organizationId: orgTestData.team.id,
+ username: "rollback-test-user",
+ },
+ });
+
+ // Create another user with the username we would try to update to
+ // This will cause the user.update to fail due to unique constraint
+ const conflictingUser = await createTestUser({
+ username: `rollback-test-user-${rollbackTestUser.id}`, // This is what removeMember would try to set
+ });
+
+ // This should fail because of username unique constraint violation
+ await expect(
+ TeamService.removeMembers({ teamIds: [orgTestData.team.id], userIds: [rollbackTestUser.id], isOrg: true })
+ ).rejects.toThrow();
+
+ // Verify nothing was changed - all data should still exist due to transaction rollback
+ const userAfterFailure = await prisma.user.findUnique({
+ where: { id: rollbackTestUser.id },
+ });
+ expect(userAfterFailure?.username).toBe("rollback-test-user"); // Username unchanged
+ expect(userAfterFailure?.organizationId).toBe(orgTestData.team.id); // Still in org
+
+ // Verify memberships still exist
+ await expectMembershipExists(rollbackTestUser.id, orgTestData.team.id);
+ await expectMembershipExists(rollbackTestUser.id, subTeamForRollback.id);
+
+ // Verify profile still exists
+ const profile = await prisma.profile.findUnique({
+ where: {
+ userId_organizationId: {
+ userId: rollbackTestUser.id,
+ organizationId: orgTestData.team.id,
+ },
+ },
+ });
+ expect(profile).not.toBeNull();
+
+ // Verify host still exists
+ const hosts = await prisma.host.findMany({
+ where: { userId: rollbackTestUser.id, eventTypeId: eventType.id },
+ });
+ expect(hosts).toHaveLength(1);
+
+ // Clean up
+ await prisma.eventType.delete({ where: { id: eventType.id } });
+ await cleanupTestData([subTeamForRollback.id], [rollbackTestUser.id, conflictingUser.id]);
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/lib/server/service/teamService.ts b/packages/lib/server/service/teamService.ts
index 424809e5900..67c679227d7 100644
--- a/packages/lib/server/service/teamService.ts
+++ b/packages/lib/server/service/teamService.ts
@@ -1,16 +1,52 @@
import { Prisma } from "@prisma/client";
import { TeamBilling } from "@calcom/features/ee/billing/teams";
-import removeMember from "@calcom/features/ee/teams/lib/removeMember";
+import { deleteWorkfowRemindersOfRemovedMember } from "@calcom/features/ee/teams/lib/deleteWorkflowRemindersOfRemovedMember";
import { deleteDomain } from "@calcom/lib/domainManager/organization";
import logger from "@calcom/lib/logger";
+import { ProfileRepository } from "@calcom/lib/server/repository/profile";
import { TeamRepository } from "@calcom/lib/server/repository/team";
import { WorkflowService } from "@calcom/lib/server/service/workflows";
import prisma from "@calcom/prisma";
+import type { Membership } from "@calcom/prisma/client";
import { MembershipRole } from "@calcom/prisma/enums";
import { TRPCError } from "@trpc/server";
+const log = logger.getSubLogger({ prefix: ["TeamService"] });
+
+type MembershipWithRelations = Pick<
+ Membership,
+ "id" | "userId" | "teamId" | "role" | "accepted" | "disableImpersonation"
+>;
+
+type TeamWithSettings = {
+ id: number;
+ isOrganization: boolean | null;
+ organizationSettings: unknown;
+ metadata: unknown;
+ activeOrgWorkflows: unknown;
+ parentId: number | null;
+};
+
+type UserWithTeams = {
+ id: number;
+ movedToProfileId: number | null;
+ email: string;
+ username: string | null;
+ completedOnboarding: boolean;
+ teams: {
+ team: {
+ id: number;
+ parentId: number | null;
+ };
+ }[];
+};
+
+export type RemoveMemberResult = {
+ membership: MembershipWithRelations;
+};
+
export class TeamService {
/**
* Deletes a team and all its associated data in a safe, transactional order.
@@ -45,15 +81,23 @@ export class TeamService {
return deletedTeam;
}
- static async removeMembers(teamIds: number[], memberIds: number[], isOrg = false) {
- const deleteMembershipPromises = [];
+ static async removeMembers({
+ teamIds,
+ userIds,
+ isOrg = false,
+ }: {
+ teamIds: number[];
+ userIds: number[];
+ isOrg?: boolean;
+ }) {
+ const deleteMembershipPromises: Promise<RemoveMemberResult>[] = [];
- for (const memberId of memberIds) {
+ for (const userId of userIds) {
for (const teamId of teamIds) {
deleteMembershipPromises.push(
- removeMember({
+ TeamService.removeMember({
teamId,
- memberId,
+ userId,
isOrg,
})
);
@@ -121,4 +165,217 @@ export class TeamService {
const teamBilling = await TeamBilling.findAndInit(teamId);
return teamBilling.publish();
}
+
+ private static async removeMember({
+ userId,
+ teamId,
+ isOrg,
+ }: {
+ userId: number;
+ teamId: number;
+ isOrg: boolean;
+ }) {
+ const membership = await TeamService.fetchMembershipOrThrow(userId, teamId);
+ const team = await TeamService.fetchTeamOrThrow(teamId);
+ const user = await TeamService.fetchUserOrThrow(userId);
+
+ if (isOrg) {
+ log.debug("Removing a member from the organization");
+ await TeamService.removeFromOrganization(membership, team, user);
+ } else {
+ log.debug("Removing a member from a team");
+ await TeamService.removeFromTeam(membership, teamId);
+ }
+
+ await deleteWorkfowRemindersOfRemovedMember(team, userId, isOrg);
+
+ return { membership };
+ }
+
+ // TODO: Needs to be moved to repository
+ private static async fetchMembershipOrThrow(
+ userId: number,
+ teamId: number
+ ): Promise<MembershipWithRelations> {
+ const membership = await prisma.membership.findUnique({
+ where: {
+ userId_teamId: { userId: userId, teamId: teamId },
+ },
+ select: {
+ id: true,
+ userId: true,
+ teamId: true,
+ role: true,
+ accepted: true,
+ disableImpersonation: true,
+ },
+ });
+
+ if (!membership) {
+ throw new TRPCError({ code: "NOT_FOUND", message: "Membership not found" });
+ }
+
+ return membership;
+ }
+
+ // TODO: Needs to be moved to repository
+ private static async fetchTeamOrThrow(teamId: number): Promise<TeamWithSettings> {
+ const team = await prisma.team.findUnique({
+ where: { id: teamId },
+ select: {
+ isOrganization: true,
+ organizationSettings: true,
+ id: true,
+ metadata: true,
+ activeOrgWorkflows: true,
+ parentId: true,
+ },
+ });
+
+ if (!team) {
+ throw new TRPCError({ code: "NOT_FOUND", message: "Team not found" });
+ }
+
+ return team;
+ }
+
+ // TODO: Needs to be moved to repository
+ private static async fetchUserOrThrow(userId: number): Promise<UserWithTeams> {
+ const user = await prisma.user.findUnique({
+ where: { id: userId },
+ select: {
+ id: true,
+ movedToProfileId: true,
+ email: true,
+ username: true,
+ completedOnboarding: true,
+ teams: {
+ select: {
+ team: {
+ select: {
+ id: true,
+ parentId: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ if (!user) {
+ throw new TRPCError({ code: "NOT_FOUND", message: "User not found" });
+ }
+
+ return user;
+ }
+
+ // TODO: Needs to be moved to repository
+ private static async cleanupTempOrgRedirect(user: UserWithTeams, team: TeamWithSettings) {
+ const profileToDelete = await ProfileRepository.findByUserIdAndOrgId({
+ userId: user.id,
+ organizationId: team.id,
+ });
+
+ if (user.username && user.movedToProfileId === profileToDelete?.id) {
+ log.debug("Cleaning up tempOrgRedirect for user", user.username);
+ await prisma.tempOrgRedirect.deleteMany({
+ where: {
+ from: user.username,
+ },
+ });
+ }
+ }
+
+ private static async removeFromOrganization(
+ membership: MembershipWithRelations,
+ team: TeamWithSettings,
+ user: UserWithTeams
+ ) {
+ await TeamService.cleanupTempOrgRedirect(user, team);
+ const newUsername = generateNewUsername(user);
+
+ await prisma.$transaction([
+ // Remove user from all sub-teams event type hosts
+ prisma.host.deleteMany({
+ where: {
+ userId: membership.userId,
+ eventType: {
+ team: {
+ parentId: team.id,
+ },
+ },
+ },
+ }),
+ // Delete managed child events in sub-teams
+ prisma.eventType.deleteMany({
+ where: {
+ userId: membership.userId,
+ parent: {
+ team: {
+ parentId: team.id,
+ },
+ },
+ },
+ }),
+ // Remove organizationId from the user
+ prisma.user.update({
+ where: { id: membership.userId },
+ data: {
+ organizationId: null,
+ username: newUsername,
+ },
+ }),
+ // Delete the profile of the user from the organization
+ ProfileRepository.delete({
+ userId: membership.userId,
+ organizationId: team.id,
+ }),
+ // Delete all sub-team memberships where this team is the organization
+ prisma.membership.deleteMany({
+ where: {
+ team: {
+ parentId: team.id,
+ },
+ userId: membership.userId,
+ },
+ }),
+ // Delete the membership of the user from the organization
+ prisma.membership.delete({
+ where: {
+ userId_teamId: { userId: membership.userId, teamId: team.id },
+ },
+ }),
+ ]);
+
+ // Generate new username for user leaving organization
+ function generateNewUsername(user: UserWithTeams): string | null {
+ // We ensure that new username would be unique across all users in the global namespace outside any organization
+ return user.username != null ? `${user.username}-${user.id}` : null;
+ }
+ }
+
+ // Remove member from regular team
+ private static async removeFromTeam(membership: MembershipWithRelations, teamId: number) {
+ await prisma.$transaction([
+ // Remove user from all team event types' hosts
+ prisma.host.deleteMany({
+ where: {
+ userId: membership.userId,
+ eventType: {
+ teamId: teamId,
+ },
+ },
+ }),
+ // Deleted managed event types from this team for this member
+ prisma.eventType.deleteMany({
+ where: { parent: { teamId: teamId }, userId: membership.userId },
+ }),
+ // Delete the membership of the user from the team
+ prisma.membership.delete({
+ where: {
+ userId_teamId: { userId: membership.userId, teamId: teamId },
+ },
+ }),
+ ]);
+ }
}
diff --git a/packages/platform/libraries/index.ts b/packages/platform/libraries/index.ts
index 0c35a53cfb5..c6da1488ea3 100644
--- a/packages/platform/libraries/index.ts
+++ b/packages/platform/libraries/index.ts
@@ -120,4 +120,5 @@ export { checkAdminOrOwner } from "@calcom/features/auth/lib/checkAdminOrOwner";
export { verifyPhoneNumber, sendVerificationCode };
+export { TeamService } from "@calcom/lib/server/service/teamService";
export { CacheService } from "@calcom/features/calendar-cache/lib/getShouldServeCache";
diff --git a/packages/trpc/server/routers/viewer/teams/removeMember.handler.ts b/packages/trpc/server/routers/viewer/teams/removeMember.handler.ts
index 1b630e4cd43..1ce45d95f79 100644
--- a/packages/trpc/server/routers/viewer/teams/removeMember.handler.ts
+++ b/packages/trpc/server/routers/viewer/teams/removeMember.handler.ts
@@ -59,7 +59,7 @@ export const removeMemberHandler = async ({ ctx, input }: RemoveMemberOptions) =
message: "You can not remove yourself from a team you own.",
});
- await TeamService.removeMembers(teamIds, memberIds, isOrg);
+ await TeamService.removeMembers({ teamIds, userIds: memberIds, isOrg });
};
export default removeMemberHandler;
diff --git a/packages/trpc/server/routers/viewer/teams/removeMember.test.ts b/packages/trpc/server/routers/viewer/teams/removeMember.test.ts
deleted file mode 100644
index b9e380336be..00000000000
--- a/packages/trpc/server/routers/viewer/teams/removeMember.test.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-nocheck
-// TODO: Bring this test back with the correct setup (no illegal imports)
-import prismaMock from "../../../../../../tests/libs/__mocks__/prisma";
-
-import { describe, test, expect } from "vitest";
-
-import { SchedulingType, MembershipRole } from "@calcom/prisma/enums";
-
-import type { TrpcSessionUser } from "../../../types";
-import removeMember from "./removeMember.handler";
-
-describe.skip("removeMember", () => {
- describe("should remove a member from a team", () => {
- test(`1) Should remove a member from a team
- 2) Should remove the member from hosts
- `, async () => {
- const org = await createOrganization({
- name: "Test Org",
- slug: "testorg",
- });
-
- // Create the child team
- const childTeam = {
- id: 202,
- name: "Team 1",
- slug: "team-1",
- parentId: org.id,
- };
-
- const organizer = getOrganizer({
- name: "Organizer",
- email: "[email protected]",
- id: 101,
- organizationId: org.id,
- schedules: [TestData.schedules.IstWorkHours],
- teams: [
- {
- membership: {
- accepted: true,
- role: MembershipRole.ADMIN,
- },
- team: {
- id: org.id,
- name: "Test Org",
- slug: "testorg",
- },
- },
- {
- membership: {
- accepted: true,
- role: MembershipRole.ADMIN,
- },
- team: {
- id: childTeam.id,
- name: "Team 1",
- slug: "team-1",
- parentId: org.id,
- },
- },
- ],
- });
-
- const otherTeamMembers = [
- {
- name: "Other Team Member 1",
- username: "other-team-member-1",
- timeZone: Timezones["+5:30"],
- defaultScheduleId: null,
- email: "[email protected]",
- id: 102,
- organizationId: org.id,
- schedules: [TestData.schedules.IstEveningShift],
- teams: [
- {
- membership: {
- accepted: true,
- role: MembershipRole.MEMBER,
- },
- team: {
- id: org.id,
- name: "Test Org",
- slug: "testorg",
- },
- },
- {
- membership: {
- accepted: true,
- role: MembershipRole.MEMBER,
- },
- team: {
- id: childTeam.id,
- name: "Team 1",
- slug: "team-1",
- parentId: org.id,
- },
- },
- ],
- },
- ];
-
- await createBookingScenario(
- getScenarioData(
- {
- eventTypes: [
- {
- id: 1,
- teamId: childTeam.id,
- schedulingType: SchedulingType.ROUND_ROBIN,
- length: 30,
- hosts: [
- {
- userId: 101,
- isFixed: false,
- },
- {
- userId: 102,
- isFixed: false,
- },
- ],
- },
- ],
- organizer,
- usersApartFromOrganizer: otherTeamMembers,
- apps: [TestData.apps["daily-video"]],
- },
- org
- )
- );
-
- //Logged in user is admin of the org
- const ctx = {
- user: {
- id: organizer.id,
- name: organizer.name,
- } as NonNullable<TrpcSessionUser>,
- };
-
- await removeMember({
- ctx,
- input: {
- teamIds: [org.id],
- memberIds: [102],
- isOrg: true,
- },
- });
-
- //Check if the remaining memberships are correct
- const remainingMemberships = await prismaMock.membership.count({
- where: {
- teamId: childTeam.id,
- },
- });
-
- expect(remainingMemberships).toBe(1);
-
- //Check if the event type has the correct hosts
- const remainingHostsCount = await prismaMock.host.count({
- where: {
- eventTypeId: 1,
- },
- });
-
- expect(remainingHostsCount).toBe(1);
- });
- });
-});
diff --git a/yarn.lock b/yarn.lock
index d6513632a03..bd6a988cad2 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2500,7 +2500,7 @@ __metadata:
"@axiomhq/winston": ^1.2.0
"@calcom/platform-constants": "*"
"@calcom/platform-enums": "*"
- "@calcom/platform-libraries": "npm:@calcom/[email protected]"
+ "@calcom/platform-libraries": "npm:@calcom/[email protected]"
"@calcom/platform-types": "*"
"@calcom/platform-utils": "*"
"@calcom/prisma": "*"
@@ -3559,13 +3559,13 @@ __metadata:
languageName: unknown
linkType: soft
-"@calcom/platform-libraries@npm:@calcom/[email protected]":
- version: 0.0.312
- resolution: "@calcom/platform-libraries@npm:0.0.312"
+"@calcom/platform-libraries@npm:@calcom/[email protected]":
+ version: 0.0.314
+ resolution: "@calcom/platform-libraries@npm:0.0.314"
dependencies:
"@calcom/features": "*"
"@calcom/lib": "*"
- checksum: 46520737404a61f3aa96c6f1adfa81e67f645fd984f495662ca7c63184b0310117a1dad57ddbe7ea487f2e5a0c9cbe62749a9a43b3197a021b19e3ccadc1f5b2
+ checksum: b59eb591273334ed7d7d07a8f0518eb8cb40255883dff49626f85d3bd804db4da357bf77cd4f7b14ae0743d0a699647232b39956af9123bdc5e7b2458cab30eb
languageName: node
linkType: hard