feat: auth routes and service

back/src/app.module.ts

@@ -4,9 +4,10 @@ import { AppService } from './app.service';
 import { PrismaService } from './prisma/prisma.service';
 import { UsersModule } from './users/users.module';
 import { PrismaModule } from './prisma/prisma.module';
+import { AuthModule } from './auth/auth.module';
 
 @Module({
-  imports: [UsersModule, PrismaModule],
+  imports: [UsersModule, PrismaModule, AuthModule],
   controllers: [AppController],
   providers: [AppService, PrismaService],
 })

back/src/auth/auth.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthController } from './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();
+  });
+});

back/src/auth/auth.controller.ts

@@ -0,0 +1,43 @@
+import { Controller, Request, Post, Get, UseGuards, Res, Body } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { JwtAuthGuard } from './jwt-auth.guard';
+import { LocalAuthGuard } from './local-auth.guard';
+import { RegisterDto } from './dto/register.dto';
+import { Response } from 'express';
+import { UsersService } from 'src/users/users.service';
+import { ApiBearerAuth, ApiOkResponse, ApiUnauthorizedResponse } from '@nestjs/swagger';
+import { ConfigService } from '@nestjs/config';
+
+@Controller('auth')
+export class AuthController {
+	constructor(
+		private authService: AuthService,
+		private usersService: UsersService,
+		private configService: ConfigService
+	) {}
+
+	@Post('register')
+	async register(@Body() registerDto: RegisterDto, @Res() res: Response) {
+		try {
+			await this.usersService.createUser(registerDto);
+			return res.status(200).json({"status": "user created"});
+		} catch {
+			return res.status(400).json({"status": "user not created"});
+		}
+	}
+
+	@UseGuards(LocalAuthGuard)
+	@Post('login')
+	async login(@Request() req) {
+		return this.authService.login(req.user);
+	}
+
+	@UseGuards(JwtAuthGuard)
+	@ApiBearerAuth()
+	@ApiOkResponse({ description: 'Successfully logged in' })
+	@ApiUnauthorizedResponse({ description: 'Invalid token' })
+	@Get('me')
+	getProfile(@Request() req) {
+  		return req.user;
+  	}
+}

back/src/auth/auth.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+import { UsersModule } from 'src/users/users.module';
+import { AuthService } from './auth.service';
+import { PassportModule } from '@nestjs/passport';
+import { AuthController } from './auth.controller';
+import { LocalStrategy } from './local.strategy';
+import { JwtModule } from '@nestjs/jwt';
+import { ConfigModule } from '@nestjs/config';
+import { ConfigService } from '@nestjs/config';
+import { JwtStrategy } from './jwt.strategy';
+
+@Module({
+  imports: [ConfigModule, UsersModule, PassportModule, 
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        secret: configService.get('JWT_SECRET'),
+        signOptions: { expiresIn: '1h' },
+      }),
+      inject: [ConfigService],
+    })],
+  providers: [AuthService, LocalStrategy, JwtStrategy],
+  controllers: [AuthController]
+})
+export class AuthModule {}

back/src/auth/auth.service.spec.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();
+  });
+});

back/src/auth/auth.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import { UsersService } from '../users/users.service';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcryptjs';
+import PayloadInterface from './interface/payload.interface';
+@Injectable()
+export class AuthService {
+
+	constructor(
+		private userService: UsersService,
+		private jwtService: JwtService
+	) {}
+
+	async validateUser(username: string, password: string): Promise<PayloadInterface> {
+    const user = await this.userService.user({username});
+		if (user && bcrypt.compareSync(password, user.password)) {
+			return {
+				username: user.username,
+				id: user.id
+			};
+		}
+		return null;
+	}
+
+	async login(user: PayloadInterface) {
+		const payload = { username: user.username, id: user.id };
+		const access_token = this.jwtService.sign(payload);
+		return {
+		  access_token
+		};
+	}
+}

back/src/auth/constants.ts

@@ -0,0 +1,12 @@
+import { Injectable } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+
+@Injectable()
+export class Constants {
+
+	constructor(private configService: ConfigService) {}
+
+	getSecret = () => {
+		return this.configService.get("JWT_SECRET");
+	}
+}

back/src/users/users.module.ts

@@ -6,6 +6,7 @@ import { PrismaModule } from 'src/prisma/prisma.module';
 @Module({
   imports: [PrismaModule],
   controllers: [UsersController],
-  providers: [UsersService]
+  providers: [UsersService],
+  exports: [UsersService]
 })
 export class UsersModule {}