@archbase/security 4.0.47 → 4.1.0

package/dist/src/ArchbaseSecurityDiagnosticsService.d.ts

@@ -0,0 +1,33 @@
+import { ArchbaseRemoteApiClient } from '@archbase/data';
+import { ArchbaseAccessDecision, ArchbaseAccessOverview, ArchbaseEffectiveAccessReport, ArchbaseSimulationRequest } from './SecurityDiagnosticsDomain';
+/**
+ * Leitura do diagnóstico de acesso — `/api/v1/security/diagnostics/*`.
+ *
+ * <p><b>Por que não estende `ArchbaseRemoteApiService`.</b> A classe base modela um CRUD de
+ * entidade: exige `getId`, `isNewRecord` e `transform`. Aqui não há entidade — há três
+ * perguntas (o retrato do tenant, o que uma pessoa pode, e se ela pode uma coisa). Implementar
+ * aqueles métodos com retorno inventado só para herdar seria mentir sobre o que este serviço é.
+ * O que importava da base — o cliente HTTP injetado e os cabeçalhos de tenant — está preservado.
+ *
+ * <p>Todos os endpoints são <b>somente leitura</b> e exigem, no servidor,
+ * `archbase.security.diagnostics.enabled=true` e usuário administrador.
+ */
+export declare class ArchbaseSecurityDiagnosticsService {
+    protected client: ArchbaseRemoteApiClient;
+    constructor(client: ArchbaseRemoteApiClient);
+    protected configureHeaders(): Record<string, string>;
+    protected getEndpoint(): string;
+    /** Retrato do tenant: contagens do catálogo e o estado das proteções configuráveis. */
+    getOverview(): Promise<ArchbaseAccessOverview>;
+    /** O que a pessoa pode, com a origem de cada concessão. */
+    getEffectiveAccessByUserId(userId: string): Promise<ArchbaseEffectiveAccessReport>;
+    /** Idem, buscando a pessoa pelo e-mail. */
+    getEffectiveAccessByEmail(email: string): Promise<ArchbaseEffectiveAccessReport>;
+    /**
+     * "Esta pessoa consegue fazer isto?"
+     *
+     * <p>A resposta traz a cadeia dos portões avaliados — é ela, e não o booleano, que diz o
+     * que precisa mudar para o acesso passar a existir.
+     */
+    simulate(request: ArchbaseSimulationRequest): Promise<ArchbaseAccessDecision>;
+}

