@smartbit4all/ng-client 3.3.215 → 3.3.217

package/fesm2020/smartbit4all-ng-client.mjs

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Optional, Inject, PLATFORM_ID, NgModule, SkipSelf, Component, RendererStyleFlags2, Input, Directive, HostBinding, HostListener, ViewChild, forwardRef, EventEmitter, Output, Pipe, ViewContainerRef, ViewEncapsulation, ChangeDetectionStrategy, ViewChildren, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, ChangeDetectorRef } from '@angular/core';
-import { Subject, takeUntil, startWith, map, distinctUntilChanged, catchError, throwError, from, lastValueFrom } from 'rxjs';
 import * as i1 from '@angular/common/http';
-import { HttpHeaders, HttpContext, HttpParams, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { HttpHeaders, HttpContext, HttpErrorResponse, HttpParams, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { Subject, lastValueFrom, takeUntil, startWith, map, distinctUntilChanged, catchError, throwError, from } from 'rxjs';
 import * as i3 from '@angular/common';
 import { isPlatformBrowser, DOCUMENT, DatePipe, CommonModule } from '@angular/common';
 import * as i2 from '@angular/material/button';
@@ -829,7 +829,7 @@ class SmartSessionService {
     }
     async handleSessionError(sessionError) {
         if (this.sessionHandlerService) {
-            await this.sessionHandlerService.handleSessionError(sessionError);
+            return await this.sessionHandlerService.handleSessionError(sessionError);
         }
         throw new Error(`sessionHandlerService was not initialized. Error: ${sessionError.code}`);
     }
@@ -924,11 +924,7 @@ class SmartSessionService {
     async startSession() {
         let sessionInfo = await this.apiService.startSession().toPromise();
         if (sessionInfo) {
-            this.sessionInfoData = sessionInfo;
-            this.token = sessionInfo.sid;
-            this.saveTokenToLocalStorage();
-            this.setAuthenticationStatus();
-            this.setUpTokenForSessionService();
+            this.updateSessionInfo(sessionInfo);
         }
         return this.sessionInfoData;
     }
@@ -947,26 +943,34 @@ class SmartSessionService {
         if (!refreshToken) {
             return await this.startSession();
         }
-        let sessionInfo = await this.apiService
-            .refreshSession({
-            refreshToken,
-        })
-            .toPromise()
-            .catch(async (error) => {
-            if (error.error &&
-                error.error.code &&
-                error.error.code === 'session.refreshtoken.invalid') {
-                await this.startSession();
+        try {
+            const sessionInfo = await lastValueFrom(this.apiService.refreshSession({ refreshToken }));
+            if (sessionInfo) {
+                this.updateSessionInfo(sessionInfo);
+                return sessionInfo;
             }
-        });
-        if (sessionInfo) {
-            this.sessionInfoData = sessionInfo;
-            this.token = sessionInfo.sid;
-            this.saveTokenToLocalStorage();
-            this.setAuthenticationStatus();
-            this.setUpTokenForSessionService();
         }
-        return this.sessionInfoData;
+        catch (error) {
+            if (this.isInvalidRefreshTokenError(error)) {
+                this.clearAndStartNewSession();
+                // still throw the error, so the error can be handled in the caller
+            }
+            throw error;
+        }
+        // no sessionInfo returned
+        throw new Error('Unable to refresh session');
+    }
+    updateSessionInfo(sessionInfo) {
+        this.sessionInfoData = sessionInfo;
+        this.token = sessionInfo.sid;
+        this.saveTokenToLocalStorage();
+        this.setAuthenticationStatus();
+        this.setUpTokenForSessionService();
+    }
+    isInvalidRefreshTokenError(error) {
+        return (error instanceof HttpErrorResponse &&
+            error.error &&
+            error.error.code === 'session.refreshtoken.invalid');
     }
     async getAuthenticationProviders() {
         let providers = await this.apiService
@@ -9064,52 +9068,68 @@ class SmartErrorCatchingInterceptor {
         this.session = session;
         this.sessionErrorCodes = [
             {
-                code: "session.expired",
+                code: 'session.expired',
                 behaviour: SessionErrorBehaviour.REFRESH,
             },
             {
-                code: "session.refreshtoken.invalid",
+                code: 'session.refreshtoken.invalid',
                 behaviour: SessionErrorBehaviour.RESTART,
             },
             {
-                code: "session.badrequest.missingtoken",
+                code: 'session.badrequest.missingtoken',
                 behaviour: SessionErrorBehaviour.RESTART,
             },
             {
-                code: "session.security.nocontext",
+                code: 'session.security.nocontext',
                 behaviour: SessionErrorBehaviour.RESTART,
             },
             {
-                code: "session.invalidsessionuri",
+                code: 'session.invalidsessionuri',
                 behaviour: SessionErrorBehaviour.RESTART,
             },
             {
-                code: "session.notinitialized",
+                code: 'session.notinitialized',
                 behaviour: SessionErrorBehaviour.RESTART,
             },
             {
-                code: "session.viewcontext.missing",
+                code: 'session.viewcontext.missing',
                 behaviour: SessionErrorBehaviour.RESTART,
             },
         ];
     }
     intercept(request, next) {
-        return next.handle(request).pipe(catchError$1((error) => {
-            if (error.status === 400 && error.error.code) {
-                let sessionError = this.sessionErrorCodes.find((sessionError) => sessionError.code === error.error.code);
-                if (sessionError) {
-                    return this.resolveError(sessionError).pipe(switchMap(() => {
-                        this.session.headerParams.map((headerParam) => {
-                            request = request.clone({
-                                headers: request.headers.set(headerParam.headerName, headerParam.value),
-                            });
-                        });
-                        return next.handle(request);
-                    }));
-                }
+        return next
+            .handle(request)
+            .pipe(catchError$1((error) => this.handleError(error, request, next)));
+    }
+    handleError(error, request, next) {
+        if (this.isSessionError(error)) {
+            const sessionError = this.getSessionError(error);
+            if (sessionError) {
+                return this.resolveError(sessionError).pipe(switchMap((resolved) => {
+                    if (resolved && sessionError.behaviour === SessionErrorBehaviour.REFRESH) {
+                        return next.handle(this.updateRequestHeaders(request));
+                    }
+                    return throwError(() => error);
+                }), catchError$1((resolveError) => {
+                    // when the resolveError throws a restart error (in the refreshSession), rethrow the original error
+                    if (this.isSessionError(resolveError)) {
+                        const resolveSessionError = this.getSessionError(resolveError);
+                        if (resolveSessionError?.behaviour === SessionErrorBehaviour.RESTART) {
+                            return throwError(() => error);
+                        }
+                    }
+                    return throwError(() => resolveError);
+                }));
             }
-            return throwError(error);
-        }));
+        }
+        return throwError(() => error);
+    }
+    isSessionError(error) {
+        return error.status === 400 && error.error.code != null;
+    }
+    getSessionError(error) {
+        return this.sessionErrorCodes.find((sessionError) => sessionError.code === error.error.code);
     }
     resolveError(sessionError) {
         if (sessionError.behaviour === SessionErrorBehaviour.RESTART) {
@@ -9117,6 +9137,14 @@ class SmartErrorCatchingInterceptor {
         }
         return from(this.session.refreshSession());
     }
+    updateRequestHeaders(request) {
+        this.session.headerParams.forEach((headerParam) => {
+            request = request.clone({
+                headers: request.headers.set(headerParam.headerName, headerParam.value),
+            });
+        });
+        return request;
+    }
 }
 SmartErrorCatchingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartErrorCatchingInterceptor, deps: [{ token: SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
 SmartErrorCatchingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartErrorCatchingInterceptor });