@igo2/auth 20.1.0-next.16 → 20.1.0-next.17

package/fesm2022/igo2-auth.mjs

@@ -1,16 +1,16 @@
 import { HttpClient, HttpHeaders, HTTP_INTERCEPTORS } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { inject, Injector, Injectable, makeEnvironmentProviders } from '@angular/core';
+import { inject, Injector, Injectable, InjectionToken, signal, makeEnvironmentProviders } from '@angular/core';
 import { BaseStorage, StorageScope, StorageService } from '@igo2/core/storage';
-import { ConfigService } from '@igo2/core/config';
-import { jwtDecode } from 'jwt-decode';
 import { Router } from '@angular/router';
+import { ConfigService } from '@igo2/core/config';
 import { LanguageService } from '@igo2/core/language';
 import { MessageService } from '@igo2/core/message';
 import { Base64 } from '@igo2/utils';
-import { BehaviorSubject, of } from 'rxjs';
-import { tap, catchError, map } from 'rxjs/operators';
+import { BehaviorSubject, tap, of, Observable, Subject, EMPTY } from 'rxjs';
+import { finalize, tap as tap$1, catchError, switchMap, takeUntil, debounceTime, map } from 'rxjs/operators';
 import { globalCacheBusterNotifier } from 'ts-cacheable';
