@codex-ts/core-lib 1.0.18 → 1.0.19

package/fesm2022/codex-ts-core-lib.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, PLATFORM_ID, signal, computed, Injectable, importProvidersFrom, APP_INITIALIZER, Component, NgModule, Directive, Input, ViewChild, Pipe } from '@angular/core';
-import * as i1 from '@angular/common/http';
-import { HttpClient, HTTP_INTERCEPTORS, HttpClientModule, HttpParams } from '@angular/common/http';
 import * as i1$2 from '@angular/common';
 import { isPlatformBrowser, CommonModule, formatDate } from '@angular/common';
+import * as i1 from '@angular/common/http';
+import { HTTP_INTERCEPTORS, HttpClientModule, HttpParams } from '@angular/common/http';
 import { from, mergeMap, catchError, throwError, map, BehaviorSubject, finalize, Observable, forkJoin, of, isObservable, Subject, take as take$1, tap as tap$1, takeUntil as takeUntil$1, ReplaySubject, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
 import * as i1$3 from '@angular/router';
 import { Router } from '@angular/router';
@@ -138,30 +138,10 @@ var TaskRole;
 
 const KEYCLOAK_CONFIG = new InjectionToken('KEYCLOAK_CONFIG');
 
-/** Keycloak error types */
-var KeycloakErrorType;
-(function (KeycloakErrorType) {
-    KeycloakErrorType["SCRIPT_LOAD"] = "SCRIPT_LOAD_ERROR";
-    KeycloakErrorType["INIT"] = "INIT_ERROR";
-    KeycloakErrorType["TOKEN_REFRESH"] = "TOKEN_REFRESH_ERROR";
-    KeycloakErrorType["PROFILE_LOAD"] = "PROFILE_LOAD_ERROR";
-})(KeycloakErrorType || (KeycloakErrorType = {}));
-/** Keycloak error with type and details */
-class KeycloakError extends Error {
-    type;
-    originalError;
-    constructor(type, message, originalError) {
-        super(message);
-        this.type = type;
-        this.originalError = originalError;
-        this.name = 'KeycloakError';
-    }
-}
 /**
  * Service for handling Keycloak authentication and authorization
  */
 class KeycloakService {
-    http = inject(HttpClient);
     platformId = inject(PLATFORM_ID);
     config = inject(KEYCLOAK_CONFIG);
     isBrowser = isPlatformBrowser(this.platformId);
@@ -170,159 +150,97 @@ class KeycloakService {
     #userProfile = signal(null);
     isAuthenticated$ = computed(() => this.#isAuthenticated());
     userProfile$ = computed(() => this.#userProfile());
+    token$ = computed(() => this.#keycloakInstance()?.token);
     /** Check if URL should be excluded from bearer token */
     isUrlExcluded(url) {
-        return this.config.bearerExcludedUrls?.some(excluded => url.startsWith(excluded) || new RegExp(excluded).test(url)) ?? false;
+        return this.config.options?.excludedUrls?.some(excluded => url.startsWith(excluded) || new RegExp(excluded).test(url)) ?? false;
     }
-    /** Validate Keycloak configuration */
-    validateConfig() {
-        if (!this.config.authServerUrl) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Auth server URL is required');
-        }
-        if (!this.config.realm) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Realm is required');
-        }
-        if (!this.config.clientId) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Client ID is required');
+    /** Initialize Keycloak authentication */
+    async initialize() {
+        if (!this.isBrowser)
+            return false;
+        await this.loadKeycloakScript();
+        const keycloak = new Keycloak({
+            url: this.config.authServerUrl,
+            realm: this.config.realm,
+            clientId: this.config.clientId
+        });
+        this.#keycloakInstance.set(keycloak);
+        const authenticated = await keycloak.init({
+            onLoad: 'login-required',
+            redirectUri: this.config.options?.loginRedirect || window.location.origin
+        });
+        this.#isAuthenticated.set(authenticated);
+        if (authenticated) {
+            await this.loadUserProfile();
         }
+        return authenticated;
     }
-    loadKeycloakScript() {
-        if (!this.isBrowser)
-            return Promise.resolve();
+    async loadKeycloakScript() {
         if (typeof Keycloak !== 'undefined')
-            return Promise.resolve();
-        return new Promise((resolve, reject) => {
-            const script = document.createElement('script');
-            script.src = `${this.config.authServerUrl}/js/keycloak.js`;
-            script.async = true;
+            return;
+        const script = document.createElement('script');
+        script.src = `${this.config.authServerUrl}/js/keycloak.js`;
+        script.async = true;
+        await new Promise((resolve, reject) => {
             script.onload = () => resolve();
             script.onerror = () => reject(new Error('Failed to load Keycloak script'));
             document.head.appendChild(script);
         });
     }
-    getSilentCheckUrl() {
-        if (!this.isBrowser)
-            return '';
-        // Use the configured URL or fallback to a default location
-        return this.config.silentCheckSsoRedirectUri ??
-            `${window.location.origin}/assets/silent-check-sso.html`;
-    }
-    /**
-     * Initialize Keycloak authentication
-     * @returns Promise resolving to true if initialization is successful
-     * @throws KeycloakError if initialization fails
-     */
-    async initialize() {
-        if (!this.isBrowser)
-            return false;
-        try {
-            this.validateConfig();
-            await this.loadKeycloakScript();
-            const keycloak = new Keycloak(this.config);
-            this.#keycloakInstance.set(keycloak);
-            const initOptions = {
-                onLoad: 'login-required',
-                silentCheckSsoRedirectUri: this.getSilentCheckUrl(),
-                checkLoginIframe: false,
-                ...this.config.initOptions
-            };
-            const authenticated = await keycloak.init(initOptions);
-            this.#isAuthenticated.set(authenticated);
-            if (authenticated) {
-                await this.loadUserProfile();
-            }
-            return authenticated;
-        }
-        catch (error) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Failed to initialize Keycloak', error);
-        }
-    }
-    /**
-     * Redirect to Keycloak login page
-     * @param options Additional login options
-     * @returns Promise resolving when login is complete
-     */
+    /** Login with optional redirect URI */
     login(options = {}) {
         const instance = this.#keycloakInstance();
-        if (!instance) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Keycloak not initialized');
-        }
-        const loginOptions = {
-            ...this.config.loginOptions,
-            ...options
-        };
-        return instance.login(loginOptions);
+        if (!instance)
+            throw new Error('Keycloak not initialized');
+        return instance.login({
+            redirectUri: options.redirectUri || this.config.options?.loginRedirect || window.location.origin
+        });
     }
-    /**
-     * Logout the current user
-     * @returns Promise resolving when logout is complete
-     */
+    /** Logout the current user */
     logout() {
         const instance = this.#keycloakInstance();
-        if (!instance) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Keycloak not initialized');
-        }
+        if (!instance)
+            throw new Error('Keycloak not initialized');
         return instance.logout();
     }
-    /**
-     * Get the current access token
-     * @returns Promise resolving to the access token or null
-     */
-    async getToken() {
-        try {
-            await this.updateToken(this.config.tokenValidityInSeconds || 60);
-            return this.#keycloakInstance()?.token ?? null;
-        }
-        catch (error) {
-            throw new KeycloakError(KeycloakErrorType.TOKEN_REFRESH, 'Failed to get token', error);
-        }
-    }
-    /**
-     * Get the current user's roles
-     * @returns Array of role names
-     */
+    /** Get roles for the current user */
     getRoles() {
-        const keycloak = this.#keycloakInstance();
-        if (!keycloak) {
-            throw new KeycloakError(KeycloakErrorType.INIT, 'Keycloak not initialized');
-        }
-        return keycloak.realmAccess?.roles ?? [];
+        const instance = this.#keycloakInstance();
+        return instance?.realmAccess?.roles ?? [];
     }
-    /**
-     * Check if the current user has a specific role
-     * @param role Role name to check
-     * @returns true if user has the role
-     */
+    /** Check if user has a specific role */
     hasRole(role) {
         return this.getRoles().includes(role);
     }
-    /**
-     * Update the access token if it's close to expiring
-     * @param minValidity Minimum validity time in seconds
-     * @returns Promise resolving to true if token was refreshed
-     */
-    updateToken(minValidity = 60) {
-        return new Promise((resolve, reject) => {
-            const keycloak = this.#keycloakInstance();
-            if (!keycloak?.token) {
-                reject(new KeycloakError(KeycloakErrorType.TOKEN_REFRESH, 'No token available'));
-                return;
-            }
-            keycloak.updateToken(minValidity)
-                .then((refreshed) => {
-                resolve(refreshed);
-            })
-                .catch((error) => {
-                reject(new KeycloakError(KeycloakErrorType.TOKEN_REFRESH, 'Failed to refresh token', error));
-            });
-        });
+    /** Get the current access token */
+    async getToken() {
+        const instance = this.#keycloakInstance();
+        if (!instance?.token)
+            return null;
+        const validityThreshold = this.config.options?.tokenValidityThreshold ?? 60;
+        await this.updateToken(validityThreshold);
+        return instance.token;
+    }
+    /** Update token if it's close to expiring */
+    async updateToken(minValidity) {
+        const instance = this.#keycloakInstance();
+        if (!instance?.token)
+            return false;
+        try {
+            return await instance.updateToken(minValidity);
+        }
+        catch (error) {
+            this.login(); // Redirect to login if token refresh fails
+            return false;
+        }
     }
     async loadUserProfile() {
+        const instance = this.#keycloakInstance();
+        if (!instance)
+            return;
         try {
-            const keycloak = this.#keycloakInstance();
-            if (!keycloak)
-                return;
-            const profile = await keycloak.loadUserProfile();
+            const profile = await instance.loadUserProfile();
             this.#userProfile.set(profile);
         }
         catch (error) {
@@ -338,55 +256,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImpor
         }] });
 
 class KeycloakAuthInterceptor {
-    keycloakService;
-    constructor(keycloakService) {
-        this.keycloakService = keycloakService;
-    }
+    keycloakService = inject(KeycloakService);
+    config = inject(KEYCLOAK_CONFIG);
     intercept(req, next) {
-        // Skip bearer token for excluded URLs
-        if (this.keycloakService.isUrlExcluded(req.url)) {
+        if (!this.config.options?.bearerToken || this.keycloakService.isUrlExcluded(req.url)) {
             return next.handle(req);
         }
         return from(this.keycloakService.getToken()).pipe(mergeMap(token => {
-            if (token) {
-                const authReq = req.clone({
-                    headers: req.headers.set('Authorization', `Bearer ${token}`)
-                });
-                return next.handle(authReq);
-            }
-            return next.handle(req);
+            if (!token)
+                return next.handle(req);
+            const authReq = req.clone({
+                headers: req.headers.set('Authorization', `Bearer ${token}`)
+            });
+            return next.handle(authReq);
         }), catchError((error) => {
-            // Handle 401/403 errors by refreshing token or redirecting to login
             if (error.status === 401 || error.status === 403) {
-                return from(this.keycloakService.updateToken()).pipe(mergeMap(refreshed => {
-                    if (refreshed) {
-                        return from(this.keycloakService.getToken()).pipe(mergeMap(newToken => {
-                            const authReq = req.clone({
-                                headers: req.headers.set('Authorization', `Bearer ${newToken}`)
-                            });
-                            return next.handle(authReq);
-                        }));
-                    }
-                    else {
-                        // Token refresh failed, redirect to login
-                        this.keycloakService.login();
-                        return throwError(() => error);
-                    }
-                }));
+                this.keycloakService.login();
             }
             return throwError(() => error);
         }));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthInterceptor, deps: [{ token: KeycloakService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthInterceptor });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthInterceptor, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: KeycloakService }] });
+        }] });
 
