oidc-client-rx/dist/flows/callback-handling/refresh-token-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 { 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 RefreshTokenCallbackHandlerService {
    refreshTokensRequestTokens(callbackContext, config, customParamsRefresh) {
        let headers = new HttpHeaders();
        headers = headers.set("Content-Type", "application/x-www-form-urlencoded");
        const authWellknownEndpoints = this.storagePersistenceService.read("authWellKnownEndPoints", config);
        const tokenEndpoint = authWellknownEndpoints?.tokenEndpoint;
        if (!tokenEndpoint) return throwError(()=>new Error("Token Endpoint not defined"));
        const data = this.urlService.createBodyForCodeFlowRefreshTokensRequest(callbackContext.refreshToken, config, customParamsRefresh);
        return this.dataService.post(tokenEndpoint, data, config, headers).pipe(switchMap((response)=>{
            this.loggerService.logDebug(config, `token refresh response: ${response}`);
            if (response) response.state = callbackContext.state;
            callbackContext.authResult = response;
            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.dataService = inject(DataService);
        this.storagePersistenceService = inject(StoragePersistenceService);
    }
}
RefreshTokenCallbackHandlerService = _ts_decorate([
    Injectable()
], RefreshTokenCallbackHandlerService);
export { RefreshTokenCallbackHandlerService };