use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use super::{error::PermissionError, model::Principal};
const MAX_PERMISSION_PART_LENGTH: usize = 256;
fn normalize_permission_part(
value: impl Into<String>,
field: &'static str,
) -> Result<String, PermissionError> {
let value = value.into().trim().to_owned();
if value.is_empty() {
return Err(PermissionError::InvalidPolicy(format!(
"{field} must not be empty"
)));
}
if value.len() > MAX_PERMISSION_PART_LENGTH {
return Err(PermissionError::InvalidPolicy(format!(
"{field} must not exceed {MAX_PERMISSION_PART_LENGTH} bytes"
)));
}
if value.chars().any(char::is_control) {
return Err(PermissionError::InvalidPolicy(format!(
"{field} must not contain control characters"
)));
}
Ok(value)
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(try_from = "PermissionRequestWire")]
pub struct PermissionRequest {
action: String,
resource: String,
}
impl PermissionRequest {
pub fn new(
action: impl Into<String>,
resource: impl Into<String>,
) -> Result<Self, PermissionError> {
let action = normalize_permission_part(action, "permission action")?;
let resource = normalize_permission_part(resource, "permission resource")?;
Ok(Self { action, resource })
}
#[must_use]
pub fn action(&self) -> &str {
&self.action
}
#[must_use]
pub fn resource(&self) -> &str {
&self.resource
}
}
#[derive(Debug, Deserialize)]
struct PermissionRequestWire {
action: String,
resource: String,
}
impl TryFrom<PermissionRequestWire> for PermissionRequest {
type Error = PermissionError;
fn try_from(value: PermissionRequestWire) -> Result<Self, Self::Error> {
Self::new(value.action, value.resource)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum PermissionDecision {
Allow,
Deny,
}
impl PermissionDecision {
#[must_use]
pub const fn is_allowed(self) -> bool {
matches!(self, Self::Allow)
}
pub fn ensure_allowed(self) -> Result<(), PermissionError> {
if self.is_allowed() {
Ok(())
} else {
Err(PermissionError::Denied)
}
}
}
#[async_trait]
pub trait PermissionChecker: Send + Sync {
async fn check(
&self,
principal: &Principal,
request: &PermissionRequest,
) -> Result<PermissionDecision, PermissionError>;
async fn ensure_allowed(
&self,
principal: &Principal,
request: &PermissionRequest,
) -> Result<(), PermissionError> {
self.check(principal, request).await?.ensure_allowed()
}
}