-function initializeKeycloak(keycloak) {
-    return () => keycloak.initialize();
-}
 /**
  * Provides Keycloak authentication and authorization services
  * @param config Keycloak configuration
@@ -395,45 +291,45 @@ function initializeKeycloak(keycloak) {
 function provideKeycloak(config) {
     return [
         importProvidersFrom(HttpClientModule),
-        {
-            provide: KEYCLOAK_CONFIG,
-            useValue: config
-        },
+        { provide: KEYCLOAK_CONFIG, useValue: config },
         KeycloakService,
         {
             provide: APP_INITIALIZER,
-            useFactory: initializeKeycloak,
+            useFactory: (keycloak) => () => keycloak.initialize(),
             multi: true,
             deps: [KeycloakService]
         },
-        {
-            provide: HTTP_INTERCEPTORS,
-            useClass: KeycloakAuthInterceptor,
-            multi: true
-        }
+        // Only provide the interceptor if bearer token is enabled
+        ...(config.options?.bearerToken ? [{
+                provide: HTTP_INTERCEPTORS,
+                useClass: KeycloakAuthInterceptor,
+                multi: true
+            }] : [])
     ];
 }
 
 class KeycloakAuthGuard {
     keycloakService = inject(KeycloakService);
+    config = inject(KEYCLOAK_CONFIG);
     router = inject(Router);
     canActivate(route, state) {
         return toObservable(this.keycloakService.isAuthenticated$).pipe(map(authenticated => {
             if (!authenticated) {
-                this.keycloakService.login({
-                    redirectUri: window.location.origin + state.url
-                });
+                this.keycloakService.login({ redirectUri: window.location.origin + state.url });
                 return false;
             }
-            const requiredRoles = route.data['roles'];
-            if (requiredRoles && !this.hasRequiredRoles(requiredRoles)) {
+            // Check for route-specific roles first, then fallback to default roles
+            const routeRoles = route.data['roles'];
+            const defaultRoles = this.config.options?.roles;
+            const requiredRoles = routeRoles || defaultRoles;
+            if (requiredRoles?.length && !this.hasRequiredRoles(requiredRoles)) {
                 return this.router.createUrlTree(['/unauthorized']);
             }
             return true;
         }));
     }
-    hasRequiredRoles(requiredRoles) {
-        return requiredRoles.every(role => this.keycloakService.getRoles().includes(role));
+    hasRequiredRoles(roles) {
+        return roles.every(role => this.keycloakService.hasRole(role));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthGuard, providedIn: 'root' });
@@ -3267,5 +3163,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AppConstants, AppMessages, BaseCrudService, BaseFormComponent, BaseListPageComponent, BaseListTabbedFormComponent, BasePageComponent, BaseTabbedFormComponent, BaseTaskDashboardComponent, BaseTaskDetailsComponent, BaseTaskService, ComponentContext, CoreFormlyModule, FormService, FormlyConfigService, HttpUtilityService, IndianDatePipe, KEYCLOAK_CONFIG, KeycloakAuthGuard, KeycloakError, KeycloakErrorType, KeycloakService, NotificationService, TabbedFormType, TaskRole, UtilsService, provideKeycloak };
+export { AppConstants, AppMessages, BaseCrudService, BaseFormComponent, BaseListPageComponent, BaseListTabbedFormComponent, BasePageComponent, BaseTabbedFormComponent, BaseTaskDashboardComponent, BaseTaskDetailsComponent, BaseTaskService, ComponentContext, CoreFormlyModule, FormService, FormlyConfigService, HttpUtilityService, IndianDatePipe, KEYCLOAK_CONFIG, KeycloakAuthGuard, KeycloakService, NotificationService, TabbedFormType, TaskRole, UtilsService, provideKeycloak };
 //# sourceMappingURL=codex-ts-core-lib.mjs.map