feat: prisma typed select (#347)

* feat: wip prisma gql select

* feat: stronger api using decorator

* feat: add PrismaSelect everywhere

* fix: remove unused

* fix: remove seed debug

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

@@ -1,39 +1,29 @@
 import * as TypeGraphQL from '@nestjs/graphql';
 import { CommentThread } from 'src/core/@generated/comment-thread/comment-thread.model';
 import { Comment } from 'src/core/@generated/comment/comment.model';
-import { Company } from 'src/core/@generated/company/company.model';
 import { Person } from 'src/core/@generated/person/person.model';
-import { PersonService } from './person.service';
 import { CommentThreadService } from '../comment/services/comment-thread.service';
 import { CommentService } from '../comment/services/comment.service';
+import {
+  PrismaSelect,
+  PrismaSelector,
+} from 'src/decorators/prisma-select.decorator';
 
 @TypeGraphQL.Resolver(() => Person)
 export class PersonRelationsResolver {
   constructor(
-    private readonly personService: PersonService,
     private readonly commentThreadService: CommentThreadService,
     private readonly commentService: CommentService,
   ) {}
 
-  @TypeGraphQL.ResolveField(() => Company, {
-    nullable: true,
-  })
-  async company(@TypeGraphQL.Parent() person: Person): Promise<Company | null> {
-    return await this.personService
-      .findUniqueOrThrow({
-        where: {
-          id: person.id,
-        },
-      })
-      .company({});
-  }
-
   @TypeGraphQL.ResolveField(() => [CommentThread], {
     nullable: false,
   })
   async commentThreads(
     @TypeGraphQL.Root() person: Person,
-  ): Promise<CommentThread[]> {
+    @PrismaSelector({ modelName: 'CommentThread' })
+    prismaSelect: PrismaSelect<'CommentThread'>,
+  ): Promise<Partial<CommentThread>[]> {
     return await this.commentThreadService.findMany({
       where: {
         commentThreadTargets: {
@@ -43,13 +33,18 @@ export class PersonRelationsResolver {
           },
         },
       },
+      select: prismaSelect.value,
     });
   }
 
   @TypeGraphQL.ResolveField(() => [Comment], {
     nullable: false,
   })
-  async comments(@TypeGraphQL.Root() person: Person): Promise<Comment[]> {
+  async comments(
+    @TypeGraphQL.Root() person: Person,
+    @PrismaSelector({ modelName: 'Comment' })
+    prismaSelect: PrismaSelect<'Comment'>,
+  ): Promise<Partial<Comment>[]> {
     return this.commentService.findMany({
       where: {
         commentThread: {
@@ -61,6 +56,7 @@ export class PersonRelationsResolver {
           },
         },
       },
+      select: prismaSelect.value,
     });
   }
 

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

@@ -15,6 +15,10 @@ 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';
+import {
+  PrismaSelect,
+  PrismaSelector,
+} from 'src/decorators/prisma-select.decorator';
 
 @UseGuards(JwtAuthGuard)
 @Resolver(() => Person)
@@ -27,13 +31,17 @@ export class PersonResolver {
   async findManyPerson(
     @Args() args: FindManyPersonArgs,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<Person[]> {
+    @PrismaSelector({ modelName: 'Person' })
+    prismaSelect: PrismaSelect<'Person'>,
+  ): Promise<Partial<Person>[]> {
     const preparedArgs = prepareFindManyArgs<FindManyPersonArgs>(
       args,
       workspace,
     );
+
     return this.personService.findMany({
       ...preparedArgs,
+      select: prismaSelect.value,
     });
   }
 
@@ -43,14 +51,17 @@ export class PersonResolver {
   })
   async updateOnePerson(
     @Args() args: UpdateOnePersonArgs,
-  ): Promise<Person | null> {
+    @PrismaSelector({ modelName: 'Person' })
+    prismaSelect: PrismaSelect<'Person'>,
+  ): Promise<Partial<Person> | null> {
     if (!args.data.company?.connect?.id) {
       args.data.company = { disconnect: true };
     }
 
     return this.personService.update({
       ...args,
-    } satisfies UpdateOnePersonArgs as Prisma.PersonUpdateArgs);
+      select: prismaSelect.value,
+    } as Prisma.PersonUpdateArgs);
   }
 
   @UseGuards(DeleteManyGuard)
@@ -72,12 +83,15 @@ export class PersonResolver {
   async createOnePerson(
     @Args() args: CreateOnePersonArgs,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<Person> {
+    @PrismaSelector({ modelName: 'Person' })
+    prismaSelect: PrismaSelect<'Person'>,
+  ): Promise<Partial<Person>> {
     return this.personService.create({
       data: {
         ...args.data,
         ...{ workspace: { connect: { id: workspace.id } } },
       },
-    } satisfies CreateOnePersonArgs as Prisma.PersonCreateArgs);
+      select: prismaSelect.value,
+    } as Prisma.PersonCreateArgs);
   }
 }