✨ (auth): Añade el catálogo de permisos y acceso

DeclarePermissions y PermissionRegistry reúnen al arrancar los
permisos que declaran las extensiones. Access define quién puede
acceder a una ruta y `deny_access()` responde a quien no lo cumple.
Las acciones de permisos (CheckPermission, DeclarePermissions y
AnonymousDenied) pasan a `base::action::auth`, con el mismo patrón
que las de páginas y componentes.
This commit is contained in:
Manuel Cillero 2026-11-07 06:19:48 +01:00
parent b2dfb52d93
commit 379450ec40
7 changed files with 567 additions and 87 deletions

View file

@ -3,10 +3,19 @@
//! Define el tipo [`CurrentUser`] que PageTop inyecta en el [`Context`] con la información mínima //! Define el tipo [`CurrentUser`] que PageTop inyecta en el [`Context`] con la información mínima
//! sobre el usuario que ejecuta la petición actual ([`HttpRequest`]). //! sobre el usuario que ejecuta la petición actual ([`HttpRequest`]).
//! //!
//! Incluye la acción [`CheckPermission`] para que las extensiones puedan implementar sus propios //! Las extensiones se conectan con este sistema mediante las acciones de [`action::auth`]: con
//! modelos de permisos. Y también las funciones auxiliares [`has_permission()`] y //! [`CheckPermission`] implementan su propio modelo de permisos. Define también [`Access`], el
//! [`require_permission()`] para validar en el comienzo de cada handler, antes de construir ni //! acceso con el que se monta cada ruta: PageTop lo comprueba antes de llegar al *handler* y
//! ejecutar nada, si la petición está autorizada. //! responde a quien no lo cumple con [`deny_access()`], la página de acceso denegado (403). A un
//! usuario anónimo le ofrece en su lugar el inicio de sesión sólo si una extensión de autenticación
//! lo prepara con [`AnonymousDenied`]. Dentro del *handler*, [`has_permission()`] y
//! [`require_permission()`] sirven para lo que el acceso de la ruta no expresa: mostrar u ocultar
//! partes de la página, o exigir un permiso más concreto.
//!
//! Las extensiones declaran además sus permisos con la acción [`DeclarePermissions`], y PageTop los
//! reúne al arrancar en un catálogo ([`PermissionRegistry`]) para que una extensión de
//! autenticación pueda mostrarlos, por ejemplo, en una pantalla de asignación de permisos a roles.
//! El catálogo sólo dice qué permisos existen; a quién se conceden lo decide la extensión.
//! //!
//! La resolución concreta del usuario (sesión en BD, LDAP, OAuth, ...) y la lógica de permisos //! La resolución concreta del usuario (sesión en BD, LDAP, OAuth, ...) y la lógica de permisos
//! (RBAC, grupos LDAP, ...) son responsabilidad de las extensiones de autenticación. Un concepto //! (RBAC, grupos LDAP, ...) son responsabilidad de las extensiones de autenticación. Un concepto
@ -15,16 +24,18 @@
//! [`CheckPermission`]. //! [`CheckPermission`].
//! //!
//! [`Context`]: crate::core::component::Context //! [`Context`]: crate::core::component::Context
//! [`action::auth`]: crate::base::action::auth
use crate::core::action::{ActionDispatcher, try_dispatch_actions}; use crate::base::action::auth::{AnonymousDenied, CheckPermission, DeclarePermissions};
use crate::core::component::Context;
use crate::core::theme::{ThemeRef, theme_by_short_name}; use crate::core::theme::{ThemeRef, theme_by_short_name};
use crate::datetime::{Timezone, Tz}; use crate::datetime::{Timezone, Tz};
use crate::locale::{LanguageIdentifier, Lc, Locale}; use crate::locale::{LanguageIdentifier, Lc, Locale};
use crate::response::ErrorPage; use crate::response::ErrorPage;
use crate::web::HttpRequest; use crate::web::{HttpRequest, IntoResponse, Response};
use crate::{AutoDefault, CowStr, Getters, Weight, builder_impl, global}; use crate::{AutoDefault, CowStr, Getters, builder_impl, global};
use std::ops::ControlFlow; use std::sync::OnceLock;
// **< CurrentUser >******************************************************************************** // **< CurrentUser >********************************************************************************
@ -202,8 +213,8 @@ pub trait Permission: Send + Sync {
/// Descripción breve para humanos (p. ej. en una pantalla de asignación de permisos a roles). /// Descripción breve para humanos (p. ej. en una pantalla de asignación de permisos a roles).
/// ///
/// Por defecto devuelve la propia clave; una extensión que registre sus permisos en un catálogo /// Por defecto devuelve la propia clave; una extensión que declare sus permisos en el catálogo
/// visible debería sobrescribirlo con un texto traducible. /// ([`DeclarePermissions`]) debería sobrescribirlo con un texto traducible.
fn label(&self) -> Lc { fn label(&self) -> Lc {
Lc::n(self.key()) Lc::n(self.key())
} }
@ -228,68 +239,6 @@ pub trait Permission: Send + Sync {
/// [`require_permission()`] o [`CheckPermission`]). /// [`require_permission()`] o [`CheckPermission`]).
pub type PermissionRef = &'static dyn Permission; pub type PermissionRef = &'static dyn Permission;
// **< CheckPermission >****************************************************************************
/// Tipo de función para comprobar si el usuario actual tiene un permiso concreto.
///
/// Se invoca con:
///
/// - `request`: petición HTTP desde la que se accede a los datos inyectados por el middleware de
/// autenticación.
/// - `perm`: permiso a comprobar; el handler usará [`Permission::key()`] para identificarlo contra
/// su propio modelo de permisos.
/// - `granted`: referencia mutable; el handler debe asignarla a `true` si concede el permiso.
pub type FnActionCheckPerm = fn(request: &HttpRequest, perm: PermissionRef, granted: &mut bool);
/// Acción para comprobar si el usuario actual tiene un permiso concreto.
///
/// Las extensiones de autenticación pueden registrar su handler sobre esta acción para implementar
/// su modelo de permisos. Los handlers son aditivos de tal forma que si cualquiera de ellos asigna
/// `granted = true`, el permiso se concede.
///
/// # Ejemplo
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// fn check_my_permissions(request: &HttpRequest, perm: PermissionRef, granted: &mut bool) {
/// // Leer los datos extendidos de autenticación inyectados en la petición.
/// // Comparar `perm.key()` contra el modelo propio.
/// // Si concede el permiso, asignar `*granted = true`.
/// }
///
/// pub struct MyAuth;
///
/// #[async_trait]
/// impl Extension for MyAuth {
/// fn actions(&self) -> Vec<ActionBox> {
/// actions![CheckPermission::new(check_my_permissions)]
/// }
/// }
/// ```
pub struct CheckPermission {
f: FnActionCheckPerm,
weight: Weight,
}
impl ActionDispatcher for CheckPermission {
fn weight(&self) -> Weight {
self.weight
}
}
impl CheckPermission {
/// Registra una nueva acción para la comprobación de permisos.
pub fn new(f: FnActionCheckPerm) -> Self {
CheckPermission { f, weight: 0 }
}
/// Opcional. Acciones con pesos más bajos se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
}
// **< has_permission >***************************************************************************** // **< has_permission >*****************************************************************************
/// Comprueba si el usuario actual tiene el permiso indicado. /// Comprueba si el usuario actual tiene el permiso indicado.
@ -318,26 +267,18 @@ impl CheckPermission {
/// } /// }
/// ``` /// ```
pub fn has_permission(request: &HttpRequest, perm: PermissionRef) -> bool { pub fn has_permission(request: &HttpRequest, perm: PermissionRef) -> bool {
// Despacha las acciones registradas con salida anticipada en cuanto una concede el permiso. CheckPermission::dispatch(request, perm)
let mut granted = false;
try_dispatch_actions(|action: &CheckPermission| {
(action.f)(request, perm, &mut granted);
if granted {
ControlFlow::Break(())
} else {
ControlFlow::Continue(())
}
});
granted
} }
// **< require_permission >************************************************************************* // **< require_permission >*************************************************************************
/// Comprueba un permiso y devuelve `Err(ErrorPage::AccessDenied)` si se deniega. /// Comprueba un permiso y devuelve `Err(ErrorPage::AccessDenied)` si se deniega.
/// ///
/// Ejecuta [`has_permission()`] para el caso más habitual: detener un handler con una respuesta 403 /// Ejecuta [`has_permission()`] para detener un *handler* con una respuesta 403 en cuanto falta el
/// en cuanto falta el permiso, sin repetir el `if`/`return` en cada punto de comprobación. Se hace /// permiso, sin repetir el `if`/`return` en cada punto de comprobación. El acceso de la ruta
/// directamente sobre la petición, antes de construir ni ejecutar nada (`Context`, `Page`, /// ([`Access`]) ya se ha comprobado antes de llegar al *handler*; esta función es para un permiso
/// más concreto que ése (p. ej. una acción que no todos los que ven la página pueden hacer). Se
/// llama directamente sobre la petición, antes de construir ni ejecutar nada (`Context`, `Page`,
/// consultas a datos, etc.), para no hacer ningún trabajo si la petición no está autorizada. /// consultas a datos, etc.), para no hacer ningún trabajo si la petición no está autorizada.
/// ///
/// Si la aplicación necesita ocultar la existencia del recurso a quien no tiene permiso (devolver /// Si la aplicación necesita ocultar la existencia del recurso a quien no tiene permiso (devolver
@ -354,7 +295,7 @@ pub fn has_permission(request: &HttpRequest, perm: PermissionRef) -> bool {
/// # fn key(&self) -> CowStr { "myapp:edit".into() } /// # fn key(&self) -> CowStr { "myapp:edit".into() }
/// # } /// # }
/// async fn my_handler(request: HttpRequest) -> Result<Markup, ErrorPage> { /// async fn my_handler(request: HttpRequest) -> Result<Markup, ErrorPage> {
/// // Comprueba si la petición está autorizada. /// // La ruta ya exige su acceso; este permiso es más concreto.
/// require_permission(&request, &MyPermission::Edit)?; /// require_permission(&request, &MyPermission::Edit)?;
/// ///
/// // Ejecuta las instrucciones propias de la petición. /// // Ejecuta las instrucciones propias de la petición.
@ -371,3 +312,163 @@ pub fn require_permission(request: &HttpRequest, perm: PermissionRef) -> Result<
Err(ErrorPage::AccessDenied(Some(request.clone()))) Err(ErrorPage::AccessDenied(Some(request.clone())))
} }
} }
// **< Access >*************************************************************************************
/// Quién puede acceder a una ruta.
///
/// Toda ruta se monta con el suyo ([`Routes::route()`](crate::web::Routes::route)), y PageTop lo
/// comprueba antes de llegar al *handler*, que sólo comprueba permisos más concretos, si los hay
/// (p. ej. que el usuario sea el autor de lo que edita). A quien no tiene acceso se le responde
/// con [`deny_access()`].
#[derive(Clone, Copy)]
pub enum Access {
/// Cualquiera, también un usuario anónimo.
///
/// Es el acceso de las páginas públicas y de las rutas que se protegen por otra vía, que su
/// *handler* comprueba (p. ej. un enlace con un *token* de un solo uso).
Public,
/// Cualquier usuario autenticado, sin exigir ningún permiso.
Authenticated,
/// Quien tenga el permiso indicado (ver [`has_permission()`]).
Permission(PermissionRef),
}
impl Access {
/// Devuelve `true` si la petición cumple este acceso.
pub fn allows(&self, request: &HttpRequest) -> bool {
match self {
Self::Public => true,
Self::Authenticated => is_authenticated(request),
Self::Permission(perm) => has_permission(request, *perm),
}
}
}
// Sin una extensión de autenticación, la petición no lleva `CurrentUser` y el usuario es anónimo.
fn is_authenticated(request: &HttpRequest) -> bool {
request
.extension::<CurrentUser>()
.is_some_and(CurrentUser::is_authenticated)
}
// **< deny_access >********************************************************************************
/// Responde a una petición sin acceso a la ruta pedida.
///
/// A un usuario anónimo le responde la primera acción [`AnonymousDenied`] que lo haga (p. ej. con
/// el inicio de sesión); a uno autenticado, o si ninguna acción responde, la página de acceso
/// denegado (403). Es lo que hace PageTop con una ruta cuyo [`Access`] no se cumple, y lo puede
/// usar un *handler* que compruebe el acceso por su cuenta.
pub fn deny_access(request: HttpRequest) -> Response {
if !is_authenticated(&request)
&& let Some(response) = AnonymousDenied::dispatch(&request)
{
return response;
}
ErrorPage::AccessDenied(Some(request)).into_response()
}
// **< PermissionRegistry >*************************************************************************
/// Catálogo de los permisos declarados por las extensiones.
///
/// Se construye una sola vez al arrancar con las acciones [`DeclarePermissions`] y se consulta con
/// [`PermissionRegistry::global()`]. Vive sólo en memoria: a quién se concede cada permiso lo
/// guarda, si hace falta, la extensión de autenticación.
///
/// Conserva el orden de registro. Para mostrar los grupos en pantalla,
/// [`groups_sorted()`](Self::groups_sorted) los ordena alfabéticamente según el idioma activo.
#[derive(AutoDefault)]
pub struct PermissionRegistry {
permissions: Vec<PermissionRef>,
// `(identificador de grupo, título traducible)`, en orden de primer registro.
groups: Vec<(&'static str, Lc)>,
}
static PERMISSIONS: OnceLock<PermissionRegistry> = OnceLock::new();
static EMPTY_PERMISSIONS: PermissionRegistry = PermissionRegistry {
permissions: Vec::new(),
groups: Vec::new(),
};
impl PermissionRegistry {
/// Devuelve el catálogo global de permisos.
///
/// Fuera de una aplicación, o antes de que ésta registre las acciones de sus extensiones,
/// devuelve un catálogo vacío.
pub fn global() -> &'static PermissionRegistry {
PERMISSIONS.get().unwrap_or(&EMPTY_PERMISSIONS)
}
/// Registra un permiso. Se ignora si ya hay uno con la misma clave.
pub fn register(&mut self, perm: PermissionRef) {
if self.has(perm) {
return;
}
let group = perm.group();
if !self.groups.iter().any(|(g, _)| *g == group) {
self.groups.push((group, perm.group_label()));
}
self.permissions.push(perm);
}
/// Comprueba si un permiso está en el catálogo.
pub fn has(&self, perm: PermissionRef) -> bool {
self.has_key(&perm.key())
}
/// Comprueba si una clave textual (p. ej. procedente de un formulario) corresponde a un
/// permiso del catálogo.
pub fn has_key(&self, key: &str) -> bool {
self.permissions.iter().any(|p| p.key() == key)
}
/// Todos los permisos, en orden de registro.
pub fn all(&self) -> impl Iterator<Item = PermissionRef> + '_ {
self.permissions.iter().copied()
}
/// Grupos en orden de primer registro, sin traducir ni ordenar alfabéticamente.
///
/// Listado de bajo nivel sobre el que se apoya [`groups_sorted()`](Self::groups_sorted); úsalo
/// en su lugar sólo cuando el orden de registro sea justo lo que se necesita (por ejemplo, para
/// inspeccionar el catálogo en pruebas).
pub fn groups(&self) -> &[(&'static str, Lc)] {
&self.groups
}
/// Grupos ordenados alfabéticamente por su título traducido al idioma del contexto, no sensible
/// a mayúsculas y, en general, a los acentos (ver [`Lc::collation_key()`] para el criterio
/// exacto y sus límites).
pub fn groups_sorted(&self, cx: &Context) -> Vec<&(&'static str, Lc)> {
let mut groups: Vec<_> = self
.groups
.iter()
.map(|g| (g.1.collation_key(cx), g))
.collect();
groups.sort_by(|a, b| a.0.cmp(&b.0));
groups.into_iter().map(|(_, g)| g).collect()
}
/// Permisos de un grupo, en orden de registro.
pub fn by_group<'a>(&'a self, group: &'a str) -> impl Iterator<Item = PermissionRef> + 'a {
self.permissions
.iter()
.copied()
.filter(move |p| p.group() == group)
}
}
// Construye el catálogo global despachando las acciones `DeclarePermissions`. Se llama al
// arrancar, justo después de registrar las acciones de las extensiones; si ya está construido (p.
// ej. por otra llamada a `Application::prepare()` en el mismo proceso, como hacen las pruebas), no
// hace nada.
pub(crate) fn build_permission_registry() {
PERMISSIONS.get_or_init(|| {
let mut registry = PermissionRegistry::default();
DeclarePermissions::dispatch(&mut registry);
registry
});
}

