From 379450ec406d1e2d446be6e5308488c7979afbd4 Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sat, 7 Nov 2026 06:19:48 +0100 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20(auth):=20A=C3=B1ade=20el=20cat?= =?UTF-8?q?=C3=A1logo=20de=20permisos=20y=20acceso?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- src/auth.rs | 275 +++++++++++++------- src/base/action.rs | 2 + src/base/action/auth.rs | 39 +++ src/base/action/auth/anonymous_denied.rs | 69 +++++ src/base/action/auth/check_permission.rs | 70 +++++ src/base/action/auth/declare_permissions.rs | 85 ++++++ tests/auth_permissions.rs | 114 ++++++++ 7 files changed, 567 insertions(+), 87 deletions(-) create mode 100644 src/base/action/auth.rs create mode 100644 src/base/action/auth/anonymous_denied.rs create mode 100644 src/base/action/auth/check_permission.rs create mode 100644 src/base/action/auth/declare_permissions.rs create mode 100644 tests/auth_permissions.rs diff --git a/src/auth.rs b/src/auth.rs index 6a9fdc67..43e49cd2 100644 --- a/src/auth.rs +++ b/src/auth.rs @@ -3,10 +3,19 @@ //! 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`]). //! -//! Incluye la acción [`CheckPermission`] para que las extensiones puedan implementar sus propios -//! modelos de permisos. Y también las funciones auxiliares [`has_permission()`] y -//! [`require_permission()`] para validar en el comienzo de cada handler, antes de construir ni -//! ejecutar nada, si la petición está autorizada. +//! Las extensiones se conectan con este sistema mediante las acciones de [`action::auth`]: con +//! [`CheckPermission`] implementan su propio modelo de permisos. Define también [`Access`], el +//! acceso con el que se monta cada ruta: PageTop lo comprueba antes de llegar al *handler* y +//! 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 //! (RBAC, grupos LDAP, ...) son responsabilidad de las extensiones de autenticación. Un concepto @@ -15,16 +24,18 @@ //! [`CheckPermission`]. //! //! [`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::datetime::{Timezone, Tz}; use crate::locale::{LanguageIdentifier, Lc, Locale}; use crate::response::ErrorPage; -use crate::web::HttpRequest; -use crate::{AutoDefault, CowStr, Getters, Weight, builder_impl, global}; +use crate::web::{HttpRequest, IntoResponse, Response}; +use crate::{AutoDefault, CowStr, Getters, builder_impl, global}; -use std::ops::ControlFlow; +use std::sync::OnceLock; // **< 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). /// - /// Por defecto devuelve la propia clave; una extensión que registre sus permisos en un catálogo - /// visible debería sobrescribirlo con un texto traducible. + /// Por defecto devuelve la propia clave; una extensión que declare sus permisos en el catálogo + /// ([`DeclarePermissions`]) debería sobrescribirlo con un texto traducible. fn label(&self) -> Lc { Lc::n(self.key()) } @@ -228,68 +239,6 @@ pub trait Permission: Send + Sync { /// [`require_permission()`] o [`CheckPermission`]). 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 { -/// 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 >***************************************************************************** /// Comprueba si el usuario actual tiene el permiso indicado. @@ -318,26 +267,18 @@ impl CheckPermission { /// } /// ``` pub fn has_permission(request: &HttpRequest, perm: PermissionRef) -> bool { - // Despacha las acciones registradas con salida anticipada en cuanto una concede el permiso. - let mut granted = false; - try_dispatch_actions(|action: &CheckPermission| { - (action.f)(request, perm, &mut granted); - if granted { - ControlFlow::Break(()) - } else { - ControlFlow::Continue(()) - } - }); - granted + CheckPermission::dispatch(request, perm) } // **< require_permission >************************************************************************* /// 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 -/// en cuanto falta el permiso, sin repetir el `if`/`return` en cada punto de comprobación. Se hace -/// directamente sobre la petición, antes de construir ni ejecutar nada (`Context`, `Page`, +/// Ejecuta [`has_permission()`] para detener un *handler* con una respuesta 403 en cuanto falta el +/// permiso, sin repetir el `if`/`return` en cada punto de comprobación. El acceso de la ruta +/// ([`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. /// /// 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() } /// # } /// async fn my_handler(request: HttpRequest) -> Result { -/// // Comprueba si la petición está autorizada. +/// // La ruta ya exige su acceso; este permiso es más concreto. /// require_permission(&request, &MyPermission::Edit)?; /// /// // 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()))) } } + +// **< 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::() + .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, + // `(identificador de grupo, título traducible)`, en orden de primer registro. + groups: Vec<(&'static str, Lc)>, +} + +static PERMISSIONS: OnceLock = 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 + '_ { + 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 + '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 + }); +} diff --git a/src/base/action.rs b/src/base/action.rs index 1e4debca..b1c83aaf 100644 --- a/src/base/action.rs +++ b/src/base/action.rs @@ -3,3 +3,5 @@ pub mod component; pub mod page; + +pub mod auth; diff --git a/src/base/action/auth.rs b/src/base/action/auth.rs new file mode 100644 index 00000000..154521fb --- /dev/null +++ b/src/base/action/auth.rs @@ -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; + +mod check_permission; +pub use check_permission::*; + +mod declare_permissions; +pub use declare_permissions::*; + +mod anonymous_denied; +pub use anonymous_denied::*; diff --git a/src/base/action/auth/anonymous_denied.rs b/src/base/action/auth/anonymous_denied.rs new file mode 100644 index 00000000..e5523522 --- /dev/null +++ b/src/base/action/auth/anonymous_denied.rs @@ -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 { +/// // 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 { +/// 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 { + let mut response = None; + try_dispatch_actions(|action: &Self| { + response = (action.f)(request); + if response.is_some() { + ControlFlow::Break(()) + } else { + ControlFlow::Continue(()) + } + }); + response + } +} diff --git a/src/base/action/auth/check_permission.rs b/src/base/action/auth/check_permission.rs new file mode 100644 index 00000000..4ca5969c --- /dev/null +++ b/src/base/action/auth/check_permission.rs @@ -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 { +/// 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 + } +} diff --git a/src/base/action/auth/declare_permissions.rs b/src/base/action/auth/declare_permissions.rs new file mode 100644 index 00000000..a938b379 --- /dev/null +++ b/src/base/action/auth/declare_permissions.rs @@ -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 { +/// 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)); + } +} diff --git a/tests/auth_permissions.rs b/tests/auth_permissions.rs new file mode 100644 index 00000000..37dac58a --- /dev/null +++ b/tests/auth_permissions.rs @@ -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 { + 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) -> Vec { + 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)); +}