Fix graphql Queries (#142)

server/src/api/api.module.ts

@@ -10,6 +10,7 @@ import { PeopleResolver } from './resolvers/people.resolver';
 import { PersonRelationsResolver } from './resolvers/relations/people-relations.resolver';
 import { UserRelationsResolver } from './resolvers/relations/user-relations.resolver';
 import { WorkspaceMemberRelationsResolver } from './resolvers/relations/workspace-member-relations.resolver';
+import { PrismaModule } from 'src/database/prisma.module';
 
 @Module({
   imports: [
@@ -17,6 +18,7 @@ import { WorkspaceMemberRelationsResolver } from './resolvers/relations/workspac
       driver: ApolloDriver,
       autoSchemaFile: true,
     }),
+    PrismaModule,
   ],
   providers: [
     PrismaClient,

server/src/api/resolvers/relation-resolver/workspace-member-relations.resolver.ts

@@ -1,43 +0,0 @@
-import * as TypeGraphQL from '@nestjs/graphql';
-import type { GraphQLResolveInfo } from 'graphql';
-import { User } from '../../generated-graphql/models/User';
-import { Workspace } from '../../generated-graphql/models/Workspace';
-import { WorkspaceMember } from '../../generated-graphql/models/WorkspaceMember';
-import { PrismaClient } from '@prisma/client';
-
-@TypeGraphQL.Resolver(() => WorkspaceMember)
-export class WorkspaceMemberRelationsResolver {
-  constructor(private readonly prismaClient: PrismaClient) {}
-
-  @TypeGraphQL.ResolveField(() => User, {
-    nullable: false,
-  })
-  async user(
-    @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
-    @TypeGraphQL.Info() info: GraphQLResolveInfo,
-  ): Promise<User> {
-    return this.prismaClient.workspaceMember
-      .findUniqueOrThrow({
-        where: {
-          id: workspaceMember.id,
-        },
-      })
-      .user({});
-  }
-
-  @TypeGraphQL.ResolveField((_type) => Workspace, {
-    nullable: false,
-  })
-  async workspace(
-    @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
-    @TypeGraphQL.Info() info: GraphQLResolveInfo,
-  ): Promise<Workspace> {
-    return this.prismaClient.workspaceMember
-      .findUniqueOrThrow({
-        where: {
-          id: workspaceMember.id,
-        },
-      })
-      .workspace({});
-  }
-}

server/src/api/resolvers/relations/user-relations.resolver.ts

@@ -7,10 +7,11 @@ import { WorkspaceMember } from '../../generated-graphql/models/WorkspaceMember'
 import { PrismaClient } from '@prisma/client';
 import { UserCompaniesArgs } from '../../generated-graphql/resolvers/relations/User/args/UserCompaniesArgs';
 import { UserRefreshTokensArgs } from '../../generated-graphql/resolvers/relations/User/args/UserRefreshTokensArgs';
+import { PrismaService } from 'src/database/prisma.service';
 
 @TypeGraphQL.Resolver(() => User)
 export class UserRelationsResolver {
-  constructor(private readonly prismaClient: PrismaClient) {}
+  constructor(private readonly prismaService: PrismaService) {}
 
   @TypeGraphQL.ResolveField(() => WorkspaceMember, {
     nullable: true,
@@ -18,8 +19,8 @@ export class UserRelationsResolver {
   async WorkspaceMember(
     @TypeGraphQL.Parent() user: User,
   ): Promise<WorkspaceMember | null> {
-    return this.prismaClient.user
-      .findUniqueOrThrow({
+    return await this.prismaService.user
+      .findFirst({
         where: {
           id: user.id,
         },
@@ -35,7 +36,7 @@ export class UserRelationsResolver {
     @TypeGraphQL.Info() info: GraphQLResolveInfo,
     @TypeGraphQL.Args() args: UserCompaniesArgs,
   ): Promise<Company[]> {
-    return this.prismaClient.user
+    return this.prismaService.user
       .findUniqueOrThrow({
         where: {
           id: user.id,
@@ -54,7 +55,7 @@ export class UserRelationsResolver {
     @TypeGraphQL.Info() info: GraphQLResolveInfo,
     @TypeGraphQL.Args() args: UserRefreshTokensArgs,
   ): Promise<RefreshToken[]> {
-    return this.prismaClient.user
+    return this.prismaService.user
       .findUniqueOrThrow({
         where: {
           id: user.id,

server/src/api/resolvers/relations/workspace-member-relations.resolver.ts

@@ -4,10 +4,11 @@ import { User } from '../../generated-graphql/models/User';
 import { Workspace } from '../../generated-graphql/models/Workspace';
 import { WorkspaceMember } from '../../generated-graphql/models/WorkspaceMember';
 import { PrismaClient } from '@prisma/client';
+import { PrismaService } from 'src/database/prisma.service';
 
 @TypeGraphQL.Resolver(() => WorkspaceMember)
 export class WorkspaceMemberRelationsResolver {
-  constructor(private readonly prismaClient: PrismaClient) {}
+  constructor(private readonly prismaService: PrismaService) {}
 
   @TypeGraphQL.ResolveField(() => User, {
     nullable: false,
@@ -16,7 +17,7 @@ export class WorkspaceMemberRelationsResolver {
     @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
     @TypeGraphQL.Info() info: GraphQLResolveInfo,
   ): Promise<User> {
-    return this.prismaClient.workspaceMember
+    return await this.prismaService.workspaceMember
       .findUniqueOrThrow({
         where: {
           id: workspaceMember.id,
@@ -32,7 +33,7 @@ export class WorkspaceMemberRelationsResolver {
     @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
     @TypeGraphQL.Info() info: GraphQLResolveInfo,
   ): Promise<Workspace> {
-    return this.prismaClient.workspaceMember
+    return this.prismaService.workspaceMember
       .findUniqueOrThrow({
         where: {
           id: workspaceMember.id,

server/src/api/resolvers/user.resolver.ts

@@ -1,27 +1,27 @@
-import { PrismaClient } from '@prisma/client';
 import { Person, User } from '../generated-graphql/models';
 import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
 import { FindManyUserArgs } from '../generated-graphql/resolvers/crud/User/args/FindManyUserArgs';
 import { FindUniqueUserOrThrowArgs } from '../generated-graphql';
+import { PrismaService } from 'src/database/prisma.service';
 
 @Resolver(() => User)
 export class UserResolver {
-  constructor(private readonly prismaClient: PrismaClient) {}
+  constructor(private readonly prismaService: PrismaService) {}
 
   @Query(() => [User], {
     nullable: false,
   })
   async users(@Args() args: FindManyUserArgs): Promise<User[]> {
-    return this.prismaClient.user.findMany({
+    return await this.prismaService.user.findMany({
       ...args,
     });
   }
 
   @Query(() => User, {
-    nullable: true,
+    nullable: false,
   })
-  async getUser(@Args() args: FindUniqueUserOrThrowArgs): Promise<User | null> {
-    return this.prismaClient.user.findUniqueOrThrow({
+  async user(@Args() args: FindUniqueUserOrThrowArgs): Promise<User | null> {
+    return await this.prismaService.user.findUnique({
       ...args,
     });
   }

server/src/app.module.ts

@@ -8,12 +8,7 @@ import { AuthModule } from './auth/auth.module';
 import { ConfigModule } from '@nestjs/config';
 import { ApiModule } from './api/api.module';
 @Module({
-  imports: [
-    ConfigModule.forRoot({}),
-    TerminusModule,
-    AuthModule,
-    ApiModule,
-  ],
+  imports: [ConfigModule.forRoot({}), TerminusModule, AuthModule, ApiModule],
   controllers: [AppController, HealthController],
   providers: [AppService],
 })

server/src/auth/auth.module.ts

@@ -12,18 +12,21 @@ import { RefreshTokenRepository } from 'src/entities/refresh-token/refresh-token
 import { PrismaService } from 'src/database/prisma.service';
 
 @Module({
-  imports: [JwtModule.registerAsync({
-    useFactory: async (configService: ConfigService) => {
-      return {
-        secret: configService.get<string>('JWT_SECRET'),
-        signOptions: {
-          expiresIn: configService.get<string>('JWT_EXPIRES_IN'),
-        },
-      };
-    },
-    imports: [ConfigModule.forRoot({})],
-    inject: [ConfigService],
-  }), ConfigModule.forRoot({})],
+  imports: [
+    JwtModule.registerAsync({
+      useFactory: async (configService: ConfigService) => {
+        return {
+          secret: configService.get<string>('JWT_SECRET'),
+          signOptions: {
+            expiresIn: configService.get<string>('JWT_EXPIRES_IN'),
+          },
+        };
+      },
+      imports: [ConfigModule.forRoot({})],
+      inject: [ConfigService],
+    }),
+    ConfigModule.forRoot({}),
+  ],
   controllers: [GoogleAuthController, AuthController],
   providers: [
     AuthService,
@@ -35,4 +38,4 @@ import { PrismaService } from 'src/database/prisma.service';
     PrismaService,
   ],
 })
-export class AuthModule {}
+export class AuthModule {}

server/src/database/schema.prisma

@@ -1,5 +1,6 @@
 generator client {
   provider = "prisma-client-js"
+  engineType = "binary"
 }
 
 datasource db {

server/src/entities/person/person.repository.ts

@@ -4,16 +4,16 @@ import { PrismaService } from 'src/database/prisma.service';
 
 @Injectable()
 export class PersonRepository {
-    constructor(private prisma: PrismaService) {}
+  constructor(private prisma: PrismaService) {}
 
-    async findMany(params: {
-        skip?: number;
-        take?: number;
-        cursor?: Prisma.PersonWhereUniqueInput;
-        where?: Prisma.PersonWhereInput;
-        orderBy?: Prisma.PersonOrderByWithRelationInput;
-      }): Promise<Person[]> {
-        const { skip, take, cursor, where, orderBy } = params;
-        return this.prisma.person.findMany({ skip, take, cursor, where, orderBy });
-      }
+  async findMany(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.PersonWhereUniqueInput;
+    where?: Prisma.PersonWhereInput;
+    orderBy?: Prisma.PersonOrderByWithRelationInput;
+  }): Promise<Person[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.person.findMany({ skip, take, cursor, where, orderBy });
+  }
 }

server/src/prisma/prisma.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}

server/src/prisma/prisma.service.ts

@@ -0,0 +1,15 @@
+import { INestApplication, Injectable, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async enableShutdownHooks(app: INestApplication) {
+    this.$on('beforeExit', async () => {
+      await app.close();
+    });
+  }
+}