keycloak-angular 7.0.1 → 7.3.1

package/fesm5/keycloak-angular.js

@@ -1,27 +1,21 @@
-import { __awaiter, __generator, __values, __spread } from 'tslib';
+import { __awaiter, __generator, __values, __spread, __decorate, __metadata } from 'tslib';
 import { Injectable, NgModule } from '@angular/core';
 import { HttpHeaders, HTTP_INTERCEPTORS } from '@angular/common/http';
-import { Observable, Subject } from 'rxjs';
+import { Subject, from } from 'rxjs';
+import { map, mergeMap } from 'rxjs/operators';
 import * as Keycloak_ from 'keycloak-js';
-import { mergeMap } from 'rxjs/operators';
 import { CommonModule } from '@angular/common';
 
-var KeycloakEventType = {
-    OnAuthError: 0,
-    OnAuthLogout: 1,
-    OnAuthRefreshError: 2,
-    OnAuthRefreshSuccess: 3,
-    OnAuthSuccess: 4,
-    OnReady: 5,
-    OnTokenExpired: 6,
-};
-KeycloakEventType[KeycloakEventType.OnAuthError] = 'OnAuthError';
-KeycloakEventType[KeycloakEventType.OnAuthLogout] = 'OnAuthLogout';
-KeycloakEventType[KeycloakEventType.OnAuthRefreshError] = 'OnAuthRefreshError';
-KeycloakEventType[KeycloakEventType.OnAuthRefreshSuccess] = 'OnAuthRefreshSuccess';
-KeycloakEventType[KeycloakEventType.OnAuthSuccess] = 'OnAuthSuccess';
-KeycloakEventType[KeycloakEventType.OnReady] = 'OnReady';
-KeycloakEventType[KeycloakEventType.OnTokenExpired] = 'OnTokenExpired';
+var KeycloakEventType;
+(function (KeycloakEventType) {
+    KeycloakEventType[KeycloakEventType["OnAuthError"] = 0] = "OnAuthError";
+    KeycloakEventType[KeycloakEventType["OnAuthLogout"] = 1] = "OnAuthLogout";
+    KeycloakEventType[KeycloakEventType["OnAuthRefreshError"] = 2] = "OnAuthRefreshError";
+    KeycloakEventType[KeycloakEventType["OnAuthRefreshSuccess"] = 3] = "OnAuthRefreshSuccess";
+    KeycloakEventType[KeycloakEventType["OnAuthSuccess"] = 4] = "OnAuthSuccess";
+    KeycloakEventType[KeycloakEventType["OnReady"] = 5] = "OnReady";
+    KeycloakEventType[KeycloakEventType["OnTokenExpired"] = 6] = "OnTokenExpired";
+})(KeycloakEventType || (KeycloakEventType = {}));
 
 var KeycloakAuthGuard = (function () {
     function KeycloakAuthGuard(router, keycloakAngular) {
@@ -30,7 +24,7 @@ var KeycloakAuthGuard = (function () {
     }
     KeycloakAuthGuard.prototype.canActivate = function (route, state) {
         var _this = this;
-        return new Promise((function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
             var _a, _b, result, error_1;
             return __generator(this, function (_c) {
                 switch (_c.label) {
@@ -56,11 +50,21 @@ var KeycloakAuthGuard = (function () {
                     case 5: return [2];
                 }
             });
-        }); }));
+        }); });
     };
     return KeycloakAuthGuard;
 }());
 
