oidc-client-rx/dist/flows/callback-handling/code-flow-callback-handler.service.js

ReactiveX enhanced OIDC and OAuth2 protocol support for browser-based JavaScript applications

import { HttpHeaders } from "@ngify/http";
import { Injectable, inject } from "injection-js";
import { of, throwError, timer } from "rxjs";
import { catchError, mergeMap, retryWhen, switchMap } from "rxjs/operators";
import { DataService } from "../../api/data.service.js";
import { LoggerService } from "../../logging/logger.service.js";
import { StoragePersistenceService } from "../../storage/storage-persistence.service.js";
import { UrlService } from "../../utils/url/url.service.js";
import { TokenValidationService } from "../../validation/token-validation.service.js";
import { FlowsDataService } from "../flows-data.service.js";
import { isNetworkError } from "./error-helper.js";
function _ts_decorate(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) 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;
}
class CodeFlowCallbackHandlerService {
    codeFlowCallback(urlToCheck, config) {
        const code = this.urlService.getUrlParameter(urlToCheck, "code");
        const state = this.urlService.getUrlParameter(urlToCheck, "state");
        const sessionState = this.urlService.getUrlParameter(urlToCheck, "session_state");
        if (!state) {
            this.loggerService.logDebug(config, "no state in url");
            return throwError(()=>new Error("no state in url"));
        }
        if (!code) {
            this.loggerService.logDebug(config, "no code in url");
            return throwError(()=>new Error("no code in url"));
        }
        this.loggerService.logDebug(config, "running validation for callback", urlToCheck);
        const initialCallbackContext = {
            code,
            refreshToken: "",
            state,
            sessionState,
            authResult: null,
            isRenewProcess: false,
            jwtKeys: null,
            validationResult: null,
            existingIdToken: null
        };
        return of(initialCallbackContext);
    }
    codeFlowCodeRequest(callbackContext, config) {
        const authStateControl = this.flowsDataService.getAuthStateControl(config);
        const isStateCorrect = this.tokenValidationService.validateStateFromHashCallback(callbackContext.state, authStateControl, config);
        if (!isStateCorrect) return throwError(()=>new Error("codeFlowCodeRequest incorrect state"));
        const authWellknownEndpoints = this.storagePersistenceService.read("authWellKnownEndPoints", config);
        const tokenEndpoint = authWellknownEndpoints?.tokenEndpoint;
        if (!tokenEndpoint) return throwError(()=>new Error("Token Endpoint not defined"));
        let headers = new HttpHeaders();
        headers = headers.set("Content-Type", "application/x-www-form-urlencoded");
        const bodyForCodeFlow = this.urlService.createBodyForCodeFlowCodeRequest(callbackContext.code, config, config?.customParamsCodeRequest);
        return this.dataService.post(tokenEndpoint, bodyForCodeFlow, config, headers).pipe(switchMap((response)=>{
            if (response) {
                const authResult = {
                    ...response,
                    state: callbackContext.state,
                    session_state: callbackContext.sessionState
                };
                callbackContext.authResult = authResult;
            }
            return of(callbackContext);
        }), retryWhen((error)=>this.handleRefreshRetry(error, config)), catchError((error)=>{
            const { authority } = config;
            const errorMessage = `OidcService code request ${authority}`;
            this.loggerService.logError(config, errorMessage, error);
            return throwError(()=>new Error(errorMessage));
        }));
    }
    handleRefreshRetry(errors, config) {
        return errors.pipe(mergeMap((error)=>{
            if (isNetworkError(error)) {
                const { authority, refreshTokenRetryInSeconds } = config;
                const errorMessage = `OidcService code request ${authority} - no internet connection`;
                this.loggerService.logWarning(config, errorMessage, error);
                return timer((refreshTokenRetryInSeconds ?? 0) * 1000);
            }
            return throwError(()=>error);
        }));
    }
    constructor(){
        this.urlService = inject(UrlService);
        this.loggerService = inject(LoggerService);
        this.tokenValidationService = inject(TokenValidationService);
        this.flowsDataService = inject(FlowsDataService);
        this.storagePersistenceService = inject(StoragePersistenceService);
        this.dataService = inject(DataService);
    }
}
CodeFlowCallbackHandlerService = _ts_decorate([
    Injectable()
], CodeFlowCallbackHandlerService);
export { CodeFlowCallbackHandlerService };