Add AuthToken and HttpError interceptors for improved HTTP request handling

Author: Shayan1375

src/app/app.module.ts

@@ -1,19 +1,19 @@
-import { APP_INITIALIZER } from '@angular/core';
+import { APP_INITIALIZER, ErrorHandler } from '@angular/core';
 import { AppComponent } from './app.component';
-import { AppConfigService } from './config/app-config.service';
 import { AppRoutingModule } from './app-routing.module';
+import { AuthTokenInterceptor } from './core/interceptors/AuthToken.interceptor';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { BrowserModule } from '@angular/platform-browser';
+import { CoreInitService } from './CoreInit.service';
 import { CoreModule } from './core/core.module';
 import { DataProtectionComponent } from './site/data-protection/data-protection.component';
 import { HTTP_INTERCEPTORS, HttpClient, HttpClientModule } from '@angular/common/http';
+import { HttpErrorInterceptor } from './core/interceptors/HttpError.interceptor';
 import { LayoutModule } from './layout/layout.module';
 import { NgModule } from '@angular/core';
-import { OAuthInitService } from './core/auth/oauth-init.service';
-import { OAuthInterceptor } from './core/interceptors/oauth.interceptor';
+import { SharedModule } from './shared/shared.module';
 import { TranslateHttpLoader } from '@ngx-translate/http-loader';
 import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
-import { CoreInitService } from './CoreInit.service';
 
 export const HttpLoaderFactory = (http: HttpClient): TranslateHttpLoader =>
   new TranslateHttpLoader(http);
@@ -27,6 +27,7 @@ export const HttpLoaderFactory = (http: HttpClient): TranslateHttpLoader =>
     LayoutModule,
     AppRoutingModule,
     HttpClientModule,
+    SharedModule,
     TranslateModule.forRoot({
       defaultLanguage: 'de',
       loader: {
@@ -45,7 +46,12 @@ export const HttpLoaderFactory = (http: HttpClient): TranslateHttpLoader =>
     },
     {
       provide: HTTP_INTERCEPTORS,
-      useClass: OAuthInterceptor,
+      useClass: AuthTokenInterceptor,
+      multi: true,
+    },
+    {
+      provide: HTTP_INTERCEPTORS,
+      useClass: HttpErrorInterceptor,
       multi: true,
     },
   ],

src/app/core/interceptors/AuthToken.interceptor.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { Observable } from 'rxjs';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+
+/**
+ * HTTP interceptor that automatically adds OAuth bearer tokens to outgoing requests.
+ * Excludes certain URLs from token injection (e.g., static assets) and validates
+ * token availability before attaching authorization headers.
+ */
+@Injectable()
+export class AuthTokenInterceptor implements HttpInterceptor {
+  /**
+   * List of URL patterns that should be excluded from token injection.
+   */
+  private readonly excludedUrls = ['assets', '/assets'];
+
+  /**
+   * Pre-compiled regular expressions for URL matching.
+   */
+  private readonly excludedUrlsRegEx = this.excludedUrls.map((url) => new RegExp('^' + url, 'i'));
+
+  constructor(private oauthService: OAuthService) {}
+
+  /**
+   * Intercepts HTTP requests and conditionally adds Authorization header with bearer token.
+   * @param req - The outgoing HTTP request to potentially modify
+   * @param next - The next handler in the interceptor chain
+   * @returns Observable of HTTP events from the modified or original request
+   */
+  public intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    const shouldExclude = this.excludedUrlsRegEx.some((regex) => regex.test(req.url));
+    if (shouldExclude) {
+      return next.handle(req);
+    }
+
+    const modifiedRequest = this.attachTokenIfAvailable(req);
+    return next.handle(modifiedRequest);
+  }
+
+  /**
+   * Creates a cloned request with Authorization header when token exists.
+   * @param req - The original HTTP request
+   * @returns Modified request with token or original request if no token available
+   */
+  private attachTokenIfAvailable(req: HttpRequest<any>): HttpRequest<any> {
+    const token = this.getValidToken();
+    if (!token) {
+      console.warn('No valid token found, request will no have Authorization header');
+      return req;
+    }
+    const header = `Bearer ${token}`;
+    return req.clone({
+      setHeaders: { Authorization: header },
+    });
+  }
+
+  /**
+   * Retrieves a valid, non-empty access token from the OAuth service.
+   * @returns Access token string if valid, otherwise null
+   */
+  private getValidToken(): string | null {
+    const token = this.oauthService.getAccessToken();
+
+    if (token && typeof token === 'string' && this.oauthService.hasValidAccessToken()) {
+      return token;
+    }
+    return null;
+  }
+}

src/app/core/interceptors/oauth.interceptor.ts renamed to src/app/core/interceptors/HttpError.interceptor.ts

@@ -12,28 +12,12 @@ import {
 import { ErrorCodes, SnackbarService } from 'src/app/shared/service/Snackbar/Snackbar.service';
 
 @Injectable()
-export class OAuthInterceptor implements HttpInterceptor {
-  excludedUrls = ['assets', '/assets'];
-  excludedUrlsRegEx = this.excludedUrls.map((url) => new RegExp('^' + url, 'i'));
-
+export class HttpErrorInterceptor implements HttpInterceptor {
   constructor(private oauthService: OAuthService, private snackbar: SnackbarService) {}
 
-  private isExcluded(req: HttpRequest<any>): boolean {
-    return this.excludedUrlsRegEx.some((toBeExcluded) => toBeExcluded.test(req.url));
-  }
-
   public intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
-    if (this.isExcluded(req)) {
-      return next.handle(req);
-    }
-    const token = this.getToken();
-    if (token) {
-      const headers = req.headers.set('Authorization', 'Bearer ' + token);
-      req = req.clone({ headers });
-    }
     return next.handle(req).pipe(
       catchError((error: HttpErrorResponse) => {
-        console.error('OAuthInterceptor: Error occurred', error);
         if (error.status === 401) {
           this.oauthService.logOut();
         }
@@ -52,13 +36,6 @@ export class OAuthInterceptor implements HttpInterceptor {
     );
   }
 
-  private getToken(): string | null {
-    if (this.oauthService.hasValidAccessToken()) {
-      return this.oauthService.getAccessToken();
-    }
-    return null;
-  }
-
   public handleErrorCodes(errorCode, retryAfter?: number) {
     this.snackbar.displayErrorMessage(errorCode, retryAfter);
   }