feat(recover-account): add reset workspace functions (#520)

* feat(recover-account): add reset workspace, remove user from all invited workspaces  functions to workspace usecases

* chore(test): add tests for workspace repository

Author: apsantiso

src/modules/folder/folder.repository.ts

@@ -691,6 +691,27 @@ export class SequelizeFolderRepository implements FolderRepository {
       },
     );
   }
+  async deleteByUserAndUuids(
+    user: User,
+    folderUuids: Folder['uuid'][],
+  ): Promise<void> {
+    await this.folderModel.update(
+      {
+        removed: true,
+        removedAt: new Date(),
+        deleted: true,
+        deletedAt: new Date(),
+      },
+      {
+        where: {
+          userId: user.id,
+          uuid: {
+            [Op.in]: folderUuids,
+          },
+        },
+      },
+    );
+  }
 
   async findAllCursorWhereUpdatedAfter(
     where: Partial<Folder>,

src/modules/folder/folder.usecase.ts

@@ -464,6 +464,11 @@ export class FolderUseCases {
       deletedAt: new Date(),
     });
   }
+
+  async deleteByUuids(user: User, uuids: Folder['uuid'][]): Promise<void> {
+    await this.folderRepository.deleteByUserAndUuids(user, uuids);
+  }
+
   async moveFoldersToTrash(
     user: User,
     folderIds: FolderAttributes['id'][],

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

@@ -665,4 +665,43 @@ describe('SequelizeWorkspaceRepository', () => {
       );
     });
   });
+
+  describe('findWorkspaceUsersByUserUuid', () => {
+    it('When workspaceUsers are found for respective user, then it should return instances of workspaceUser', async () => {
+      const mockUser = newUser();
+      const mockWorkspaceUser = newWorkspaceUser({ memberId: mockUser.uuid });
+      const mockWorkspaceUserModelResponse = {
+        ...mockWorkspaceUser,
+        toJSON: jest.fn().mockReturnValue({
+          ...mockWorkspaceUser,
+        }),
+      };
+
+      jest
+        .spyOn(workspaceUserModel, 'findAll')
+        .mockResolvedValueOnce([mockWorkspaceUserModelResponse] as any);
+
+      const result = await repository.findWorkspaceUsersByUserUuid(
+        mockUser.uuid,
+      );
+
+      expect(result).toBeInstanceOf(Array);
+      expect(result[0]).toBeInstanceOf(WorkspaceUser);
+      expect(result[0].id).toBe(mockWorkspaceUser.id);
+      expect(result[0].memberId).toBe(mockWorkspaceUser.memberId);
+    });
+
+    it('When workspaceUsers are not found for respective user, then it should return empty array', async () => {
+      const mockUser = newUser();
+
+      jest.spyOn(workspaceUserModel, 'findAll').mockResolvedValueOnce([]);
+
+      const result = await repository.findWorkspaceUsersByUserUuid(
+        mockUser.uuid,
+      );
+
+      expect(result).toBeInstanceOf(Array);
+      expect(result.length).toEqual(0);
+    });
+  });
 });

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

@@ -361,6 +361,40 @@ export class SequelizeWorkspaceRepository {
     );
   }
 
+  async findWorkspaceUsersByUserUuid(
+    userUuid: string,
+  ): Promise<WorkspaceUser[]> {
+    const workspaceUsers = await this.modelWorkspaceUser.findAll({
+      where: { memberId: userUuid },
+    });
+    return workspaceUsers.map((user) => this.workspaceUserToDomain(user));
+  }
+
+  async deleteUsersFromWorkspace(
+    workspaceId: WorkspaceUser['id'],
+    memberIds: WorkspaceUser['memberId'][],
+  ): Promise<void> {
+    await this.modelWorkspaceUser.destroy({
+      where: { memberId: { [Op.in]: memberIds }, workspaceId },
+    });
+  }
+
+  async deleteAllInvitationsByWorkspace(
+    workspaceId: WorkspaceAttributes['id'],
+  ): Promise<void> {
+    await this.modelWorkspaceInvite.destroy({
+      where: { workspaceId },
+    });
+  }
+
+  async deleteAllInvitationByUser(
+    userUUid: WorkspaceInviteAttributes['invitedUser'],
+  ): Promise<void> {
+    await this.modelWorkspaceInvite.destroy<WorkspaceInviteModel>({
+      where: { invitedUser: userUUid },
+    });
+  }
+
   async findUserAvailableWorkspaces(userUuid: string) {
     const userWorkspaces = await this.modelWorkspaceUser.findAll({
       where: { memberId: userUuid },

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

@@ -6364,4 +6364,231 @@ describe('WorkspacesUsecases', () => {
       );
     });
   });
