update user mutation

src/center/center.schema.ts

@@ -31,7 +31,7 @@ export class CenterSchema extends PothosSchema {
         updatedAt: t.expose('updatedAt', { type: 'DateTime' }),
         services: t.relation('services'),
         centerOwner: t.relation('centerOwner'),
-        // chatRoom: t.relation('chatRoom'),
+        chatRoom: t.relation('chatRoom'),
         centerStaff: t.relation('CenterStaff'),
         resume: t.relation('Resume'),
       }),
@@ -43,15 +43,43 @@ export class CenterSchema extends PothosSchema {
     this.builder.queryFields((t) => ({
       centers: t.prismaField({
         type: [this.center()],
+        args: this.builder.generator.findManyArgs('Center'),
+        resolve: async (query, root, args, ctx, info) => {
+          return await this.prisma.center.findMany({
+            ...query,
+            skip: args.skip ?? undefined,
+            take: args.take ?? 10,
+            orderBy: args.orderBy ?? undefined,
+            where: args.filter ?? undefined,
+          });
+        },
+      }),
+      center: t.prismaField({
+        type: this.center(),
+        args: this.builder.generator.findUniqueArgs('Center'),
+        resolve: async (query, root, args, ctx, info) => {
+          return await this.prisma.center.findUnique({
+            ...query,
+            where: args.where,
+          });
+        },
+      }),
+    }));
+
+    // mutation section
+    this.builder.mutationFields((t) => ({
+      createCenter: t.prismaField({
+        type: this.center(),
         args: {
-          skip: t.arg.int(),
-          take: t.arg.int(),
+          input: t.arg({
+            type: this.builder.generator.getCreateInput('Center'),
+            required: true,
+          }),
         },
         resolve: async (query, root, args, ctx, info) => {
-          const { skip, take } = args;
-          return await this.prisma.center.findMany({
-            skip: skip ?? 0,
-            take: take ?? 10,
+          return await this.prisma.center.create({
+            ...query,
+            data: args.input,
           });
         },
       }),

src/centerstaff/centerstaff.schema.ts

@@ -31,4 +31,23 @@ export class CenterStaffSchema extends PothosSchema {
       }),
     });
   }
+
+  @Pothos()
+  init(): void {
+    this.builder.queryFields((t) => ({
+      centerStaff: t.prismaField({
+        type: [this.centerStaff()],
+        args: this.builder.generator.findManyArgs('CenterStaff'),
+        resolve: async (query, root, args, ctx, info) => {
+          return await this.prisma.centerStaff.findMany({
+            ...query,
+            skip: args.skip ?? undefined,
+            take: args.take ?? 10,
+            orderBy: args.orderBy ?? undefined,
+            where: args.filter ?? undefined,
+          });
+        },
+      }),
+    }));
+  }
 }

src/graphql/graphql.builder.ts

@@ -52,7 +52,7 @@ export class Builder extends SchemaBuilder<SchemaBuilderOption> {
     this.addScalarType('DateTime', DateTimeResolver);
     this.addScalarType('Json', JSONResolver);
     this.queryType({});
-    // this.mutationType({});
+    this.mutationType({});
   }
 }
 export type BuilderTypes =

src/graphql/graphql.generator.ts

@@ -75,6 +75,14 @@ export class PrismaCrudGenerator<Types extends SchemaTypes> {
     }));
   }
 
+  findUniqueArgs<Name extends string & keyof Types['PrismaTypes']>(
+    modelName: Name,
+  ) {
+    return this.builder.args((t) => ({
+      where: t.field({ type: this.getWhereUnique(modelName), required: true }),
+    }));
+  }
+
   getWhere<Name extends string & keyof Types['PrismaTypes']>(
     modelName: Name,
     without?: string[],

src/resume/resume.schema.ts

@@ -39,14 +39,32 @@ export class ResumeSchema extends PothosSchema {
   }
 
   @Pothos()
-  init() {
-    this.builder.queryField('resumes', (t) =>
-      t.field({
+  init(): void {
+    this.builder.queryFields((t) => ({
+      resumes: t.prismaField({
         type: [this.resume()],
-        resolve: async () => {
-          return await this.prisma.resume.findMany();
+        args: this.builder.generator.findManyArgs('Resume'),
+        resolve: async (query, root, args, ctx, info) => {
+          return await this.prisma.resume.findMany({
+            ...query,
+            skip: args.skip ?? undefined,
+            take: args.take ?? 10,
+            orderBy: args.orderBy ?? undefined,
+            where: args.filter ?? undefined,
+          });
         },
       }),
-    );
+
+      resume: t.prismaField({
+        type: this.resume(),
+        args: this.builder.generator.findUniqueArgs('Resume'),
+        resolve: async (query, root, args, ctx, info) => {
+          return await this.prisma.resume.findUnique({
+            ...query,
+            where: args.where,
+          });
+        },
+      }),
+    }));
   }
 }

src/user/user.module.ts

@@ -1,30 +1,9 @@
 import { Global, Module } from '@nestjs/common';
 import { UserSchema } from './user.schema';
-import { Builder, BuilderTypes } from '../graphql/graphql.builder';
-import { PrismaCrudGenerator } from 'src/graphql/graphql.generator';
 import { PrismaService } from 'src/prisma/prisma.service';
 @Global()
 @Module({
-  providers: [
-    PrismaService,
-    UserSchema,
-    {
-      provide: Builder,
-      useFactory: (prisma: PrismaService) => new Builder(prisma),
-      inject: [PrismaService],
-    },
-    {
-      provide: PrismaCrudGenerator,
-      inject: [
-        {
-          token: Builder,
-          optional: false,
-        },
-      ],
-      useFactory: (builder: Builder) =>
-        new PrismaCrudGenerator<BuilderTypes>(builder),
-    },
-  ],
+  providers: [PrismaService, UserSchema],
   exports: [UserSchema],
 })
 export class UserModule {}