Fix graphql Queries (#142)

front/src/components/editable-cell/EditableChip.tsx

@@ -25,7 +25,7 @@ const StyledInplaceInput = styled.input`
   }
 `;
 
-const StyledInplaceShow = styled.input`
+const StyledInplaceShow = styled.div`
   width: 100%;
   border: none;
   outline: none;

front/src/components/form/Checkbox.tsx

@@ -56,7 +56,7 @@ function Checkbox({ name, id, checked, onChange, indeterminate }: OwnProps) {
         name={name}
         checked={checked}
         onChange={onChange}
-      ></input>
+      />
     </StyledContainer>
   );
 }

front/src/components/table/table-header/__stories__/SortDropdownButton.stories.tsx

@@ -33,14 +33,14 @@ const availableSorts = [
     label: 'People',
     icon: <TbUser size={16} />,
     _type: 'custom_sort',
-    orderByTemplate: () => ({ email: Order_By.Asc }),
+    orderByTemplates: [() => ({ email: Order_By.Asc })],
   },
   {
     key: 'company_name',
     label: 'Company',
     icon: <TbBuilding size={16} />,
     _type: 'custom_sort',
-    orderByTemplate: () => ({ email: Order_By.Asc }),
+    orderByTemplates: [() => ({ email: Order_By.Asc })],
   },
   {
     key: 'email',

front/src/components/table/table-header/helpers.ts

@@ -33,9 +33,13 @@ export const reduceSortsToOrderBy = <OrderByTemplate>(
   sorts: Array<SelectedSortType<OrderByTemplate>>,
 ): OrderByTemplate[] => {
   const mappedSorts = sorts.map((sort) => {
-    if (sort._type === 'custom_sort')
+    if (sort._type === 'custom_sort') {
-      return sort.orderByTemplate(mapOrderToOrder_By(sort.order));
+      return sort.orderByTemplates.map((orderByTemplate) =>
+        orderByTemplate(mapOrderToOrder_By(sort.order)),
+      );
+    }
+
     return defaultOrderByTemplateFactory(sort.key as string)(sort.order);
   });
-  return mappedSorts as OrderByTemplate[];
+  return mappedSorts.flat() as OrderByTemplate[];
 };

front/src/interfaces/sorts/interface.ts

@@ -13,7 +13,7 @@ export type SortType<OrderByTemplate> =
       label: string;
       key: string;
       icon?: ReactNode;
-      orderByTemplate: (order: Order_By) => OrderByTemplate;
+      orderByTemplates: Array<(order: Order_By) => OrderByTemplate>;
     };
 
 export type SelectedSortType<OrderByTemplate> = SortType<OrderByTemplate> & {

front/src/pages/people/people-sorts.tsx

@@ -18,17 +18,21 @@ export const availableSorts = [
     label: 'People',
     icon: <TbUser size={16} />,
     _type: 'custom_sort',
-    orderByTemplate: (order: Order_By) => ({
+    orderByTemplates: [
-      firstname: order,
+      (order: Order_By) => ({
-      lastname: order,
+        firstname: order,
-    }),
+      }),
+      (order: Order_By) => ({
+        lastname: order,
+      }),
+    ],
   },
   {
     key: 'company_name',
     label: 'Company',
     icon: <TbBuilding size={16} />,
     _type: 'custom_sort',
-    orderByTemplate: (order: Order_By) => ({ company: { name: order } }),
+    orderByTemplates: [(order: Order_By) => ({ company: { name: order } })],
   },
   {
     key: 'email',

front/src/services/api/users/index.tsx

@@ -2,7 +2,7 @@ import { QueryResult, gql, useQuery } from '@apollo/client';
 import { GraphqlQueryUser } from '../../../interfaces/entities/user.interface';
 
 export const GET_CURRENT_USER = gql`
-  query getUser($uuid: String) {
+  query getCurrentUser($uuid: String) {
     users(where: { id: { equals: $uuid } }) {
       id
       email

front/src/services/auth/AuthService.ts

@@ -13,7 +13,7 @@ export const getUserIdFromToken: () => string | null = () => {
   }
 
   try {
-    return jwt<{ sub: string }>(accessToken).sub;
+    return jwt<{ userId: string }>(accessToken).userId;
   } catch (error) {
     return null;
   }

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
+    return await this.prismaService.user
-      .findUniqueOrThrow({
+      .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> {
+  async user(@Args() args: FindUniqueUserOrThrowArgs): Promise<User | null> {
-    return this.prismaClient.user.findUniqueOrThrow({
+    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: [
+  imports: [ConfigModule.forRoot({}), TerminusModule, AuthModule, ApiModule],
-    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({
+  imports: [
-    useFactory: async (configService: ConfigService) => {
+    JwtModule.registerAsync({
-      return {
+      useFactory: async (configService: ConfigService) => {
-        secret: configService.get<string>('JWT_SECRET'),
+        return {
-        signOptions: {
+          secret: configService.get<string>('JWT_SECRET'),
-          expiresIn: configService.get<string>('JWT_EXPIRES_IN'),
+          signOptions: {
-        },
+            expiresIn: configService.get<string>('JWT_EXPIRES_IN'),
-      };
+          },
-    },
+        };
-    imports: [ConfigModule.forRoot({})],
+      },
-    inject: [ConfigService],
+      imports: [ConfigModule.forRoot({})],
-  }), 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: {
+  async findMany(params: {
-        skip?: number;
+    skip?: number;
-        take?: number;
+    take?: number;
-        cursor?: Prisma.PersonWhereUniqueInput;
+    cursor?: Prisma.PersonWhereUniqueInput;
-        where?: Prisma.PersonWhereInput;
+    where?: Prisma.PersonWhereInput;
-        orderBy?: Prisma.PersonOrderByWithRelationInput;
+    orderBy?: Prisma.PersonOrderByWithRelationInput;
-      }): Promise<Person[]> {
+  }): Promise<Person[]> {
-        const { skip, take, cursor, where, orderBy } = params;
+    const { skip, take, cursor, where, orderBy } = params;
-        return this.prisma.person.findMany({ skip, take, cursor, where, orderBy });
+    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();
+    });
+  }
+}