@krypton-org/krypton-auth/lib/model/SessionModel.js

Express authentication middleware, using GraphQL and JSON Web Tokens.

"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 });
/**
 * Module returning the Session model built with Mongoose
 * @module model/SessionModel
 */
const mongoose_1 = require("mongoose");
const config_1 = __importDefault(require("../config"));
const TokenGenerator_1 = __importDefault(require("../crypto/TokenGenerator"));
const ErrorTypes_1 = require("../error/ErrorTypes");
const REFRESH_TOKEN_LENGTH = 256;
const sessionFields = {
    expiryDate: {
        isPublic: false,
        type: Date,
    },
    refreshToken: {
        isPublic: false,
        type: String,
    },
    userId: {
        type: mongoose_1.Schema.Types.ObjectId,
    },
};
const SessionSchema = new mongoose_1.Schema(sessionFields);
/**
 * Returns the expiry date of a new refreshToken from now on.
 * @returns {Date}
 */
function getExpiryDate() {
    const expiryDate = new Date();
    expiryDate.setTime(expiryDate.getTime() + config_1.default.refreshTokenExpiryTime);
    return expiryDate;
}
/** @see {@link ISessionModel#isValid} */
SessionSchema.statics.isValid = function (userId, refreshToken) {
    return __awaiter(this, void 0, void 0, function* () {
        if (userId && refreshToken) {
            const session = yield this.findOne({ userId, refreshToken });
            return !!session && session.expiryDate > new Date();
        }
        else {
            return false;
        }
    });
};
/** @see {@link ISessionModel#createToken} */
SessionSchema.statics.createSession = function (userId) {
    return __awaiter(this, void 0, void 0, function* () {
        const Session = mongoose_1.model('Session', SessionSchema);
        const session = new Session();
        session.refreshToken = TokenGenerator_1.default(REFRESH_TOKEN_LENGTH);
        session.expiryDate = getExpiryDate();
        session.userId = userId;
        yield session.save();
        return { refreshToken: session.refreshToken, expiryDate: session.expiryDate };
    });
};
/** @see {@link ISessionModel#removeSession} */
SessionSchema.statics.removeSession = function (userId, refreshToken) {
    return __awaiter(this, void 0, void 0, function* () {
        return yield this.deleteOne({ userId, refreshToken });
    });
};
/** @see {@link ISessionModel#removeOutdatedSessions} */
SessionSchema.statics.removeOutdatedSessions = function (userId) {
    return __awaiter(this, void 0, void 0, function* () {
        return yield this.deleteMany({ userId, expiryDate: { $lt: new Date() } });
    });
};
/** @see {@link ISessionModel#removeOutdatedSessions} */
SessionSchema.statics.removeAllOutdatedSessions = function () {
    return __awaiter(this, void 0, void 0, function* () {
        return yield this.deleteMany({ expiryDate: { $lt: new Date() } });
    });
};
/** @see {@link ISessionModel#removeSession} */
SessionSchema.statics.updateSession = function (userId, refreshToken) {
    return __awaiter(this, void 0, void 0, function* () {
        const data = {
            expiryDate: getExpiryDate(),
            refreshToken: TokenGenerator_1.default(REFRESH_TOKEN_LENGTH),
        };
        yield this.updateOne({ userId, refreshToken }, data, { runValidators: true });
        return data;
    });
};
/** @see {@link ISessionModel#getUserAndSessionFromRefreshToken} */
SessionSchema.statics.getUserAndSessionFromRefreshToken = function (refreshToken) {
    return __awaiter(this, void 0, void 0, function* () {
        const aggregate = yield this.aggregate([
            { $match: { refreshToken } },
            {
                $lookup: {
                    as: 'user',
                    foreignField: '_id',
                    from: 'users',
                    localField: 'userId',
                },
            },
        ]);
        if (aggregate &&
            aggregate.length > 0 &&
            aggregate[0].user &&
            aggregate[0].user.length > 0 &&
            aggregate[0].user[0]) {
            return { user: aggregate[0].user[0], session: aggregate[0] };
        }
        else {
            throw new ErrorTypes_1.UnauthorizedError('Please login.');
        }
    });
};
const SessionModel = mongoose_1.model('Session', SessionSchema);
exports.default = SessionModel;
//# sourceMappingURL=SessionModel.js.map