angular-auth-oidc-client
Version:
Angular Lib for OpenID Connect & OAuth2
133 lines • 27.2 kB
JavaScript
import { Injectable } from '@angular/core';
import { forkJoin, of, throwError } from 'rxjs';
import { catchError, switchMap } from 'rxjs/operators';
import { EventTypes } from '../public-events/event-types';
import * as i0 from "@angular/core";
import * as i1 from "../flows/reset-auth-data.service";
import * as i2 from "../utils/flowHelper/flow-helper.service";
import * as i3 from "../flows/flows-data.service";
import * as i4 from "../logging/logger.service";
import * as i5 from "../user-data/user.service";
import * as i6 from "../auth-state/auth-state.service";
import * as i7 from "../iframe/refresh-session-iframe.service";
import * as i8 from "./refresh-session-refresh-token.service";
import * as i9 from "./interval.service";
import * as i10 from "../storage/storage-persistence.service";
import * as i11 from "../public-events/public-events.service";
import * as i12 from "../config/config.service";
export class PeriodicallyTokenCheckService {
constructor(resetAuthDataService, flowHelper, flowsDataService, loggerService, userService, authStateService, refreshSessionIframeService, refreshSessionRefreshTokenService, intervalService, storagePersistenceService, publicEventsService, configurationService) {
this.resetAuthDataService = resetAuthDataService;
this.flowHelper = flowHelper;
this.flowsDataService = flowsDataService;
this.loggerService = loggerService;
this.userService = userService;
this.authStateService = authStateService;
this.refreshSessionIframeService = refreshSessionIframeService;
this.refreshSessionRefreshTokenService = refreshSessionRefreshTokenService;
this.intervalService = intervalService;
this.storagePersistenceService = storagePersistenceService;
this.publicEventsService = publicEventsService;
this.configurationService = configurationService;
}
startTokenValidationPeriodically(allConfigs, currentConfig) {
const configsWithSilentRenewEnabled = this.getConfigsWithSilentRenewEnabled(allConfigs);
if (configsWithSilentRenewEnabled.length <= 0) {
return;
}
if (this.intervalService.isTokenValidationRunning()) {
return;
}
const refreshTimeInSeconds = this.getSmallestRefreshTimeFromConfigs(configsWithSilentRenewEnabled);
const periodicallyCheck$ = this.intervalService.startPeriodicTokenCheck(refreshTimeInSeconds).pipe(switchMap(() => {
const objectWithConfigIdsAndRefreshEvent = {};
configsWithSilentRenewEnabled.forEach((config) => {
objectWithConfigIdsAndRefreshEvent[config.configId] = this.getRefreshEvent(config, allConfigs);
});
return forkJoin(objectWithConfigIdsAndRefreshEvent);
}));
this.intervalService.runTokenValidationRunning = periodicallyCheck$
.pipe(catchError((error) => throwError(() => new Error(error))))
.subscribe({
next: (objectWithConfigIds) => {
for (const [configId, _] of Object.entries(objectWithConfigIds)) {
this.configurationService.getOpenIDConfiguration(configId).subscribe((config) => {
this.loggerService.logDebug(config, 'silent renew, periodic check finished!');
if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {
this.flowsDataService.resetSilentRenewRunning(config);
}
});
}
},
error: (error) => {
this.loggerService.logError(currentConfig, 'silent renew failed!', error);
},
});
}
getRefreshEvent(config, allConfigs) {
const shouldStartRefreshEvent = this.shouldStartPeriodicallyCheckForConfig(config);
if (!shouldStartRefreshEvent) {
return of(null);
}
const refreshEvent$ = this.createRefreshEventForConfig(config, allConfigs);
this.publicEventsService.fireEvent(EventTypes.SilentRenewStarted);
const refreshEventWithErrorHandler$ = refreshEvent$.pipe(catchError((error) => {
this.loggerService.logError(config, 'silent renew failed!', error);
this.flowsDataService.resetSilentRenewRunning(config);
return throwError(() => new Error(error));
}));
return refreshEventWithErrorHandler$;
}
getSmallestRefreshTimeFromConfigs(configsWithSilentRenewEnabled) {
const result = configsWithSilentRenewEnabled.reduce((prev, curr) => prev.tokenRefreshInSeconds < curr.tokenRefreshInSeconds ? prev : curr);
return result.tokenRefreshInSeconds;
}
getConfigsWithSilentRenewEnabled(allConfigs) {
return allConfigs.filter((x) => x.silentRenew);
}
createRefreshEventForConfig(configuration, allConfigs) {
this.loggerService.logDebug(configuration, 'starting silent renew...');
return this.configurationService.getOpenIDConfiguration(configuration.configId).pipe(switchMap((config) => {
if (!config?.silentRenew) {
this.resetAuthDataService.resetAuthorizationData(config, allConfigs);
return of(null);
}
this.flowsDataService.setSilentRenewRunning(config);
if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {
// Retrieve Dynamically Set Custom Params for refresh body
const customParamsRefresh = this.storagePersistenceService.read('storageCustomParamsRefresh', config) || {};
const { customParamsRefreshTokenRequest } = config;
const mergedParams = { ...customParamsRefreshTokenRequest, ...customParamsRefresh };
// Refresh Session using Refresh tokens
return this.refreshSessionRefreshTokenService.refreshSessionWithRefreshTokens(config, allConfigs, mergedParams);
}
// Retrieve Dynamically Set Custom Params
const customParams = this.storagePersistenceService.read('storageCustomParamsAuthRequest', config);
return this.refreshSessionIframeService.refreshSessionWithIframe(config, allConfigs, customParams);
}));
}
shouldStartPeriodicallyCheckForConfig(config) {
const idToken = this.authStateService.getIdToken(config);
const isSilentRenewRunning = this.flowsDataService.isSilentRenewRunning(config);
const isCodeFlowinProgress = this.flowsDataService.isCodeFlowInProgress(config);
const userDataFromStore = this.userService.getUserDataFromStore(config);
this.loggerService.logDebug(config, `Checking: silentRenewRunning: ${isSilentRenewRunning}, isCodeFlowInProgress: ${isCodeFlowinProgress} - has idToken: ${!!idToken} - has userData: ${!!userDataFromStore}`);
const shouldBeExecuted = !!userDataFromStore && !isSilentRenewRunning && !!idToken && !isCodeFlowinProgress;
if (!shouldBeExecuted) {
return false;
}
const idTokenStillValid = this.authStateService.hasIdTokenExpiredAndRenewCheckIsEnabled(config);
const accessTokenHasExpired = this.authStateService.hasAccessTokenExpiredIfExpiryExists(config);
if (!idTokenStillValid && !accessTokenHasExpired) {
return false;
}
return true;
}
}
PeriodicallyTokenCheckService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: PeriodicallyTokenCheckService, deps: [{ token: i1.ResetAuthDataService }, { token: i2.FlowHelper }, { token: i3.FlowsDataService }, { token: i4.LoggerService }, { token: i5.UserService }, { token: i6.AuthStateService }, { token: i7.RefreshSessionIframeService }, { token: i8.RefreshSessionRefreshTokenService }, { token: i9.IntervalService }, { token: i10.StoragePersistenceService }, { token: i11.PublicEventsService }, { token: i12.ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
PeriodicallyTokenCheckService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: PeriodicallyTokenCheckService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: PeriodicallyTokenCheckService, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: function () { return [{ type: i1.ResetAuthDataService }, { type: i2.FlowHelper }, { type: i3.FlowsDataService }, { type: i4.LoggerService }, { type: i5.UserService }, { type: i6.AuthStateService }, { type: i7.RefreshSessionIframeService }, { type: i8.RefreshSessionRefreshTokenService }, { type: i9.IntervalService }, { type: i10.StoragePersistenceService }, { type: i11.PublicEventsService }, { type: i12.ConfigurationService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"periodically-token-check.service.js","sourceRoot":"","sources":["../../../../../projects/angular-auth-oidc-client/src/lib/callback/periodically-token-check.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { forkJoin, Observable, of, throwError } from 'rxjs';\r\nimport { catchError, switchMap } from 'rxjs/operators';\r\nimport { AuthStateService } from '../auth-state/auth-state.service';\r\nimport { ConfigurationService } from '../config/config.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 { ResetAuthDataService } from '../flows/reset-auth-data.service';\r\nimport { RefreshSessionIframeService } from '../iframe/refresh-session-iframe.service';\r\nimport { LoggerService } from '../logging/logger.service';\r\nimport { EventTypes } from '../public-events/event-types';\r\nimport { PublicEventsService } from '../public-events/public-events.service';\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 { IntervalService } from './interval.service';\r\nimport { RefreshSessionRefreshTokenService } from './refresh-session-refresh-token.service';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class PeriodicallyTokenCheckService {\r\n  constructor(\r\n    private readonly resetAuthDataService: ResetAuthDataService,\r\n    private readonly flowHelper: FlowHelper,\r\n    private readonly flowsDataService: FlowsDataService,\r\n    private readonly loggerService: LoggerService,\r\n    private readonly userService: UserService,\r\n    private readonly authStateService: AuthStateService,\r\n    private readonly refreshSessionIframeService: RefreshSessionIframeService,\r\n    private readonly refreshSessionRefreshTokenService: RefreshSessionRefreshTokenService,\r\n    private intervalService: IntervalService,\r\n    private readonly storagePersistenceService: StoragePersistenceService,\r\n    private readonly publicEventsService: PublicEventsService,\r\n    private readonly configurationService: ConfigurationService\r\n  ) {}\r\n\r\n  startTokenValidationPeriodically(allConfigs: OpenIdConfiguration[], currentConfig: OpenIdConfiguration): void {\r\n    const configsWithSilentRenewEnabled = this.getConfigsWithSilentRenewEnabled(allConfigs);\r\n\r\n    if (configsWithSilentRenewEnabled.length <= 0) {\r\n      return;\r\n    }\r\n\r\n    if (this.intervalService.isTokenValidationRunning()) {\r\n      return;\r\n    }\r\n\r\n    const refreshTimeInSeconds = this.getSmallestRefreshTimeFromConfigs(configsWithSilentRenewEnabled);\r\n    const periodicallyCheck$ = this.intervalService.startPeriodicTokenCheck(refreshTimeInSeconds).pipe(\r\n      switchMap(() => {\r\n        const objectWithConfigIdsAndRefreshEvent = {};\r\n\r\n        configsWithSilentRenewEnabled.forEach((config) => {\r\n          objectWithConfigIdsAndRefreshEvent[config.configId] = this.getRefreshEvent(config, allConfigs);\r\n        });\r\n\r\n        return forkJoin(objectWithConfigIdsAndRefreshEvent);\r\n      })\r\n    );\r\n\r\n    this.intervalService.runTokenValidationRunning = periodicallyCheck$\r\n      .pipe(catchError((error) => throwError(() => new Error(error))))\r\n      .subscribe({\r\n        next: (objectWithConfigIds) => {\r\n          for (const [configId, _] of Object.entries(objectWithConfigIds)) {\r\n            this.configurationService.getOpenIDConfiguration(configId).subscribe((config) => {\r\n              this.loggerService.logDebug(config, 'silent renew, periodic check finished!');\r\n\r\n              if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {\r\n                this.flowsDataService.resetSilentRenewRunning(config);\r\n              }\r\n            });\r\n          }\r\n        },\r\n        error: (error) => {\r\n          this.loggerService.logError(currentConfig, 'silent renew failed!', error);\r\n        },\r\n      });\r\n  }\r\n\r\n  private getRefreshEvent(config: OpenIdConfiguration, allConfigs: OpenIdConfiguration[]): Observable<any> {\r\n    const shouldStartRefreshEvent = this.shouldStartPeriodicallyCheckForConfig(config);\r\n\r\n    if (!shouldStartRefreshEvent) {\r\n      return of(null);\r\n    }\r\n\r\n    const refreshEvent$ = this.createRefreshEventForConfig(config, allConfigs);\r\n\r\n    this.publicEventsService.fireEvent(EventTypes.SilentRenewStarted);\r\n\r\n    const refreshEventWithErrorHandler$ = refreshEvent$.pipe(\r\n      catchError((error) => {\r\n        this.loggerService.logError(config, 'silent renew failed!', error);\r\n        this.flowsDataService.resetSilentRenewRunning(config);\r\n\r\n        return throwError(() => new Error(error));\r\n      })\r\n    );\r\n\r\n    return refreshEventWithErrorHandler$;\r\n  }\r\n\r\n  private getSmallestRefreshTimeFromConfigs(configsWithSilentRenewEnabled: OpenIdConfiguration[]): number {\r\n    const result = configsWithSilentRenewEnabled.reduce((prev, curr) =>\r\n      prev.tokenRefreshInSeconds < curr.tokenRefreshInSeconds ? prev : curr\r\n    );\r\n\r\n    return result.tokenRefreshInSeconds;\r\n  }\r\n\r\n  private getConfigsWithSilentRenewEnabled(allConfigs: OpenIdConfiguration[]): OpenIdConfiguration[] {\r\n    return allConfigs.filter((x) => x.silentRenew);\r\n  }\r\n\r\n  private createRefreshEventForConfig(\r\n    configuration: OpenIdConfiguration,\r\n    allConfigs: OpenIdConfiguration[]\r\n  ): Observable<boolean | CallbackContext> {\r\n    this.loggerService.logDebug(configuration, 'starting silent renew...');\r\n\r\n    return this.configurationService.getOpenIDConfiguration(configuration.configId).pipe(\r\n      switchMap((config) => {\r\n        if (!config?.silentRenew) {\r\n          this.resetAuthDataService.resetAuthorizationData(config, allConfigs);\r\n\r\n          return of(null);\r\n        }\r\n\r\n        this.flowsDataService.setSilentRenewRunning(config);\r\n\r\n        if (this.flowHelper.isCurrentFlowCodeFlowWithRefreshTokens(config)) {\r\n          // Retrieve Dynamically Set Custom Params for refresh body\r\n          const customParamsRefresh: { [key: string]: string | number | boolean } =\r\n            this.storagePersistenceService.read('storageCustomParamsRefresh', config) || {};\r\n\r\n          const { customParamsRefreshTokenRequest } = config;\r\n\r\n          const mergedParams = { ...customParamsRefreshTokenRequest, ...customParamsRefresh };\r\n\r\n          // Refresh Session using Refresh tokens\r\n          return this.refreshSessionRefreshTokenService.refreshSessionWithRefreshTokens(config, allConfigs, mergedParams);\r\n        }\r\n\r\n        // Retrieve Dynamically Set Custom Params\r\n        const customParams: { [key: string]: string | number | boolean } = this.storagePersistenceService.read(\r\n          'storageCustomParamsAuthRequest',\r\n          config\r\n        );\r\n\r\n        return this.refreshSessionIframeService.refreshSessionWithIframe(config, allConfigs, customParams);\r\n      })\r\n    );\r\n  }\r\n\r\n  private shouldStartPeriodicallyCheckForConfig(config: OpenIdConfiguration): boolean {\r\n    const idToken = this.authStateService.getIdToken(config);\r\n    const isSilentRenewRunning = this.flowsDataService.isSilentRenewRunning(config);\r\n    const isCodeFlowinProgress = this.flowsDataService.isCodeFlowInProgress(config);\r\n    const userDataFromStore = this.userService.getUserDataFromStore(config);\r\n\r\n    this.loggerService.logDebug(\r\n      config,\r\n      `Checking: silentRenewRunning: ${isSilentRenewRunning}, isCodeFlowInProgress: ${isCodeFlowinProgress} - has idToken: ${!!idToken} - has userData: ${!!userDataFromStore}`\r\n    );\r\n\r\n    const shouldBeExecuted = !!userDataFromStore && !isSilentRenewRunning && !!idToken && !isCodeFlowinProgress;\r\n\r\n    if (!shouldBeExecuted) {\r\n      return false;\r\n    }\r\n\r\n    const idTokenStillValid = this.authStateService.hasIdTokenExpiredAndRenewCheckIsEnabled(config);\r\n    const accessTokenHasExpired = this.authStateService.hasAccessTokenExpiredIfExpiryExists(config);\r\n\r\n    if (!idTokenStillValid && !accessTokenHasExpired) {\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n}\r\n"]}