@valtimo/access-control-management 13.31.0 → 13.32.0

package/lib/components/access-control-json-editor-tab/access-control-json-editor-tab.component.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { EditorModel } from '@valtimo/components';
+import { IconService, ListItem } from 'carbon-components-angular';
+import { Observable } from 'rxjs';
+import { PermissionSchema } from '../../models';
+import { PermissionSchemaMetadataService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class AccessControlJsonEditorTabComponent implements OnInit, OnChanges, OnDestroy {
+    private readonly activatedRoute;
+    private readonly iconService;
+    private readonly metadataService;
+    private readonly router;
+    private readonly translateService;
+    disabled: boolean | null;
+    model: EditorModel;
+    validEvent: EventEmitter<boolean>;
+    valueChangeEvent: EventEmitter<string>;
+    private readonly _sourceModel$;
+    private readonly _filter$;
+    private readonly _subscriptions;
+    readonly isFilterActive$: Observable<boolean>;
+    readonly resourceTypeItems$: Observable<ListItem[]>;
+    readonly actionItems$: Observable<ListItem[]>;
+    readonly filteredModel$: Observable<EditorModel | null>;
+    readonly editorDisabled$: Observable<boolean>;
+    readonly permissionSchema$: Observable<PermissionSchema>;
+    constructor(activatedRoute: ActivatedRoute, iconService: IconService, metadataService: PermissionSchemaMetadataService, router: Router, translateService: TranslateService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onValid(valid: boolean): void;
+    onValueChange(value: string): void;
+    onResourceTypeSelected(event: {
+        item?: ListItem & {
+            resourceType?: string;
+        };
+    }): void;
+    onActionSelected(event: {
+        item?: ListItem & {
+            action?: string;
+        };
+    }): void;
+    onClearFilter(): void;
+    private parsePermissions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccessControlJsonEditorTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccessControlJsonEditorTabComponent, "valtimo-access-control-json-editor-tab", never, { "disabled": { "alias": "disabled"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, { "validEvent": "validEvent"; "valueChangeEvent": "valueChangeEvent"; }, never, never, true, never>;
+}

package/lib/components/access-control-overview-tab/access-control-overview-tab.component.d.ts

@@ -0,0 +1,56 @@
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { Permission, PermissionCondition } from '../../models';
+import { PermissionSchemaMetadataService } from '../../services';
+import * as i0 from "@angular/core";
+interface FormattedFieldCondition {
+    kind: 'field';
+    field: string;
+    operator: string;
+    value: string;
+    customField: boolean;
+}
+interface FormattedExpressionCondition {
+    kind: 'expression';
+    field: string;
+    path: string;
+    operator: string;
+    value: string;
+    clazz: string;
+    customField: boolean;
+}
+interface FormattedContainerCondition {
+    kind: 'container';
+    resourceType: string;
+    conditions: PermissionCondition[];
+    customResource: boolean;
+}
+type FormattedCondition = FormattedFieldCondition | FormattedExpressionCondition | FormattedContainerCondition;
+interface ActionOverview {
+    action: string;
+    grants: Permission[];
+}
+interface ResourceOverview {
+    resourceType: string;
+    actions: ActionOverview[];
+}
+export declare class AccessControlOverviewTabComponent {
+    private readonly metadataService;
+    private readonly translateService;
+    roleKey: string | null;
+    set permissions(value: Permission[] | null);
+    private readonly _permissions$;
+    readonly overview$: Observable<ResourceOverview[]>;
+    constructor(metadataService: PermissionSchemaMetadataService, translateService: TranslateService);
+    formatConditions(conditions: PermissionCondition[] | null | undefined, resourceType: string): FormattedCondition[];
+    isNoContext(contextResourceType: string | null | undefined): boolean;
+    private buildOverview;
+    private permissionGrants;
+    private formatCondition;
+    private formatField;
+    private formatExpression;
+    private formatContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccessControlOverviewTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccessControlOverviewTabComponent, "valtimo-access-control-overview-tab", never, { "roleKey": { "alias": "roleKey"; "required": false; }; "permissions": { "alias": "permissions"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/editor/access-control-editor.component.d.ts

@@ -1,9 +1,9 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { AccessControlService } from '../../services/access-control.service';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
 import { ActivatedRoute, Router } from '@angular/router';
 import { EditorModel, PageHeaderService, PageTitleService } from '@valtimo/components';
-import { PermissionSchema, Role } from '../../models';
+import { AccessControlEditorTab, Permission, Role } from '../../models';
 import { TranslateService } from '@ngx-translate/core';
 import { AccessControlExportService } from '../../services/access-control-export.service';
 import { GlobalNotificationService } from '@valtimo/shared';
@@ -18,6 +18,7 @@ export declare class AccessControlEditorComponent implements OnInit, OnDestroy {
     private readonly accessControlExportService;
     private readonly pageHeaderService;
     readonly model$: BehaviorSubject<EditorModel>;
+    readonly permissions$: BehaviorSubject<Permission[]>;
     readonly roleKey$: BehaviorSubject<string>;
     readonly saveDisabled$: BehaviorSubject<boolean>;
     readonly editorDisabled$: BehaviorSubject<boolean>;
@@ -25,8 +26,9 @@ export declare class AccessControlEditorComponent implements OnInit, OnDestroy {
     readonly showDeleteModal$: BehaviorSubject<boolean>;
     readonly showEditModal$: BehaviorSubject<boolean>;
     readonly selectedRowKeys$: BehaviorSubject<string[]>;
-    readonly compactMode$: Observable<boolean>;
-    readonly schema$: Observable<PermissionSchema>;
+    readonly compactMode$: import("rxjs").Observable<boolean>;
+    readonly $activeTab: import("@angular/core").WritableSignal<AccessControlEditorTab>;
+    protected readonly AccessControlEditorTab: typeof AccessControlEditorTab;
     private _roleKeySubscription;
     private _roleKey;
     private readonly _updatedModelValue$;
@@ -40,6 +42,8 @@ export declare class AccessControlEditorComponent implements OnInit, OnDestroy {
     showDeleteModal(): void;
     showEditModal(): void;
     onEdit(currentRoleKey: string, data: Role | null): void;
+    setActiveTab(tab: AccessControlEditorTab): void;
+    private restoreActiveTabFromUrl;
     exportPermissions(): void;
     private openRoleKeySubscription;
     private getPermissions;

package/lib/constants/access-control-labels.d.ts

@@ -0,0 +1,4 @@
+import { ConditionOperator } from '../models';
+declare const OPERATOR_LABEL: Record<ConditionOperator, string>;
+declare const NO_CONTEXT_RESOURCE_TYPE = "com.ritense.authorization.NoContext";
+export { NO_CONTEXT_RESOURCE_TYPE, OPERATOR_LABEL };

package/lib/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './access-control-labels';

package/lib/models/access-control-editor-tab.model.d.ts

@@ -0,0 +1,9 @@
+declare enum AccessControlEditorTab {
+    SUMMARY = "summary",
+    JSON_EDITOR = "jsonEditor"
+}
+interface AccessControlFilter {
+    resourceType: string | null;
+    action: string | null;
+}
+export { AccessControlEditorTab, AccessControlFilter };

package/lib/models/index.d.ts

@@ -1,2 +1,4 @@
+export * from './access-control-editor-tab.model';
+export * from './permission.model';
 export * from './permission-schema.model';
 export * from './role.model';

package/lib/models/permission-schema.model.d.ts

@@ -1,2 +1,47 @@
 type PermissionSchema = object;
-export { PermissionSchema };
+interface SchemaAllOfBranch {
+    if?: {
+        properties?: {
+            resourceType?: {
+                const?: string;
+            };
+        };
+    };
+    then?: {
+        properties?: {
+            action?: {
+                enum?: string[];
+            };
+        };
+    };
+}
+interface SchemaOneOfEntry {
+    const?: string;
+}
+interface SchemaCondListVariant {
+    allOf?: Array<{
+        $ref?: string;
+        properties?: {
+            field?: {
+                enum?: string[];
+            };
+        };
+    }>;
+}
+interface SchemaCondListDefinition {
+    items?: {
+        oneOf?: SchemaCondListVariant[];
+    };
+}
+interface SchemaShape {
+    items?: {
+        allOf?: SchemaAllOfBranch[];
+        properties?: {
+            resourceType?: {
+                oneOf?: SchemaOneOfEntry[];
+            };
+        };
+    };
+    definitions?: Record<string, SchemaCondListDefinition>;
+}
+export { PermissionSchema, SchemaShape };

package/lib/models/permission.model.d.ts

@@ -0,0 +1,35 @@
+type ConditionOperator = '==' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'list_contains';
+interface FieldCondition {
+    type: 'field';
+    field: string;
+    operator: ConditionOperator;
+    value: unknown;
+}
+interface ExpressionCondition {
+    type: 'expression';
+    field: string;
+    path: string;
+    operator: ConditionOperator;
+    value: unknown;
+    clazz: string;
+}
+interface ContainerCondition {
+    type: 'container';
+    resourceType: string;
+    conditions: PermissionCondition[];
+}
+type PermissionCondition = FieldCondition | ExpressionCondition | ContainerCondition;
+interface Permission {
+    resourceType: string;
+    action?: string;
+    actions?: string[];
+    roleKey: string;
+    conditions?: PermissionCondition[];
+    contextResourceType?: string;
+    contextConditions?: PermissionCondition[];
+}
+interface ResourcePermissionGroup {
+    resourceType: string;
+    permissions: Permission[];
+}
+export { ConditionOperator, ContainerCondition, ExpressionCondition, FieldCondition, Permission, PermissionCondition, ResourcePermissionGroup, };

package/lib/pipes/index.d.ts

@@ -0,0 +1 @@
+export * from './resource-type-label.pipe';

package/lib/pipes/resource-type-label.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare class ResourceTypeLabelPipe implements PipeTransform {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    transform(fqn: string | null | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceTypeLabelPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ResourceTypeLabelPipe, "resourceTypeLabel", true>;
+}

package/lib/services/access-control.service.d.ts

@@ -1,7 +1,7 @@
 import { HttpClient } from '@angular/common/http';
 import { ConfigService } from '@valtimo/shared';
 import { BehaviorSubject, Observable } from 'rxjs';
-import { DeleteRolesRequest, PermissionSchema, Role } from '../models';
+import { DeleteRolesRequest, Permission, PermissionSchema, Role } from '../models';
 import * as i0 from "@angular/core";
 export declare class AccessControlService {
     private readonly configService;
@@ -15,7 +15,7 @@ export declare class AccessControlService {
     deleteRoles(request: DeleteRolesRequest): Observable<null>;
     dispatchAction(actionResult: Observable<Role | null>): void;
     loadRoles(): void;
-    getRolePermissions(roleKey: string): Observable<Array<object>>;
+    getRolePermissions(roleKey: string): Observable<Permission[]>;
     exportRolePermissions(roles: string[]): Observable<object[]>;
     updateRolePermissions(roleKey: string, updatedPermission: object): Observable<object>;
     getPermissionSchema(): Observable<PermissionSchema>;

package/lib/services/index.d.ts

@@ -1 +1,2 @@
 export * from './access-control.service';
+export * from './permission-schema-metadata.service';

package/lib/services/permission-schema-metadata.service.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { PermissionSchema } from '../models';
+import { AccessControlService } from './access-control.service';
+import * as i0 from "@angular/core";
+export declare class PermissionSchemaMetadataService {
+    private readonly accessControlService;
+    private readonly _knownResourceTypes$;
+    private readonly _fieldsByResourceType$;
+    readonly schema$: Observable<PermissionSchema>;
+    readonly actionsByResourceType$: Observable<Record<string, string[]>>;
+    readonly allResourceTypes$: Observable<string[]>;
+    constructor(accessControlService: AccessControlService);
+    isResourceTypeKnown(fqn: string): boolean;
+    isFieldKnown(resourceType: string, field: string): boolean;
+    private extractActionsByResourceType;
+    private extractKnownResourceTypes;
+    private extractFieldsByResourceType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionSchemaMetadataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionSchemaMetadataService>;
+}

package/lib/utils/format-condition.d.ts

@@ -0,0 +1,8 @@
+import { TranslateService } from '@ngx-translate/core';
+import { ConditionOperator } from '../models';
+declare function formatResourceType(translate: TranslateService, fqn: string): string;
+declare function formatField(translate: TranslateService, resourceType: string, field: string): string;
+declare function formatOperator(translate: TranslateService, operator: ConditionOperator): string;
+declare function formatValue(translate: TranslateService, value: unknown): string;
+declare function humanizeFieldPath(field: string): string;
+export { formatField, formatOperator, formatResourceType, formatValue, humanizeFieldPath };

package/lib/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './format-condition';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valtimo/access-control-management",
-  "version": "13.31.0",
+  "version": "13.32.0",
   "peerDependencies": {
     "@angular/common": "19.2.20",
     "@angular/core": "19.2.20"