Interceptor w/ refresh token

import { catchError, delay, filter, switchMap, take } from 'rxjs/operators';
import {
  HttpErrorResponse,
  HttpEvent,
  HttpHandler,
  HttpInterceptor,
  HttpRequest,
} from '@angular/common/http';
import { BehaviorSubject, Observable, of, throwError } from 'rxjs';
import { Injectable, Injector } from '@angular/core';
import { v4 as uuidv4 } from 'uuid';
import { TranslateService } from '@ngx-translate/core';
import { environment } from '@environments/environment';
import { AppConfig } from '@config/app.config';
import { HttpService } from '@shared/modules/http/http.service';
import { EndpointsConfig } from '@config/endpoints.config';
import { AuthService } from '../auth/services/auth.service';
import { GlobalLoaderService } from '../global-loader/services/global-loader.service';
import { version } from '../../../../../package.json';

@Injectable()
export class WsInterceptor implements HttpInterceptor {
  private isRefreshing = false;
  private readonly refreshToken$ = new BehaviorSubject<string>(null);

  constructor(
    private loader: GlobalLoaderService,
    private injector: Injector,
    private translate: TranslateService,
    private httpService: HttpService
  ) {}

  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    let requestClone = req.clone();
    const auth = this.injector.get<AuthService>(AuthService);
    const apiCall =
      requestClone.urlWithParams.includes(environment.apiUrl) &&
      !requestClone.url.includes('assets');

    if (!apiCall) {
      return next.handle(requestClone);
    }

    requestClone = this.setCommonHeaders(requestClone);

    return next.handle(requestClone).pipe(
      catchError((error) => {
        if (error instanceof HttpErrorResponse && error.status === 401) {
          const skippedUrls = [EndpointsConfig.refresh, EndpointsConfig.login];
          if (!skippedUrls.some((route) => requestClone.url.includes(route))) {
            return this.handle401Error(requestClone, next);
          }

          // unsuccessful refresh call
          auth.logout(true);
        }

        return throwError(error);
      })
    );
  }

  setCommonHeaders(req: HttpRequest<any>): HttpRequest<any> {
    return req.clone({
      withCredentials: true, // to send cookies with the request
      setHeaders: this.getHeaders(),
    });
  }

  private handle401Error(request: HttpRequest<any>, next: HttpHandler) {
    if (this.isRefreshing) {
      return this.refreshToken$.pipe(
        filter((token) => token != null),
        take(1),
        switchMap(() => {
          return next.handle(this.setCommonHeaders(request));
        })
      );
    }

    this.isRefreshing = true;
    this.refreshToken$.next(null);

    return of(null).pipe(
      delay(300),
      switchMap(() => {
        return this.httpService
          .postWithHeaders(EndpointsConfig.refresh, {}, this.getHeaders())
          .pipe(
            switchMap(({ token }) => {
              this.isRefreshing = false;
              this.refreshToken$.next(token);
              return next.handle(this.setCommonHeaders(request));
            }),
            catchError((err) => {
              return throwError(err);
            })
          );
      })
    );
  }

  private getHeaders(): { [key: string]: string } {
    const auth = this.injector.get<AuthService>(AuthService);

    let headers: { [key: string]: string } = {
      'Accept-Language': this.translate.currentLang || AppConfig.defaultLanguage,
      'x-client-version': version,
      'x-client-env': environment.name,
      'x-request-id': uuidv4(),
    };

    const CSRFToken = auth.authStorage.readCSRFToken();

    if (environment.authStorageStrategy === 'cookie' && CSRFToken) {
      headers = { ...headers, 'x-csrf-token': CSRFToken };
    }

    return headers;
  }
}