chore: refacto NestJS in modules (#308)

* chore: wip refacto in modules

* fix: rollback port

* fix: jwt guard in wrong folder

* chore: rename folder exception-filter in filters

* fix: tests are running

* fix: excessive stack depth comparing types

* fix: auth issue

* chore: move createUser in UserService

* fix: test

* fix: guards

* fix: jwt guard don't handle falsy user

server/src/core/person/person.resolver.ts

@@ -0,0 +1,83 @@
+import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
+import { Person } from '../../core/@generated/person/person.model';
+import { FindManyPersonArgs } from '../../core/@generated/person/find-many-person.args';
+import { UpdateOnePersonArgs } from '../../core/@generated/person/update-one-person.args';
+import { CreateOnePersonArgs } from '../../core/@generated/person/create-one-person.args';
+import { AffectedRows } from '../../core/@generated/prisma/affected-rows.output';
+import { DeleteManyPersonArgs } from '../../core/@generated/person/delete-many-person.args';
+import { Workspace } from '../../core/@generated/workspace/workspace.model';
+import { AuthWorkspace } from '../../decorators/auth-workspace.decorator';
+import { Prisma } from '@prisma/client';
+import { UpdateOneGuard } from '../../guards/update-one.guard';
+import { DeleteManyGuard } from '../../guards/delete-many.guard';
+import { CreateOneGuard } from '../../guards/create-one.guard';
+import { PersonService } from './person.service';
+import { prepareFindManyArgs } from 'src/utils/prepare-find-many';
+
+@UseGuards(JwtAuthGuard)
+@Resolver(() => Person)
+export class PersonResolver {
+  constructor(private readonly personService: PersonService) {}
+
+  @Query(() => [Person], {
+    nullable: false,
+  })
+  async findManyPerson(
+    @Args() args: FindManyPersonArgs,
+    @AuthWorkspace() workspace: Workspace,
+  ): Promise<Person[]> {
+    const preparedArgs = prepareFindManyArgs<FindManyPersonArgs>(
+      args,
+      workspace,
+    );
+    return this.personService.findMany({
+      ...preparedArgs,
+    });
+  }
+
+  @UseGuards(UpdateOneGuard)
+  @Mutation(() => Person, {
+    nullable: true,
+  })
+  async updateOnePerson(
+    @Args() args: UpdateOnePersonArgs,
+  ): Promise<Person | null> {
+    if (!args.data.company?.connect?.id) {
+      args.data.company = { disconnect: true };
+    }
+
+    return this.personService.update({
+      ...args,
+    } satisfies UpdateOnePersonArgs as Prisma.PersonUpdateArgs);
+  }
+
+  @UseGuards(DeleteManyGuard)
+  @Mutation(() => AffectedRows, {
+    nullable: false,
+  })
+  async deleteManyPerson(
+    @Args() args: DeleteManyPersonArgs,
+  ): Promise<AffectedRows> {
+    return this.personService.deleteMany({
+      ...args,
+    });
+  }
+
+  @UseGuards(CreateOneGuard)
+  @Mutation(() => Person, {
+    nullable: false,
+  })
+  async createOnePerson(
+    @Args() args: CreateOnePersonArgs,
+    @AuthWorkspace() workspace: Workspace,
+  ): Promise<Person> {
+    return this.personService.create({
+      data: {
+        ...args.data,
+        ...{ workspace: { connect: { id: workspace.id } } },
+      },
+    } satisfies CreateOnePersonArgs as Prisma.PersonCreateArgs);
+  }
+}