[submit] Parts 1-2 and some of Parts 3-4 of the coding challenge

README.md

@@ -26,8 +26,8 @@ This project aims to create a backend solution for a web application. It consist
 ## Endpoints
 
 - **Login**: `/api/auth/login`
-- **Customers**: `/api/auth/customers`
-- **Products**: `/api/auth/products`
+- **Customers**: `/api/customers`
+- **Products**: `/api/products`
 
 ## Impress us
 

package.json

@@ -22,7 +22,10 @@
   "dependencies": {
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
+    "@nestjs/jwt": "^10.2.0",
     "@nestjs/platform-express": "^10.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.1"
   },

src/app.controller.ts

@@ -1,7 +1,12 @@
-import { Controller } from '@nestjs/common';
+import { Controller, Get } from '@nestjs/common';
 import { AppService } from './app.service';
 
 @Controller()
 export class AppController {
   constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello() {
+    return { data: 'hello world' };
+  }
 }

src/app.module.ts

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

src/auth/auth.controller.ts

@@ -1,13 +1,15 @@
-import { Controller, HttpCode, HttpStatus, Post } from '@nestjs/common';
+import { Body, Controller, HttpCode, HttpStatus, Post } from '@nestjs/common';
 import { AuthService } from './auth.service';
+import { LoginDto } from './dto/login.dto';
 
 @Controller('auth')
 export class AuthController {
   constructor(private authService: AuthService) {}
 
   @HttpCode(HttpStatus.OK)
   @Post('login')
-  signIn() {
-    return this.authService.signIn();
+  async signIn(@Body() { username, password }: LoginDto) {
+    const { token } = await this.authService.signIn(username, password);
+    return { token };
   }
 }

src/auth/auth.guard.ts

@@ -0,0 +1,40 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Request } from 'express';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(private jwtService: JwtService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+
+    try {
+      const payload = await this.jwtService.verifyAsync(token, {
+        // TODO: get this from env
+        secret: 'supersecret',
+      });
+
+      // 💡 We're assigning the payload to the request object here
+      // so that we can access it in our route handlers
+      request['user'] = payload;
+    } catch {
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}

src/auth/auth.module.ts

@@ -1,10 +1,22 @@
 import { Module } from '@nestjs/common';
 import { AuthService } from './auth.service';
 import { AuthController } from './auth.controller';
+import { UsersModule } from 'src/users/users.module';
+import { JwtModule } from '@nestjs/jwt';
+import { AuthGuard } from './auth.guard';
 
 @Module({
-  providers: [AuthService],
+  providers: [AuthService, AuthGuard],
   controllers: [AuthController],
-  exports: [AuthService],
+  exports: [AuthService, AuthGuard],
+  imports: [
+    UsersModule,
+    JwtModule.register({
+      global: true,
+      // TODO: move this to env variables
+      secret: 'supersecret',
+      signOptions: { expiresIn: '120s' },
+    }),
+  ],
 })
 export class AuthModule {}

src/auth/auth.service.spec.ts

@@ -1,12 +1,18 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthService } from './auth.service';
+import { UsersService } from '../users/users.service';
+import { JwtService } from '@nestjs/jwt';
 
 describe('AuthService', () => {
   let service: AuthService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [AuthService],
+      providers: [
+        AuthService,
+        { provide: UsersService, useValue: {} },
+        { provide: JwtService, useValue: {} },
+      ],
     }).compile();
 
     service = module.get<AuthService>(AuthService);

src/auth/auth.service.ts

@@ -1,8 +1,32 @@
-import { Injectable } from '@nestjs/common';
+import { HttpException, Injectable } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { UsersService } from '../users/users.service';
 
 @Injectable()
 export class AuthService {
-  async signIn() {
-    return;
+  constructor(
+    private usersService: UsersService,
+    private jwtService: JwtService,
+  ) {}
+
+  async signIn(username, password) {
+    const user = await this.usersService.findOne(username);
+    if (!user) {
+      throw new HttpException('User not found', 404);
+    }
+
+    if (password !== user.password) {
+      throw new HttpException('Wrong password', 401);
+    }
+
+    // valid credentials at this point
+
+    // create JWT token with user info
+    const token = this.jwtService.sign({
+      userId: user.userId,
+      username: user.username,
+    });
+
+    return { token };
   }
 }

src/auth/dto/login.dto.ts

@@ -0,0 +1,10 @@
+import { IsNotEmpty } from 'class-validator';
+
+export class LoginDto {
+  @IsNotEmpty()
+  username: string;
+
+  // TODO: add more constraints here
+  @IsNotEmpty()
+  password: string;
+}

src/customers/customers.controller.ts

@@ -0,0 +1,21 @@
+import {
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
+import { CustomersService } from './customers.service';
+import { AuthGuard } from 'src/auth/auth.guard';
+
+@Controller('customers')
+@UseGuards(AuthGuard)
+export class CustomersController {
+  constructor(private customersService: CustomersService) {}
+
+  @Get()
+  async getAll() {
+    const customers = await this.customersService.getAll();
+    return customers;
+  }
+}

src/customers/customers.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { CustomersController } from './customers.controller';
+import { CustomersService } from './customers.service';
+import { AuthModule } from 'src/auth/auth.module';
+
+@Module({
+  controllers: [CustomersController],
+  providers: [CustomersService],
+  imports: [AuthModule],
+})
+export class CustomersModule {}

src/customers/customers.service.spec.ts

@@ -0,0 +1,42 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UsersService } from '../users/users.service';
+
+// Mock some dependencies before importing CustomersService
+jest.mock('../Mocks/customers', () => ({
+  customers: [
+    { customer_id: '1', name: 'Test 1', email: '[email protected]' },
+    { customer_id: '2', name: 'Test 2', email: '[email protected]' },
+  ],
+}));
+import { CustomersService } from './customers.service';
+
+describe('CustomersService', () => {
+  let service: CustomersService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CustomersService, { provide: UsersService, useValue: {} }],
+    }).compile();
+
+    service = module.get<CustomersService>(CustomersService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('getAll', () => {
+    it('should return an array', async () => {
+      const result = await service.getAll();
+      expect(result).toBeInstanceOf(Array);
+    });
+
+    it('should return mocked customers', async () => {
+      const result = await service.getAll();
+      expect(result).toStrictEqual([
+        { customer_id: '1', name: 'Test 1', email: '[email protected]' },
+        { customer_id: '2', name: 'Test 2', email: '[email protected]' },
+      ]);
+    });
+  });
+});

src/customers/customers.service.ts

@@ -0,0 +1,10 @@
+import { Injectable } from '@nestjs/common';
+import { customers } from '../Mocks/customers';
+
+@Injectable()
+export class CustomersService {
+  // TODO: add Customer type
+  async getAll() {
+    return customers;
+  }
+}

src/main.ts

@@ -1,8 +1,11 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
+import { ValidationPipe } from '@nestjs/common';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  app.setGlobalPrefix('api');
+  app.useGlobalPipes(new ValidationPipe());
   await app.listen(3000);
 }
 bootstrap();

src/users/users.service.ts

@@ -8,6 +8,7 @@ export type User = {
 
 @Injectable()
 export class UsersService {
+  // TODO: hash the passwords
   private readonly users = [
     {
       userId: 1,