rauth/session/SessionControl.js

Authentication and Authorization library via JWT

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const uuid_1 = __importDefault(require("uuid"));
const ConnectionStore_1 = require("../store/ConnectionStore");
const Error_1 = require("../util/Error");
const JWTControl_1 = require("./JWTControl");
const Session_1 = require("./Session");
require("../engines/MemoryEngine");
class SessionControl {
    constructor(opts) {
        this.opts = opts;
        this.jwtControl = this.opts?.jwtControl instanceof JWTControl_1.JWTControl ? this.opts.jwtControl : new JWTControl_1.JWTControl(this.opts?.jwtControl);
        this.connectionStore = this.opts?.connectionStore ?? new ConnectionStore_1.ConnectionStore(this.opts?.engineConnectionStore ?? 'Memory');
        this.accessTokenExpires = this.opts?.accessTokenExpires ?? '1h';
        this.refreshTokenExpires = this.opts?.refreshTokenExpires ?? '4w';
        this.events = new events_1.EventEmitter();
    }
    async verify(accessToken, options) {
        return Session_1.Session.from(this.jwtControl.verify(accessToken, {
            subject: 'access_token',
            ...options,
        }), this);
    }
    async createSession(userId, scope = '', data, moreData) {
        const register = await this.connectionStore.create({
            userId,
            scope,
            sessionId: uuid_1.default(),
            createdAt: Date.now(),
            refreshAt: Date.now(),
            ...moreData,
        });
        register.data = data;
        this.emit('create-session', { register });
        return Session_1.Session.from(register, this);
    }
    async createUnregisterSession(userId, scope, data, signOptions) {
        const session = Session_1.Session.from({
            scope,
            data,
            userId: userId.toString(),
            sessionId: uuid_1.default(),
        }, this);
        return session;
    }
    async refreshSession(refreshToken, options) {
        const tokenDecoded = this.jwtControl.verify(refreshToken, {
            subject: 'refresh_token',
        });
        const register = await this.connectionStore.findById(tokenDecoded.sessionId);
        if (!register) {
            throw new Error_1.RAuthError('Not found Session');
        }
        if (tokenDecoded.refreshAt.toString() !== register.refreshAt.toString()) {
            throw new Error_1.RAuthError('Token is not valid');
        }
        const nextRegister = await this.connectionStore.update(register, {
            refreshAt: Date.now(),
        });
        nextRegister.data = options?.data;
        this.emit('refresh-session', { register: nextRegister });
        return Session_1.Session.from(nextRegister, this);
    }
    async revokeSession(session) {
        if (session.sessionId) {
            return this.connectionStore.deleteById(session.sessionId);
        }
        return false;
    }
    async revokeAllSessions(session) {
        if (session.userId) {
            return this.connectionStore.deleteByUserId(session.userId);
        }
        return false;
    }
    async getAllSessions(session) {
        const registers = session.userId ? await this.connectionStore.findByUserId(session.userId) : [];
        return registers.map(register => Session_1.Session.from(register, this));
    }
    emit(event, ...args) {
        return this.events.emit(event, ...args);
    }
    on(event, listener) {
        return this.events.on(event, listener);
    }
}
exports.SessionControl = SessionControl;
//# sourceMappingURL=SessionControl.js.map