+
+  describe('removeUserFromNonOwnedWorkspaces', () => {
+    const user = newUser();
+
+    it('When user owns no workspaces, then it should remove user from all workspaces', async () => {
+      jest.spyOn(workspaceRepository, 'findByOwner').mockResolvedValueOnce([]);
+
+      const memberships = [newWorkspaceUser(), newWorkspaceUser()];
+      jest
+        .spyOn(workspaceRepository, 'findWorkspaceUsersByUserUuid')
+        .mockResolvedValueOnce(memberships);
+
+      const leaveWorkspaceSpy = jest
+        .spyOn(service, 'leaveWorkspace')
+        .mockResolvedValue(undefined);
+
+      await service.removeUserFromNonOwnedWorkspaces(user);
+
+      expect(leaveWorkspaceSpy).toHaveBeenCalledTimes(2);
+      expect(leaveWorkspaceSpy).toHaveBeenCalledWith(
+        memberships[0].workspaceId,
+        user,
+      );
+      expect(leaveWorkspaceSpy).toHaveBeenCalledWith(
+        memberships[1].workspaceId,
+        user,
+      );
+    });
+
+    it('When user owns some workspaces, then it should only remove user from non-owned workspaces', async () => {
+      const ownedWorkspaces = [newWorkspace(), newWorkspace()];
+      const nonOwnedWorkspacesIds = [v4(), v4()];
+
+      jest
+        .spyOn(workspaceRepository, 'findByOwner')
+        .mockResolvedValueOnce(ownedWorkspaces);
+
+      const memberships = [
+        newWorkspaceUser({ workspaceId: ownedWorkspaces[0].id }),
+        newWorkspaceUser({ workspaceId: ownedWorkspaces[1].id }),
+        newWorkspaceUser({ workspaceId: nonOwnedWorkspacesIds[0] }),
+        newWorkspaceUser({ workspaceId: nonOwnedWorkspacesIds[1] }),
+      ];
+      jest
+        .spyOn(workspaceRepository, 'findWorkspaceUsersByUserUuid')
+        .mockResolvedValueOnce(memberships);
+
+      const leaveWorkspaceSpy = jest
+        .spyOn(service, 'leaveWorkspace')
+        .mockResolvedValue(undefined);
+
+      await service.removeUserFromNonOwnedWorkspaces(user);
+
+      expect(leaveWorkspaceSpy).toHaveBeenCalledTimes(2);
+      expect(leaveWorkspaceSpy).toHaveBeenCalledWith(
+        nonOwnedWorkspacesIds[0],
+        user,
+      );
+      expect(leaveWorkspaceSpy).toHaveBeenCalledWith(
+        nonOwnedWorkspacesIds[1],
+        user,
+      );
+    });
+
+    it('When user has no workspace memberships, then it should not call leaveWorkspace', async () => {
+      jest.spyOn(workspaceRepository, 'findByOwner').mockResolvedValueOnce([]);
+
+      jest
+        .spyOn(workspaceRepository, 'findWorkspaceUsersByUserUuid')
+        .mockResolvedValueOnce([]);
+      const leaveWorkspaceSpy = jest.spyOn(service, 'leaveWorkspace');
+
+      await service.removeUserFromNonOwnedWorkspaces(user);
+
+      expect(leaveWorkspaceSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('resetWorkspace', () => {
+    it('When called, then it should reset the workspace by removing all non-owner members and reassigning space', async () => {
+      const workspaceNetworkUserId = v4();
+      const workspaceOwnerId = v4();
+      const workspaceNetworkUser = newUser({
+        attributes: { uuid: workspaceNetworkUserId },
+      });
+      const workspace = newWorkspace({
+        attributes: {
+          workspaceUserId: workspaceNetworkUserId,
+          ownerId: workspaceOwnerId,
+        },
+      });
+      jest
+        .spyOn(userRepository, 'findByUuid')
+        .mockResolvedValueOnce(workspaceNetworkUser);
+
+      const ownerMember = newWorkspaceUser({
+        workspaceId: workspace.id,
+        memberId: workspaceOwnerId,
+      });
+      const nonOwnerMembers = Array.from({ length: 2 }, () =>
+        newWorkspaceUser({
+          workspaceId: workspace.id,
+        }),
+      );
+
+      jest
+        .spyOn(workspaceRepository, 'findWorkspaceUsers')
+        .mockResolvedValueOnce([ownerMember, ...nonOwnerMembers]);
+
+      const deleteFoldersSpy = jest
+        .spyOn(folderUseCases, 'deleteByUuids')
+        .mockResolvedValueOnce(undefined);
+
+      const deleteUsersSpy = jest
+        .spyOn(workspaceRepository, 'deleteUsersFromWorkspace')
+        .mockResolvedValueOnce(undefined);
+
+      const totalSpace = 5000000;
+      jest
+        .spyOn(service, 'getWorkspaceNetworkLimit')
+        .mockResolvedValueOnce(totalSpace);
+
+      const updateUserSpy = jest
+        .spyOn(workspaceRepository, 'updateWorkspaceUserBy')
+        .mockResolvedValueOnce(undefined);
+
+      await service.resetWorkspace(workspace);
+
+      expect(deleteFoldersSpy).toHaveBeenCalledWith(
+        workspaceNetworkUser,
+        expect.arrayContaining([
+          nonOwnerMembers[1].rootFolderId,
+          nonOwnerMembers[0].rootFolderId,
+        ]),
+      );
+
+      expect(deleteUsersSpy).toHaveBeenCalledWith(
+        workspace.id,
+        expect.arrayContaining([
+          nonOwnerMembers[1].memberId,
+          nonOwnerMembers[0].memberId,
+        ]),
+      );
+
+      expect(updateUserSpy).toHaveBeenCalledWith(
+        { workspaceId: workspace.id, memberId: workspace.ownerId },
+        { spaceLimit: totalSpace },
+      );
+    });
+
+    it('When workspace has only the owner as member, it should still update space allocation', async () => {
+      const workspaceNetworkUserId = v4();
+      const workspaceOwnerId = v4();
+      const workspaceNetworkUser = newUser({
+        attributes: { uuid: workspaceNetworkUserId },
+      });
+      const workspace = newWorkspace({
+        attributes: {
+          workspaceUserId: workspaceNetworkUserId,
+          ownerId: workspaceOwnerId,
+        },
+      });
+      jest
+        .spyOn(userRepository, 'findByUuid')
+        .mockResolvedValueOnce(workspaceNetworkUser);
+
+      const ownerMember = newWorkspaceUser({
+        workspaceId: workspace.id,
+        memberId: workspaceOwnerId,
+      });
+
+      jest
+        .spyOn(workspaceRepository, 'findWorkspaceUsers')
+        .mockResolvedValueOnce([ownerMember]);
+
+      const deleteFoldersSpy = jest.spyOn(folderUseCases, 'deleteByUuids');
+
+      const deleteUsersSpy = jest.spyOn(
+        workspaceRepository,
+        'deleteUsersFromWorkspace',
+      );
+
+      const totalSpace = 5000000;
+      jest
+        .spyOn(service, 'getWorkspaceNetworkLimit')
+        .mockResolvedValueOnce(totalSpace);
+
+      const updateUserSpy = jest.spyOn(
+        workspaceRepository,
+        'updateWorkspaceUserBy',
+      );
+
+      await service.resetWorkspace(workspace);
+
+      expect(deleteFoldersSpy).toHaveBeenCalledWith(workspaceNetworkUser, []);
+      expect(deleteUsersSpy).toHaveBeenCalledWith(workspace.id, []);
+
+      expect(updateUserSpy).toHaveBeenCalledWith(
+        { workspaceId: workspace.id, memberId: workspace.ownerId },
+        { spaceLimit: totalSpace },
+      );
+    });
+  });
+
+  describe('emptyAllUserOwnedWorkspaces', () => {
+    it('When user owns multiple workspaces, it should reset all of them', async () => {
+      const user = newUser();
+      const ownedWorkspaces = Array.from({ length: 3 }, () =>
+        newWorkspace({ owner: user }),
+      );
+
+      jest
+        .spyOn(workspaceRepository, 'findByOwner')
+        .mockResolvedValueOnce(ownedWorkspaces);
+
+      const resetWorkspaceSpy = jest
+        .spyOn(service, 'resetWorkspace')
+        .mockResolvedValue(undefined);
+
+      await service.emptyAllUserOwnedWorkspaces(user);
+
+      expect(resetWorkspaceSpy).toHaveBeenCalledTimes(3);
+      expect(resetWorkspaceSpy).toHaveBeenCalledWith(ownedWorkspaces[0]);
+      expect(resetWorkspaceSpy).toHaveBeenCalledWith(ownedWorkspaces[1]);
+      expect(resetWorkspaceSpy).toHaveBeenCalledWith(ownedWorkspaces[2]);
+    });
+  });
 });