@mediusinc/mng-commons 0.9.7 → 0.10.3-rc

package/esm2020/lib/router/tableview-route-builder.mjs

@@ -0,0 +1,160 @@
+import { MngActionRouteComponent } from '../components/action';
+import { MngTableviewRouteComponent } from '../components/tableview';
+import { ActionEditorAddDescriptor, ActionEditorDetailsDescriptor, ActionEditorEditDescriptor } from '../descriptors';
+import { Permissions } from '../security/model';
+import { RouteBuilder } from './route-builder';
+export class TableviewRouteBuilder {
+    constructor(path) {
+        this.path = path;
+        this.hasDetails = true;
+        this.detailsPath = ':itemId';
+        this.hasEdit = true;
+        this.editPath = ':itemId/edit';
+        this.hasAdd = true;
+        this.addPath = 'add';
+    }
+    static fromComponent(path, component) {
+        const inst = new TableviewRouteBuilder(path);
+        inst.component = component;
+        return inst;
+    }
+    static from(path, descriptor, dataProvider, actions) {
+        const inst = new TableviewRouteBuilder(path);
+        inst.descriptor = descriptor;
+        inst.dataProvider = dataProvider;
+        inst.actions = actions;
+        inst.hasDetails = false;
+        inst.hasAdd = false;
+        inst.hasEdit = false;
+        for (const action of inst.actions) {
+            if (action instanceof ActionEditorDetailsDescriptor) {
+                inst.hasDetails = true;
+            }
+            else if (action instanceof ActionEditorAddDescriptor) {
+                inst.hasAdd = true;
+            }
+            else if (action instanceof ActionEditorEditDescriptor) {
+                inst.hasEdit = true;
+            }
+        }
+        return inst;
+    }
+    withDetails(hasDetails = true, permissions, path) {
+        this.hasDetails = hasDetails;
+        if (permissions) {
+            this.withPermissions(undefined, undefined, undefined, undefined, permissions);
+        }
+        if (path) {
+            this.detailsPath = path;
+        }
+        return this;
+    }
+    withAdd(hasAdd = true, permissions, path) {
+        this.hasAdd = hasAdd;
+        if (permissions) {
+            this.withPermissions(undefined, permissions);
+        }
+        if (path) {
+            this.addPath = path;
+        }
+        return this;
+    }
+    withEdit(hasEdit = true, permissions, path) {
+        this.hasEdit = hasEdit;
+        if (permissions) {
+            this.withPermissions(undefined, undefined, permissions);
+        }
+        if (path) {
+            this.editPath = path;
+        }
+        return this;
+    }
+    withPermissions(read, add, edit, delet, details) {
+        if (!this.permissions) {
+            this.permissions = {};
+        }
+        if (read) {
+            this.permissions[Permissions.ActionTypes.READ] = read;
+        }
+        if (add) {
+            this.permissions[Permissions.ActionTypes.ADD] = add;
+        }
+        if (edit) {
+            this.permissions[Permissions.ActionTypes.EDIT] = edit;
+        }
+        if (delet) {
+            this.permissions[Permissions.ActionTypes.DELETE] = delet;
+        }
+        if (details) {
+            this.permissions[Permissions.ActionTypes.DETAILS] = details;
+        }
+        return this;
+    }
+    withPermissionsOther(key, permissions) {
+        if (!this.permissions) {
+            this.permissions = {};
+        }
+        this.permissions[key] = permissions;
+        return this;
+    }
+    withPermissionsObject(permissions) {
+        this.permissions = permissions;
+        return this;
+    }
+    build() {
+        return this.toRouteBuilder().buildRoute();
+    }
+    toRouteBuilder() {
+        const tableviewRouteBuilder = RouteBuilder.createFromRoute({
+            path: this.path,
+            component: this.component ? this.component : MngTableviewRouteComponent
+        });
+        const routeData = {};
+        if (!this.component) {
+            routeData.tableview = {
+                descriptor: this.descriptor,
+                dataProvider: this.dataProvider
+            };
+            if (this.actions) {
+                routeData.tableview.actions = this.actions;
+            }
+        }
+        if (this.permissions) {
+            routeData.tableviewPermissions = { ...this.permissions };
+        }
+        tableviewRouteBuilder.withData(routeData);
+        if (this.permissions?.[Permissions.ActionTypes.READ]) {
+            tableviewRouteBuilder.withPermissions(this.permissions[Permissions.ActionTypes.READ]);
+        }
+        // list route
+        const rootChildRouteBuilder = RouteBuilder.create('', MngActionRouteComponent);
+        if (this.permissions?.[Permissions.ActionTypes.READ]) {
+            rootChildRouteBuilder.withPermissions(this.permissions[Permissions.ActionTypes.READ]);
+        }
+        tableviewRouteBuilder.addChildBuilder(rootChildRouteBuilder);
+        // add route
+        if (this.hasAdd) {
+            const routeBuilder = RouteBuilder.create(this.addPath, MngActionRouteComponent);
+            if (this.permissions?.[Permissions.ActionTypes.ADD]) {
+                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.ADD]);
+            }
+            tableviewRouteBuilder.addChildBuilder(routeBuilder);
+        }
+        if (this.hasDetails) {
+            const routeBuilder = RouteBuilder.create(this.detailsPath, MngActionRouteComponent);
+            if (this.permissions?.[Permissions.ActionTypes.DETAILS]) {
+                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.DETAILS]);
+            }
+            tableviewRouteBuilder.addChildBuilder(routeBuilder);
+        }
+        if (this.hasEdit) {
+            const routeBuilder = RouteBuilder.create(this.editPath, MngActionRouteComponent);
+            if (this.permissions?.[Permissions.ActionTypes.EDIT]) {
+                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.EDIT]);
+            }
+            tableviewRouteBuilder.addChildBuilder(routeBuilder);
+        }
+        return tableviewRouteBuilder;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-route-builder.js","sourceRoot":"","sources":["../../../../src/lib/router/tableview-route-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\nimport {Route} from '@angular/router';\n\nimport {MngActionRouteComponent} from '../components/action';\nimport {AMngTableviewRouteComponent, MngTableviewRouteComponent} from '../components/tableview';\nimport {ITableviewDataProvider} from '../data-providers';\nimport {ActionDescriptor, ActionEditorAddDescriptor, ActionEditorDetailsDescriptor, ActionEditorEditDescriptor, TableviewDescriptor} from '../descriptors';\nimport {APermissions, Permissions} from '../security/model';\nimport {MngRouterData} from './models';\nimport {RouteBuilder} from './route-builder';\n\nexport class TableviewRouteBuilder<C extends AMngTableviewRouteComponent<any, any>> {\n    private descriptor?: TableviewDescriptor<any>;\n    private dataProvider?: ITableviewDataProvider<any, any>;\n    private actions?: Array<ActionDescriptor<any>>;\n\n    private component?: Type<C>;\n\n    private hasDetails = true;\n    private detailsPath = ':itemId';\n    private hasEdit = true;\n    private editPath = ':itemId/edit';\n    private hasAdd = true;\n    private addPath = 'add';\n\n    private permissions?: {\n        [key: string]: APermissions;\n    };\n\n    private constructor(private path: string) {}\n\n    public static fromComponent<C extends AMngTableviewRouteComponent<any, any>>(path: string, component: Type<C>): TableviewRouteBuilder<C> {\n        const inst = new TableviewRouteBuilder<C>(path);\n        inst.component = component;\n        return inst;\n    }\n\n    public static from(\n        path: string,\n        descriptor: TableviewDescriptor<any>,\n        dataProvider: ITableviewDataProvider<any, any>,\n        actions: Array<ActionDescriptor<any>>\n    ): TableviewRouteBuilder<never> {\n        const inst = new TableviewRouteBuilder<never>(path);\n        inst.descriptor = descriptor;\n        inst.dataProvider = dataProvider;\n        inst.actions = actions;\n\n        inst.hasDetails = false;\n        inst.hasAdd = false;\n        inst.hasEdit = false;\n        for (const action of inst.actions) {\n            if (action instanceof ActionEditorDetailsDescriptor) {\n                inst.hasDetails = true;\n            } else if (action instanceof ActionEditorAddDescriptor) {\n                inst.hasAdd = true;\n            } else if (action instanceof ActionEditorEditDescriptor) {\n                inst.hasEdit = true;\n            }\n        }\n\n        return inst;\n    }\n\n    public withDetails(hasDetails = true, permissions?: APermissions, path?: string): this {\n        this.hasDetails = hasDetails;\n        if (permissions) {\n            this.withPermissions(undefined, undefined, undefined, undefined, permissions);\n        }\n        if (path) {\n            this.detailsPath = path;\n        }\n        return this;\n    }\n\n    public withAdd(hasAdd = true, permissions?: APermissions, path?: string): this {\n        this.hasAdd = hasAdd;\n        if (permissions) {\n            this.withPermissions(undefined, permissions);\n        }\n        if (path) {\n            this.addPath = path;\n        }\n        return this;\n    }\n\n    public withEdit(hasEdit = true, permissions?: APermissions, path?: string): this {\n        this.hasEdit = hasEdit;\n        if (permissions) {\n            this.withPermissions(undefined, undefined, permissions);\n        }\n        if (path) {\n            this.editPath = path;\n        }\n        return this;\n    }\n\n    public withPermissions(read?: APermissions, add?: APermissions, edit?: APermissions, delet?: APermissions, details?: APermissions): this {\n        if (!this.permissions) {\n            this.permissions = {};\n        }\n        if (read) {\n            this.permissions[Permissions.ActionTypes.READ] = read;\n        }\n        if (add) {\n            this.permissions[Permissions.ActionTypes.ADD] = add;\n        }\n        if (edit) {\n            this.permissions[Permissions.ActionTypes.EDIT] = edit;\n        }\n        if (delet) {\n            this.permissions[Permissions.ActionTypes.DELETE] = delet;\n        }\n        if (details) {\n            this.permissions[Permissions.ActionTypes.DETAILS] = details;\n        }\n        return this;\n    }\n\n    public withPermissionsOther(key: string, permissions: APermissions): this {\n        if (!this.permissions) {\n            this.permissions = {};\n        }\n        this.permissions[key] = permissions;\n        return this;\n    }\n\n    public withPermissionsObject(permissions: {[key: string]: APermissions}): this {\n        this.permissions = permissions;\n        return this;\n    }\n\n    public build(): Route {\n        return this.toRouteBuilder().buildRoute();\n    }\n\n    public toRouteBuilder(): RouteBuilder {\n        const tableviewRouteBuilder = RouteBuilder.createFromRoute({\n            path: this.path,\n            component: this.component ? this.component : MngTableviewRouteComponent\n        });\n\n        const routeData: MngRouterData = {};\n        if (!this.component) {\n            routeData.tableview = {\n                descriptor: this.descriptor!,\n                dataProvider: this.dataProvider!\n            };\n            if (this.actions) {\n                routeData.tableview.actions = this.actions;\n            }\n        }\n        if (this.permissions) {\n            routeData.tableviewPermissions = {...this.permissions};\n        }\n        tableviewRouteBuilder.withData(routeData);\n        if (this.permissions?.[Permissions.ActionTypes.READ]) {\n            tableviewRouteBuilder.withPermissions(this.permissions[Permissions.ActionTypes.READ]);\n        }\n\n        // list route\n        const rootChildRouteBuilder = RouteBuilder.create('', MngActionRouteComponent);\n        if (this.permissions?.[Permissions.ActionTypes.READ]) {\n            rootChildRouteBuilder.withPermissions(this.permissions[Permissions.ActionTypes.READ]);\n        }\n        tableviewRouteBuilder.addChildBuilder(rootChildRouteBuilder);\n\n        // add route\n        if (this.hasAdd) {\n            const routeBuilder = RouteBuilder.create(this.addPath, MngActionRouteComponent);\n            if (this.permissions?.[Permissions.ActionTypes.ADD]) {\n                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.ADD]);\n            }\n            tableviewRouteBuilder.addChildBuilder(routeBuilder);\n        }\n        if (this.hasDetails) {\n            const routeBuilder = RouteBuilder.create(this.detailsPath, MngActionRouteComponent);\n            if (this.permissions?.[Permissions.ActionTypes.DETAILS]) {\n                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.DETAILS]);\n            }\n            tableviewRouteBuilder.addChildBuilder(routeBuilder);\n        }\n        if (this.hasEdit) {\n            const routeBuilder = RouteBuilder.create(this.editPath, MngActionRouteComponent);\n            if (this.permissions?.[Permissions.ActionTypes.EDIT]) {\n                routeBuilder.withPermissions(this.permissions[Permissions.ActionTypes.EDIT]);\n            }\n            tableviewRouteBuilder.addChildBuilder(routeBuilder);\n        }\n\n        return tableviewRouteBuilder;\n    }\n}\n"]}

package/esm2020/lib/security/authorization.guard.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { first } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./authorization.service";
+export class MngAuthorizationGuard {
+    constructor(authorization) {
+        this.authorization = authorization;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    canActivate(route, state) {
+        const data = route.data;
+        if (data.permissions) {
+            return this.authorization.isPermitted(data.permissions).pipe(first());
+        }
+        else {
+            return of(true);
+        }
+    }
+}
+MngAuthorizationGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: MngAuthorizationGuard, deps: [{ token: i1.MngAuthorizationService }], target: i0.ɵɵFactoryTarget.Injectable });
+MngAuthorizationGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: MngAuthorizationGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: MngAuthorizationGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MngAuthorizationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/security/authorization.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { combineLatest, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AuthorizationTypeEnum } from '../security/model';
+import { AuthorizationUtil } from './authorization.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../services";
+export class MngAuthorizationService {
+    constructor(injector, router, commons) {
+        this.injector = injector;
+        this.router = router;
+        this.commons = commons;
+    }
+    isPermitted(permissions, route, actionCtx) {
+        switch (permissions.authorizationType) {
+            case AuthorizationTypeEnum.All:
+                return this.isPermittedAll(permissions, route, actionCtx);
+            case AuthorizationTypeEnum.Any:
+                return this.isPermittedAny(permissions, route, actionCtx);
+            case AuthorizationTypeEnum.Service:
+                return this.isPermittedService(permissions, route, actionCtx);
+            default:
+                return this.commons.userRoles$.pipe(map(ur => AuthorizationUtil.isPermitted(permissions, ur)));
+        }
+    }
+    isPermittedAll(permission, route, actionCtx) {
+        return combineLatest(permission.permissions.map(p => this.isPermitted(p, route, actionCtx))).pipe(map(res => res.every(ip => ip === true)));
+    }
+    isPermittedAny(permission, route, actionCtx) {
+        return combineLatest(permission.permissions.map(p => this.isPermitted(p, route, actionCtx))).pipe(map(res => res.some(ip => ip === true)));
+    }
+    isPermittedService(permission, route, actionCtx) {
+        const serviceInstance = this.injector.get(permission.service);
+        if (!serviceInstance) {
+            console.warn(`Service instance could not be retreived for type ${permission.service}`);
+            return of(false);
+        }
+        return serviceInstance.isPermitted(route, this.router.routerState.snapshot, actionCtx);
+    }
+}
+MngAuthorizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: MngAuthorizationService, deps: [{ token: i0.Injector }, { token: i1.Router }, { token: i2.MngCommonsService }], target: i0.ɵɵFactoryTarget.Injectable });
+MngAuthorizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: MngAuthorizationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: MngAuthorizationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.Router }, { type: i2.MngCommonsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/security/authorization.util.mjs

@@ -0,0 +1,16 @@
+import { AuthorizationTypeEnum } from './model';
+export class AuthorizationUtil {
+    static isPermitted(permissions, userRoles) {
+        switch (permissions.authorizationType) {
+            case AuthorizationTypeEnum.Rbac:
+                return AuthorizationUtil.isRbacPermitted(permissions, userRoles);
+            default:
+                console.error(`Permission type "${permissions.authorizationType}" not implemented`);
+                return false;
+        }
+    }
+    static isRbacPermitted(permissions, userRoles) {
+        return permissions.roles.some(prg => prg.every(pr => userRoles.indexOf(pr) > -1));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXphdGlvbi51dGlsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9zZWN1cml0eS9hdXRob3JpemF0aW9uLnV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFlLHFCQUFxQixFQUFjLE1BQU0sU0FBUyxDQUFDO0FBRXpFLE1BQU0sT0FBTyxpQkFBaUI7SUFDbkIsTUFBTSxDQUFDLFdBQVcsQ0FBQyxXQUF5QixFQUFFLFNBQXdCO1FBQ3pFLFFBQVEsV0FBVyxDQUFDLGlCQUFpQixFQUFFO1lBQ25DLEtBQUsscUJBQXFCLENBQUMsSUFBSTtnQkFDM0IsT0FBTyxpQkFBaUIsQ0FBQyxlQUFlLENBQUMsV0FBZ0MsRUFBRSxTQUFTLENBQUMsQ0FBQztZQUMxRjtnQkFDSSxPQUFPLENBQUMsS0FBSyxDQUFDLG9CQUFvQixXQUFXLENBQUMsaUJBQWlCLG1CQUFtQixDQUFDLENBQUM7Z0JBQ3BGLE9BQU8sS0FBSyxDQUFDO1NBQ3BCO0lBQ0wsQ0FBQztJQUVNLE1BQU0sQ0FBQyxlQUFlLENBQUMsV0FBOEIsRUFBRSxTQUF3QjtRQUNsRixPQUFPLFdBQVcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3RGLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QVBlcm1pc3Npb25zLCBBdXRob3JpemF0aW9uVHlwZUVudW0sIFBlcm1pc3Npb25zfSBmcm9tICcuL21vZGVsJztcblxuZXhwb3J0IGNsYXNzIEF1dGhvcml6YXRpb25VdGlsIHtcbiAgICBwdWJsaWMgc3RhdGljIGlzUGVybWl0dGVkKHBlcm1pc3Npb25zOiBBUGVybWlzc2lvbnMsIHVzZXJSb2xlczogQXJyYXk8c3RyaW5nPik6IGJvb2xlYW4ge1xuICAgICAgICBzd2l0Y2ggKHBlcm1pc3Npb25zLmF1dGhvcml6YXRpb25UeXBlKSB7XG4gICAgICAgICAgICBjYXNlIEF1dGhvcml6YXRpb25UeXBlRW51bS5SYmFjOlxuICAgICAgICAgICAgICAgIHJldHVybiBBdXRob3JpemF0aW9uVXRpbC5pc1JiYWNQZXJtaXR0ZWQocGVybWlzc2lvbnMgYXMgUGVybWlzc2lvbnMuUm9sZXMsIHVzZXJSb2xlcyk7XG4gICAgICAgICAgICBkZWZhdWx0OlxuICAgICAgICAgICAgICAgIGNvbnNvbGUuZXJyb3IoYFBlcm1pc3Npb24gdHlwZSBcIiR7cGVybWlzc2lvbnMuYXV0aG9yaXphdGlvblR5cGV9XCIgbm90IGltcGxlbWVudGVkYCk7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHVibGljIHN0YXRpYyBpc1JiYWNQZXJtaXR0ZWQocGVybWlzc2lvbnM6IFBlcm1pc3Npb25zLlJvbGVzLCB1c2VyUm9sZXM6IEFycmF5PHN0cmluZz4pOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIHBlcm1pc3Npb25zLnJvbGVzLnNvbWUocHJnID0+IHByZy5ldmVyeShwciA9PiB1c2VyUm9sZXMuaW5kZXhPZihwcikgPiAtMSkpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/lib/security/index.mjs

@@ -0,0 +1,4 @@
+export * from './authorization.guard';
+export * from './authorization.service';
+export * from './authorization.util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlY3VyaXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemF0aW9uLmd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXphdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXphdGlvbi51dGlsJztcbiJdfQ==

package/esm2020/lib/security/model/authorization.type.mjs

@@ -0,0 +1,8 @@
+export var AuthorizationTypeEnum;
+(function (AuthorizationTypeEnum) {
+    AuthorizationTypeEnum["All"] = "ALL";
+    AuthorizationTypeEnum["Any"] = "ANY";
+    AuthorizationTypeEnum["Rbac"] = "ROLE_BASED_ACCESS_CONTROL";
+    AuthorizationTypeEnum["Service"] = "SERVICE";
+})(AuthorizationTypeEnum || (AuthorizationTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXphdGlvbi50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9zZWN1cml0eS9tb2RlbC9hdXRob3JpemF0aW9uLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVkscUJBS1g7QUFMRCxXQUFZLHFCQUFxQjtJQUM3QixvQ0FBVyxDQUFBO0lBQ1gsb0NBQVcsQ0FBQTtJQUNYLDJEQUFrQyxDQUFBO0lBQ2xDLDRDQUFtQixDQUFBO0FBQ3ZCLENBQUMsRUFMVyxxQkFBcUIsS0FBckIscUJBQXFCLFFBS2hDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gQXV0aG9yaXphdGlvblR5cGVFbnVtIHtcbiAgICBBbGwgPSAnQUxMJyxcbiAgICBBbnkgPSAnQU5ZJyxcbiAgICBSYmFjID0gJ1JPTEVfQkFTRURfQUNDRVNTX0NPTlRST0wnLFxuICAgIFNlcnZpY2UgPSAnU0VSVklDRSdcbn1cbiJdfQ==

package/esm2020/lib/security/model/index.mjs

@@ -0,0 +1,4 @@
+export * from './authorization.type';
+export * from './permission-service.interface';
+export * from './permissions.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlY3VyaXR5L21vZGVsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemF0aW9uLnR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wZXJtaXNzaW9uLXNlcnZpY2UuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGVybWlzc2lvbnMubW9kZWwnO1xuIl19

package/esm2020/lib/security/model/permission-service.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi1zZXJ2aWNlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VjdXJpdHkvbW9kZWwvcGVybWlzc2lvbi1zZXJ2aWNlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBSb3V0ZXJTdGF0ZVNuYXBzaG90fSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuXG5pbXBvcnQge09ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQge0FjdGlvbkNvbnRleHRWYWxpZGF0aW9ufSBmcm9tICcuLi8uLi9jb21wb25lbnRzL2FjdGlvbi9tb2RlbHMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIElQZXJtaXNzaW9uU2VydmljZSB7XG4gICAgaXNQZXJtaXR0ZWQocm91dGU/OiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCByb3V0ZXJTdGF0ZT86IFJvdXRlclN0YXRlU25hcHNob3QsIGFjdGlvbkN0eD86IEFjdGlvbkNvbnRleHRWYWxpZGF0aW9uPHVua25vd24sIHVua25vd24+KTogT2JzZXJ2YWJsZTxib29sZWFuPjtcbn1cbiJdfQ==

package/esm2020/lib/security/model/permissions.model.mjs

@@ -0,0 +1,95 @@
+import { AuthorizationTypeEnum } from './authorization.type';
+export class APermissions {
+    constructor(type) {
+        this._authorizationType = type;
+    }
+    get authorizationType() {
+        return this._authorizationType;
+    }
+}
+export var Permissions;
+(function (Permissions) {
+    class All extends APermissions {
+        constructor() {
+            super(AuthorizationTypeEnum.All);
+            this._permissions = [];
+        }
+        static of(...permissions) {
+            const inst = new All();
+            inst.and(...permissions);
+            return inst;
+        }
+        get permissions() {
+            return this._permissions;
+        }
+        and(...permissions) {
+            this._permissions.push(...permissions);
+            return this;
+        }
+    }
+    Permissions.All = All;
+    class Any extends APermissions {
+        constructor() {
+            super(AuthorizationTypeEnum.Any);
+            this._permissions = [];
+        }
+        static of(...permissions) {
+            const inst = new Any();
+            inst.or(...permissions);
+            return inst;
+        }
+        get permissions() {
+            return this._permissions;
+        }
+        or(...permissions) {
+            this._permissions.push(...permissions);
+            return this;
+        }
+    }
+    Permissions.Any = Any;
+    class Roles extends APermissions {
+        constructor() {
+            super(AuthorizationTypeEnum.Rbac);
+            this._roles = [];
+        }
+        static of(...roles) {
+            const inst = new Roles();
+            inst.or(...roles);
+            return inst;
+        }
+        get roles() {
+            return this._roles;
+        }
+        and(...roles) {
+            if (this._roles.length === 0) {
+                this._roles.push([]);
+            }
+            this._roles[this._roles.length - 1].push(...roles);
+            return this;
+        }
+        or(...roles) {
+            this._roles.push(...roles.map(s => [s]));
+            return this;
+        }
+    }
+    Permissions.Roles = Roles;
+    class Service extends APermissions {
+        constructor(service) {
+            super(AuthorizationTypeEnum.Service);
+            this.service = service;
+        }
+        static of(service) {
+            return new Service(service);
+        }
+    }
+    Permissions.Service = Service;
+    class ActionTypes {
+    }
+    ActionTypes.READ = 'read';
+    ActionTypes.ADD = 'add';
+    ActionTypes.EDIT = 'edit';
+    ActionTypes.DELETE = 'delete';
+    ActionTypes.DETAILS = 'details';
+    Permissions.ActionTypes = ActionTypes;
+})(Permissions || (Permissions = {}));
+//# sourceMappingURL=data:application/json;base64,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