api_directorio/src/auth/auth.service.ts

import { HttpException, Inject, Injectable, UnauthorizedException } from '@nestjs/common';
import { UsersService } from '../users/users.service';
import { JwtService } from '@nestjs/jwt';
import { registerDto } from './dto/registerDto.dto';
import { User } from 'src/users/entities/user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { hash } from 'bcrypt'; 
import { compare } from 'bcryptjs';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class AuthService {
  constructor(
    private usersService: UsersService,
    private jwtService: JwtService,
    private configService:ConfigService,
    @InjectRepository(User) private userRepository: Repository<User>
  ) {}

  async register(data: registerDto){
    const{username, password,} = data;

    if(await this.usersService.findOne(data.username)){
      throw new HttpException("User already exist",403);
    }

    const hashedpassword = await hash(password, 10);

     data = {...data, password:hashedpassword}
    return this.userRepository.save(
      this.userRepository.create(data)
    )
  }


  async signIn(data: registerDto) {
    const{password} = data;
    const user = await this.usersService.findOne(data.username);

    const checkPassword = await compare(password, (await user).password)

    if (!checkPassword) {
      throw new UnauthorizedException();
    }
    const payload = { 
      idUser: user.userId,
      username: user.username 
    };
    const token = this.jwtService.sign(payload);

    await this.usersService.updateTokenAndDates(user.userId,token, new Date(), new Date(Date.now() + 3600 * 1000));

    return {token: token};
  }

  async create(data){

  }

  async update(
    id,
    updateUserDto
  ){

  }

  async remove(
    id
  ){

  }

  async validateToken(token: string): Promise<User> {
    try {
      const decoded = this.jwtService.verify(token, {
        secret: this.configService.get<string>('JWT_SECRET'),
      });

      //verify JWT's username with DB's username
      const user = await this.usersService.findOne(decoded.username);
      if (!user) {
        throw new UnauthorizedException('Invalid token');
      }

      //verify JWT doesn't expired
      const currentTime = Math.floor(Date.now() / 1000);
      if (decoded.exp < currentTime) {
        throw new UnauthorizedException('Token has expired');
      }
      
      return user;
    } catch (error) {
      throw new UnauthorizedException('validation token failed');
    }
  }

}