🥳 inital gql api's

Author: Rajashekhar-Reddy

src/app.module.ts

@@ -1,6 +1,8 @@
 import { DBModule } from '@libs/db/db.module';
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
+import { GraphQLModule } from '@nestjs/graphql';
 import { validateEnv } from '@src/libs/core/utils/config';
 import { LoggerModule } from 'nestjs-pino';
 
@@ -18,6 +20,22 @@ import { UserModule } from './modules';
     }),
     DBModule,
     UserModule,
+    GraphQLModule.forRootAsync<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      useFactory: (): ApolloDriverConfig => ({
+        autoSchemaFile: true,
+        playground: process.env.NODE_ENV !== 'production',
+        formatError: err => ({
+          message: err.message,
+          status: err.extensions?.code,
+          statusCode: (err.extensions?.originalError as any)?.statusCode,
+        }),
+        context: ({ req, res }: { req: Request; res: Response }) => ({
+          req,
+          res,
+        }),
+      }),
+    }),
     LoggerModule.forRoot({
       pinoHttp: {
         autoLogging: false,

src/libs/converters/user.converter.ts

@@ -1,13 +1,21 @@
-import { GqlUser } from '@src/modules/admin/user/dto/user.output';
+import { GqlUser, GqlUserWithToken } from '@src/modules/user/dto/user.outputs';
 
 import { UserEntity } from '../db/entities';
 
 export const transformToUserGQLType = (user: UserEntity): GqlUser => ({
   id: user.id,
   fullName: user.fullName,
+  email: user.email,
+  gender: user.gender,
 });
 
-export const transformToUserWithGQLType = (user: UserEntity): GqlUser => ({
+export const transformToUserWithTokenGQLType = (
+  user: UserEntity,
+  token: string,
+): GqlUserWithToken => ({
   id: user.id,
   fullName: user.fullName,
+  email: user.email,
+  gender: user.gender,
+  token,
 });

src/libs/db/db.module.ts

@@ -15,12 +15,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
         database: configService.get('DATABASE_NAME'),
         autoLoadEntities: true,
         synchronize: true,
-        ssl: true,
-        extra: {
-          ssl: {
-            rejectUnauthorized: false,
-          },
-        },
+        ssl: false,
       }),
 
       inject: [ConfigService],

src/libs/db/entities/user.entity.ts

@@ -12,22 +12,16 @@ export class UserEntity {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column({ unique: true, nullable: true })
+  @Column({ unique: true, nullable: false })
   email: string;
 
-  @Column({ nullable: true })
-  countryCode: string;
-
-  @Column({ nullable: true })
-  mobileNumber: string;
-
   @Column()
   fullName: string;
 
-  @Column({ nullable: true })
-  profilePicture: string;
+  @Column()
+  gender: string;
 
-  @Column({ type: 'enum', enum: UserRoles })
+  @Column({ type: 'enum', enum: UserRoles, default: UserRoles.USER })
   role: string;
 
   @Column({

src/modules/user/dto/user.inputs.ts

@@ -1,6 +1,6 @@
-import { Field, ObjectType } from '@nestjs/graphql';
+import { Field, InputType } from '@nestjs/graphql';
 
-@ObjectType('User')
+@InputType()
 export class CreateUserInput {
   @Field(() => String)
   fullName: string;
@@ -14,3 +14,12 @@ export class CreateUserInput {
   @Field(() => String)
   gender: string;
 }
+
+@InputType()
+export class LoginUserInput {
+  @Field(() => String)
+  email: string;
+
+  @Field(() => String)
+  password: string;
+}

src/modules/user/user.resolver.ts

@@ -5,7 +5,7 @@ import {
 } from '@src/libs/core/decorators';
 import { UserEntity } from '@src/libs/db/entities';
 
-import { CreateUserInput } from './dto/user.inputs';
+import { CreateUserInput, LoginUserInput } from './dto/user.inputs';
 import { GqlUser, GqlUserWithToken } from './dto/user.outputs';
 import { UserService } from './user.service';
 
@@ -15,14 +15,14 @@ export class UserResolver {
 
   @AllowUnauthorizedRequest()
   @Mutation(() => GqlUserWithToken, { name: 'login' })
-  login(@Args('adminLogInput') adminLogInput: CreateUserInput) {
-    return this.userService.login(adminLogInput);
+  login(@Args('loginUserInput') loginUserInput: LoginUserInput) {
+    return this.userService.login(loginUserInput);
   }
 
   @AllowUnauthorizedRequest()
-  @Mutation(() => GqlUserWithToken, { name: 'login' })
-  createUser(@Args('adminLogInput') adminLogInput: CreateUserInput) {
-    return this.userService.login(adminLogInput);
+  @Mutation(() => GqlUserWithToken)
+  createUser(@Args('createUserInput') createUserInput: CreateUserInput) {
+    return this.userService.createUser(createUserInput);
   }
   @Query(() => GqlUserWithToken, { name: 'profile' })
   async profile(@CurrentUser() user: UserEntity): Promise<GqlUserWithToken> {

src/modules/user/user.service.ts

@@ -1,13 +1,14 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
+import { transformToUserWithTokenGQLType } from '@src/libs/converters';
 import { AuthService } from '@src/libs/core/auth/auth.service';
-import { DefaultStatus } from '@src/libs/core/utils';
+import { UserStatus } from '@src/libs/core/utils';
 import { UserEntity } from '@src/libs/db/entities';
 import * as bcrypt from 'bcrypt';
 import { PinoLogger } from 'nestjs-pino';
 import { Repository } from 'typeorm';
 
-import { AdminLoginInput } from './dto/admin-login.input';
+import { CreateUserInput, LoginUserInput } from './dto/user.inputs';
 import { GqlUserWithToken } from './dto/user.outputs';
 
 @Injectable()
@@ -20,11 +21,11 @@ export class UserService {
     private authService: AuthService,
   ) {}
 
-  async login(inputs: AdminLoginInput): Promise<GqlUserWithToken> {
+  async login(inputs: LoginUserInput): Promise<GqlUserWithToken> {
     const user = await this.usersRepository.findOne({
       where: {
         email: inputs.email,
-        status: DefaultStatus.ACTIVE,
+        status: UserStatus.ACTIVE,
       },
     });
 
@@ -37,27 +38,36 @@ export class UserService {
       throw new BadRequestException('email or password is incorrect');
     }
 
-    const userWithToken = new GqlUserWithToken();
-    userWithToken.id = user.id;
-    userWithToken.token = this.authService.createJwt(user).token;
-    userWithToken.fullName = user.fullName;
-    return userWithToken;
+    const token = this.authService.createJwt(user).token;
+    return transformToUserWithTokenGQLType(user, token);
   }
 
   async profile(user: UserEntity): Promise<GqlUserWithToken> {
     const foundUser = await this.usersRepository.findOne({
       where: {
         id: user.id,
-        status: DefaultStatus.ACTIVE,
+        status: UserStatus.ACTIVE,
       },
     });
     if (!foundUser) {
       throw new BadRequestException('email or password is incorrect');
     }
-    const userWithToken = new GqlUserWithToken();
-    userWithToken.id = foundUser.id;
-    userWithToken.token = this.authService.createJwt(foundUser).token;
-    userWithToken.fullName = foundUser.fullName;
-    return userWithToken;
+    const token = this.authService.createJwt(foundUser).token;
+    return transformToUserWithTokenGQLType(foundUser, token);
+  }
+
+  async createUser(user: CreateUserInput): Promise<GqlUserWithToken> {
+    const foundUser = await this.usersRepository.findOne({
+      where: {
+        email: user.email,
+      },
+    });
+    if (foundUser) {
+      throw new BadRequestException('email is already taken');
+    }
+    user.password = bcrypt.hashSync(user.password, 10);
+    const createdUser = await this.usersRepository.save(user);
+    const token = this.authService.createJwt(createdUser).token;
+    return transformToUserWithTokenGQLType(createdUser, token);
   }
 }