angular-auth-oidc-client
Version:
Angular Lib for OpenID Connect & OAuth2
116 lines • 22.1 kB
JavaScript
import { Injectable } from '@angular/core';
import { forkJoin, of, throwError, TimeoutError, timer } from 'rxjs';
import { map, mergeMap, retryWhen, switchMap, take, timeout } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "../utils/flowHelper/flow-helper.service";
import * as i2 from "../flows/flows-data.service";
import * as i3 from "../logging/logger.service";
import * as i4 from "../iframe/silent-renew.service";
import * as i5 from "../auth-state/auth-state.service";
import * as i6 from "../config/auth-well-known/auth-well-known.service";
import * as i7 from "../iframe/refresh-session-iframe.service";
import * as i8 from "../storage/storage-persistence.service";
import * as i9 from "./refresh-session-refresh-token.service";
import * as i10 from "../user-data/user.service";
export const MAX_RETRY_ATTEMPTS = 3;
export class RefreshSessionService {
constructor(flowHelper, flowsDataService, loggerService, silentRenewService, authStateService, authWellKnownService, refreshSessionIframeService, storagePersistenceService, refreshSessionRefreshTokenService, userService) {
this.flowHelper = flowHelper;
this.flowsDataService = flowsDataService;
this.loggerService = loggerService;
this.silentRenewService = silentRenewService;
this.authStateService = authStateService;
this.authWellKnownService = authWellKnownService;
this.refreshSessionIframeService = refreshSessionIframeService;
this.storagePersistenceService = storagePersistenceService;
this.refreshSessionRefreshTokenService = refreshSessionRefreshTokenService;
this.userService = userService;
}
userForceRefreshSession(config, allConfigs, extraCustomParams) {
this.persistCustomParams(extraCustomParams, config);
return this.forceRefreshSession(config, allConfigs, extraCustomParams);
}
forceRefreshSession(config, allConfigs, extraCustomParams) {
const { customParamsRefreshTokenRequest, configId } = config;
const mergedParams = { ...customParamsRefreshTokenRequest, ...extraCustomParams };
if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {
return this.startRefreshSession(config, allConfigs, mergedParams).pipe(map(() => {
const isAuthenticated = this.authStateService.areAuthStorageTokensValid(config);
if (isAuthenticated) {
return {
idToken: this.authStateService.getIdToken(config),
accessToken: this.authStateService.getAccessToken(config),
userData: this.userService.getUserDataFromStore(config),
isAuthenticated,
configId,
};
}
return null;
}));
}
const { silentRenewTimeoutInSeconds } = config;
const timeOutTime = silentRenewTimeoutInSeconds * 1000;
return forkJoin([
this.startRefreshSession(config, allConfigs, extraCustomParams),
this.silentRenewService.refreshSessionWithIFrameCompleted$.pipe(take(1)),
]).pipe(timeout(timeOutTime), retryWhen(this.timeoutRetryStrategy.bind(this)), map(([_, callbackContext]) => {
const isAuthenticated = this.authStateService.areAuthStorageTokensValid(config);
if (isAuthenticated) {
return {
idToken: callbackContext?.authResult?.id_token,
accessToken: callbackContext?.authResult?.access_token,
userData: this.userService.getUserDataFromStore(config),
isAuthenticated,
configId,
};
}
return null;
}));
}
persistCustomParams(extraCustomParams, config) {
const { useRefreshToken } = config;
if (extraCustomParams) {
if (useRefreshToken) {
this.storagePersistenceService.write('storageCustomParamsRefresh', extraCustomParams, config);
}
else {
this.storagePersistenceService.write('storageCustomParamsAuthRequest', extraCustomParams, config);
}
}
}
startRefreshSession(config, allConfigs, extraCustomParams) {
const isSilentRenewRunning = this.flowsDataService.isSilentRenewRunning(config);
this.loggerService.logDebug(config, `Checking: silentRenewRunning: ${isSilentRenewRunning}`);
const shouldBeExecuted = !isSilentRenewRunning;
if (!shouldBeExecuted) {
return of(null);
}
return this.authWellKnownService.queryAndStoreAuthWellKnownEndPoints(config).pipe(switchMap(() => {
this.flowsDataService.setSilentRenewRunning(config);
if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {
// Refresh Session using Refresh tokens
return this.refreshSessionRefreshTokenService.refreshSessionWithRefreshTokens(config, allConfigs, extraCustomParams);
}
return this.refreshSessionIframeService.refreshSessionWithIframe(config, allConfigs, extraCustomParams);
}));
}
timeoutRetryStrategy(errorAttempts, config) {
return errorAttempts.pipe(mergeMap((error, index) => {
const scalingDuration = 1000;
const currentAttempt = index + 1;
if (!(error instanceof TimeoutError) || currentAttempt > MAX_RETRY_ATTEMPTS) {
return throwError(() => new Error(error));
}
this.loggerService.logDebug(config, `forceRefreshSession timeout. Attempt #${currentAttempt}`);
this.flowsDataService.resetSilentRenewRunning(config);
return timer(currentAttempt * scalingDuration);
}));
}
}
RefreshSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RefreshSessionService, deps: [{ token: i1.FlowHelper }, { token: i2.FlowsDataService }, { token: i3.LoggerService }, { token: i4.SilentRenewService }, { token: i5.AuthStateService }, { token: i6.AuthWellKnownService }, { token: i7.RefreshSessionIframeService }, { token: i8.StoragePersistenceService }, { token: i9.RefreshSessionRefreshTokenService }, { token: i10.UserService }], target: i0.ɵɵFactoryTarget.Injectable });
RefreshSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RefreshSessionService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RefreshSessionService, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: function () { return [{ type: i1.FlowHelper }, { type: i2.FlowsDataService }, { type: i3.LoggerService }, { type: i4.SilentRenewService }, { type: i5.AuthStateService }, { type: i6.AuthWellKnownService }, { type: i7.RefreshSessionIframeService }, { type: i8.StoragePersistenceService }, { type: i9.RefreshSessionRefreshTokenService }, { type: i10.UserService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"refresh-session.service.js","sourceRoot":"","sources":["../../../../../projects/angular-auth-oidc-client/src/lib/callback/refresh-session.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { forkJoin, Observable, of, throwError, TimeoutError, timer } from 'rxjs';\r\nimport { map, mergeMap, retryWhen, switchMap, take, timeout } from 'rxjs/operators';\r\nimport { AuthStateService } from '../auth-state/auth-state.service';\r\nimport { AuthWellKnownService } from '../config/auth-well-known/auth-well-known.service';\r\nimport { OpenIdConfiguration } from '../config/openid-configuration';\r\nimport { CallbackContext } from '../flows/callback-context';\r\nimport { FlowsDataService } from '../flows/flows-data.service';\r\nimport { RefreshSessionIframeService } from '../iframe/refresh-session-iframe.service';\r\nimport { SilentRenewService } from '../iframe/silent-renew.service';\r\nimport { LoggerService } from '../logging/logger.service';\r\nimport { LoginResponse } from '../login/login-response';\r\nimport { StoragePersistenceService } from '../storage/storage-persistence.service';\r\nimport { UserService } from '../user-data/user.service';\r\nimport { FlowHelper } from '../utils/flowHelper/flow-helper.service';\r\nimport { RefreshSessionRefreshTokenService } from './refresh-session-refresh-token.service';\r\n\r\nexport const MAX_RETRY_ATTEMPTS = 3;\r\n@Injectable({ providedIn: 'root' })\r\nexport class RefreshSessionService {\r\n  constructor(\r\n    private readonly flowHelper: FlowHelper,\r\n    private readonly flowsDataService: FlowsDataService,\r\n    private readonly loggerService: LoggerService,\r\n    private readonly silentRenewService: SilentRenewService,\r\n    private readonly authStateService: AuthStateService,\r\n    private readonly authWellKnownService: AuthWellKnownService,\r\n    private readonly refreshSessionIframeService: RefreshSessionIframeService,\r\n    private readonly storagePersistenceService: StoragePersistenceService,\r\n    private readonly refreshSessionRefreshTokenService: RefreshSessionRefreshTokenService,\r\n    private readonly userService: UserService\r\n  ) {}\r\n\r\n  userForceRefreshSession(\r\n    config: OpenIdConfiguration,\r\n    allConfigs: OpenIdConfiguration[],\r\n    extraCustomParams?: { [key: string]: string | number | boolean }\r\n  ): Observable<LoginResponse> {\r\n    this.persistCustomParams(extraCustomParams, config);\r\n\r\n    return this.forceRefreshSession(config, allConfigs, extraCustomParams);\r\n  }\r\n\r\n  forceRefreshSession(\r\n    config: OpenIdConfiguration,\r\n    allConfigs: OpenIdConfiguration[],\r\n    extraCustomParams?: { [key: string]: string | number | boolean }\r\n  ): Observable<LoginResponse> {\r\n    const { customParamsRefreshTokenRequest, configId } = config;\r\n    const mergedParams = { ...customParamsRefreshTokenRequest, ...extraCustomParams };\r\n\r\n    if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {\r\n      return this.startRefreshSession(config, allConfigs, mergedParams).pipe(\r\n        map(() => {\r\n          const isAuthenticated = this.authStateService.areAuthStorageTokensValid(config);\r\n\r\n          if (isAuthenticated) {\r\n            return {\r\n              idToken: this.authStateService.getIdToken(config),\r\n              accessToken: this.authStateService.getAccessToken(config),\r\n              userData: this.userService.getUserDataFromStore(config),\r\n              isAuthenticated,\r\n              configId,\r\n            } as LoginResponse;\r\n          }\r\n\r\n          return null;\r\n        })\r\n      );\r\n    }\r\n\r\n    const { silentRenewTimeoutInSeconds } = config;\r\n    const timeOutTime = silentRenewTimeoutInSeconds * 1000;\r\n\r\n    return forkJoin([\r\n      this.startRefreshSession(config, allConfigs, extraCustomParams),\r\n      this.silentRenewService.refreshSessionWithIFrameCompleted$.pipe(take(1)),\r\n    ]).pipe(\r\n      timeout(timeOutTime),\r\n      retryWhen(this.timeoutRetryStrategy.bind(this)),\r\n      map(([_, callbackContext]) => {\r\n        const isAuthenticated = this.authStateService.areAuthStorageTokensValid(config);\r\n\r\n        if (isAuthenticated) {\r\n          return {\r\n            idToken: callbackContext?.authResult?.id_token,\r\n            accessToken: callbackContext?.authResult?.access_token,\r\n            userData: this.userService.getUserDataFromStore(config),\r\n            isAuthenticated,\r\n            configId,\r\n          };\r\n        }\r\n\r\n        return null;\r\n      })\r\n    );\r\n  }\r\n\r\n  private persistCustomParams(extraCustomParams: { [key: string]: string | number | boolean }, config: OpenIdConfiguration): void {\r\n    const { useRefreshToken } = config;\r\n\r\n    if (extraCustomParams) {\r\n      if (useRefreshToken) {\r\n        this.storagePersistenceService.write('storageCustomParamsRefresh', extraCustomParams, config);\r\n      } else {\r\n        this.storagePersistenceService.write('storageCustomParamsAuthRequest', extraCustomParams, config);\r\n      }\r\n    }\r\n  }\r\n\r\n  private startRefreshSession(\r\n    config: OpenIdConfiguration,\r\n    allConfigs: OpenIdConfiguration[],\r\n    extraCustomParams?: { [key: string]: string | number | boolean }\r\n  ): Observable<boolean | CallbackContext | null> {\r\n    const isSilentRenewRunning = this.flowsDataService.isSilentRenewRunning(config);\r\n\r\n    this.loggerService.logDebug(config, `Checking: silentRenewRunning: ${isSilentRenewRunning}`);\r\n    const shouldBeExecuted = !isSilentRenewRunning;\r\n\r\n    if (!shouldBeExecuted) {\r\n      return of(null);\r\n    }\r\n\r\n    return this.authWellKnownService.queryAndStoreAuthWellKnownEndPoints(config).pipe(\r\n      switchMap(() => {\r\n        this.flowsDataService.setSilentRenewRunning(config);\r\n\r\n        if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {\r\n          // Refresh Session using Refresh tokens\r\n          return this.refreshSessionRefreshTokenService.refreshSessionWithRefreshTokens(config, allConfigs, extraCustomParams);\r\n        }\r\n\r\n        return this.refreshSessionIframeService.refreshSessionWithIframe(config, allConfigs, extraCustomParams);\r\n      })\r\n    );\r\n  }\r\n\r\n  private timeoutRetryStrategy(errorAttempts: Observable<any>, config: OpenIdConfiguration): Observable<number> {\r\n    return errorAttempts.pipe(\r\n      mergeMap((error, index) => {\r\n        const scalingDuration = 1000;\r\n        const currentAttempt = index + 1;\r\n\r\n        if (!(error instanceof TimeoutError) || currentAttempt > MAX_RETRY_ATTEMPTS) {\r\n          return throwError(() => new Error(error));\r\n        }\r\n\r\n        this.loggerService.logDebug(config, `forceRefreshSession timeout. Attempt #${currentAttempt}`);\r\n\r\n        this.flowsDataService.resetSilentRenewRunning(config);\r\n\r\n        return timer(currentAttempt * scalingDuration);\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}