@acorex/platform 1.0.0 → 1.0.2

package/fesm2022/acorex-platform-auth.mjs

@@ -1,10 +1,9 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injector, Injectable, inject, Directive, Input, APP_INITIALIZER, NgModule, Optional, Inject } from '@angular/core';
-import { of, BehaviorSubject, shareReplay, defaultIfEmpty, map, combineLatest, filter, firstValueFrom, take, first } from 'rxjs';
-import { AXPSignOutAction, AXPSignInAction, AXP_PLATFORM_CONFIG_TOKEN } from '@acorex/platform/common';
+import { InjectionToken, Injector, Injectable, signal, inject, Directive, Input, APP_INITIALIZER, NgModule, Optional, Inject } from '@angular/core';
+import { of, map, BehaviorSubject, shareReplay, defaultIfEmpty, firstValueFrom, first } from 'rxjs';
+import { AXPSignOutAction, AXPSignInAction } from '@acorex/platform/common';
 import { Store } from '@ngrx/store';
 import { merge, isEmpty } from 'lodash-es';
-import { Router } from '@angular/router';
 
 const AXP_APPLICATION_LOADER = new InjectionToken('AXP_APPLICATION_LOADER', {
     providedIn: 'root',
@@ -13,7 +12,7 @@ const AXP_APPLICATION_LOADER = new InjectionToken('AXP_APPLICATION_LOADER', {
     },
 });
 class AXPApplicationDefaultLoader {
-    getList() {
+    getList(context) {
         return of([
             {
                 id: '1',
@@ -25,9 +24,6 @@ class AXPApplicationDefaultLoader {
             },
         ]);
     }
-    set(application) {
-        throw new Error('Method not implemented.');
-    }
 }
 
 const AXP_TENANT_LOADER = new InjectionToken('AXP_TENANT_LOADER', {
@@ -37,7 +33,7 @@ const AXP_TENANT_LOADER = new InjectionToken('AXP_TENANT_LOADER', {
     },
 });
 class AXPTenantDefaultLoader {
-    getList() {
+    getList(context) {
         return of([
             {
                 id: '1',
@@ -46,8 +42,32 @@ class AXPTenantDefaultLoader {
             },
         ]);
     }
-    set(tenant) {
-        throw new Error('Method not implemented.');
+}
+
+const AXP_PERMISSION_LOADER = new InjectionToken('AXP_PERMISSION_LOADER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXPPermissionDefaultLoader();
+    }
+});
+class AXPPermissionDefaultLoader {
+    getList(context) {
+        return of([]);
+    }
+}
+
+class AXPUnauthorizedError extends Error {
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+        this.name = 'AXPUnauthorizedError';
+    }
+}
+class AXPUnauthenticatedError extends Error {
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+        this.name = 'AXPUnauthenticatedError';
     }
 }
 
@@ -68,95 +88,200 @@ class AXPAuthStrategyRegistryService {
     get(strategyKey) {
         return this.strategies.get(strategyKey);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthStrategyRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthStrategyRegistryService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthStrategyRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthStrategyRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthStrategyRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthStrategyRegistryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
-const AXP_PERMISSION_LOADER = new InjectionToken('AXP_PERMISSION_LOADER', {
+const AXP_FEATURE_LOADER = new InjectionToken('AXP_FEATURE_LOADER', {
     providedIn: 'root',
     factory: () => {
-        return new AXPPermissionDefaultLoader();
-    }
+        return new AXPFeatureDefaultLoader();
+    },
 });
-class AXPPermissionDefaultLoader {
-    getList() {
+class AXPFeatureDefaultLoader {
+    getList(context) {
         return of([]);
     }
 }
 
+class AXPFeatureDirective {
+    constructor(templateRef, viewContainer) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.hasView = signal(false);
+        this.sessionService = inject(AXPSessionService);
+    }
+    set feature(featureKeys) {
+        const keys = !featureKeys ? [] : (Array.isArray(featureKeys) ? featureKeys : [featureKeys]);
+        if (keys.length == 0) {
+            // If featureKey is null or empty, decide the default behavior here
+            this.viewContainer.createEmbeddedView(this.templateRef);
+            this.hasView.set(true);
+            return;
+        }
+        this.subscription = this.sessionService.features$
+            //.pipe(first())
+            .subscribe(() => {
+            if (this.sessionService.isFeatureEnabled(...keys)) {
+                if (!this.hasView()) {
+                    this.viewContainer.createEmbeddedView(this.templateRef);
+                    this.hasView.set(true);
+                }
+            }
+            else {
+                this.viewContainer.clear();
+                this.hasView.set(false);
+            }
+        });
+    }
+    set featureElse(elseTemplateRef) {
+        if (!this.hasView()) {
+            this.viewContainer.createEmbeddedView(elseTemplateRef);
+        }
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPFeatureDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.2", type: AXPFeatureDirective, selector: "[feature]", inputs: { feature: "feature", featureElse: "featureElse" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPFeatureDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[feature]',
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }], propDecorators: { feature: [{
+                type: Input
+            }], featureElse: [{
+                type: Input
+            }] } });
+
+const AXPFeatureGuard = (route, state) => {
+    const sessionService = inject(AXPSessionService);
+    const requiredFeatures = route.data['requiredFeature'];
+    return sessionService.features$.pipe(map(() => {
+        const keys = !requiredFeatures ? [] : (Array.isArray(requiredFeatures) ? requiredFeatures : [requiredFeatures]);
+        const hasFeature = keys.length == 0 || sessionService.isFeatureEnabled(...keys);
+        if (!hasFeature) {
+            throw new AXPUnauthorizedError(`Access Denied. You do not have access to this feature. Required feature(s): ${keys.join(', ')}. Please contact support if you need access.`, {
+                redirectUrl: state.url
+            });
+        }
+        return true;
+    }));
+};
+
+class AXPSessionContext {
+    get user() {
+        return this._user;
+    }
+    get tenant() {
+        return this._tenant;
+    }
+    get application() {
+        return this._application;
+    }
+    constructor(context) {
+        this._user = null;
+        this._tenant = null;
+        this._application = null;
+        this._user = context.user;
+        this._tenant = context.tenant;
+        this._application = context.application;
+    }
+}
+var AXPSessionStatus;
+(function (AXPSessionStatus) {
+    AXPSessionStatus["Authenticated"] = "authenticated";
+    AXPSessionStatus["Unauthenticated"] = "unauthenticated";
+    AXPSessionStatus["Unauthorized"] = "unauthorized";
+    AXPSessionStatus["Authorized"] = "authorized";
+    AXPSessionStatus["Expired"] = "expired";
+    AXPSessionStatus["SignedOut"] = "signedOut";
+})(AXPSessionStatus || (AXPSessionStatus = {}));
+
 class AXPSessionService {
     constructor() {
         this.store = inject(Store);
         this.currentAuthStrategyKey = null;
         this.authStrategyRegistry = inject(AXPAuthStrategyRegistryService);
-        this.tenantService = inject(AXP_TENANT_LOADER);
-        this.applicationLoader = inject(AXP_APPLICATION_LOADER);
+        this.SESSION_KEY = 'AXP_SESSION';
         this.permissionLoader = inject(AXP_PERMISSION_LOADER);
+        this.featureLoader = inject(AXP_FEATURE_LOADER);
+        this.tenantLoader = inject(AXP_TENANT_LOADER);
+        this.applicationLoader = inject(AXP_APPLICATION_LOADER);
+        this.status = new BehaviorSubject(AXPSessionStatus.Unauthenticated);
+        this.status$ = this.status.asObservable().pipe(shareReplay(1));
         this.currentUserSubject = new BehaviorSubject(null);
-        this.SESSION_KEY = 'AXP_SESSION';
         this.user$ = this.currentUserSubject.asObservable().pipe(shareReplay(1));
         this.currentTenantSubject = new BehaviorSubject(null);
-        this.tenantsSubject = new BehaviorSubject([]);
-        this.tenants$ = this.tenantsSubject.asObservable().pipe(shareReplay(1));
         this.tenant$ = this.currentTenantSubject.asObservable().pipe(shareReplay(1));
         this.currentApplicationSubject = new BehaviorSubject(null);
-        this.applicationsSubject = new BehaviorSubject([]);
-        this.applications$ = this.applicationsSubject.asObservable().pipe(shareReplay(1));
         this.application$ = this.currentApplicationSubject.asObservable().pipe(shareReplay(1));
-        this.permissionsSubject = new BehaviorSubject(null);
+        this.permissionsSubject = new BehaviorSubject([]);
         this.permissions$ = this.permissionsSubject.asObservable().pipe(shareReplay(1), defaultIfEmpty([]));
-        this.isAuthenticated$ = this.currentUserSubject.asObservable().pipe(map((user) => !!user), shareReplay(1));
-        this.isAuthorized$ = combineLatest([
-            this.currentUserSubject,
-            this.currentTenantSubject,
-            this.currentApplicationSubject,
-            this.permissionsSubject,
-        ]).pipe(filter(([user, tenant, application, permissions]) => {
-            return permissions != null;
-        }), map(([user, tenant, application, permissions]) => {
-            return !!user && !!tenant && !!application && !!permissions;
-        }), shareReplay(1));
+        this.featuresSubject = new BehaviorSubject([]);
+        this.features$ = this.featuresSubject.asObservable().pipe(shareReplay(1), defaultIfEmpty([]));
+        this.isAuthenticated$ = this.status$.pipe(map((status) => status === AXPSessionStatus.Authenticated || status === AXPSessionStatus.Authorized), shareReplay(1));
+        this.isAuthorized$ = this.status$.pipe(map((status) => status === AXPSessionStatus.Authorized), shareReplay(1));
     }
     get user() {
+        const session = this.getSessionData();
+        if (session?.user && !this.currentUserSubject.value) {
+            this.currentUserSubject.next(session.user);
+        }
         return this.currentUserSubject.value;
     }
     get tenant() {
+        const session = this.getSessionData();
+        if (session?.tenant && !this.currentTenantSubject.value) {
+            this.currentTenantSubject.next(session.tenant);
+        }
         return this.currentTenantSubject.value;
     }
+    get tenants$() {
+        return this.tenantLoader.getList(this.getContext());
+    }
     get application() {
+        const session = this.getSessionData();
+        if (session?.application && !this.currentApplicationSubject.value) {
+            this.currentApplicationSubject.next(session.application);
+        }
         return this.currentApplicationSubject.value;
     }
+    get applications$() {
+        return this.applicationLoader.getList(this.getContext());
+    }
     get permissions() {
         return this.permissionsSubject.value ?? [];
     }
-    async signInWithStoredSession() {
+    get features() {
+        return this.featuresSubject.value ?? [];
+    }
+    async restoreSession() {
         const sessionData = this.getSessionData();
         if (sessionData) {
             this.currentAuthStrategyKey = sessionData.strategy;
             if (sessionData.user) {
                 this.currentUserSubject.next(sessionData.user);
-                await this.loadTenants();
+                this.status.next(AXPSessionStatus.Authenticated);
             }
             if (sessionData.tenant) {
-                this.currentTenantSubject.next(sessionData.tenant);
-                await this.loadApplications();
+                this.setTenant(sessionData.tenant);
             }
             if (sessionData.application) {
-                this.currentApplicationSubject.next(sessionData.application);
-                await this.loadPermissions();
+                this.setApplication(sessionData.application);
             }
+            await this.signInComplete();
         }
         else {
-            this.currentUserSubject.next(null);
-            this.currentTenantSubject.next(null);
-            this.currentApplicationSubject.next(null);
-            this.permissionsSubject.next([]);
+            this.status.next(AXPSessionStatus.Unauthorized);
         }
     }
     async signin(credentials) {
@@ -165,50 +290,29 @@ class AXPSessionService {
             throw new Error(`Authentication strategy '${credentials.strategy}' is not supported`);
         }
         this.currentAuthStrategyKey = credentials.strategy; // Store the used strategy key
-        const tokens = await strategy.signin(credentials);
-        if (tokens.user) {
-            this.currentUserSubject.next(tokens.user);
+        const result = await strategy.signin(credentials);
+        if (result.succeed) {
+            this.currentUserSubject.next(result.data.user);
+            this.setSession({
+                accessToken: result.data.accessToken,
+                refreshToken: result.data.refreshToken,
+                user: result.data.user,
+            });
+            this.status.next(AXPSessionStatus.Authenticated);
+        }
+        else {
+            this.status.next(AXPSessionStatus.Unauthenticated);
+            throw new Error(`Invalid Username or Password`);
         }
-        this.setSession(tokens);
-        await this.loadTenants();
     }
     async signout() {
-        if (!this.currentAuthStrategyKey) {
-            this.currentAuthStrategyKey = null;
-            //
-            this.currentUserSubject.next(null);
-            //
-            this.currentTenantSubject.next(null);
-            this.tenantsSubject.next([]);
-            //
-            this.currentApplicationSubject.next(null);
-            this.applicationsSubject.next([]);
-            //
-            this.permissionsSubject.next(null);
-            //
-            this.clearSession();
-            this.store.dispatch(AXPSignOutAction());
-            throw new Error('No authentication strategy used for current session');
+        const strategy = this.currentAuthStrategyKey ? this.authStrategyRegistry.get(this.currentAuthStrategyKey) : null;
+        if (strategy) {
+            await strategy.signout();
         }
-        const strategy = this.authStrategyRegistry.get(this.currentAuthStrategyKey);
-        if (!strategy) {
-            throw new Error(`Authentication strategy '${this.currentAuthStrategyKey}' is not found for logout`);
-        }
-        await strategy.signout();
-        //
-        this.currentAuthStrategyKey = null;
-        //
-        this.currentUserSubject.next(null);
-        //
-        this.currentTenantSubject.next(null);
-        this.tenantsSubject.next([]);
-        //
-        this.currentApplicationSubject.next(null);
-        this.applicationsSubject.next([]);
-        //
-        this.permissionsSubject.next(null);
         //
         this.clearSession();
+        this.status.next(AXPSessionStatus.SignedOut);
         this.store.dispatch(AXPSignOutAction());
     }
     async refreshToken() {
@@ -220,75 +324,57 @@ class AXPSessionService {
         if (!strategy) {
             throw new Error(`Authentication strategy '${this.currentAuthStrategyKey}' is not found`);
         }
-        const tokens = await strategy.refreshToken(sessionData.refreshToken);
-        this.setSession(tokens);
-    }
-    async selectTenant(tenantId) {
-        const tenant = await firstValueFrom(this.tenants$.pipe(take(1), map((tenants) => tenants.find((t) => t.name === tenantId))));
-        if (!tenant) {
-            throw new Error('Tenant not found');
+        const result = await strategy.refreshToken(sessionData.refreshToken);
+        if (result.succeed) {
+            this.setSession(result.data);
+            this.status.next(AXPSessionStatus.Authorized);
         }
-        const newToken = await firstValueFrom(this.tenantService.set(tenant));
-        this.currentTenantSubject.next(tenant);
-        this.updateSession({ tenant, accessToken: newToken.accessToken, refreshToken: newToken.refreshToken });
-        // Fetch applications for the selected tenant
-        await this.loadApplications();
-    }
-    async selectApplication(applicationId) {
-        const application = await firstValueFrom(this.applications$.pipe(take(1), map((applications) => applications.find((a) => a.name === applicationId))));
-        if (!application) {
-            throw new Error('Application not found');
+        else {
+            this.status.next(AXPSessionStatus.Expired);
         }
-        const newToken = await firstValueFrom(this.applicationLoader.set(application));
-        this.currentApplicationSubject.next(application);
-        this.updateSession({ application, accessToken: newToken.accessToken, refreshToken: newToken.refreshToken });
-        // Fetch permissions for the selected application
-        await this.loadPermissions();
     }
-    async loadTenants() {
-        try {
-            const tenants = await firstValueFrom(this.tenantService.getList());
-            this.tenantsSubject.next(tenants);
-        }
-        catch (error) {
-            console.error('Error loading tenants:', error);
-            // Handle error, for example, by setting an empty permissions list
-            //this.applicationsSubject.next([]);
-            this.signout();
-        }
+    async setTenant(tenant) {
+        this.currentTenantSubject.next(tenant);
+        if (tenant)
+            this.updateSession({ tenant: tenant });
     }
-    async loadApplications() {
-        try {
-            const applications = await firstValueFrom(this.applicationLoader.getList());
-            this.applicationsSubject.next(applications ?? []);
-        }
-        catch (error) {
-            console.error('Error loading applications:', error);
-            // Handle error, for example, by setting an empty permissions list
-            //this.applicationsSubject.next([]);
-            this.signout();
-        }
+    async setApplication(application) {
+        this.currentApplicationSubject.next(application);
+        if (application)
+            this.updateSession({ application: application });
     }
     async loadPermissions() {
         try {
-            const permissions = await firstValueFrom(this.permissionLoader.getList());
+            const permissions = await firstValueFrom(this.permissionLoader.getList(this.getContext()));
             this.permissionsSubject.next(permissions ?? []);
             this.store.dispatch(AXPSignInAction());
         }
         catch (error) {
             console.error('Error loading permissions:', error);
-            // Handle error, for example, by setting an empty permissions list
             this.permissionsSubject.next([]);
         }
     }
+    async loadFeatures() {
+        try {
+            const features = await firstValueFrom(this.featureLoader.getList(this.getContext()));
+            this.featuresSubject.next(features ?? []);
+        }
+        catch (error) {
+            console.error('Error loading features:', error);
+            this.featuresSubject.next([]);
+        }
+    }
+    async signInComplete() {
+        await this.loadPermissions();
+        await this.loadFeatures();
+        this.status.next(AXPSessionStatus.Authorized);
+    }
     setSession(tokens) {
         const sessionData = {
             accessToken: tokens.accessToken,
             refreshToken: tokens.refreshToken,
-            strategy: this.currentAuthStrategyKey ?? 'false',
+            strategy: this.currentAuthStrategyKey ?? undefined,
             user: this.user,
-            tenant: this.tenant,
-            application: this.application,
         };
         this.updateSession(sessionData);
     }
@@ -302,122 +388,133 @@ class AXPSessionService {
         return sessionDataString ? JSON.parse(sessionDataString) : null;
     }
     clearSession() {
+        //
+        this.currentAuthStrategyKey = null;
+        //
+        this.currentUserSubject.next(null);
+        //
+        this.setTenant(null);
+        //
+        this.setApplication(null);
+        //
+        this.permissionsSubject.next([]);
+        //
+        this.featuresSubject.next([]);
+        //
         localStorage.removeItem(this.SESSION_KEY);
     }
     authorize(...keys) {
         return keys.every((k) => isEmpty(k) || this.permissions.indexOf(k) > -1);
     }
+    isFeatureEnabled(...keys) {
+        return keys.every((k) => isEmpty(k) || this.features.some((c) => c.name == k && c.value == true));
+    }
     getToken() {
         return of(this.getSessionData()?.accessToken);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPSessionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPSessionService, providedIn: 'root' }); }
+    getContext() {
+        return new AXPSessionContext({
+            user: this.user,
+            tenant: this.tenant,
+            application: this.application,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSessionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSessionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPSessionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSessionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
+const AXPPermissionGuard = (route, state) => {
+    const sessionService = inject(AXPSessionService);
+    const permissionKeys = route.data['requiredPermission'];
+    return sessionService.isAuthorized$.pipe(first(), map((value) => {
+        const keys = !permissionKeys ? [] : Array.isArray(permissionKeys) ? permissionKeys : [permissionKeys];
+        const hasPermission = keys.length == 0 || sessionService.authorize(...keys);
+        if (!hasPermission) {
+            throw new AXPUnauthorizedError(`Access denied. Required permissions: ${keys.join(', ')}. Please contact your administrator if you believe this is an error.`, {
+                redirectUrl: state.url
+            });
+        }
+        return true;
+    }));
+};
+
 class AXPPermissionDirective {
-    constructor(templateRef, viewContainer, sessionService) {
+    constructor(templateRef, viewContainer) {
         this.templateRef = templateRef;
         this.viewContainer = viewContainer;
-        this.sessionService = sessionService;
-        this.hasView = false;
-        this.configs = inject(AXP_PLATFORM_CONFIG_TOKEN);
+        this.hasView = signal(false);
+        this.sessionService = inject(AXPSessionService);
     }
-    set permission(permissionKey) {
-        if (!permissionKey) {
+    set permission(permissionKeys) {
+        const keys = !permissionKeys ? [] : (Array.isArray(permissionKeys) ? permissionKeys : [permissionKeys]);
+        if (keys.length == 0) {
             // If permissionKey is null or empty, decide the default behavior here
             this.viewContainer.createEmbeddedView(this.templateRef);
-            this.hasView = true;
+            this.hasView.set(true);
             return;
         }
         this.subscription = this.sessionService.isAuthorized$
-            .pipe(first())
             .subscribe((isAuthorized) => {
-            if (isAuthorized && this.sessionService.authorize(permissionKey)) {
-                if (!this.hasView) {
+            if (isAuthorized && this.sessionService.authorize(...keys)) {
+                if (!this.hasView()) {
                     this.viewContainer.createEmbeddedView(this.templateRef);
-                    this.hasView = true;
+                    this.hasView.set(true);
                 }
             }
             else {
                 this.viewContainer.clear();
-                this.hasView = false;
+                this.hasView.set(false);
             }
         });
     }
+    set permissionElse(elseTemplateRef) {
+        if (!this.hasView()) {
+            this.viewContainer.createEmbeddedView(elseTemplateRef);
+        }
+    }
     ngOnDestroy() {
         this.subscription?.unsubscribe();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPPermissionDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: AXPSessionService }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: AXPPermissionDirective, selector: "[permission]", inputs: { permission: "permission" }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPPermissionDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.2", type: AXPPermissionDirective, selector: "[permission]", inputs: { permission: "permission", permissionElse: "permissionElse" }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPPermissionDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPPermissionDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[permission]',
                 }]
-        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: AXPSessionService }], propDecorators: { permission: [{
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }], propDecorators: { permission: [{
+                type: Input
+            }], permissionElse: [{
                 type: Input
             }] } });
 
-class AXPUnauthorizedError extends Error {
-    constructor() {
-        super('UNAUTHORIZED_ACCESS');
-        this.name = 'AXPUnauthorizedError';
-    }
-}
-class AXPUnauthenticatedError extends Error {
-    constructor() {
-        super('UNAUTHNTICATED_USER');
-        this.name = 'AXPUnauthenticatedError';
-    }
-}
-
-const AXPPermissionGuard = (route, state) => {
-    const sessionService = inject(AXPSessionService);
-    const requiredPermission = route.data['requiredPermission'];
-    return sessionService.isAuthorized$.pipe(first(), map(() => {
-        const hasPermission = !requiredPermission || sessionService.authorize(requiredPermission);
-        if (!hasPermission) {
-            throw new AXPUnauthorizedError();
-        }
-        return true;
-    }));
-};
-
-const AXP_FEATURE_LOADER = new InjectionToken('AXP_FEATURE_LOADER', {
-    providedIn: 'root',
-    factory: () => {
-        return new AXPFeatureDefaultLoader();
-    },
-});
-class AXPFeatureDefaultLoader {
-    getList() {
-        return of([]);
-    }
-}
-
 const AXPAuthGuard = (route, state) => {
     const sessionService = inject(AXPSessionService);
-    const router = inject(Router);
-    return sessionService.isAuthenticated$.pipe(first(), // Ensure that the Observable completes after receiving the first value
-    map(isAuthenticated => {
-        if (!isAuthenticated) {
-            // User is not authenticated, redirect to login
-            throw new AXPUnauthenticatedError();
+    return sessionService.isAuthenticated$.pipe(first(), map(value => {
+        if (value) {
+            return true;
         }
-        return true; // User is authenticated 
+        throw new AXPUnauthenticatedError(`Access denied. You are not currently logged in. Please log in to access this page. If you continue to see this message after logging in, please contact support.`, {
+            redirectUrl: state.url
+        });
     }));
 };
 
 function initializeAppState(service) {
     return async () => {
-        await service.signInWithStoredSession();
+        try {
+            await service.restoreSession();
+        }
+        catch (error) {
+            console.error(error);
+        }
     };
 }
 class AXPAuthModule {
@@ -432,9 +529,9 @@ class AXPAuthModule {
                         registry.register(...(configs?.strategies || []));
                     },
                     deps: [AXPAuthStrategyRegistryService],
-                    multi: true
-                }
-            ]
+                    multi: true,
+                },
+            ],
         };
     }
     static forChild(configs) {
@@ -448,22 +545,22 @@ class AXPAuthModule {
                         registry.register(...(configs?.strategies || []));
                     },
                     deps: [AXPAuthStrategyRegistryService],
-                    multi: true
-                }
-            ]
+                    multi: true,
+                },
+            ],
         };
     }
     /**
      * @ignore
      */
     constructor(instances) {
-        instances?.forEach(f => {
+        instances?.forEach((f) => {
             f();
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthModule, deps: [{ token: 'AXPAuthModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthModule, declarations: [AXPPermissionDirective], exports: [AXPPermissionDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthModule, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthModule, deps: [{ token: 'AXPAuthModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthModule, declarations: [AXPPermissionDirective, AXPFeatureDirective], exports: [AXPPermissionDirective, AXPFeatureDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthModule, providers: [
             {
                 provide: APP_INITIALIZER,
                 useFactory: initializeAppState,
@@ -472,12 +569,12 @@ class AXPAuthModule {
             },
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPAuthModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAuthModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
-                    exports: [AXPPermissionDirective],
-                    declarations: [AXPPermissionDirective],
+                    exports: [AXPPermissionDirective, AXPFeatureDirective],
+                    declarations: [AXPPermissionDirective, AXPFeatureDirective],
                     providers: [
                         {
                             provide: APP_INITIALIZER,
@@ -485,7 +582,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                             deps: [AXPSessionService],
                             multi: true,
                         },
-                    ]
+                    ],
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Optional
@@ -498,5 +595,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXPAuthGuard, AXPAuthModule, AXPPermissionDirective, AXPPermissionGuard, AXPSessionService, AXPUnauthenticatedError, AXPUnauthorizedError, AXP_APPLICATION_LOADER, AXP_FEATURE_LOADER, AXP_PERMISSION_LOADER, AXP_TENANT_LOADER, initializeAppState };
+export { AXPAuthGuard, AXPAuthModule, AXPFeatureDirective, AXPFeatureGuard, AXPPermissionDirective, AXPPermissionGuard, AXPSessionContext, AXPSessionService, AXPSessionStatus, AXPUnauthenticatedError, AXPUnauthorizedError, AXP_APPLICATION_LOADER, AXP_FEATURE_LOADER, AXP_PERMISSION_LOADER, AXP_TENANT_LOADER, initializeAppState };
 //# sourceMappingURL=acorex-platform-auth.mjs.map