Merge pull request #58 from techknowledge-blog/feature/user-auth

User Auth

Author: leticiadia

package-lock.json

@@ -4,15 +4,23 @@ import { AppService } from './app.service';
 import { PostsService } from './modules/posts/posts.service';
 import { PrismaService } from './prisma.service';
 import { PostsModule } from './modules/posts/posts.module';
-import { AuthModule } from './modules/auth/auth.module';
 import { UsersModule } from './modules/users/users.module';
 import { UsersController } from './modules/users/users.controller';
 import { UsersService } from './modules/users/users.service';
+import { AuthModule } from './modules/auth/auth.module';
+import { AuthService } from './modules/auth/auth.service';
+import { AuthController } from './modules/auth/auth.controller';
 
 @Module({
   imports: [PostsModule, AuthModule, UsersModule],
-  controllers: [AppController, UsersController],
-  providers: [AppService, PrismaService, PostsService, UsersService],
+  controllers: [AppController, UsersController, AuthController],
+  providers: [
+    AppService,
+    PrismaService,
+    PostsService,
+    UsersService,
+    AuthService,
+  ],
   exports: [PrismaService],
 })
 export class AppModule {}

src/app.module.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthController } from '../auth/auth.controller';
+
+describe('AuthController', () => {
+  let controller: AuthController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuthController],
+    }).compile();
+
+    controller = module.get<AuthController>(AuthController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/modules/auth/auth.controller.spec.ts

@@ -1,16 +1,26 @@
-import { Controller, Post, Body, UnauthorizedException } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Post,
+  Request,
+  UseGuards,
+} from '@nestjs/common';
 import { AuthService } from './auth.service';
+import { AuthGuard } from './guards/auth.guard';
 
 @Controller('auth')
 export class AuthController {
   constructor(private authService: AuthService) {}
 
   @Post('login')
-  async login(@Body() body: { username: string; password: string }) {
-    const user = await this.authService.validateUser(body.username, body.password);
-    if (!user) {
-      throw new UnauthorizedException('Invalid credentials');
-    }
-    return this.authService.login(user);
+  login(@Body() input: { username: string; password: string }) {
+    return this.authService.authenticate(input);
+  }
+
+  @UseGuards(AuthGuard)
+  @Get('profile')
+  getUserInfo(@Request() request) {
+    return request.user;
   }
 }

src/modules/auth/auth.controller.ts

@@ -1,21 +1,22 @@
 import { Module } from '@nestjs/common';
-import { PassportModule } from '@nestjs/passport';
-import { JwtModule } from '@nestjs/jwt';
-import { PrismaService } from 'src/prisma.service';
-import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
-import { JwtStrategy } from './jwt.strategy';
+import { AuthController } from './auth.controller';
+import { UsersModule } from '../users/users.module';
+import { PrismaService } from 'src/prisma.service';
+import { JwtModule } from '@nestjs/jwt';
+import { JWT_SECRET } from '../config/jwt-secret';
+import { JwtStrategy } from './strategy/jwt.strategy';
 
 @Module({
+  providers: [AuthService, PrismaService, JwtStrategy],
+  controllers: [AuthController],
   imports: [
-    PassportModule.register({ defaultStrategy: 'jwt' }),
+    UsersModule,
     JwtModule.register({
-      secret: 'secretKey',
-      signOptions: { expiresIn: '1h' },
+      global: true,
+      secret: JWT_SECRET,
+      signOptions: { expiresIn: '1d' },
     }),
   ],
-  controllers: [AuthController],
-  providers: [AuthService, PrismaService, JwtStrategy],
-  exports: [AuthService],
 })
 export class AuthModule {}

src/modules/auth/auth.module.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthService } from './auth.service';
+
+describe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AuthService],
+    }).compile();
+
+    service = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/modules/auth/auth.service.spec.ts

@@ -1,38 +1,61 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { UsersService } from '../users/users.service';
 import { JwtService } from '@nestjs/jwt';
-import * as bcrypt from 'bcryptjs';
-import { PrismaService } from 'src/prisma.service';
+
+type AuthInput = { username: string; password: string };
+type SignInData = { userId: number; username: string; role: string };
+type AuthResult = {
+  accessToken: string;
+  userId: number;
+  username: string;
+  role: string;
+};
 
 @Injectable()
 export class AuthService {
   constructor(
+    private usersService: UsersService,
     private jwtService: JwtService,
-    private prismaService: PrismaService,
   ) {}
 
-  async validateUser(username: string, password: string): Promise<any> {
-    const user = await this.prismaService.user.findFirst({
-      where: { name: username },
-    });
+  async authenticate(input: AuthInput): Promise<AuthResult> {
+    const user = await this.validateUser(input);
 
     if (!user) {
-      return null;
+      throw new UnauthorizedException();
     }
 
-    // const isMatch = await bcrypt.compare(password, user.passwordHash);
-    const isMatch = password == user.passwordHash;
-    if (isMatch) {
-      const { passwordHash, ...result } = user;
-      return result;
+    return this.signIn(user);
+  }
+
+  async validateUser(input: AuthInput): Promise<SignInData | null> {
+    const user = await this.usersService.findUserByName(input.username);
+
+    if (user && user.passwordHash === input.password) {
+      return {
+        userId: user.id,
+        username: user.name,
+        role: user.role,
+      };
     }
 
     return null;
   }
 
-  async login(user: any) {
-    const payload = { username: user.name, sub: user.id, role: user.role };
+  async signIn(user: SignInData): Promise<AuthResult> {
+    const tokenPayload = {
+      sub: user.userId,
+      username: user.username,
+      role: user.role,
+    };
+
+    const accessToken = await this.jwtService.signAsync(tokenPayload);
+
     return {
-      access_token: this.jwtService.sign(payload),
+      accessToken,
+      username: user.username,
+      userId: user.userId,
+      role: user.role,
     };
   }
 }

src/modules/auth/auth.service.ts

@@ -0,0 +1,34 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(private jwtService: JwtService) {}
+
+  async canActivate(context: ExecutionContext) {
+    const request = context.switchToHttp().getRequest();
+    const authorization = request.headers.authorization;
+    const token = authorization?.split(' ')[1];
+
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+
+    try {
+      const tokenPayload = await this.jwtService.verifyAsync(token);
+      request.user = {
+        userId: tokenPayload.sub,
+        username: tokenPayload.username,
+        role: tokenPayload.role,
+      };
+      return true;
+    } catch (error) {
+      throw new UnauthorizedException();
+    }
+  }
+}