[_] fix: get/delete teams endpoints and update team manager

src/modules/workspaces/repositories/team.repository.spec.ts

@@ -216,4 +216,46 @@ describe('SequelizeWorkspaceTeamRepository', () => {
       ]);
     });
   });
+
+  describe('getTeamsUserBelongsTo', () => {
+    it('When teams are not found, then return an empty array', async () => {
+      const memberId = v4();
+      const workspaceId = v4();
+
+      jest.spyOn(workspaceTeamUserModel, 'findAll').mockResolvedValueOnce([]);
+
+      const result = await repository.getTeamsUserBelongsTo(
+        memberId,
+        workspaceId,
+      );
+
+      expect(result).toEqual([]);
+    });
+
+    it('When teams are found, then return the teams the user belongs to', async () => {
+      const memberId = v4();
+      const workspaceId = v4();
+      const team = newWorkspaceTeam({ workspaceId });
+      const teamUser = newWorkspaceTeamUser({ memberId, teamId: team.id });
+
+      jest.spyOn(workspaceTeamUserModel, 'findAll').mockResolvedValueOnce([
+        {
+          ...teamUser.toJSON(),
+          toJSON: jest.fn().mockReturnValue(teamUser),
+          team: {
+            ...team.toJSON(),
+            toJSON: jest.fn().mockReturnValue(team),
+          },
+        },
+      ] as any);
+
+      const result = await repository.getTeamsUserBelongsTo(
+        memberId,
+        workspaceId,
+      );
+
+      expect(result).toEqual([expect.any(WorkspaceTeam)]);
+      expect(result[0].id).toEqual(team.id);
+    });
+  });
 });

src/modules/workspaces/repositories/team.repository.ts

@@ -212,6 +212,21 @@ export class SequelizeWorkspaceTeamRepository {
     return teams.map((team) => this.toDomain(team));
   }
 
