express-typeorm-rest-boilerplate/dist/api/services/UserService.js

Boilerplate code to get started with building RESTful API Services

"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); }
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
const bcrypt_1 = __importDefault(require("bcrypt"));
const config_1 = __importDefault(require("../../config"));
const typedi_1 = require("typedi");
const User_1 = require("../entities/User");
const typeorm_1 = require("typeorm");
const typeorm_typedi_extensions_1 = require("typeorm-typedi-extensions");
const class_validator_1 = require("class-validator");
const CRUD_1 = __importDefault(require("./CRUD"));
const ErrorHandler_1 = require("../../helpers/ErrorHandler");
let UserService = class UserService extends CRUD_1.default {
    constructor(userRepo, logger) {
        super(userRepo, logger);
        this.userRepo = userRepo;
        this.logger = logger;
    }
    getRepo() {
        return this.userRepo;
    }
    register(userInputDTO) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('Registering user...');
            const hashedPassword = yield bcrypt_1.default.hash(userInputDTO.password, 12);
            const newUser = new User_1.User({
                firstName: userInputDTO.firstName,
                lastName: userInputDTO.lastName,
                email: userInputDTO.email,
                password: hashedPassword,
            });
            const errors = yield class_validator_1.validate(newUser, {
                validationError: { target: false },
            });
            if (errors.length > 0)
                throw errors;
            const foundUser = yield this.userRepo.findOne({ email: newUser.email });
            if (foundUser)
                throw new ErrorHandler_1.ErrorHandler(400, 'The email address already exists');
            const userRecord = yield this.userRepo.save(newUser);
            if (!userRecord)
                throw new ErrorHandler_1.ErrorHandler(500, 'User cannot be created');
            const token = this.generateToken(userRecord);
            const user = userRecord;
            Reflect.deleteProperty(user, 'password');
            return { user, token };
        });
    }
    login(email, password) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('Authenticating user...');
            const userRecord = yield this.userRepo.findOne({ email });
            if (!userRecord)
                throw new ErrorHandler_1.ErrorHandler(401, 'Invalid email or password');
            const validPassword = yield bcrypt_1.default.compare(password, userRecord.password);
            if (validPassword) {
                const token = this.generateToken(userRecord);
                const user = userRecord;
                Reflect.deleteProperty(user, 'password');
                return { user, token };
            }
            throw new ErrorHandler_1.ErrorHandler(401, 'Invalid email or password');
        });
    }
    generateToken(userRecord) {
        const today = new Date();
        const exp = new Date(today);
        exp.setDate(today.getDate() + 7);
        this.logger.debug(`Signing JWT for userId: ${userRecord.id}`);
        return jsonwebtoken_1.default.sign({
            id: userRecord.id,
            email: userRecord.email,
            exp: exp.getTime() / 1000,
        }, config_1.default.jwtSecret);
    }
    find() {
        return __awaiter(this, void 0, void 0, function* () {
            const users = yield this.repo.find();
            for (const user of users) {
                Reflect.deleteProperty(user, 'password');
            }
            return users;
        });
    }
    findOne(id) {
        return __awaiter(this, void 0, void 0, function* () {
            const user = yield this.repo.findOne(id);
            if (user) {
                Reflect.deleteProperty(user, 'password');
            }
            return user;
        });
    }
};
UserService = __decorate([
    typedi_1.Service(),
    __param(0, typeorm_typedi_extensions_1.InjectRepository(User_1.User)),
    __param(1, typedi_1.Inject('logger')),
    __metadata("design:paramtypes", [typeorm_1.MongoRepository, Object])
], UserService);
exports.default = UserService;
//# sourceMappingURL=UserService.js.map