+function toPromise(originalPromise) {
+    if (originalPromise instanceof Promise) {
+        return originalPromise;
+    }
+    return new Promise(function (resolve, reject) {
+        originalPromise.success(resolve);
+        originalPromise.error(reject);
+    });
+}
+
 var Keycloak = Keycloak_;
 var KeycloakService = (function () {
     function KeycloakService() {
@@ -68,39 +72,39 @@ var KeycloakService = (function () {
     }
     KeycloakService.prototype.bindsKeycloakEvents = function () {
         var _this = this;
-        this._instance.onAuthError = (function (errorData) {
+        this._instance.onAuthError = function (errorData) {
             _this._keycloakEvents$.next({
                 args: errorData,
-                type: KeycloakEventType.OnAuthError
+                type: KeycloakEventType.OnAuthError,
             });
-        });
-        this._instance.onAuthLogout = (function () {
+        };
+        this._instance.onAuthLogout = function () {
             _this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthLogout });
-        });
-        this._instance.onAuthRefreshSuccess = (function () {
+        };
+        this._instance.onAuthRefreshSuccess = function () {
             _this._keycloakEvents$.next({
-                type: KeycloakEventType.OnAuthRefreshSuccess
+                type: KeycloakEventType.OnAuthRefreshSuccess,
             });
-        });
-        this._instance.onAuthRefreshError = (function () {
+        };
+        this._instance.onAuthRefreshError = function () {
             _this._keycloakEvents$.next({
-                type: KeycloakEventType.OnAuthRefreshError
+                type: KeycloakEventType.OnAuthRefreshError,
             });
-        });
-        this._instance.onAuthSuccess = (function () {
+        };
+        this._instance.onAuthSuccess = function () {
             _this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthSuccess });
-        });
-        this._instance.onTokenExpired = (function () {
+        };
+        this._instance.onTokenExpired = function () {
             _this._keycloakEvents$.next({
-                type: KeycloakEventType.OnTokenExpired
+                type: KeycloakEventType.OnTokenExpired,
             });
-        });
-        this._instance.onReady = (function (authenticated) {
+        };
+        this._instance.onReady = function (authenticated) {
             _this._keycloakEvents$.next({
                 args: authenticated,
-                type: KeycloakEventType.OnReady
+                type: KeycloakEventType.OnReady,
             });
-        });
+        };
     };
     KeycloakService.prototype.loadExcludedUrls = function (bearerExcludedUrls) {
         var e_1, _a;
@@ -115,7 +119,7 @@ var KeycloakService = (function () {
                 else {
                     excludedUrl = {
                         urlPattern: new RegExp(item.url, 'i'),
-                        httpMethods: item.httpMethods
+                        httpMethods: item.httpMethods,
                     };
                 }
                 excludedUrls.push(excludedUrl);
@@ -140,90 +144,77 @@ var KeycloakService = (function () {
         this._silentRefresh = initOptions ? initOptions.flow === 'implicit' : false;
     };
     KeycloakService.prototype.init = function (options) {
-        var _this = this;
         if (options === void 0) { options = {}; }
-        return new Promise((function (resolve, reject) {
-            _this.initServiceValues(options);
-            var config = options.config, initOptions = options.initOptions;
-            _this._instance = Keycloak(config);
-            _this.bindsKeycloakEvents();
-            _this._instance
-                .init(initOptions)
-                .success((function (authenticated) { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!(authenticated && this._loadUserProfileAtStartUp)) return [3, 2];
-                            return [4, this.loadUserProfile()];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            resolve(authenticated);
-                            return [2];
-                    }
-                });
-            }); }))
-                .error((function (kcError) {
-                var msg = 'An error happened during Keycloak initialization.';
-                if (kcError) {
-                    var error = kcError.error, error_description = kcError.error_description;
-                    msg = msg.concat("\nAdapter error details:\nError: " + error + "\nDescription: " + error_description);
+        return __awaiter(this, void 0, void 0, function () {
+            var config, initOptions, authenticated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.initServiceValues(options);
+                        config = options.config, initOptions = options.initOptions;
+                        this._instance = Keycloak(config);
+                        this.bindsKeycloakEvents();
+                        return [4, toPromise(this._instance.init(initOptions))];
+                    case 1:
+                        authenticated = _a.sent();
+                        if (!(authenticated && this._loadUserProfileAtStartUp)) return [3, 3];
+                        return [4, this.loadUserProfile()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2, authenticated];
                 }
-                reject(msg);
-            }));
-        }));
+            });
+        });
     };
     KeycloakService.prototype.login = function (options) {
-        var _this = this;
         if (options === void 0) { options = {}; }
-        return new Promise((function (resolve, reject) {
-            _this._instance
-                .login(options)
-                .success((function () { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!this._loadUserProfileAtStartUp) return [3, 2];
-                            return [4, this.loadUserProfile()];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            resolve();
-                            return [2];
-                    }
-                });
-            }); }))
-                .error((function () { return reject("An error happened during the login."); }));
-        }));
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, toPromise(this._instance.login(options))];
+                    case 1:
+                        _a.sent();
+                        if (!this._loadUserProfileAtStartUp) return [3, 3];
+                        return [4, this.loadUserProfile()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2];
+                }
+            });
+        });
     };
     KeycloakService.prototype.logout = function (redirectUri) {
-        var _this = this;
-        return new Promise((function (resolve, reject) {
-            var options = {
-                redirectUri: redirectUri
-            };
-            _this._instance
-                .logout(options)
-                .success((function () {
-                _this._userProfile = undefined;
-                resolve();
-            }))
-                .error((function () { return reject('An error happened during logout.'); }));
-        }));
+        return __awaiter(this, void 0, void 0, function () {
+            var options;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            redirectUri: redirectUri,
+                        };
+                        return [4, toPromise(this._instance.logout(options))];
+                    case 1:
+                        _a.sent();
+                        this._userProfile = undefined;
+                        return [2];
+                }
+            });
+        });
     };
     KeycloakService.prototype.register = function (options) {
-        var _this = this;
         if (options === void 0) { options = { action: 'register' }; }
-        return new Promise((function (resolve, reject) {
-            _this._instance
-                .register(options)
-                .success((function () {
-                resolve();
-            }))
-                .error((function () { return reject('An error happened during the register execution.'); }));
-        }));
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, toPromise(this._instance.register(options))];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
     };
     KeycloakService.prototype.isUserInRole = function (role, resource) {
         var hasRole;
@@ -278,61 +269,45 @@ var KeycloakService = (function () {
         return this._instance.isTokenExpired(minValidity);
     };
     KeycloakService.prototype.updateToken = function (minValidity) {
-        var _this = this;
         if (minValidity === void 0) { minValidity = 5; }
-        return new Promise((function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+        return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 if (this._silentRefresh) {
                     if (this.isTokenExpired()) {
-                        reject('Failed to refresh the token, or the session is expired');
+                        throw new Error('Failed to refresh the token, or the session is expired');
                     }
-                    else {
-                        resolve(true);
-                    }
-                    return [2];
+                    return [2, true];
                 }
                 if (!this._instance) {
-                    reject('Keycloak Angular library is not initialized.');
-                    return [2];
+                    throw new Error('Keycloak Angular library is not initialized.');
                 }
-                this._instance
-                    .updateToken(minValidity)
-                    .success((function (refreshed) {
-                    resolve(refreshed);
-                }))
-                    .error((function () { return reject('Failed to refresh the token, or the session is expired'); }));
-                return [2];
+                return [2, toPromise(this._instance.updateToken(minValidity))];
             });
-        }); }));
+        });
     };
     KeycloakService.prototype.loadUserProfile = function (forceReload) {
-        var _this = this;
         if (forceReload === void 0) { forceReload = false; }
-        return new Promise((function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (this._userProfile && !forceReload) {
-                    resolve(this._userProfile);
-                    return [2];
-                }
-                if (!this._instance.authenticated) {
-                    reject('The user profile was not loaded as the user is not logged in.');
-                    return [2];
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this._userProfile && !forceReload) {
+                            return [2, this._userProfile];
+                        }
+                        if (!this._instance.authenticated) {
+                            throw new Error('The user profile was not loaded as the user is not logged in.');
+                        }
+                        _a = this;
+                        return [4, toPromise(this._instance.loadUserProfile())];
+                    case 1: return [2, (_a._userProfile = _b.sent())];
                 }
-                this._instance
-                    .loadUserProfile()
-                    .success((function (result) {
-                    _this._userProfile = ((result));
-                    resolve(_this._userProfile);
-                }))
-                    .error((function () { return reject('The user profile could not be loaded.'); }));
-                return [2];
             });
