Workspace member (#552)

* fix: clean small back-end issues

* fix: apollo factory causing infinite loop on token renew

* feat: small refactor and add ability to remove workspace member

* fix: test

server/src/ability/ability.factory.ts

@@ -58,7 +58,9 @@ export class AbilityFactory {
     can(AbilityAction.Update, 'Workspace', { id: workspace.id });
 
     // Workspace Member
-    can(AbilityAction.Read, 'WorkspaceMember', { userId: user.id });
+    can(AbilityAction.Read, 'WorkspaceMember', { workspaceId: workspace.id });
+    can(AbilityAction.Delete, 'WorkspaceMember', { workspaceId: workspace.id });
+    cannot(AbilityAction.Delete, 'WorkspaceMember', { userId: user.id });
 
     // Company
     can(AbilityAction.Read, 'Company', { workspaceId: workspace.id });

server/src/core/workspace/resolvers/workspace-member.resolver.spec.ts

@@ -1,12 +1,24 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { WorkspaceMemberResolver } from './workspace-member.resolver';
+import { WorkspaceMemberService } from '../services/workspace-member.service';
+import { AbilityFactory } from 'src/ability/ability.factory';
 
 describe('WorkspaceMemberResolver', () => {
   let resolver: WorkspaceMemberResolver;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [WorkspaceMemberResolver],
+      providers: [
+        WorkspaceMemberResolver,
+        {
+          provide: WorkspaceMemberService,
+          useValue: {},
+        },
+        {
+          provide: AbilityFactory,
+          useValue: {},
+        },
+      ],
     }).compile();
 
     resolver = module.get<WorkspaceMemberResolver>(WorkspaceMemberResolver);

server/src/core/workspace/resolvers/workspace-member.resolver.ts

@@ -1,5 +1,62 @@
-import { Resolver } from '@nestjs/graphql';
+import { Args, Query, Resolver, Mutation } from '@nestjs/graphql';
 import { WorkspaceMember } from '../../@generated/workspace-member/workspace-member.model';
+import { UseGuards } from '@nestjs/common';
+import { AbilityGuard } from 'src/guards/ability.guard';
+import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
+import {
+  DeleteWorkspaceMemberAbilityHandler,
+  ReadWorkspaceMemberAbilityHandler,
+} from 'src/ability/handlers/workspace-member.ability-handler';
+import { FindManyWorkspaceMemberArgs } from 'src/core/@generated/workspace-member/find-many-workspace-member.args';
+import { UserAbility } from 'src/decorators/user-ability.decorator';
+import { AppAbility } from 'src/ability/ability.factory';
+import {
+  PrismaSelect,
+  PrismaSelector,
+} from 'src/decorators/prisma-select.decorator';
+import { WorkspaceMemberService } from '../services/workspace-member.service';
+import { accessibleBy } from '@casl/prisma';
+import { DeleteOneWorkspaceMemberArgs } from 'src/core/@generated/workspace-member/delete-one-workspace-member.args';
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
 
+@UseGuards(JwtAuthGuard)
 @Resolver(() => WorkspaceMember)
-export class WorkspaceMemberResolver {}
+export class WorkspaceMemberResolver {
+  constructor(
+    private readonly workspaceMemberService: WorkspaceMemberService,
+  ) {}
+
+  @Query(() => [WorkspaceMember])
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(ReadWorkspaceMemberAbilityHandler)
+  async findManyWorkspaceMember(
+    @Args() args: FindManyWorkspaceMemberArgs,
+    @UserAbility() ability: AppAbility,
+    @PrismaSelector({ modelName: 'WorkspaceMember' })
+    prismaSelect: PrismaSelect<'WorkspaceMember'>,
+  ): Promise<Partial<WorkspaceMember>[]> {
+    return this.workspaceMemberService.findMany({
+      ...args,
+      where: args.where
+        ? {
+            AND: [args.where, accessibleBy(ability).WorkspaceMember],
+          }
+        : accessibleBy(ability).WorkspaceMember,
+      select: prismaSelect.value,
+    });
+  }
+
+  @Mutation(() => WorkspaceMember)
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(DeleteWorkspaceMemberAbilityHandler)
+  async deleteWorkspaceMember(
+    @Args() args: DeleteOneWorkspaceMemberArgs,
+    @PrismaSelector({ modelName: 'WorkspaceMember' })
+    prismaSelect: PrismaSelect<'WorkspaceMember'>,
+  ): Promise<Partial<WorkspaceMember>> {
+    return this.workspaceMemberService.delete({
+      where: args.where,
+      select: prismaSelect.value,
+    });
+  }
+}

server/src/core/workspace/resolvers/workspace.resolver.ts

@@ -50,8 +50,8 @@ export class WorkspaceResolver {
   @Query(() => Workspace)
   async currentWorkspace(
     @AuthWorkspace() workspace: Workspace,
-    @PrismaSelector({ modelName: 'User' })
-    prismaSelect: PrismaSelect<'User'>,
+    @PrismaSelector({ modelName: 'Workspace' })
+    prismaSelect: PrismaSelect<'Workspace'>,
   ) {
     const selectedWorkspace = await this.workspaceService.findUnique({
       where: {

server/src/guards/show-one.guard.ts

@@ -1,12 +0,0 @@
-import { CanActivate, Injectable } from '@nestjs/common';
-import { PrismaService } from 'src/database/prisma.service';
-
-@Injectable()
-export class ShowOneGuard implements CanActivate {
-  constructor(private prismaService: PrismaService) {}
-
-  async canActivate(): Promise<boolean> {
-    // TODO
-    return true;
-  }
-}