View file

@ -3,3 +3,5 @@
pub mod component; pub mod component;
pub mod page; pub mod page;
pub mod auth;

39
src/base/action/auth.rs Normal file
View file

@ -0,0 +1,39 @@
//! Acciones para conectar las extensiones de autenticación y declarar permisos.
//!
//! Con ellas una extensión concede los permisos al usuario actual ([`CheckPermission`]), da a
//! conocer los suyos en el catálogo ([`DeclarePermissions`]) o decide qué responder a un usuario
//! anónimo sin acceso a una ruta ([`AnonymousDenied`]). El resto del sistema de autorización está
//! en el módulo [`auth`](crate::auth).
use crate::auth::{PermissionRef, PermissionRegistry};
use crate::web::{HttpRequest, Response};
/// Tipo de función para comprobar si el usuario actual tiene un permiso concreto.
///
/// Se invoca con:
///
/// - `request`: petición HTTP desde la que se accede a los datos inyectados por el middleware de
/// autenticación.
/// - `perm`: permiso a comprobar; el handler usará
/// [`Permission::key()`](crate::auth::Permission::key) para identificarlo contra su propio
/// modelo de permisos.
/// - `granted`: referencia mutable; el handler debe asignarla a `true` si concede el permiso.
pub type FnActionCheckPerm = fn(request: &HttpRequest, perm: PermissionRef, granted: &mut bool);
/// Tipo de función para declarar permisos en el catálogo.
pub type FnActionDeclarePermissions = fn(registry: &mut PermissionRegistry);
/// Tipo de función para responder a un usuario anónimo sin acceso a una ruta.
///
/// Devuelve la respuesta (p. ej. una redirección al formulario de inicio de sesión), o `None` para
/// dejar que responda otra acción o, si ninguna lo hace, la página de acceso denegado.
pub type FnActionAnonymousDenied = fn(request: &HttpRequest) -> Option<Response>;
mod check_permission;
pub use check_permission::*;
mod declare_permissions;
pub use declare_permissions::*;
mod anonymous_denied;
pub use anonymous_denied::*;