-        }); }));
+        });
     };
-    KeycloakService.prototype.getToken = function () {
-        var _this = this;
-        return new Promise((function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+    KeycloakService.prototype.getToken = function (forceLogin) {
+        if (forceLogin === void 0) { forceLogin = true; }
+        return __awaiter(this, void 0, void 0, function () {
             var error_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -341,22 +316,26 @@ var KeycloakService = (function () {
                         return [4, this.updateToken(10)];
                     case 1:
                         _a.sent();
-                        resolve(this._instance.token);
-                        return [3, 3];
+                        return [2, this._instance.token];
                     case 2:
                         error_2 = _a.sent();
-                        this.login();
+                        if (forceLogin) {
+                            this.login();
+                        }
+                        else {
+                            throw error_2;
+                        }
                         return [3, 3];
                     case 3: return [2];
                 }
             });
-        }); }));
+        });
     };
     KeycloakService.prototype.getUsername = function () {
         if (!this._userProfile) {
             throw new Error('User not logged in or user profile was not loaded.');
         }
-        return ((this._userProfile.username));
+        return this._userProfile.username;
     };
     KeycloakService.prototype.clearToken = function () {
         this._instance.clearToken();
@@ -364,27 +343,9 @@ var KeycloakService = (function () {
     KeycloakService.prototype.addTokenToHeader = function (headers) {
         var _this = this;
         if (headers === void 0) { headers = new HttpHeaders(); }
-        return Observable.create((function (observer) { return __awaiter(_this, void 0, void 0, function () {
-            var token, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4, this.getToken()];
-                    case 1:
-                        token = _a.sent();
-                        headers = headers.set(this._authorizationHeaderName, this._bearerPrefix + token);
-                        observer.next(headers);
-                        observer.complete();
-                        return [3, 3];
-                    case 2:
-                        error_3 = _a.sent();
-                        observer.error(error_3);
-                        return [3, 3];
-                    case 3: return [2];
-                }
-            });
-        }); }));
+        return from(this.getToken()).pipe(map(function (token) {
+            return headers.set(_this._authorizationHeaderName, _this._bearerPrefix + token);
+        }));
     };
     KeycloakService.prototype.getKeycloakInstance = function () {
         return this._instance;
@@ -410,9 +371,9 @@ var KeycloakService = (function () {
         enumerable: true,
         configurable: true
     });
-    KeycloakService.decorators = [
-        { type: Injectable }
-    ];
+    KeycloakService = __decorate([
+        Injectable()
+    ], KeycloakService);
     return KeycloakService;
 }());
 