+  async getTeamsUserBelongsTo(
+    memberId: WorkspaceTeamUserAttributes['memberId'],
+    workspaceId: WorkspaceAttributes['id'],
+  ): Promise<WorkspaceTeam[]> {
+    const results = await this.teamUserModel.findAll({
+      where: { memberId },
+      include: {
+        model: WorkspaceTeamModel,
+        where: { workspaceId },
+      },
+    });
+
+    return results.map((teamUser) => this.toDomain(teamUser.team));
+  }
+
   toDomain(model: WorkspaceTeamModel): WorkspaceTeam {
     return WorkspaceTeam.build({
       ...model.toJSON(),

src/modules/workspaces/workspaces.controller.ts

@@ -204,7 +204,7 @@ export class WorkspacesController {
     return this.workspaceUseCases.editTeamData(teamId, editTeamBody);
   }
 
-  @Delete('/teams/:teamId')
+  @Delete('/:workspaceId/teams/:teamId')
   @ApiOperation({
     summary: 'Deletes a team in a workspace',
   })
@@ -263,7 +263,7 @@ export class WorkspacesController {
     return this.workspaceUseCases.removeMemberFromTeam(teamId, memberId);
   }
 
-  @Patch('/teams/:teamId/manager')
+  @Patch('/:workspaceId/teams/:teamId/manager')
   @ApiOperation({
     summary: 'Changes the manager of a team',
   })

src/modules/workspaces/workspaces.usecase.spec.ts

@@ -4056,6 +4056,108 @@ describe('WorkspacesUsecases', () => {
           expect(teamRepository.deleteTeamById).toHaveBeenCalledWith(team.id);
         });
       });
+
+      describe('getWorkspaceTeams', () => {
+        it('When workspace is not found, then fail', async () => {
+          const user = newUser();
+          const workspaceId = v4();
+
+          jest.spyOn(workspaceRepository, 'findOne').mockResolvedValue(null);
+
+          await expect(
+            service.getWorkspaceTeams(user, workspaceId),
+          ).rejects.toThrow(BadRequestException);
+        });
+
+        it('When user is the workspace owner, then retrieve all teams except default', async () => {
+          const user = newUser();
+          const workspace = newWorkspace({ owner: user });
+          const teams = [
+            newWorkspaceTeam({ workspaceId: workspace.id }),
+            newWorkspaceTeam({ workspaceId: workspace.id }),
+            newWorkspaceTeam({ workspaceId: workspace.id }),
+          ];
+          const teamsWithMemberCount = [
+            { team: teams[0], membersCount: 5 },
+            { team: teams[1], membersCount: 10 },
+            { team: teams[2], membersCount: 7 },
+          ];
+          const teamsUserBelongsTo = [teams[1]];
+          workspace.defaultTeamId = teams[0].id;
+
+          jest
+            .spyOn(workspaceRepository, 'findOne')
+            .mockResolvedValue(workspace);
+          jest
+            .spyOn(teamRepository, 'getTeamsAndMembersCountByWorkspace')
+            .mockResolvedValue(teamsWithMemberCount);
+          jest
+            .spyOn(teamRepository, 'getTeamsUserBelongsTo')
+            .mockResolvedValue(teamsUserBelongsTo);
+
+          const result = await service.getWorkspaceTeams(user, workspace.id);
+
+          expect(result).toEqual([
+            teamsWithMemberCount[1],
+            teamsWithMemberCount[2],
+          ]);
+        });
+
+        it('When user is not the owner and belongs to a team, then retrieve user teams except default', async () => {
+          const owner = newUser();
+          const user = newUser();
+          const workspace = newWorkspace({ owner });
+          const teams = [
+            newWorkspaceTeam({ workspaceId: workspace.id }),
+            newWorkspaceTeam({ workspaceId: workspace.id }),
+            newWorkspaceTeam({ workspaceId: workspace.id }),
+          ];
+          const teamsWithMemberCount = [
+            { team: teams[0], membersCount: 5 },
+            { team: teams[1], membersCount: 10 },
+            { team: teams[2], membersCount: 7 },
+          ];
+          const teamsUserBelongsTo = [teams[1]];
+          workspace.defaultTeamId = teams[0].id;
+
+          jest
+            .spyOn(workspaceRepository, 'findOne')
+            .mockResolvedValue(workspace);
+          jest
+            .spyOn(teamRepository, 'getTeamsAndMembersCountByWorkspace')
+            .mockResolvedValue(teamsWithMemberCount);
+          jest
+            .spyOn(teamRepository, 'getTeamsUserBelongsTo')
+            .mockResolvedValue(teamsUserBelongsTo);
+
+          const result = await service.getWorkspaceTeams(user, workspace.id);
+
+          expect(result).toEqual([teamsWithMemberCount[1]]);
+        });
+
+        it('When user is not the owner and does not belong to any team, then return empty array', async () => {
+          const owner = newUser();
+          const user = newUser();
+          const workspace = newWorkspace({ owner });
+          const teams = [newWorkspaceTeam({ workspaceId: workspace.id })];
+          const teamsWithMemberCount = [{ team: teams[0], membersCount: 5 }];
+          workspace.defaultTeamId = teams[0].id;
+
+          jest
+            .spyOn(workspaceRepository, 'findOne')
+            .mockResolvedValue(workspace);
+          jest
+            .spyOn(teamRepository, 'getTeamsAndMembersCountByWorkspace')
+            .mockResolvedValue(teamsWithMemberCount);
+          jest
+            .spyOn(teamRepository, 'getTeamsUserBelongsTo')
+            .mockResolvedValue([]);
+
+          const result = await service.getWorkspaceTeams(user, workspace.id);
+
+          expect(result).toEqual([]);
+        });
+      });
     });
 
     describe('deleteWorkspaceContent', () => {

src/modules/workspaces/workspaces.usecase.ts

@@ -1658,16 +1658,22 @@ export class WorkspacesUsecases {
       throw new BadRequestException('Not valid workspace');
     }
 
-    const teamsWithMemberCount =
-      await this.teamRepository.getTeamsAndMembersCountByWorkspace(
-        workspace.id,
-      );
+    const [teamsWithMemberCount, teamsUserBelongsTo] = await Promise.all([
+      this.teamRepository.getTeamsAndMembersCountByWorkspace(workspace.id),
+      this.teamRepository.getTeamsUserBelongsTo(user.uuid, workspace.id),
+    ]);
 
-    const teamsWithouDefaultTeam = teamsWithMemberCount.filter(
-      (teamAndMembers) => workspace.defaultTeamId !== teamAndMembers.team.id,
-    );
+    const isUserOwner = workspace.isUserOwner(user);
+    const userTeamsSet = new Set(teamsUserBelongsTo.map((team) => team.id));
+
+    const filteredTeams = teamsWithMemberCount.filter((teamAndMembers) => {
+      const isDefaultTeam = workspace.defaultTeamId === teamAndMembers.team.id;
+      const isUserTeamMember = userTeamsSet.has(teamAndMembers.team.id);
+
+      return !isDefaultTeam && (isUserOwner || isUserTeamMember);
+    });
 
-    return teamsWithouDefaultTeam;
+    return filteredTeams;
   }
 
   async getWorkspaceMembers(