@webda/core/lib/utils/session.js

Expose API with Lambda

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;
};
import { NotEnumerable } from "../models/coremodel.js";
import { Inject, Service, ServiceParameters } from "../services/service.js";
import { WebContext } from "./context.js";
import { CookieOptions, SecureCookie } from "./cookie.js";
/**
 * Manage load and save of sessions
 */
export class SessionManager extends Service {
}
export class CookieSessionParameters extends ServiceParameters {
    constructor(params) {
        super(params);
        this.cookie ?? (this.cookie = new CookieOptions(params.cookie || {}));
    }
}
/**
 * SessionManager that store info in a cookie
 *
 * If SessionStore service exists, only uuid is in the cookie
 * the rest of data is stored within the session store
 *
 * @WebdaModda
 */
export class CookieSessionManager extends SessionManager {
    /**
     * @override
     */
    loadParameters(params) {
        return new CookieSessionParameters(params);
    }
    /**
     * @override
     */
    resolve() {
        super.resolve();
        if (this.sessionStore && this.sessionStore.getParameters().expose) {
            throw new Error("SessionStore should not be exposed");
        }
        return this;
    }
    /**
     * @override
     */
    async load(context) {
        if (!(context instanceof WebContext)) {
            return new Session();
        }
        const session = new Session();
        let cookie = await SecureCookie.load(this.parameters.cookie.name, context, this.parameters.jwt);
        if (this.sessionStore) {
            if (cookie.sub) {
                Object.assign(session, (await this.sessionStore.get(cookie.sub))?.session);
                session.uuid = cookie.sub;
            }
            session.uuid ?? (session.uuid = context.getWebda().getUuid("base64"));
        }
        else {
            Object.assign(session, cookie);
        }
        return session;
    }
    /**
     * @override
     */
    async newSession(context) {
        return new Session();
    }
    /**
     * @override
     */
    async save(context, session) {
        if (!(context instanceof WebContext)) {
            return;
        }
        // If store is found session info are stored in db
        if (this.sessionStore) {
            await this.sessionStore.save({
                uuid: session.uuid,
                session,
                ttl: Date.now() + this.parameters.cookie.maxAge * 1000
            });
            SecureCookie.save(this.parameters.cookie.name, context, {}, { ...this.parameters.jwt, subject: session.uuid.toString() }, this.parameters.cookie);
            return;
        }
        SecureCookie.save(this.parameters.cookie.name, context, session, this.parameters.jwt, this.parameters.cookie);
    }
}
__decorate([
    Inject("CryptoService")
], CookieSessionManager.prototype, "cryptoService", void 0);
__decorate([
    Inject("SessionStore", true)
], CookieSessionManager.prototype, "sessionStore", void 0);
/**
 * Session
 */
export class Session {
    constructor() {
        this.changed = false;
    }
    /**
     * Login
     * @param userId
     * @param identUsed
     */
    login(userId, identUsed) {
        this.userId = userId;
        this.identUsed = identUsed;
    }
    /**
     * Logout
     */
    logout() {
        delete this.userId;
        delete this.identUsed;
        delete this.roles;
    }
    /**
     * If session is authenticated
     */
    isLogged() {
        return this.userId !== undefined;
    }
    /**
     * Session is dirty and requires save
     * @returns
     */
    isDirty() {
        return this.changed;
    }
    /**
     * Get the proxy to be able to track modification
     * @returns
     */
    getProxy() {
        const proxyHandler = {
            set: (obj, property, value) => {
                this.changed = true;
                obj[property] = value;
                return true;
            },
            get: (obj, property) => {
                if (typeof obj[property] === "object") {
                    return new Proxy(obj[property], proxyHandler);
                }
                return obj[property];
            }
        };
        return new Proxy(this, proxyHandler);
    }
}
__decorate([
    NotEnumerable
], Session.prototype, "changed", void 0);
/**
 * Unknown session that allows all keys
 */
export class UnknownSession extends Session {
}
//# sourceMappingURL=session.js.map