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>,
  ) {}

  //register users
  async register(data: registerDto) {
    const { usuario, contraseña} = data;

    if (await this.usersService.findOne(usuario)) {
      throw new HttpException('User already exist', 403);
    }

    const hashedpassword = await hash(contraseña, 10);

    data = { ...data, contraseña: hashedpassword };
    return this.userRepository.save(this.userRepository.create(data));
  }

  //singin
  async signIn(data: registerDto) {
    const { usuario, contraseña } = data;
    const user = await this.usersService.findOne(usuario);
    if (!user) {
      throw new UnauthorizedException('Invalid name');
    }

    const checkPassword = await compare(contraseña, user.contraseña);
    if (!checkPassword) {
      throw new UnauthorizedException('Invalid password');
    }
    const payload = {
      idUser: user.id_usuario,
      username: user.usuario,
    };
    const token = this.jwtService.sign(payload);

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

    return { token: token };
  }

  async update(userId, updateUserDto) {
    return await this.userRepository.update(userId, updateUserDto);
  }

  async remove(userId: number): Promise<void> {
    await this.userRepository.delete(userId);
  }

  //validate tojen of users
  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 hasn'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');
    }
  }
}