use serde::{Deserialize, Serialize};
use serde_json::{json, Map, Value};
use crate::auth::{AuthContext, PRINCIPAL_CLAIM};
use crate::grants::{ScopeRef, CEILING_KEY};
use crate::identity::Issuer;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum InputBy {
#[default]
Caller,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum Answerer {
#[default]
Caller,
Person,
Grant(String),
}
pub const ANSWER_BY_SPELLINGS: &str = "`caller` (the default), `person`, or `grant:<activation.method>`";
impl Answerer {
pub fn declared(&self) -> Option<String> {
match self {
Self::Caller => None,
Self::Person => Some("person".into()),
Self::Grant(g) => Some(format!("grant:{g}")),
}
}
pub fn of_schema(answer_by: Option<&str>) -> Result<Self, String> {
answer_by.map_or(Ok(Self::Caller), Self::parse)
}
pub fn parse(text: &str) -> Result<Self, String> {
match text.trim() {
"caller" => Ok(Self::Caller),
"person" => Ok(Self::Person),
t => match t.strip_prefix("grant:") {
Some(g) if g.contains('.') && !g.contains(char::is_whitespace) => Ok(Self::Grant(g.to_string())),
_ => Err(format!("answer_by `{t}`: one of {ANSWER_BY_SPELLINGS}")),
},
}
}
}
pub fn is_person(ctx: &AuthContext) -> bool {
ctx.principal().is_some_and(|p| matches!(p.issuer(), Issuer::Idp | Issuer::Oidc))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CallCeiling {
pub credit: u64,
pub max_items: u64,
pub max_bytes: u64,
}
impl Default for CallCeiling {
fn default() -> Self {
Self { credit: 64, max_items: 1_000_000, max_bytes: 64 * 1024 * 1024 }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct CallRef {
pub conn: u64,
pub subscription: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DuplexRefusalCode {
Forbidden,
Unauthenticated,
TooManyCalls,
NotThisCall,
PastCredit,
TooMuchInput,
PersonRequired,
InputClosed,
}
impl DuplexRefusalCode {
pub fn as_str(&self) -> &'static str {
match self {
Self::Forbidden => "forbidden",
Self::Unauthenticated => "unauthenticated",
Self::TooManyCalls => "too_many_calls",
Self::NotThisCall => "not_this_call",
Self::PastCredit => "past_credit",
Self::TooMuchInput => "too_much_input",
Self::PersonRequired => "person_required",
Self::InputClosed => "input_closed",
}
}
}
pub const FOR_KEY: &str = "for";
pub fn hop_identity(hop: &AuthContext, caller: &AuthContext, verdict: &[ScopeRef]) -> AuthContext {
let mut meta = Map::new();
for key in [PRINCIPAL_CLAIM, crate::auth::EXPIRES_AT_KEY] {
if let Some(v) = hop.metadata.get(key) {
meta.insert(key.into(), v.clone());
}
}
let mut chain = vec![Value::String(caller.principal().map(|p| p.to_string()).unwrap_or_else(|| "anonymous".into()))];
if let Some(Value::Array(earlier)) = caller.metadata.get(FOR_KEY) {
chain.extend(earlier.iter().cloned());
}
meta.insert(FOR_KEY.into(), Value::Array(chain));
let layers_of = |ctx: &AuthContext| -> Vec<Value> {
match ctx.metadata.get(CEILING_KEY) {
Some(Value::Array(items)) if items.iter().all(Value::is_string) => vec![Value::Array(items.clone())],
Some(Value::Array(items)) => items.clone(),
Some(other) => vec![other.clone()],
None => Vec::new(),
}
};
let mut layers = layers_of(hop);
layers.extend(layers_of(caller));
layers.push(Value::Array(verdict.iter().map(|s| json!(format!("{}@{s}", crate::grants::ADMIN))).collect()));
meta.insert(CEILING_KEY.into(), Value::Array(layers));
AuthContext::new(hop.user_id.clone(), hop.session_id.clone(), hop.roles.clone(), Value::Object(meta))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn answerer_reads_its_declaration() {
assert_eq!(Answerer::parse("caller"), Ok(Answerer::Caller));
assert_eq!(Answerer::parse(" person "), Ok(Answerer::Person));
assert_eq!(Answerer::parse("grant:runs.approve"), Ok(Answerer::Grant("runs.approve".into())));
assert!(Answerer::parse("grant:approve").is_err());
assert!(Answerer::parse("anyone").is_err());
assert_eq!(Answerer::default(), Answerer::Caller);
for a in [Answerer::Caller, Answerer::Person, Answerer::Grant("runs.approve".into())] {
assert_eq!(Answerer::of_schema(a.declared().as_deref()), Ok(a.clone()));
}
assert_eq!(Answerer::Caller.declared(), None);
assert!(Answerer::of_schema(Some("anyone")).unwrap_err().contains("`person`"));
}
}