@brewww/authentication-service/dist/src/user/user.service.js

Authenticator service for Brew projects.

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.UserService = void 0;
const common_1 = require("@nestjs/common");
const entities_1 = require("../entities");
const typeorm_1 = require("@nestjs/typeorm");
const typeorm_2 = require("typeorm");
const bcrypt = require("bcrypt");
const error_1 = require("../error");
const invalid_argument_error_1 = require("../error/invalid-argument.error");
let UserService = class UserService {
    constructor(userRepository, userRoleRepository) {
        this.userRepository = userRepository;
        this.userRoleRepository = userRoleRepository;
        this.preRegisterUserHandlers = [];
        this.postRegisterUserHandlers = [];
        this.userValidators = [];
    }
    async getUserAsync(options) {
        var _a, _b;
        if (!options.username &&
            !options.email &&
            (!((_a = options.phone) === null || _a === void 0 ? void 0 : _a.number) || !((_b = options.phone) === null || _b === void 0 ? void 0 : _b.countryCode)))
            throw new invalid_argument_error_1.InvalidArgumentError("Provide at least one of: username, email, or phone number.");
        const whereClause = [];
        if (options.username)
            whereClause.push({ username: options.username });
        if (options.email)
            whereClause.push({ email: options.email });
        if (options.phone) {
            whereClause.push({
                phoneNumber: options.phone.number,
                countryCode: options.phone.countryCode,
            });
        }
        return await this.userRepository.findOne({
            where: whereClause,
            relations: ["roles", "roles.role"],
        });
    }
    async validateUserAsync(credentials) {
        const user = await this.validateUserPasswordAsync(credentials);
        const isUserValid = await this.applyUserValidatorsAsync(user);
        if (!isUserValid)
            throw new error_1.InvalidCredentialsError();
        return user;
    }
    async validateUserPasswordAsync(credentials) {
        const user = await this.getUserAsync({
            username: credentials.username,
            email: credentials.email,
        });
        if (!user)
            throw new error_1.InvalidCredentialsError();
        const isPasswordValid = await bcrypt.compare(credentials.password, user.passwordHash);
        if (!isPasswordValid)
            throw new error_1.InvalidCredentialsError();
        return user;
    }
    async createUserAsync(user, appData) {
        const existingUser = await this.getUserAsync({
            username: user.username,
            email: user.email,
            phone: { number: user.phoneNumber, countryCode: user.countryCode },
        });
        if (existingUser)
            throw new error_1.UserAlreadyExistsError();
        user = await this.applyPreRegisterUserHandlersAsync(user, appData);
        user = await this.insertUserAsync(user);
        user = await this.applyPostRegisterUserHandlersAsync(user, appData);
        return user;
    }
    async updateUserPasswordAsync(user, newPassword) {
        const newSalt = bcrypt.genSaltSync();
        user.passwordHash = bcrypt.hashSync(newPassword, newSalt);
        user.passwordSalt = newSalt;
        await this.userRepository.save(user);
    }
    async insertUserAsync(user) {
        const savedUser = await this.userRepository.save(user);
        if (user.roles) {
            const roles = user.roles.map((userRoles) => (Object.assign(Object.assign({}, userRoles), { user: savedUser })));
            savedUser.roles = await this.userRoleRepository.save(roles);
        }
        return savedUser;
    }
    addPreRegisterUserHandler(handler) {
        this.preRegisterUserHandlers.push(handler);
    }
    addPostRegisterUserHandler(handler) {
        this.postRegisterUserHandlers.push(handler);
    }
    addUserValidator(userValidator) {
        this.userValidators.push(userValidator);
    }
    async applyPreRegisterUserHandlersAsync(user, appData) {
        for (const preRegisterUserHandler of this.preRegisterUserHandlers)
            user = await preRegisterUserHandler.handleAsync(user, appData);
        return user;
    }
    async applyPostRegisterUserHandlersAsync(user, appData) {
        for (const preRegisterUserHandler of this.postRegisterUserHandlers) {
            user = await preRegisterUserHandler.handleAsync(user, appData);
        }
        return user;
    }
    async applyUserValidatorsAsync(user) {
        for (const userValidator of this.userValidators) {
            const isValid = await userValidator.validateAsync(user);
            if (!isValid)
                return false;
        }
        return true;
    }
};
UserService = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, typeorm_1.InjectRepository)(entities_1.User)),
    __param(1, (0, typeorm_1.InjectRepository)(entities_1.UserRole)),
    __metadata("design:paramtypes", [typeorm_2.Repository,
        typeorm_2.Repository])
], UserService);
exports.UserService = UserService;
//# sourceMappingURL=user.service.js.map