🔥 (user): Retira Account::roles y has_role()

Se autoriza sólo por permiso. La carga de sesión ya no lee la
tabla roles y los administradores se ahorran la consulta.
This commit is contained in:
Manuel Cillero 2026-10-13 23:35:27 +02:00
parent 53b73a0970
commit 1577891fe3
3 changed files with 48 additions and 69 deletions

View file

@ -36,22 +36,19 @@ impl UserStatus {
// **< PermissionSet >******************************************************************************
/// Conjunto de permisos resuelto para un usuario concreto.
// Conjunto de permisos resuelto para una petición: los de una cuenta autenticada o, sin sesión, los
// del rol "anonymous".
#[derive(AutoDefault, Clone, Debug)]
pub struct PermissionSet(HashSet<String>);
pub(crate) struct PermissionSet(HashSet<String>);
impl PermissionSet {
pub fn new(keys: impl IntoIterator<Item = String>) -> Self {
pub(crate) fn new(keys: impl IntoIterator<Item = String>) -> Self {
PermissionSet(keys.into_iter().collect())
}
pub fn contains(&self, key: &str) -> bool {
pub(crate) fn contains(&self, key: &str) -> bool {
self.0.contains(key)
}
pub fn extend(&mut self, keys: impl IntoIterator<Item = String>) {
self.0.extend(keys);
}
}
// **< Account >************************************************************************************
@ -74,9 +71,6 @@ pub struct Account {
/// Estado de la cuenta.
#[getters(copy)]
status: UserStatus,
/// Nombres de máquina de los roles asignados explícitamente. No incluye "authenticated", que
/// es implícito (ver [`Account::has_role`]).
roles: Vec<String>,
// Unión de permisos de sus roles y del rol implícito "authenticated". Vacío si es
// administrador: no se cargan porque `has_permission()` ya concede todos. Sin getter para que
// la única consulta posible sea `has_permission()`.
@ -91,14 +85,13 @@ pub struct Account {
impl Account {
// Sólo se construye desde la carga de sesión, para que ningún otro crate pueda fabricar una
// cuenta e inyectarla en la petición.
pub(crate) fn new(user: user::Model, roles: Vec<String>, permissions: PermissionSet) -> Self {
pub(crate) fn new(user: user::Model, permissions: PermissionSet) -> Self {
Account {
id: user.id,
username: user.username,
email: user.email,
display_name: user.display_name.unwrap_or_default(),
status: UserStatus::from_i16(user.status),
roles,
permissions,
is_admin: user.is_admin,
}
@ -117,9 +110,4 @@ impl Account {
self.display_name()
}
}
/// Comprueba si la cuenta tiene el rol indicado ("authenticated" siempre se cumple).
pub fn has_role(&self, machine_name: &str) -> bool {
machine_name == "authenticated" || self.roles().iter().any(|r| r == machine_name)
}
}

View file

@ -23,8 +23,8 @@ struct AnonymousPermissions(Arc<PermissionSet>);
/// petición HTTP.
///
/// - Siempre inserta [`pagetop::auth::CurrentUser`] (anónimo o autenticado).
/// - Si hay sesión activa, inserta también el [`Account`] con roles y permisos; si no, los permisos
/// del rol "anonymous".
/// - Si hay sesión activa, inserta también el [`Account`] con sus permisos; si no, los permisos del
/// rol "anonymous".
/// - Si se ha prorrogado una sesión iniciada con "recordarme", renueva su cookie en la respuesta.
pub(crate) async fn session_middleware(
mut req: web::Request,

View file

@ -12,7 +12,7 @@ use pagetop_seaorm::db::{Condition, DbErr, Set, dbconn};
use crate::account::{Account, PermissionSet, UserStatus};
use crate::config::SETTINGS;
use crate::entity::{role, role_permission, session, user, user_role};
use crate::entity::{role_permission, session, user, user_role};
use crate::{ANONYMOUS_ROLE_ID, AUTHENTICATED_ROLE_ID};
// **< Generación de session ID >*******************************************************************
@ -84,8 +84,8 @@ pub fn extract_sid(headers: Option<&web::http::HeaderMap>) -> Option<&str> {
/// Lee la cookie de sesión de las cabeceras y resuelve la terna
/// `(CurrentUser, Option<Account>, Option<String>)` de [`load_user_from_session`].
///
/// Si no hay una cookie de sesión válida, o la sesión no existe o ha expirado, devuelve
/// `(CurrentUser::anonymous(), None, None)`. Se llama desde el middleware de sesión, que es async.
/// Si no hay una cookie de sesión válida, o [`load_user_from_session`] no resuelve la sesión,
/// devuelve `(CurrentUser::anonymous(), None, None)`. Se llama desde el middleware de sesión.
pub async fn resolve_session(
headers: &web::http::HeaderMap,
) -> (CurrentUser, Option<Account>, Option<String>) {
@ -103,7 +103,8 @@ pub async fn resolve_session(
/// Devuelve la terna `(CurrentUser, Option<Account>, Option<String>)`, cuyo tercer elemento es la
/// cabecera `Set-Cookie` que renueva la cookie persistente cuando se prorroga una sesión iniciada
/// con "recordarme". Devuelve `(CurrentUser::anonymous(), None, None)` si la sesión no existe o ha
/// expirado.
/// expirado, si la cuenta no está activa (p. ej. bloqueada tras iniciar la sesión) o si falla la
/// consulta, que se registra como aviso.
pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option<Account>, Option<String>) {
let now = Utc::now();
@ -124,19 +125,21 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option<Account>,
return (CurrentUser::anonymous(), None, None);
}
// Roles explícitos del usuario más el implícito "authenticated" (no se asigna en `user_role`
// pero se aplica siempre), con sus permisos, en una sola consulta: una fila por permiso, o una
// sin permiso si el rol no tiene ninguno. "anonymous" se excluye aunque figure en `user_role`
// (p. ej. insertado directamente en la base de datos): sus permisos nunca llegan a una cuenta.
let rows = role::Entity::find()
// Un administrador tiene todos los permisos (ver `Account::has_permission`): no se cargan.
// Si no, se leen en una sola consulta los de sus roles más los del implícito "authenticated",
// que no se asigna en `user_role` pero se aplica siempre. "anonymous" se excluye aunque figure
// en `user_role` (p. ej. insertado directamente en la base de datos): sus permisos nunca llegan
// a una cuenta.
let permissions = if user_model.is_admin {
PermissionSet::default()
} else {
let keys = role_permission::Entity::find()
.select_only()
.columns([role::Column::Id, role::Column::MachineName])
.column(role_permission::Column::PermissionKey)
.left_join(role_permission::Entity)
.filter(
Condition::any()
.add(
role::Column::Id.in_subquery(
role_permission::Column::RoleId.in_subquery(
Query::select()
.column(user_role::Column::RoleId)
.from(user_role::Entity)
@ -145,32 +148,20 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option<Account>,
.to_owned(),
),
)
.add(role::Column::Id.eq(AUTHENTICATED_ROLE_ID)),
.add(role_permission::Column::RoleId.eq(AUTHENTICATED_ROLE_ID)),
)
.into_tuple::<(i32, String, Option<String>)>()
.into_tuple::<String>()
.all(dbconn())
.await;
let rows = match rows {
Ok(rows) => rows,
match keys {
Ok(keys) => PermissionSet::new(keys),
Err(err) => {
trace::warn!("session: failed to load roles and permissions: {err}");
trace::warn!("session: failed to load permissions: {err}");
return (CurrentUser::anonymous(), None, None);
}
}
};
// Un administrador tiene todos los permisos: no hace falta guardar los de sus roles.
let is_admin = user_model.is_admin;
let mut role_names: Vec<String> = Vec::new();
let mut permissions = PermissionSet::default();
for (role_id, machine_name, key) in rows {
if role_id != AUTHENTICATED_ROLE_ID && !role_names.contains(&machine_name) {
role_names.push(machine_name);
}
if !is_admin {
permissions.extend(key);
}
}
let mut renewed_cookie = None;
if let Some(expires_at) = renewed_expiry(
sess.last_activity_at,
@ -197,7 +188,7 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option<Account>,
let language = user_model.language.take();
let timezone = user_model.timezone.take();
let theme = user_model.theme.take();
let account = Account::new(user_model, role_names, permissions);
let account = Account::new(user_model, permissions);
let current_user = CurrentUser::authenticated(account.id(), account.display())
.with_language(language.as_deref())
.with_timezone(timezone.as_deref())