@@ -434,51 +395,57 @@ var KeycloakBearerInterceptor = (function () {
         if (!enableBearerInterceptor) {
             return next.handle(req);
         }
-        var shallPass = excludedUrls.findIndex((function (item) { return _this.isUrlExcluded(req, item); })) > -1;
+        var shallPass = excludedUrls.findIndex(function (item) { return _this.isUrlExcluded(req, item); }) > -1;
         if (shallPass) {
             return next.handle(req);
         }
-        return this.keycloak.addTokenToHeader(req.headers).pipe(mergeMap((function (headersWithBearer) {
+        return from(this.keycloak.isLoggedIn()).pipe(mergeMap(function (loggedIn) { return loggedIn
+            ? _this.handleRequestWithTokenHeader(req, next)
+            : next.handle(req); }));
+    };
+    KeycloakBearerInterceptor.prototype.handleRequestWithTokenHeader = function (req, next) {
+        return this.keycloak.addTokenToHeader(req.headers).pipe(mergeMap(function (headersWithBearer) {
             var kcReq = req.clone({ headers: headersWithBearer });
             return next.handle(kcReq);
-        })));
+        }));
     };
-    KeycloakBearerInterceptor.decorators = [
-        { type: Injectable }
-    ];
     KeycloakBearerInterceptor.ctorParameters = function () { return [
         { type: KeycloakService }
     ]; };
+    KeycloakBearerInterceptor = __decorate([
+        Injectable(),
+        __metadata("design:paramtypes", [KeycloakService])
+    ], KeycloakBearerInterceptor);
     return KeycloakBearerInterceptor;
 }());
 
 var CoreModule = (function () {
     function CoreModule() {
     }
-    CoreModule.decorators = [
-        { type: NgModule, args: [{
-                    imports: [CommonModule],
-                    providers: [
-                        KeycloakService,
-                        {
-                            provide: HTTP_INTERCEPTORS,
-                            useClass: KeycloakBearerInterceptor,
-                            multi: true
-                        }
-                    ]
-                },] }
-    ];
+    CoreModule = __decorate([
+        NgModule({
+            imports: [CommonModule],
+            providers: [
+                KeycloakService,
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: KeycloakBearerInterceptor,
+                    multi: true
+                }
+            ]
+        })
+    ], CoreModule);
     return CoreModule;
 }());
 
 var KeycloakAngularModule = (function () {
     function KeycloakAngularModule() {
     }
-    KeycloakAngularModule.decorators = [
-        { type: NgModule, args: [{
-                    imports: [CoreModule]
-                },] }
-    ];
+    KeycloakAngularModule = __decorate([
+        NgModule({
+            imports: [CoreModule]
+        })
+    ], KeycloakAngularModule);
     return KeycloakAngularModule;
 }());