tickethead-sdk/dist/src/credential/jwt-credentials.js

SDK for the Tickethead API

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.JwtCredentials = void 0;
exports.isRefreshableToken = isRefreshableToken;
const credential_1 = require("./credential");
const jwt_1 = require("../utils/jwt");
/**
 * This class is used for restoring the authorization
 */
class JwtCredentials {
    constructor(jwt) {
        this.jwt = jwt;
        this.type = credential_1.CredentialType.Jwt;
    }
    getToken() {
        return this.jwt;
    }
    authorize(authService, organizer) {
        return __awaiter(this, void 0, void 0, function* () {
            // Refresh an organizer if it is specified and theres been a change
            // This is since we need a new jwt for the new organizer
            if (isRefreshableToken(this.jwt) &&
                organizer &&
                organizer !== this.jwt.organizerId &&
                !this.hasOrganizerInToken(this.jwt, organizer)) {
                // This handles a case in the build function where we have the organizer specified right away
                // But the token is not set in the authorization header, leading to errors when you need to refresh
                // it right at the start. This makes it so that the token we have in this.jwt is used.
                if (this.hasAuthorizationHeaders(authService)) {
                    this.jwt = yield authService.refreshToken({
                        refreshToken: this.jwt.refreshToken,
                        organizerId: organizer,
                    });
                }
                else {
                    this.jwt = yield authService.refreshToken({
                        refreshToken: this.jwt.refreshToken,
                        organizerId: organizer,
                    }, this.jwt);
                }
                // Re-add the organizer ID to the JWT
                ;
                this.jwt.organizerId = organizer;
            }
            return this.jwt;
        });
    }
    hasAuthorizationHeaders(authService) {
        return authService.client.defaults.headers.common.Authorization != null;
    }
    refreshToken(authService, organizer) {
        return __awaiter(this, void 0, void 0, function* () {
            // If the token can be refreshed, do it
            if (isRefreshableToken(this.jwt)) {
                if (organizer) {
                    this.jwt = yield authService.refreshToken({
                        refreshToken: this.jwt.refreshToken,
                        organizerId: organizer,
                    });
                    this.jwt.organizerId = organizer;
                }
                else {
                    this.jwt = yield authService.refreshToken(this.jwt);
                }
            }
            return this.jwt;
        });
    }
    hasOrganizerInToken(jwt, organizer) {
        if (!(jwt === null || jwt === void 0 ? void 0 : jwt.token) || !organizer)
            return false;
        const orgsInToken = (0, jwt_1.extractOrganizersFromJwt)(jwt);
        return !!orgsInToken.find((org) => org == organizer);
    }
    isRefreshable() {
        return isRefreshableToken(this.jwt);
    }
}
exports.JwtCredentials = JwtCredentials;
function isRefreshableToken(jwt) {
    return jwt.refreshToken !== undefined;
}
//# sourceMappingURL=jwt-credentials.js.map