package/dist/src/SecurityDiagnosticsDomain.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Tipos dos endpoints de diagnóstico de acesso — `/api/v1/security/diagnostics/*`.
+ *
+ * <p>Espelham os records do `archbase-security` 3.1.0 campo a campo. Onde o nome aqui
+ * diverge do backend, é bug: a tela existe para responder "por que esta pessoa não passou?",
+ * e ela só responde isso se o que chega for exatamente o que o avaliador decidiu.
+ */
+/**
+ * Os cinco portões do core de autorização, na ordem em que são avaliados.
+ *
+ * <p>A regra que organiza o modelo: <b>IDENTITY a LEVEL só sabem NEGAR; só GRANT CONCEDE.</b>
+ * É por isso que a tela de simulação mostra a cadeia inteira em vez de um sim/não — saber
+ * em qual portão parou é o que diz o que precisa ser mudado.
+ */
+export type ArchbaseAccessGate = 'IDENTITY' | 'SCOPE' | 'RESTRICTION' | 'LEVEL' | 'GRANT';
+/** Escala de nível de acesso. `NONE` é sentinela de anotação, não valor de perfil. */
+export type ArchbaseAccessLevel = 'NONE' | 'READER' | 'OPERATOR' | 'SUPERVISOR' | 'TENANT_ADMIN';
+/**
+ * Situação de uma capacidade concedida.
+ *
+ * - `EFFECTIVE` — concedida e valendo.
+ * - `INERT` — concedida, mas a ação ou o recurso está inativo. É o acesso que o operador
+ *   acredita ter dado e que não decide nada.
+ * - `DENIED` — bloqueada por negação explícita ou por nível insuficiente.
+ */
+export type ArchbaseCapabilitySituation = 'EFFECTIVE' | 'INERT' | 'DENIED';
+/** Quem recebeu a permissão. */
+export type ArchbaseSecurityTypeName = 'USER' | 'GROUP' | 'PROFILE';
+/**
+ * Estado das proteções configuráveis.
+ *
+ * <p>Vem antes dos números na tela de propósito: contagem alta de permissões não significa
+ * nada se o portão correspondente está inerte.
+ */
+export interface ArchbaseAccessFlags {
+    /** `false` = permissão apontando para ação inativa ainda decide. */
+    requireActive: boolean;
+    /** `false` = o catálogo não se alimenta do código; nada de `@HasPermission` foi varrido. */
+    scanConfigured: boolean;
+    /** `permit` = qualquer autenticado administra segurança. */
+    adminEndpointsPolicy: string;
+    requireRoleNoResolverPolicy: string;
+    /** `false` = `@RequireRole` não restringe nada. */
+    roleResolverRegistered: boolean;
+}
+/** Retrato do tenant — `GET /diagnostics/overview`. */
+export interface ArchbaseAccessOverview {
+    users: number;
+    administrators: number;
+    groups: number;
+    profiles: number;
+    resources: number;
+    apiResources: number;
+    apiResourcesInactive: number;
+    resourcesWithoutAction: number;
+    actions: number;
+    actionsInactive: number;
+    actionsWithoutPermission: number;
+    permissions: number;
+    permissionsPointingToInactive: number;
+    permissionsBySecurityType: Record<string, number>;
+    flags: ArchbaseAccessFlags;
+}
+/** Uma capacidade que a pessoa recebeu, com a origem da concessão. */
+export interface ArchbaseEffectiveCapability {
+    resource: string;
+    action: string;
+    grantedBy: string;
+    grantedByName: string;
+    grantedByType: ArchbaseSecurityTypeName;
+    actionActive: boolean;
+    resourceActive: boolean;
+    situation: ArchbaseCapabilitySituation;
+}
+/** O que a pessoa pode — `GET /diagnostics/users/{id}/effective`. */
+export interface ArchbaseEffectiveAccessReport {
+    userId: string;
+    userLabel: string;
+    profileName: string;
+    groupNames: string[];
+    administrator: boolean;
+    enabled: boolean;
+    granted: number;
+    effective: number;
+    inert: number;
+    denied: number;
+    capabilities: ArchbaseEffectiveCapability[];
+}
+/** O que aconteceu em um portão. */
+export interface ArchbaseGateOutcome {
+    gate: ArchbaseAccessGate;
+    passed: boolean;
+    reasonCode: string;
+    detail: string;
+}
+/** Resultado de `POST /diagnostics/simulate`. */
+export interface ArchbaseAccessDecision {
+    allowed: boolean;
+    /** Portão onde parou, ou `null` quando concedeu. */
+    deniedAt: ArchbaseAccessGate | null;
+    reasonCode: string;
+    message: string;
+    grantedBy: string | null;
+    grantedByName: string | null;
+    chain: ArchbaseGateOutcome[];
+}
+/**
+ * Pergunta da simulação.
+ *
+ * <p>Identifica a pessoa por `userId` <b>ou</b> `email`. O escopo aceito é o que o avaliador
+ * conhece — tenant, empresa e projeto. Dimensão de negócio (departamento, filial) só chega
+ * aqui se a aplicação a mapear para um destes.
+ */
+export interface ArchbaseSimulationRequest {
+    userId?: string;
+    email?: string;
+    resource: string;
+    action: string;
+    tenantId?: string;
+    companyId?: string;
+    projectId?: string;
+}

package/dist/src/index.d.ts

@@ -13,11 +13,13 @@ export * from './ArchbaseProfileService';
 export * from './ArchbaseApiTokenService';
 export * from './ArchbaseAccessTokenService';
 export * from './ArchbaseResourceService';
+export * from './ArchbaseSecurityDiagnosticsService';
 export * from './ArchbaseLogin';
 export * from './ArchbaseMfaSetup';
 export * from './ArchbaseResetPassword';
 export * from './SecurityType';
 export * from './SecurityDomain';
+export * from './SecurityDiagnosticsDomain';
 export * from './hooks';
 export { ArchbaseSecurityProvider, ArchbaseViewSecurityProvider, DefaultSecurityLoading } from './ArchbaseSecurityContext';
 export { useArchbaseSecurity, useArchbaseViewSecurity, useArchbaseSecureForm, useArchbasePermissionCheck } from './ArchbaseSecurityHooks';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archbase/security",
-  "version": "4.0.47",
+  "version": "4.1.0",
   "description": "Security and authentication components for Archbase React",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -37,10 +37,10 @@
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.2",
     "uuid": "^9.0.1",
-    "@archbase/components": "4.0.47",
-    "@archbase/core": "4.0.47",
-    "@archbase/data": "4.0.47",
-    "@archbase/layout": "4.0.47"
+    "@archbase/components": "4.1.0",
+    "@archbase/core": "4.1.0",
+    "@archbase/data": "4.1.0",
+    "@archbase/layout": "4.1.0"
   },
   "devDependencies": {
     "@types/crypto-js": "^4.1.1",