2060 create a new api key (#2206)

* Add folder for api settings

* Init create api key page

* Update create api key page

* Implement api call to create apiKey

* Add create api key mutation

* Get id when creating apiKey

* Display created Api Key

* Add delete api key button

* Remove button from InputText

* Update stuff

* Add test for ApiDetail

* Fix type

* Use recoil instead of router state

* Remane route paths

* Remove online return

* Move and test date util

* Remove useless Component

* Rename ApiKeys paths

* Rename ApiKeys files

* Add input text info testing

* Rename hooks to webhooks

* Remove console error

* Add tests to reach minimum coverage

server/src/core/web-hook/web-hook.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { PrismaModule } from 'src/database/prisma.module';
+import { AbilityModule } from 'src/ability/ability.module';
+import { WebHookResolver } from 'src/core/web-hook/web-hook.resolver';
+
+@Module({
+  imports: [PrismaModule, AbilityModule],
+  providers: [WebHookResolver],
+})
+export class WebHookModule {}

server/src/core/web-hook/web-hook.resolver.ts

@@ -0,0 +1,72 @@
+import { NotFoundException, UseGuards } from '@nestjs/common';
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+
+import { accessibleBy } from '@casl/prisma';
+
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
+import { AbilityGuard } from 'src/guards/ability.guard';
+import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
+import {
+  CreateWebHookAbilityHandler,
+  DeleteWebHookAbilityHandler,
+  ReadWebHookAbilityHandler,
+} from 'src/ability/handlers/web-hook.ability-handler';
+import { PrismaService } from 'src/database/prisma.service';
+import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
+import { Workspace } from 'src/core/@generated/workspace/workspace.model';
+import { UserAbility } from 'src/decorators/user-ability.decorator';
+import { AppAbility } from 'src/ability/ability.factory';
+import { CreateOneWebHookArgs } from 'src/core/@generated/web-hook/create-one-web-hook.args';
+import { DeleteOneWebHookArgs } from 'src/core/@generated/web-hook/delete-one-web-hook.args';
+import { FindManyWebHookArgs } from 'src/core/@generated/web-hook/find-many-web-hook.args';
+import { WebHook } from 'src/core/@generated/web-hook/web-hook.model';
+
+@UseGuards(JwtAuthGuard)
+@Resolver(() => WebHook)
+export class WebHookResolver {
+  constructor(private readonly prismaService: PrismaService) {}
+  @Mutation(() => WebHook)
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(CreateWebHookAbilityHandler)
+  async createOneWebHook(
+    @Args() args: CreateOneWebHookArgs,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ): Promise<WebHook> {
+    return this.prismaService.client.webHook.create({
+      data: {
+        ...args.data,
+        ...{ workspace: { connect: { id: workspaceId } } },
+      },
+    });
+  }
+
+  @Mutation(() => WebHook, { nullable: false })
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(DeleteWebHookAbilityHandler)
+  async deleteOneWebHook(@Args() args: DeleteOneWebHookArgs): Promise<WebHook> {
+    const hookToDelete = this.prismaService.client.webHook.findUnique({
+      where: args.where,
+    });
+    if (!hookToDelete) {
+      throw new NotFoundException();
+    }
+    return await this.prismaService.client.webHook.delete({
+      where: args.where,
+    });
+  }
+
+  @Query(() => [WebHook])
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(ReadWebHookAbilityHandler)
+  async findManyWebHook(
+    @Args() args: FindManyWebHookArgs,
+    @UserAbility() ability: AppAbility,
+  ) {
+    const filterOptions = [accessibleBy(ability).WorkspaceMember];
+    if (args.where) filterOptions.push(args.where);
+    return this.prismaService.client.webHook.findMany({
+      ...args,
+      where: { AND: filterOptions },
+    });
+  }
+}