+import { jwtDecode } from 'jwt-decode';
 import { Md5 } from 'ts-md5';
 
 class TokenService {
@@ -56,9 +56,42 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+const USER_AUTH_OPTIONS = new InjectionToken('USER_AUTH_OPTIONS');
+class UserService {
+    http = inject(HttpClient);
+    options = inject(USER_AUTH_OPTIONS);
+    baseUrl;
+    _user$ = new BehaviorSubject(undefined);
+    user$ = this._user$.asObservable();
+    constructor() {
+        this.baseUrl = this.options.apiUrl;
+    }
+    getUser() {
+        return this.http
+            .get(this.baseUrl)
+            .pipe(tap((user) => this._user$.next(user)));
+    }
+    sync() {
+        return this.http
+            .get(`${this.baseUrl}/sync`)
+            .pipe(tap((user) => this._user$.next(user)));
+    }
+    updatePreference(preference) {
+        return this.http.patch(this.baseUrl, { preference });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: UserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: UserService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 class AuthService {
     http = inject(HttpClient);
     tokenService = inject(TokenService);
+    userService = inject(UserService, {
+        optional: true
+    });
     config = inject(ConfigService);
     languageService = inject(LanguageService);
     messageService = inject(MessageService);
@@ -67,8 +100,9 @@ class AuthService {
     logged$ = new BehaviorSubject(undefined);
     redirectUrl;
     languageForce = false;
-    anonymous = false;
     authOptions;
+    anonymous = false;
+    isLogging = signal(false, ...(ngDevMode ? [{ debugName: "isLogging" }] : []));
     get hasAuthService() {
         return this.authOptions?.url !== undefined;
     }
@@ -78,26 +112,28 @@ class AuthService {
     }
     constructor() {
         this.authOptions = this.config.getConfig('auth');
-        this.authenticate$.next(this.authenticated);
+        this.initializeAuthentication(this.authenticated).subscribe();
         this.authenticate$.subscribe((authenticated) => {
             this.logged$.next(authenticated);
             globalCacheBusterNotifier.next();
         });
     }
     login(username, password) {
+        this.isLogging.set(true);
         const myHeader = new HttpHeaders({ 'Content-Type': 'application/json' });
         const body = {
             username,
             password: this.encodePassword(password)
         };
-        return this.loginCall(body, myHeader);
+        return this.loginCall(body, myHeader).pipe(finalize(() => this.isLogging.set(false)));
     }
-    loginWithToken(token, type, infosUser) {
+    loginWithToken(token, type, infosUser, applicationId) {
         const myHeader = new HttpHeaders({ 'Content-Type': 'application/json' });
         const body = {
             token,
             typeConnection: type,
-            infosUser
+            infosUser,
+            applicationId
         };
         return this.loginCall(body, myHeader);
     }
@@ -107,7 +143,7 @@ class AuthService {
         return of(true);
     }
     refresh() {
-        return this.http.post(`${this.authOptions?.url}/refresh`, {}).pipe(tap((data) => {
+        return this.http.post(`${this.authOptions?.url}/refresh`, {}).pipe(tap$1((data) => {
             this.tokenService.set(data.token);
         }), catchError((err) => {
             err.error.caught = true;
@@ -115,10 +151,15 @@ class AuthService {
         }));
     }
     logout() {
+        this.logoutInternal();
+        if (this.authOptions.logoutRedirectRoute) {
+            this.router.navigate([this.authOptions.logoutRedirectRoute]);
+        }
+    }
+    logoutInternal() {
         this.anonymous = false;
         this.tokenService.remove();
         this.authenticate$.next(false);
-        return of(true);
     }
     isAuthenticated() {
         return !this.tokenService.isExpired();
@@ -136,14 +177,8 @@ class AuthService {
         if (!this.router) {
             return;
         }
-        const redirectUrl = this.redirectUrl || this.router.url;
-        if (redirectUrl === this.authOptions.loginRoute) {
-            const homeRoute = this.authOptions.homeRoute || '/';
-            this.router.navigateByUrl(homeRoute);
-        }
-        else if (redirectUrl) {
-            this.router.navigateByUrl(redirectUrl);
-        }
+        const redirectUrl = this.redirectUrl ?? this.authOptions.homeRoute ?? '/';
+        this.router.navigateByUrl(redirectUrl);
     }
     getUserInfo() {
         const url = this.authOptions?.url + '/info';
@@ -155,6 +190,24 @@ class AuthService {
     updateUser(user) {
         return this.http.patch(this.authOptions?.url, user);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    translateError(prefix, error) {
+        return new Observable((observer) => {
+            try {
+                this.languageService.translate
+                    .get(prefix + error.error.message)
+                    .subscribe((errorMsg) => {
+                    observer.next(errorMsg);
+                    observer.complete();
+                });
+            }
+            catch {
+                if (error.error)
+                    observer.next(error.error.message);
+                observer.complete();
+            }
+        });
+    }
     encodePassword(password) {
         return Base64.encode(password);
     }
@@ -178,7 +231,7 @@ class AuthService {
     loginCall(body, headers) {
         return this.http
             .post(`${this.authOptions?.url}/login`, body, { headers })
-            .pipe(tap((data) => {
+            .pipe(tap$1((data) => {
             this.tokenService.set(data.token);
             const tokenDecoded = this.decodeToken();
             if (tokenDecoded?.user) {
@@ -186,14 +239,24 @@ class AuthService {
                     this.languageService.setLanguage(tokenDecoded.user.locale);
                 }
                 if (tokenDecoded.user.isExpired) {
-                    this.messageService.alert('igo.auth.error.Password expired');
+                    this.messageService.alert('igo.auth.error.intern.Password expired');
                 }
             }
-            this.authenticate$.next(true);
-        }), catchError((err) => {
-            err.error.caught = true;
-            throw err;
-        }));
+        }), switchMap(() => this.initializeAuthentication(true)));
+    }
+    initializeAuthentication(isAuthenticated) {
+        if (!isAuthenticated) {
+            this.authenticate$.next(false);
+            return of(null);
+        }
+        if (this.userService) {
+            const obs$ = this.authOptions.user.withSync
+                ? this.userService.sync()
+                : this.userService.getUser();
+            return obs$.pipe(tap$1(() => this.authenticate$.next(true)));
+        }
+        this.authenticate$.next(true);
+        return of(null);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthService, providedIn: 'root' });
@@ -205,59 +268,92 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+class AdminGuard {
+    authService = inject(AuthService);
+    config = inject(ConfigService);
+    router = inject(Router);
+    canActivate(route, state) {
+        if (this.authService.isAdmin) {
+            return true;
+        }
+        this.authService.redirectUrl = state.url;
+        const authConfig = this.config.getConfig('auth');
+        if (authConfig?.loginRoute) {
+            this.router.navigateByUrl(authConfig.loginRoute);
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AdminGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AdminGuard, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AdminGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const DEBOUNCE_TIME = 3000; // 3 seconds;
 class AuthStorageService extends BaseStorage {
-    http = inject(HttpClient);
     authService = inject(AuthService);
+    userService = inject(UserService, {
+        optional: true
+    });
     tokenService = inject(TokenService);
+    preferencesChanged$ = new Subject();
+    destroy$ = new Subject();
+    pendingPreferences = {};
+    serverPreferences = {};
     constructor() {
         const config = inject(ConfigService);
         super(config);
-        this.authService.authenticate$.subscribe((isAuthenticated) => {
-            if (isAuthenticated && this.options.url) {
-                this.http
-                    .get(this.options.url)
-                    .subscribe((userIgo) => {
-                    if (userIgo && userIgo.preference) {
-                        for (const key of Object.keys(userIgo.preference)) {
-                            const value = userIgo.preference[key];
-                            super.set(key, value);
-                        }
-                    }
-                });
+        this.authService.authenticate$
+            .pipe(switchMap((isAuthenticated) => {
+            if (isAuthenticated && this.userService) {
+                return this.userService.user$;
+            }
+            return EMPTY;
+        }), takeUntil(this.destroy$))
+            .subscribe((user) => {
+            if (!user?.preference) {
+                return;
             }
+            this.serverPreferences = { ...user.preference };
+            for (const key of Object.keys(user.preference)) {
+                const value = user.preference[key];
+                super.set(key, value);
+            }
+        });
+        this.preferencesChanged$
+            .pipe(debounceTime(DEBOUNCE_TIME), // Wait for more changes to accumulate
+        takeUntil(this.destroy$))
+            .subscribe(() => {
+            this.syncPreferences();
         });
     }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.preferencesChanged$.complete();
+    }
     set(key, value, scope = StorageScope.LOCAL) {
-        if (scope === StorageScope.LOCAL &&
-            this.authService.authenticated &&
-            this.options.url) {
-            const preference = {};
-            preference[key] = value;
-            this.http.patch(this.options.url, { preference }).subscribe();
+        if (scope === StorageScope.LOCAL && this.authService.authenticated) {
+            this.pendingPreferences[key] = value;
+            this.preferencesChanged$.next();
         }
         super.set(key, value, scope);
     }
     remove(key, scope = StorageScope.LOCAL) {
-        if (scope === StorageScope.LOCAL &&
-            this.authService.authenticated &&
-            this.options.url) {
-            const preference = {};
-            preference[key] = undefined;
-            this.http.patch(this.options.url, { preference }).subscribe();
+        if (scope === StorageScope.LOCAL && this.authService.authenticated) {
+            this.pendingPreferences[key] = undefined;
+            this.preferencesChanged$.next();
         }
         super.remove(key, scope);
     }
     clear(scope = StorageScope.LOCAL) {
-        if (scope === StorageScope.LOCAL &&
-            this.authService.authenticated &&
-            this.options.url) {
-            this.http
-                .patch(this.options.url, { preference: {} }, {
-                params: {
-                    mergePreference: 'false'
-                }
-            })
-                .subscribe();
+        if (scope === StorageScope.LOCAL && this.authService.authenticated) {
+            this.pendingPreferences = {};
+            this.preferencesChanged$.next();
         }
         let token;
         if (scope === StorageScope.LOCAL) {
@@ -267,18 +363,24 @@ class AuthStorageService extends BaseStorage {
         if (token) {
             this.tokenService.set(token);
         }
-        if (scope === StorageScope.LOCAL &&
-            this.authService.authenticated &&
-            this.options.url) {
-            this.http
-                .get(this.options.url)
-                .subscribe((userIgo) => {
-                if (userIgo && userIgo.preference) {
-                    for (const key of Object.keys(userIgo.preference)) {
-                        const value = userIgo.preference[key];
-                        super.set(key, value);
-                    }
-                }
+    }
+    syncPreferences() {
+        if (Object.keys(this.pendingPreferences).length === 0) {
+            return;
+        }
+        // Filter out preferences that haven't actually changed
+        const changedPreferences = {};
+        for (const key of Object.keys(this.pendingPreferences)) {
+            const newValue = this.pendingPreferences[key];
+            const oldValue = this.serverPreferences[key];
+            if (JSON.stringify(newValue) !== JSON.stringify(oldValue)) {
+                changedPreferences[key] = newValue;
+            }
+        }
+        this.pendingPreferences = {};
+        if (Object.keys(changedPreferences).length > 0) {
+            this.userService?.updatePreference(changedPreferences).subscribe(() => {
+                Object.assign(this.serverPreferences, changedPreferences);
             });
         }
     }
@@ -292,10 +394,30 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
-var AuthFeatureKind;
-(function (AuthFeatureKind) {
-    AuthFeatureKind[AuthFeatureKind["Microsoft"] = 0] = "Microsoft";
-})(AuthFeatureKind || (AuthFeatureKind = {}));
+class AuthGuard {
+    authService = inject(AuthService);
+    config = inject(ConfigService);
+    router = inject(Router);
+    canActivate(route, state) {
+        if (this.authService.authenticated) {
+            return true;
+        }
+        this.authService.redirectUrl = state.url;
+        const authConfig = this.config.getConfig('auth');
+        if (authConfig?.loginRoute) {
+            this.router.navigateByUrl(authConfig.loginRoute);
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthGuard, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
 
 class AuthInterceptor {
     config = inject(ConfigService);
@@ -425,7 +547,9 @@ class AuthInterceptor {
             currentTime > jwt.exp - 1800) {
             this.refreshInProgress = true;
             const url = this.authOptions?.url;
-            return this.http.post(`${url}/refresh`, {}).subscribe((data) => {
+            return this.http.post(`${url}/refresh`, {}).subscribe(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (data) => {
                 this.tokenService.set(data.token);
                 this.refreshInProgress = false;
             }, (err) => {
@@ -444,6 +568,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+var AuthFeatureKind;
+(function (AuthFeatureKind) {
+    AuthFeatureKind[AuthFeatureKind["Microsoft"] = 0] = "Microsoft";
+    AuthFeatureKind[AuthFeatureKind["User"] = 1] = "User";
+})(AuthFeatureKind || (AuthFeatureKind = {}));
+
 class LoggedGuard {
     authService = inject(AuthService);
     config = inject(ConfigService);
@@ -469,56 +599,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImpo
                 }]
         }] });
 
-class AuthGuard {
-    authService = inject(AuthService);
-    config = inject(ConfigService);
-    router = inject(Router);
-    canActivate(route, state) {
-        if (this.authService.authenticated) {
-            return true;
-        }
-        this.authService.redirectUrl = state.url;
-        const authConfig = this.config.getConfig('auth');
-        if (authConfig?.loginRoute) {
-            this.router.navigateByUrl(authConfig.loginRoute);
-        }
-        return false;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthGuard, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AuthGuard, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
-class AdminGuard {
-    authService = inject(AuthService);
-    config = inject(ConfigService);
-    router = inject(Router);
-    canActivate(route, state) {
-        if (this.authService.isAdmin) {
-            return true;
-        }
-        this.authService.redirectUrl = state.url;
-        const authConfig = this.config.getConfig('auth');
-        if (authConfig?.loginRoute) {
-            this.router.navigateByUrl(authConfig.loginRoute);
-        }
-        return false;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AdminGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AdminGuard, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: AdminGuard, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
 class ProfilsGuard {
     authService = inject(AuthService);
     config = inject(ConfigService);
@@ -548,6 +628,29 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImpo
                 }]
         }] });
 
+function withUserIgo() {
+    return {
+        kind: AuthFeatureKind.User,
+        providers: [
+            {
+                provide: USER_AUTH_OPTIONS,
+                useFactory: (config) => config.getConfig('auth.user'),
+                deps: [ConfigService]
+            },
+            {
+                provide: UserService,
+                useFactory: (options) => {
+                    if (!options) {
+                        return undefined;
+                    }
+                    return new UserService();
+                },
+                deps: [USER_AUTH_OPTIONS]
+            }
+        ]
+    };
+}
+
 function provideAuthentification(...features) {
     const providers = [
         {
@@ -574,5 +677,5 @@ function provideAuthentification(...features) {
  * Generated bundle index. Do not edit.
  */
 
-export { AdminGuard, AuthFeatureKind, AuthGuard, AuthInterceptor, AuthService, AuthStorageService, LoggedGuard, ProfilsGuard, TokenService, provideAuthentification };
+export { AdminGuard, AuthFeatureKind, AuthGuard, AuthInterceptor, AuthService, AuthStorageService, LoggedGuard, ProfilsGuard, TokenService, USER_AUTH_OPTIONS, UserService, provideAuthentification, withUserIgo };
 //# sourceMappingURL=igo2-auth.mjs.map