View file

@ -0,0 +1,69 @@
use crate::prelude::*;
use super::FnActionAnonymousDenied;
use std::ops::ControlFlow;
/// Acción para responder a un usuario anónimo sin acceso a una ruta.
///
/// La registra una extensión de autenticación para ofrecer el inicio de sesión en lugar de la
/// página de acceso denegado, y volver después a la ruta pedida. Responde la primera acción, por
/// orden de peso, que devuelva una respuesta. Ver [`deny_access()`].
///
/// # Ejemplo
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// fn offer_login(request: &HttpRequest) -> Option<Response> {
/// // Vuelve a la ruta pedida tras iniciar sesión.
/// let waypoint = Waypoint::new(request.uri().to_owned());
/// Some(Redirect::see_other(waypoint.append_to("/login")))
/// }
///
/// pub struct MyAuth;
///
/// #[async_trait]
/// impl Extension for MyAuth {
/// fn actions(&self) -> Vec<ActionBox> {
/// actions![action::auth::AnonymousDenied::new(offer_login)]
/// }
/// }
/// ```
pub struct AnonymousDenied {
f: FnActionAnonymousDenied,
weight: Weight,
}
impl ActionDispatcher for AnonymousDenied {
fn weight(&self) -> Weight {
self.weight
}
}
impl AnonymousDenied {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionAnonymousDenied`].
pub fn new(f: FnActionAnonymousDenied) -> Self {
AnonymousDenied { f, weight: 0 }
}
/// Opcional. Acciones con pesos más bajos se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
/// Despacha las acciones hasta que una responde, y devuelve su respuesta.
#[inline]
pub(crate) fn dispatch(request: &HttpRequest) -> Option<Response> {
let mut response = None;
try_dispatch_actions(|action: &Self| {
response = (action.f)(request);
if response.is_some() {
ControlFlow::Break(())
} else {
ControlFlow::Continue(())
}
});
response
}
}

View file

@ -0,0 +1,70 @@
use crate::prelude::*;
use super::FnActionCheckPerm;
use std::ops::ControlFlow;
/// Acción para comprobar si el usuario actual tiene un permiso concreto.
///
/// Las extensiones de autenticación pueden registrar su handler sobre esta acción para implementar
/// su modelo de permisos. Los handlers son aditivos de tal forma que si cualquiera de ellos asigna
/// `granted = true`, el permiso se concede. La consultan [`has_permission()`] y el acceso de las
/// rutas ([`Access::Permission`]).
///
/// # Ejemplo
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// fn check_my_permissions(request: &HttpRequest, perm: PermissionRef, granted: &mut bool) {
/// // Leer los datos extendidos de autenticación inyectados en la petición.
/// // Comparar `perm.key()` contra el modelo propio.
/// // Si concede el permiso, asignar `*granted = true`.
/// }
///
/// pub struct MyAuth;
///
/// #[async_trait]
/// impl Extension for MyAuth {
/// fn actions(&self) -> Vec<ActionBox> {
/// actions![action::auth::CheckPermission::new(check_my_permissions)]
/// }
/// }
/// ```
pub struct CheckPermission {
f: FnActionCheckPerm,
weight: Weight,
}
impl ActionDispatcher for CheckPermission {
fn weight(&self) -> Weight {
self.weight
}
}
impl CheckPermission {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionCheckPerm`].
pub fn new(f: FnActionCheckPerm) -> Self {
CheckPermission { f, weight: 0 }
}
/// Opcional. Acciones con pesos más bajos se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
/// Despacha las acciones hasta que una concede el permiso, y devuelve si alguna lo ha hecho.
#[inline]
pub(crate) fn dispatch(request: &HttpRequest, perm: PermissionRef) -> bool {
let mut granted = false;
try_dispatch_actions(|action: &Self| {
(action.f)(request, perm, &mut granted);
if granted {
ControlFlow::Break(())
} else {
ControlFlow::Continue(())
}
});
granted
}
}

View file

@ -0,0 +1,85 @@
use crate::prelude::*;
use super::FnActionDeclarePermissions;
/// Acción para declarar los permisos de una extensión en el catálogo de permisos.
///
/// Cada extensión añade una instancia en [`Extension::actions()`]. PageTop despacha todas al
/// arrancar, después de registrar las acciones y antes de inicializar las extensiones, y construye
/// el catálogo global ([`PermissionRegistry::global()`]). El texto y el grupo de cada permiso los
/// aporta el propio [`Permission`] ([`label()`], [`group()`] y [`group_label()`]).
///
/// Declarar un permiso no lo concede a nadie: sólo lo da a conocer, para que una extensión de
/// autenticación pueda ofrecerlo (p. ej. en una pantalla de asignación de permisos a roles). Sin
/// ninguna, el permiso existe en el catálogo pero [`has_permission()`] lo deniega siempre.
///
/// Un permiso que exige una ruta ([`Access::Permission`]) o una pieza del panel de administración
/// sin estar declarado se avisa en las trazas al arrancar: nadie podría concederlo desde una
/// pantalla así.
///
/// # Ejemplo
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// #[derive(Clone, Copy, Debug)]
/// enum MyPermission {
/// DoSomething,
/// }
///
/// impl Permission for MyPermission {
/// fn key(&self) -> CowStr {
/// match self {
/// Self::DoSomething => "myext:do_something".into(),
/// }
/// }
/// }
///
/// fn declare_permissions(registry: &mut PermissionRegistry) {
/// registry.register(&MyPermission::DoSomething);
/// }
///
/// pub struct MyExtension;
///
/// #[async_trait]
/// impl Extension for MyExtension {
/// fn actions(&self) -> Vec<ActionBox> {
/// actions![action::auth::DeclarePermissions::new(declare_permissions)]
/// }
/// }
/// ```
///
/// [`label()`]: Permission::label
/// [`group()`]: Permission::group
/// [`group_label()`]: Permission::group_label
pub struct DeclarePermissions {
f: FnActionDeclarePermissions,
weight: Weight,
}
impl ActionDispatcher for DeclarePermissions {
fn weight(&self) -> Weight {
self.weight
}
}
impl DeclarePermissions {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionDeclarePermissions`].
pub fn new(f: FnActionDeclarePermissions) -> Self {
DeclarePermissions { f, weight: 0 }
}
/// Opcional. Acciones con pesos más bajos se aplican antes. Se pueden usar valores negativos.
///
/// Determina el orden de registro en el catálogo y, con él, el de los permisos de un mismo
/// grupo en [`PermissionRegistry::by_group()`].
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
/// Despacha las acciones sobre el catálogo que se está construyendo.
#[inline]
pub(crate) fn dispatch(registry: &mut PermissionRegistry) {
dispatch_actions(|action: &Self| (action.f)(registry));
}
}

114
tests/auth_permissions.rs Normal file
View file

@ -0,0 +1,114 @@
use pagetop::prelude::*;
// The permission catalog is built once per process, at startup: every declaration of this test is
// in a single extension and the cases are different tests on top of it.
#[derive(Clone, Copy, Debug)]
enum Perm {
Read,
Write,
Audit,
}
impl Permission for Perm {
fn key(&self) -> CowStr {
match self {
Self::Read => "test:read".into(),
Self::Write => "test:write".into(),
Self::Audit => "test:audit".into(),
}
}
fn group(&self) -> &'static str {
match self {
Self::Read | Self::Write => "content",
Self::Audit => "security",
}
}
}
// Same key as `Perm::Read`, declared again by another action.
struct Duplicate;
impl Permission for Duplicate {
fn key(&self) -> CowStr {
"test:read".into()
}
fn group(&self) -> &'static str {
"duplicated"
}
}
fn declare_audit(registry: &mut PermissionRegistry) {
registry.register(&Perm::Audit);
}
fn declare_content(registry: &mut PermissionRegistry) {
registry.register(&Perm::Read);
registry.register(&Perm::Write);
registry.register(&Duplicate);
}
struct Ext;
#[async_trait]
impl Extension for Ext {
fn actions(&self) -> Vec<ActionBox> {
actions![
action::auth::DeclarePermissions::new(declare_audit),
action::auth::DeclarePermissions::new(declare_content).with_weight(-1),
]
}
}
async fn start() {
// Starting more than once in the same process (as tests do) does not duplicate the catalog.
let _ = Application::prepare(&Ext).await;
let _ = Application::prepare(&Ext).await;
}
fn keys(permissions: impl Iterator<Item = PermissionRef>) -> Vec<String> {
permissions.map(|p| p.key().into_owned()).collect()
}
#[pagetop::test]
async fn declarations_are_registered_by_weight_then_registration_order() {
start().await;
let registry = PermissionRegistry::global();
assert_eq!(
keys(registry.all()),
["test:read", "test:write", "test:audit"]
);
let groups: Vec<_> = registry.groups().iter().map(|(g, _)| *g).collect();
assert_eq!(groups, ["content", "security"]);
}
#[pagetop::test]
async fn a_repeated_key_is_ignored_with_its_group() {
start().await;
let registry = PermissionRegistry::global();
assert!(registry.has(&Duplicate));
assert!(registry.has_key("test:read"));
assert!(!registry.has_key("test:unknown"));
assert!(!registry.groups().iter().any(|(g, _)| *g == "duplicated"));
}
#[pagetop::test]
async fn permissions_are_listed_by_group() {
start().await;
let registry = PermissionRegistry::global();
assert_eq!(
keys(registry.by_group("content")),
["test:read", "test:write"]
);
assert_eq!(keys(registry.by_group("security")), ["test:audit"]);
assert!(registry.by_group("missing").next().is_none());
}
#[pagetop::test]
async fn declaring_a_permission_does_not_grant_it() {
start().await;
let request = web::test::TestRequest::get().uri("/").to_http_request();
assert!(!has_permission(&request, &Perm::Read));
}