@spartacus/core
Version:
Spartacus - the core framework
248 lines • 36.9 kB
JavaScript
import { Injectable } from '@angular/core';
import { combineLatest, defer, EMPTY, queueScheduler, Subject, Subscription, using, } from 'rxjs';
import { filter, map, observeOn, pairwise, shareReplay, skipWhile, switchMap, take, tap, withLatestFrom, } from 'rxjs/operators';
import { GlobalMessageType } from '../../../global-message/models/global-message.model';
import * as i0 from "@angular/core";
import * as i1 from "../facade/auth.service";
import * as i2 from "./auth-storage.service";
import * as i3 from "./oauth-lib-wrapper.service";
import * as i4 from "../../../routing/facade/routing.service";
import * as i5 from "../../../occ/services/occ-endpoints.service";
import * as i6 from "../../../global-message/facade/global-message.service";
import * as i7 from "./auth-redirect.service";
/**
* Extendable service for `AuthInterceptor`.
*/
export class AuthHttpHeaderService {
constructor(authService, authStorageService, oAuthLibWrapperService, routingService, occEndpoints, globalMessageService, authRedirectService) {
this.authService = authService;
this.authStorageService = authStorageService;
this.oAuthLibWrapperService = oAuthLibWrapperService;
this.routingService = routingService;
this.occEndpoints = occEndpoints;
this.globalMessageService = globalMessageService;
this.authRedirectService = authRedirectService;
/**
* Indicates whether the access token is being refreshed
*
* @deprecated will be removed in the next major. Use `AuthService.refreshInProgress$` instead.
*/
// TODO:#13421 - legacy, remove this flag
this.refreshInProgress = false;
/**
* Starts the refresh of the access token
*/
this.refreshTokenTrigger$ = new Subject();
/**
* Internal token streams which reads the latest from the storage.
* Emits the token or `undefined`
*/
this.token$ = this.authStorageService
.getToken()
.pipe(map((token) => ((token === null || token === void 0 ? void 0 : token.access_token) ? token : undefined)));
/**
* Compares the previous and the new token in order to stop the refresh or logout processes
*/
this.stopProgress$ = this.token$.pipe(
// Keeps the previous and the new token
pairwise(), tap(([oldToken, newToken]) => {
// if we got the new token we know that either the refresh or logout finished
if ((oldToken === null || oldToken === void 0 ? void 0 : oldToken.access_token) !== (newToken === null || newToken === void 0 ? void 0 : newToken.access_token)) {
this.authService.setLogoutProgress(false);
this.authService.setRefreshProgress(false);
}
}));
/**
* Refreshes the token only if currently there's no refresh nor logout in progress.
* If the refresh token is not present, it triggers the logout process
*/
this.refreshToken$ = this.refreshTokenTrigger$.pipe(withLatestFrom(this.authService.refreshInProgress$, this.authService.logoutInProgress$), filter(([, refreshInProgress, logoutInProgress]) => !refreshInProgress && !logoutInProgress), tap(([token]) => {
if (token === null || token === void 0 ? void 0 : token.refresh_token) {
this.oAuthLibWrapperService.refreshToken();
this.authService.setRefreshProgress(true);
}
else {
this.handleExpiredRefreshToken();
}
}));
/**
* Kicks of the process by listening to the new token and refresh token processes.
* This token should be used when retrying the failed http request.
*/
this.tokenToRetryRequest$ = using(() => this.refreshToken$.subscribe(), () => this.getStableToken()).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
this.subscriptions = new Subscription();
// We need to have stopProgress$ stream active for the whole time,
// so when the logout finishes we finish it's process.
// It could happen when retryToken$ is not active.
this.subscriptions.add(this.stopProgress$.subscribe());
}
/**
* Checks if request should be handled by this service (if it's OCC call).
*/
shouldCatchError(request) {
return this.isOccUrl(request.url);
}
shouldAddAuthorizationHeader(request) {
const hasAuthorizationHeader = !!this.getAuthorizationHeader(request);
const isOccUrl = this.isOccUrl(request.url);
return !hasAuthorizationHeader && isOccUrl;
}
/**
* Adds `Authorization` header for OCC calls.
*/
alterRequest(request, token) {
const hasAuthorizationHeader = !!this.getAuthorizationHeader(request);
const isOccUrl = this.isOccUrl(request.url);
if (!hasAuthorizationHeader && isOccUrl) {
return request.clone({
setHeaders: Object.assign({}, this.createAuthorizationHeader(token)),
});
}
return request;
}
isOccUrl(url) {
return url.includes(this.occEndpoints.getBaseUrl());
}
getAuthorizationHeader(request) {
const rawValue = request.headers.get('Authorization');
return rawValue;
}
createAuthorizationHeader(token) {
if (token === null || token === void 0 ? void 0 : token.access_token) {
return {
Authorization: `${token.token_type || 'Bearer'} ${token.access_token}`,
};
}
let currentToken;
this.authStorageService
.getToken()
.subscribe((token) => (currentToken = token))
.unsubscribe();
if (currentToken === null || currentToken === void 0 ? void 0 : currentToken.access_token) {
return {
Authorization: `${currentToken.token_type || 'Bearer'} ${currentToken.access_token}`,
};
}
return {};
}
/**
* Refreshes access_token and then retries the call with the new token.
*/
handleExpiredAccessToken(request, next,
// TODO:#13421 make required
initialToken) {
// TODO:#13421 remove this if-statement, and just return the stream.
if (initialToken) {
return this.getValidToken(initialToken).pipe(switchMap((token) =>
// we break the stream with EMPTY when we don't have the token. This prevents sending the requests with `Authorization: bearer undefined` header
token
? next.handle(this.createNewRequestWithNewToken(request, token))
: EMPTY));
}
// TODO:#13421 legacy - remove in 5.0
return this.handleExpiredToken().pipe(switchMap((token) => {
return token
? next.handle(this.createNewRequestWithNewToken(request, token))
: EMPTY;
}));
}
/**
* Logout user, redirected to login page and informs about expired session.
*/
handleExpiredRefreshToken() {
// There might be 2 cases:
// 1. when user is already on some page (router is stable) and performs an UI action
// that triggers http call (i.e. button click to save data in backend)
// 2. when user is navigating to some page and a route guard triggers the http call
// (i.e. guard loading cms page data)
//
// In the second case, we want to remember the anticipated url before we navigate to
// the login page, so we can redirect back to that URL after user authenticates.
this.authRedirectService.saveCurrentNavigationUrl();
// Logout user
// TODO(#9638): Use logout route when it will support passing redirect url
this.authService.coreLogout().finally(() => {
this.routingService.go({ cxRoute: 'login' });
this.globalMessageService.add({
key: 'httpHandlers.sessionExpired',
}, GlobalMessageType.MSG_TYPE_ERROR);
});
}
// TODO:#13421 - remove this method
/**
* Attempts to refresh token if possible.
* If it is not possible calls `handleExpiredRefreshToken`.
*
* @return observable which omits new access_token. (Warn: might never emit!).
*
* @deprecated will be removed in the next major. Use `getValidToken()` instead
*/
handleExpiredToken() {
const stream = this.authStorageService.getToken();
let oldToken;
return stream.pipe(tap((token) => {
if (token.access_token &&
token.refresh_token &&
!oldToken &&
!this.refreshInProgress) {
this.refreshInProgress = true;
this.oAuthLibWrapperService.refreshToken();
}
else if (!token.refresh_token) {
this.handleExpiredRefreshToken();
}
oldToken = oldToken || token;
}), filter((token) => oldToken.access_token !== token.access_token), tap(() => {
this.refreshInProgress = false;
}), map((token) => ((token === null || token === void 0 ? void 0 : token.access_token) ? token : undefined)), take(1));
}
/**
* Emits the token or `undefined` only when the refresh or the logout processes are finished.
*/
getStableToken() {
return combineLatest([
this.token$,
this.authService.refreshInProgress$,
this.authService.logoutInProgress$,
]).pipe(observeOn(queueScheduler), filter(([_, refreshInProgress, logoutInProgress]) => !refreshInProgress && !logoutInProgress), switchMap(() => this.token$));
}
/**
* Returns a valid access token.
* It will attempt to refresh it if the current one expired; emits after the new one is retrieved.
*/
getValidToken(requestToken) {
return defer(() => {
// flag to only refresh token only on first emission
let refreshTriggered = false;
return this.tokenToRetryRequest$.pipe(tap((token) => {
// we want to refresh the access token only when it is old.
// this is a guard for the case when there are multiple parallel http calls
if ((token === null || token === void 0 ? void 0 : token.access_token) === (requestToken === null || requestToken === void 0 ? void 0 : requestToken.access_token) &&
!refreshTriggered) {
this.refreshTokenTrigger$.next(token);
}
refreshTriggered = true;
}), skipWhile((token) => (token === null || token === void 0 ? void 0 : token.access_token) === requestToken.access_token), take(1));
});
}
createNewRequestWithNewToken(request, token) {
request = request.clone({
setHeaders: {
Authorization: `${token.token_type || 'Bearer'} ${token.access_token}`,
},
});
return request;
}
ngOnDestroy() {
this.subscriptions.unsubscribe();
}
}
AuthHttpHeaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: AuthHttpHeaderService, deps: [{ token: i1.AuthService }, { token: i2.AuthStorageService }, { token: i3.OAuthLibWrapperService }, { token: i4.RoutingService }, { token: i5.OccEndpointsService }, { token: i6.GlobalMessageService }, { token: i7.AuthRedirectService }], target: i0.ɵɵFactoryTarget.Injectable });
AuthHttpHeaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: AuthHttpHeaderService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: AuthHttpHeaderService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], ctorParameters: function () { return [{ type: i1.AuthService }, { type: i2.AuthStorageService }, { type: i3.OAuthLibWrapperService }, { type: i4.RoutingService }, { type: i5.OccEndpointsService }, { type: i6.GlobalMessageService }, { type: i7.AuthRedirectService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-http-header.service.js","sourceRoot":"","sources":["../../../../../../../projects/core/src/auth/user-auth/services/auth-http-header.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpEvent, HttpHandler, HttpRequest } from '@angular/common/http';\nimport { Injectable, OnDestroy } from '@angular/core';\nimport {\n  combineLatest,\n  defer,\n  EMPTY,\n  Observable,\n  queueScheduler,\n  Subject,\n  Subscription,\n  using,\n} from 'rxjs';\nimport {\n  filter,\n  map,\n  observeOn,\n  pairwise,\n  shareReplay,\n  skipWhile,\n  switchMap,\n  take,\n  tap,\n  withLatestFrom,\n} from 'rxjs/operators';\nimport { GlobalMessageService } from '../../../global-message/facade/global-message.service';\nimport { GlobalMessageType } from '../../../global-message/models/global-message.model';\nimport { OccEndpointsService } from '../../../occ/services/occ-endpoints.service';\nimport { RoutingService } from '../../../routing/facade/routing.service';\nimport { AuthService } from '../facade/auth.service';\nimport { AuthToken } from '../models/auth-token.model';\nimport { AuthRedirectService } from './auth-redirect.service';\nimport { AuthStorageService } from './auth-storage.service';\nimport { OAuthLibWrapperService } from './oauth-lib-wrapper.service';\n\n/**\n * Extendable service for `AuthInterceptor`.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class AuthHttpHeaderService implements OnDestroy {\n  /**\n   * Indicates whether the access token is being refreshed\n   *\n   * @deprecated will be removed in the next major. Use `AuthService.refreshInProgress$` instead.\n   */\n  // TODO:#13421 - legacy, remove this flag\n  protected refreshInProgress = false;\n\n  /**\n   * Starts the refresh of the access token\n   */\n  protected refreshTokenTrigger$ = new Subject<AuthToken>();\n\n  /**\n   * Internal token streams which reads the latest from the storage.\n   * Emits the token or `undefined`\n   */\n  protected token$: Observable<AuthToken | undefined> = this.authStorageService\n    .getToken()\n    .pipe(map((token) => (token?.access_token ? token : undefined)));\n\n  /**\n   * Compares the previous and the new token in order to stop the refresh or logout processes\n   */\n  protected stopProgress$ = this.token$.pipe(\n    // Keeps the previous and the new token\n    pairwise(),\n    tap(([oldToken, newToken]) => {\n      // if we got the new token we know that either the refresh or logout finished\n      if (oldToken?.access_token !== newToken?.access_token) {\n        this.authService.setLogoutProgress(false);\n        this.authService.setRefreshProgress(false);\n      }\n    })\n  );\n\n  /**\n   * Refreshes the token only if currently there's no refresh nor logout in progress.\n   * If the refresh token is not present, it triggers the logout process\n   */\n  protected refreshToken$ = this.refreshTokenTrigger$.pipe(\n    withLatestFrom(\n      this.authService.refreshInProgress$,\n      this.authService.logoutInProgress$\n    ),\n    filter(\n      ([, refreshInProgress, logoutInProgress]) =>\n        !refreshInProgress && !logoutInProgress\n    ),\n    tap(([token]) => {\n      if (token?.refresh_token) {\n        this.oAuthLibWrapperService.refreshToken();\n        this.authService.setRefreshProgress(true);\n      } else {\n        this.handleExpiredRefreshToken();\n      }\n    })\n  );\n\n  /**\n   * Kicks of the process by listening to the new token and refresh token processes.\n   * This token should be used when retrying the failed http request.\n   */\n  protected tokenToRetryRequest$ = using(\n    () => this.refreshToken$.subscribe(),\n    () => this.getStableToken()\n  ).pipe(shareReplay({ refCount: true, bufferSize: 1 }));\n\n  protected subscriptions = new Subscription();\n\n  constructor(\n    protected authService: AuthService,\n    protected authStorageService: AuthStorageService,\n    protected oAuthLibWrapperService: OAuthLibWrapperService,\n    protected routingService: RoutingService,\n    protected occEndpoints: OccEndpointsService,\n    protected globalMessageService: GlobalMessageService,\n    protected authRedirectService: AuthRedirectService\n  ) {\n    // We need to have stopProgress$ stream active for the whole time,\n    // so when the logout finishes we finish it's process.\n    // It could happen when retryToken$ is not active.\n    this.subscriptions.add(this.stopProgress$.subscribe());\n  }\n\n  /**\n   * Checks if request should be handled by this service (if it's OCC call).\n   */\n  public shouldCatchError(request: HttpRequest<any>): boolean {\n    return this.isOccUrl(request.url);\n  }\n\n  public shouldAddAuthorizationHeader(request: HttpRequest<any>): boolean {\n    const hasAuthorizationHeader = !!this.getAuthorizationHeader(request);\n    const isOccUrl = this.isOccUrl(request.url);\n    return !hasAuthorizationHeader && isOccUrl;\n  }\n\n  /**\n   * Adds `Authorization` header for OCC calls.\n   */\n  public alterRequest(\n    request: HttpRequest<any>,\n    token?: AuthToken\n  ): HttpRequest<any> {\n    const hasAuthorizationHeader = !!this.getAuthorizationHeader(request);\n    const isOccUrl = this.isOccUrl(request.url);\n    if (!hasAuthorizationHeader && isOccUrl) {\n      return request.clone({\n        setHeaders: {\n          ...this.createAuthorizationHeader(token),\n        },\n      });\n    }\n    return request;\n  }\n\n  protected isOccUrl(url: string): boolean {\n    return url.includes(this.occEndpoints.getBaseUrl());\n  }\n\n  protected getAuthorizationHeader(request: HttpRequest<any>): string | null {\n    const rawValue = request.headers.get('Authorization');\n    return rawValue;\n  }\n\n  protected createAuthorizationHeader(\n    token?: AuthToken\n  ): { Authorization: string } | {} {\n    if (token?.access_token) {\n      return {\n        Authorization: `${token.token_type || 'Bearer'} ${token.access_token}`,\n      };\n    }\n    let currentToken: AuthToken | undefined;\n    this.authStorageService\n      .getToken()\n      .subscribe((token) => (currentToken = token))\n      .unsubscribe();\n\n    if (currentToken?.access_token) {\n      return {\n        Authorization: `${currentToken.token_type || 'Bearer'} ${\n          currentToken.access_token\n        }`,\n      };\n    }\n    return {};\n  }\n\n  /**\n   * Refreshes access_token and then retries the call with the new token.\n   */\n  public handleExpiredAccessToken(\n    request: HttpRequest<any>,\n    next: HttpHandler,\n    // TODO:#13421 make required\n    initialToken?: AuthToken\n  ): Observable<HttpEvent<AuthToken>> {\n    // TODO:#13421 remove this if-statement, and just return the stream.\n    if (initialToken) {\n      return this.getValidToken(initialToken).pipe(\n        switchMap((token) =>\n          // we break the stream with EMPTY when we don't have the token. This prevents sending the requests with `Authorization: bearer undefined` header\n          token\n            ? next.handle(this.createNewRequestWithNewToken(request, token))\n            : EMPTY\n        )\n      );\n    }\n\n    // TODO:#13421 legacy - remove in 5.0\n    return this.handleExpiredToken().pipe(\n      switchMap((token) => {\n        return token\n          ? next.handle(this.createNewRequestWithNewToken(request, token))\n          : EMPTY;\n      })\n    );\n  }\n\n  /**\n   * Logout user, redirected to login page and informs about expired session.\n   */\n  public handleExpiredRefreshToken(): void {\n    // There might be 2 cases:\n    // 1. when user is already on some page (router is stable) and performs an UI action\n    // that triggers http call (i.e. button click to save data in backend)\n    // 2. when user is navigating to some page and a route guard triggers the http call\n    // (i.e. guard loading cms page data)\n    //\n    // In the second case, we want to remember the anticipated url before we navigate to\n    // the login page, so we can redirect back to that URL after user authenticates.\n    this.authRedirectService.saveCurrentNavigationUrl();\n\n    // Logout user\n    // TODO(#9638): Use logout route when it will support passing redirect url\n    this.authService.coreLogout().finally(() => {\n      this.routingService.go({ cxRoute: 'login' });\n\n      this.globalMessageService.add(\n        {\n          key: 'httpHandlers.sessionExpired',\n        },\n        GlobalMessageType.MSG_TYPE_ERROR\n      );\n    });\n  }\n\n  // TODO:#13421 - remove this method\n  /**\n   * Attempts to refresh token if possible.\n   * If it is not possible calls `handleExpiredRefreshToken`.\n   *\n   * @return observable which omits new access_token. (Warn: might never emit!).\n   *\n   * @deprecated will be removed in the next major. Use `getValidToken()` instead\n   */\n  protected handleExpiredToken(): Observable<AuthToken | undefined> {\n    const stream = this.authStorageService.getToken();\n    let oldToken: AuthToken;\n    return stream.pipe(\n      tap((token) => {\n        if (\n          token.access_token &&\n          token.refresh_token &&\n          !oldToken &&\n          !this.refreshInProgress\n        ) {\n          this.refreshInProgress = true;\n          this.oAuthLibWrapperService.refreshToken();\n        } else if (!token.refresh_token) {\n          this.handleExpiredRefreshToken();\n        }\n        oldToken = oldToken || token;\n      }),\n      filter((token) => oldToken.access_token !== token.access_token),\n      tap(() => {\n        this.refreshInProgress = false;\n      }),\n      map((token) => (token?.access_token ? token : undefined)),\n      take(1)\n    );\n  }\n\n  /**\n   * Emits the token or `undefined` only when the refresh or the logout processes are finished.\n   */\n  getStableToken(): Observable<AuthToken | undefined> {\n    return combineLatest([\n      this.token$,\n      this.authService.refreshInProgress$,\n      this.authService.logoutInProgress$,\n    ]).pipe(\n      observeOn(queueScheduler),\n      filter(\n        ([_, refreshInProgress, logoutInProgress]) =>\n          !refreshInProgress && !logoutInProgress\n      ),\n      switchMap(() => this.token$)\n    );\n  }\n\n  /**\n   * Returns a valid access token.\n   * It will attempt to refresh it if the current one expired; emits after the new one is retrieved.\n   */\n  protected getValidToken(\n    requestToken: AuthToken\n  ): Observable<AuthToken | undefined> {\n    return defer(() => {\n      // flag to only refresh token only on first emission\n      let refreshTriggered = false;\n      return this.tokenToRetryRequest$.pipe(\n        tap((token) => {\n          // we want to refresh the access token only when it is old.\n          // this is a guard for the case when there are multiple parallel http calls\n          if (\n            token?.access_token === requestToken?.access_token &&\n            !refreshTriggered\n          ) {\n            this.refreshTokenTrigger$.next(token);\n          }\n          refreshTriggered = true;\n        }),\n        skipWhile((token) => token?.access_token === requestToken.access_token),\n        take(1)\n      );\n    });\n  }\n\n  protected createNewRequestWithNewToken(\n    request: HttpRequest<any>,\n    token: AuthToken\n  ): HttpRequest<any> {\n    request = request.clone({\n      setHeaders: {\n        Authorization: `${token.token_type || 'Bearer'} ${token.access_token}`,\n      },\n    });\n    return request;\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n}\n"]}