Merge pull request #382 from internxt/feat/delete-workspace-members

[PB-2446]: feat/remove workspace member from workspace

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

@@ -125,6 +125,25 @@ describe('SequelizeWorkspaceRepository', () => {
       const result = await repository.findWorkspaceUser({ memberId: '1' });
       expect(result).toBeNull();
     });
+
+    it('When a workspace user is searched with a user include, then it should return the user', async () => {
+      const user = newUser();
+      const mockWorworkspaceUserkspaceUser = newWorkspaceUser({
+        memberId: user.uuid,
+        member: user,
+      });
+
+      jest
+        .spyOn(workspaceUserModel, 'findOne')
+        .mockResolvedValueOnce(mockWorworkspaceUserkspaceUser as any);
+
+      const result = await repository.findWorkspaceUser(
+        { memberId: '1' },
+        true,
+      );
+      expect(result).toBeInstanceOf(WorkspaceUser);
+      expect(result.member).toBeInstanceOf(User);
+    });
   });
 
   describe('getSpaceLimitInInvitations', () => {

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

@@ -124,9 +124,11 @@ export class SequelizeWorkspaceRepository {
 
   async findWorkspaceUser(
     where: Partial<WorkspaceUserAttributes>,
+    includeUser = false,
   ): Promise<WorkspaceUser> {
     const workspaceUser = await this.modelWorkspaceUser.findOne({
       where,
+      include: includeUser ? [{ model: UserModel, as: 'member' }] : [],
     });
 
     return workspaceUser ? this.workspaceUserToDomain(workspaceUser) : null;

src/modules/workspaces/workspaces.controller.spec.ts

@@ -631,4 +631,24 @@ describe('Workspace Controller', () => {
       ).resolves.toEqual(workspace.toJSON());
     });
   });
+
+  describe('DELETE /:workspaceId/members/:memberId', () => {
+    it('When a member is removed from the workspace, then it should call the service with the respective arguments', async () => {
+      const workspaceId = v4();
+      const memberId = v4();
+
+      jest
+        .spyOn(workspacesUsecases, 'removeWorkspaceMember')
+        .mockResolvedValue(Promise.resolve());
+
+      await expect(
+        workspacesController.removeWorkspaceMember(workspaceId, memberId),
+      ).resolves.toBeUndefined();
+
+      expect(workspacesUsecases.removeWorkspaceMember).toHaveBeenCalledWith(
+        workspaceId,
+        memberId,
+      );
+    });
+  });
 });

src/modules/workspaces/workspaces.controller.ts

@@ -995,4 +995,25 @@ export class WorkspacesController {
   ) {
     return this.workspaceUseCases.getWorkspaceDetails(workspaceId);
   }
+
+  @Delete(':workspaceId/members/:memberId')
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary: 'Remove member from workspace',
+  })
+  @ApiParam({ name: 'workspaceId', type: String, required: true })
+  @ApiParam({ name: 'memberId', type: String, required: true })
+  @ApiOkResponse({
+    description: 'Member removed from workspace',
+  })
+  @UseGuards(WorkspaceGuard)
+  @WorkspaceRequiredAccess(AccessContext.WORKSPACE, WorkspaceRole.OWNER)
+  async removeWorkspaceMember(
+    @Param('workspaceId', ValidateUUIDPipe)
+    workspaceId: WorkspaceAttributes['id'],
+    @Param('memberId', ValidateUUIDPipe)
+    memberId: WorkspaceTeamAttributes['id'],
+  ) {
+    return this.workspaceUseCases.removeWorkspaceMember(workspaceId, memberId);
+  }
 }

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

@@ -4191,6 +4191,68 @@ describe('WorkspacesUsecases', () => {
       });
     });
 
+    describe('removeMemberFromWorkspace', () => {
+      it('When member is not found, then it should throw', async () => {
+        const workspaceId = v4();
+        const memberId = v4();
+        jest
+          .spyOn(workspaceRepository, 'findWorkspaceUser')
+          .mockResolvedValue(null);
+
+        await expect(
+          service.removeWorkspaceMember(workspaceId, memberId),
+        ).rejects.toThrow(NotFoundException);
+      });
+
+      it('When member is the owner of the workspace, then it should throw', async () => {
+        const owner = newUser();
+        const workspace = newWorkspace({ owner });
+        const workspaceUser = newWorkspaceUser({
+          workspaceId: workspace.id,
+          memberId: owner.uuid,
+          member: owner,
+        });
+
+        jest
+          .spyOn(workspaceRepository, 'findWorkspaceUser')
+          .mockResolvedValue(workspaceUser);
+        jest
+          .spyOn(workspaceRepository, 'findById')
+          .mockResolvedValue(workspace);
+
+        await expect(
+          service.removeWorkspaceMember(workspace.id, owner.uuid),
+        ).rejects.toThrow(BadRequestException);
+      });
+
+      it('When member is not the owner of the workspace, then it should remove the member', async () => {
+        const owner = newUser();
+        const member = newUser();
+        const workspace = newWorkspace({ owner });
+        const workspaceUser = newWorkspaceUser({
+          workspaceId: workspace.id,
+          memberId: member.uuid,
+          member,
+        });
+
+        jest
+          .spyOn(workspaceRepository, 'findWorkspaceUser')
+          .mockResolvedValue(workspaceUser);
+        jest
+          .spyOn(workspaceRepository, 'findById')
+          .mockResolvedValue(workspace);
+        jest.spyOn(workspaceRepository, 'deleteUserFromWorkspace');
+
+        expect(
+          await service.removeWorkspaceMember(workspace.id, member.uuid),
+        ).toBeUndefined();
+
+        expect(
+          workspaceRepository.deleteUserFromWorkspace,
+        ).toHaveBeenCalledWith(member.uuid, workspace.id);
+      });
+    });
+
     describe('leaveWorkspace', () => {
       it('When workspace is not found, then it should throw', async () => {
         const workspaceId = v4();

src/modules/workspaces/workspaces.usecase.ts

@@ -2213,6 +2213,26 @@ export class WorkspacesUsecases {
     await this.folderUseCases.renameFolder(movedFolder, user.username);
   }
 
+  async removeWorkspaceMember(
+    workspaceId: Workspace['id'],
+    memberId: User['uuid'],
+  ): Promise<void> {
+    const workspaceUserToRemove =
+      await this.workspaceRepository.findWorkspaceUser(
+        {
+          workspaceId,
+          memberId,
+        },
+        true,
+      );
+
+    if (!workspaceUserToRemove) {
+      throw new NotFoundException('User not found in workspace');
+    }
+
+    await this.leaveWorkspace(workspaceId, workspaceUserToRemove.member);
+  }
+
   async leaveWorkspace(
     workspaceId: Workspace['id'],
     user: User,
@@ -2246,6 +2266,7 @@ export class WorkspacesUsecases {
       workspaceId,
     );
   }
+
   async validateWorkspaceInvite(
     inviteId: WorkspaceInvite['id'],
   ): Promise<string> {