@acorex/platform 19.4.15 → 20.0.0-next.0

package/auth/index.d.ts

@@ -1,13 +1,300 @@
-export * from './lib/application/application.loader';
-export * from './lib/application/application.types';
-export * from './lib/tenant/tenant.loader';
-export * from './lib/tenant/tenant.types';
-export * from './lib/permission';
-export * from './lib/feature';
-export * from './lib/user/user.types';
-export * from './lib/auth.guard';
-export * from './lib/auth.module';
-export * from './lib/auth.strategy';
-export * from './lib/errors.types';
-export * from './lib/session.types';
-export * from './lib/session.service';
+import * as i0 from '@angular/core';
+import { InjectionToken, TemplateRef, ViewContainerRef, ModuleWithProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AXPLogoConfig } from '@acorex/platform/core';
+import { CanActivateFn } from '@angular/router';
+
+interface AXPApplication {
+    id: string;
+    name: string;
+    title?: string;
+    version?: string;
+    editionName?: string;
+    description?: string;
+    logo?: AXPLogoConfig;
+}
+
+interface AXPTenant {
+    id: string;
+    name: string;
+    title: string;
+    description?: string;
+    logo?: AXPLogoConfig;
+}
+
+interface AXPUser {
+    id: string;
+    name: string;
+    title: string;
+    avatar?: string;
+}
+
+declare class AXPSessionContext {
+    private _user;
+    get user(): AXPUser | null;
+    private _tenant;
+    get tenant(): AXPTenant | null;
+    private _application;
+    get application(): AXPApplication | null;
+    constructor(context: {
+        user: AXPUser | null;
+        tenant: AXPTenant | null;
+        application: AXPApplication | null;
+    });
+}
+declare enum AXPSessionStatus {
+    Authenticated = "authenticated",
+    Unauthenticated = "unauthenticated",
+    Unauthorized = "unauthorized",
+    Authorized = "authorized",
+    Expired = "expired",
+    SignedOut = "signedOut"
+}
+
+interface AXPApplicationLoader {
+    getList(context: AXPSessionContext): Observable<AXPApplication[]>;
+}
+declare const AXP_APPLICATION_LOADER: InjectionToken<AXPApplicationLoader>;
+
+interface AXPTenantLoader {
+    getList(context: AXPSessionContext): Observable<AXPTenant[]>;
+}
+declare const AXP_TENANT_LOADER: InjectionToken<AXPTenantLoader>;
+
+declare class AXPPermissionDirective {
+    private templateRef;
+    private viewContainer;
+    private hasView;
+    private subscription;
+    private sessionService;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    set permission(permissionKeys: string | string[] | null);
+    set permissionElse(elseTemplateRef: TemplateRef<any>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPermissionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPPermissionDirective, "[permission]", never, { "permission": { "alias": "permission"; "required": false; }; "permissionElse": { "alias": "permissionElse"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const AXPPermissionGuard: CanActivateFn;
+
+type AXPPermission = string;
+interface AXPPermissionGroupDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    permissions: AXPPermissionDefinition[];
+}
+type AXPPermissionDefinition = {
+    name: AXPPermission;
+    title: string;
+    description?: string;
+    children: AXPPermissionDefinition[];
+};
+
+interface AXPPermissionLoader {
+    getList(context: AXPSessionContext): Observable<AXPPermission[]>;
+}
+declare const AXP_PERMISSION_LOADER: InjectionToken<AXPPermissionLoader>;
+
+declare class AXPPermissionDefinitionProviderContext {
+    private builders;
+    addGroup(name: string, title: string, description?: string): AXPPermissionDefinitionGroupBuilder;
+    getGroupDefinitions(): AXPPermissionGroupDefinition[];
+    findGroup(name: string): AXPPermissionDefinitionGroupBuilder | undefined;
+    isGroupDefined(name: string): boolean;
+}
+declare class AXPPermissionDefinitionGroupBuilder {
+    private context;
+    private _group;
+    get group(): AXPPermissionGroupDefinition;
+    constructor(context: AXPPermissionDefinitionProviderContext, group: AXPPermissionGroupDefinition);
+    addPermission(name: string, title: string, description?: string): AXPPermissionDefinitionBuilder;
+    endGroup(): AXPPermissionDefinitionProviderContext;
+    findPermission(path: string): AXPPermissionDefinition | undefined;
+    findGroup(name: string): AXPPermissionDefinitionGroupBuilder | undefined;
+}
+declare class AXPPermissionDefinitionBuilder {
+    private groupBuilder;
+    private permission;
+    constructor(groupBuilder: AXPPermissionDefinitionGroupBuilder, permission: AXPPermissionDefinition);
+    addChild(name: string, title: string, description?: string): AXPPermissionDefinitionBuilder;
+    endPermission(): AXPPermissionDefinitionGroupBuilder;
+}
+
+interface AXPPermissionDefinitionProvider {
+    define(context: AXPPermissionDefinitionProviderContext): Promise<void>;
+}
+declare const AXP_PERMISSION_DEFINITION_PROVIDER: InjectionToken<AXPPermissionDefinitionProvider[]>;
+declare class AXPPermissionDefinitionService {
+    private providers;
+    private cache;
+    private load;
+    reload(): Promise<void>;
+    getGroups(): Promise<AXPPermissionGroupDefinition[]>;
+    getPermissions(): Promise<AXPPermissionDefinition[]>;
+    getGroup(name: string): Promise<AXPPermissionGroupDefinition | null>;
+    getPermission(name: string): Promise<AXPPermissionDefinition | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPermissionDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPermissionDefinitionService>;
+}
+
+interface AXPFeature {
+    name: string;
+    title: string;
+    description?: string;
+    value?: any;
+}
+
+interface AXPFeatureLoader {
+    getList(context: AXPSessionContext): Observable<AXPFeature[]>;
+}
+declare const AXP_FEATURE_LOADER: InjectionToken<AXPFeatureLoader>;
+
+declare class AXPFeatureDirective {
+    private templateRef;
+    private viewContainer;
+    private hasView;
+    private subscription;
+    private sessionService;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    set feature(featureKeys: string | string[] | null);
+    set featureElse(elseTemplateRef: TemplateRef<any>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFeatureDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPFeatureDirective, "[feature]", never, { "feature": { "alias": "feature"; "required": false; }; "featureElse": { "alias": "featureElse"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const AXPFeatureGuard: CanActivateFn;
+
+declare const AXPAuthGuard: CanActivateFn;
+
+interface AXPBaseCredentials {
+    strategy: string;
+    [key: string]: string;
+}
+interface AXPTokenResult {
+    accessToken: string;
+    expiresIn?: string | null;
+    refreshToken?: string;
+    tenant?: AXPTenant | null;
+    application?: AXPApplication | null;
+}
+interface AXPSignInResult {
+    succeed: boolean;
+    data?: {
+        accessToken: string;
+        idToken?: string | null;
+        expiresIn?: string | null;
+        refreshToken: string;
+        user: AXPUser;
+        tenant?: AXPTenant | null;
+        application?: AXPApplication | null;
+    };
+}
+interface AXPRefreshTokenResult {
+    succeed: boolean;
+    data?: AXPTokenResult;
+}
+interface AXPAuthStrategy {
+    get name(): string;
+    signin(credentials: AXPBaseCredentials): Promise<AXPSignInResult>;
+    signout(): Promise<void>;
+    refreshToken(context: AXPSessionContext): Promise<AXPRefreshTokenResult>;
+}
+interface AXPSessionData {
+    accessToken: string;
+    refreshToken: string;
+    idToken: string | null;
+    strategy: string;
+    user?: AXPUser | null;
+    tenant?: AXPTenant | null;
+    application?: AXPApplication | null;
+    expiresIn?: string | null;
+}
+
+declare class AXPSessionService {
+    private eventService;
+    private authStrategyRegistry;
+    static readonly SESSION_KEY = "AXP_SESSION";
+    private readonly permissionLoader;
+    private readonly featureLoader;
+    private readonly tenantLoader;
+    private readonly applicationLoader;
+    private status;
+    readonly status$: Observable<AXPSessionStatus>;
+    private currentUserSubject;
+    readonly user$: Observable<AXPUser | null>;
+    get user(): AXPUser | null;
+    private currentTenantSubject;
+    readonly tenant$: Observable<AXPTenant | null>;
+    get tenant(): AXPTenant | null;
+    get tenants$(): Observable<AXPTenant[]>;
+    private currentApplicationSubject;
+    readonly application$: Observable<AXPApplication | null>;
+    get application(): AXPApplication | null;
+    get applications$(): Observable<AXPApplication[]>;
+    private permissionsSubject;
+    readonly permissions$: Observable<never[] | string[]>;
+    get permissions(): AXPPermission[];
+    private featuresSubject;
+    readonly features$: Observable<never[] | AXPFeature[]>;
+    get features(): AXPFeature[];
+    readonly isAuthenticated$: Observable<boolean>;
+    readonly isAuthorized$: Observable<boolean>;
+    restoreSession(): Promise<void>;
+    signin(credentials: AXPBaseCredentials): Promise<void>;
+    signout(): Promise<void>;
+    refreshToken(): Promise<any>;
+    setTenant(tenant: AXPTenant | null): Promise<void>;
+    setApplication(application: AXPApplication | null): Promise<void>;
+    private loadPermissions;
+    private loadFeatures;
+    signInComplete(): Promise<void>;
+    private setSession;
+    private updateSession;
+    getSessionData(): AXPSessionData | null;
+    private clearSession;
+    authorize(...keys: string[]): boolean;
+    isFeatureEnabled(...keys: string[]): boolean;
+    getToken(): string | undefined;
+    private checkTokenValidation;
+    private getContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSessionService>;
+}
+
+interface AXPAuthModuleConfigs {
+    strategies: (new () => AXPAuthStrategy)[];
+}
+declare function initializeAppState(service: AXPSessionService): () => Promise<void>;
+declare class AXPAuthModule {
+    static forRoot(configs?: AXPAuthModuleConfigs): ModuleWithProviders<AXPAuthModule>;
+    static forChild(configs?: AXPAuthModuleConfigs): ModuleWithProviders<AXPAuthModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAuthModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPAuthModule, [typeof AXPPermissionDirective, typeof AXPFeatureDirective], never, [typeof AXPPermissionDirective, typeof AXPFeatureDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPAuthModule>;
+}
+
+declare class AXPUnauthorizedError extends Error {
+    data?: {
+        redirectUrl?: string;
+    } | undefined;
+    constructor(message?: string, data?: {
+        redirectUrl?: string;
+    } | undefined);
+}
+declare class AXPUnauthenticatedError extends Error {
+    data?: {
+        redirectUrl?: string;
+    } | undefined;
+    constructor(message?: string, data?: {
+        redirectUrl?: string;
+    } | undefined);
+}
+
+export { AXPAuthGuard, AXPAuthModule, AXPFeatureDirective, AXPFeatureGuard, AXPPermissionDefinitionBuilder, AXPPermissionDefinitionGroupBuilder, AXPPermissionDefinitionProviderContext, AXPPermissionDefinitionService, AXPPermissionDirective, AXPPermissionGuard, AXPSessionContext, AXPSessionService, AXPSessionStatus, AXPUnauthenticatedError, AXPUnauthorizedError, AXP_APPLICATION_LOADER, AXP_FEATURE_LOADER, AXP_PERMISSION_DEFINITION_PROVIDER, AXP_PERMISSION_LOADER, AXP_TENANT_LOADER, initializeAppState };
+export type { AXPApplication, AXPApplicationLoader, AXPAuthModuleConfigs, AXPAuthStrategy, AXPBaseCredentials, AXPFeature, AXPFeatureLoader, AXPPermission, AXPPermissionDefinition, AXPPermissionDefinitionProvider, AXPPermissionGroupDefinition, AXPPermissionLoader, AXPRefreshTokenResult, AXPSessionData, AXPSignInResult, AXPTenant, AXPTenantLoader, AXPTokenResult, AXPUser };