@greenpress/auth/dist/server/services/users.js

Express Passport authentication service

"use strict";
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 });
exports.getUserIfTokenExists = exports.deleteToken = exports.updateToken = exports.setToken = exports.comparePassword = exports.deleteUser = exports.updateUser = exports.getUser = void 0;
const user_1 = __importDefault(require("../models/user"));
const config_1 = require("../../config");
function getUser(query) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const user = yield user_1.default.findOne(query);
            if (user) {
                return user;
            }
        }
        catch (err) {
            throw { code: 'FORM_SUBMISSION_FAILED', info: err };
        }
        throw { code: 'INCORRECT_CREDENTIALS' };
    });
}
exports.getUser = getUser;
function updateUser(user, { email = null, password = null, name = null, roles = null }) {
    return __awaiter(this, void 0, void 0, function* () {
        let directUpdate;
        if (!(user instanceof user_1.default)) {
            if (email || roles || password) {
                console.log('loading the user: ', user);
                user = yield user_1.default.findOne(user);
                console.log('this is the user:', user._id);
            }
            else {
                directUpdate = { _id: user._id, tenant: user.tenant };
                user = {};
            }
        }
        if (name) {
            user.name = name;
        }
        if (email) {
            user.email = email;
        }
        if (password) {
            user.password = password;
        }
        if (roles) {
            user.roles = roles;
        }
        return (directUpdate
            ? user_1.default.updateOne(directUpdate, { $set: user })
            : user.save()).catch((err) => Promise.reject({ code: 'UPDATE_USER_FAILED', info: err }));
    });
}
exports.updateUser = updateUser;
function deleteUser(userId, tenant) {
    user_1.default.deleteOne({ _id: userId, tenant })
        .then(() => Promise.resolve({ code: 'USER_DELETED_SUCCESSFULLY', info: userId }))
        .catch((error) => Promise.reject({ code: 'USER_DELETE_FAILED', info: error }));
}
exports.deleteUser = deleteUser;
function comparePassword(user, password) {
    return new Promise((resolve, reject) => {
        return user.comparePassword(password.trim(), (passwordErr, isMatch) => {
            if (passwordErr) {
                return reject({ code: 'FORM_SUBMISSION_FAILED', info: passwordErr });
            }
            if (!isMatch) {
                return reject({ code: 'INCORRECT_CREDENTIAL' });
            }
            resolve(user);
        });
    });
}
exports.comparePassword = comparePassword;
function setToken(user, authType) {
    if (authType === 'oauth') {
        return setOAuthAuthentication(user);
    }
    if (authType === 'cookie') {
        return setCookieAuthentication(user);
    }
    throw { code: 'INVALID_AUTH_TYPE' };
}
exports.setToken = setToken;
function updateToken(user, authType, currentToken, newToken) {
    return user
        .updateToken(authType, currentToken, newToken)
        .catch((err) => Promise.reject({ code: 'UPDATE_TOKEN_FAILED', info: err }));
}
exports.updateToken = updateToken;
function deleteToken(tenant, userId, authType, token, isRelatedToken) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const user = yield user_1.default.findOne({ _id: userId, tenant });
            if (isRelatedToken) {
                token = yield (user === null || user === void 0 ? void 0 : user.getTokenByRelatedTokens(authType, token));
            }
            user === null || user === void 0 ? void 0 : user.deleteToken(authType, token);
        }
        catch (e) {
            return false;
        }
        return true;
    });
}
exports.deleteToken = deleteToken;
function setOAuthAuthentication(user) {
    const token = user.getToken('oauth');
    const refreshToken = user.getRefreshToken(token);
    return user.save().then(() => {
        return {
            token,
            refreshToken,
            user,
        };
    });
}
function setCookieAuthentication(user) {
    const cookieToken = user.getToken('cookie', config_1.cookieTokenExpiration / 1000);
    return user.save().then(() => {
        return { user, cookieToken };
    });
}
function getUserIfTokenExists(tenant, userId, tokenId) {
    return user_1.default.findOne({
        _id: userId,
        tenant,
        'tokens.tokenIdentifier': tokenId,
    })
        .then((user) => user || Promise.reject())
        .catch(() => Promise.reject({ code: 'USER_WITH_TOKEN_NOT_EXISTS' }));
}
exports.getUserIfTokenExists = getUserIfTokenExists;