use crate::authorization::Authorization;
use crate::errors::{Error, Result};
use crate::token::Tokens;
use crate::types::{Account, JsonbAny, JsonbArray};
#[derive(Debug, Clone)]
pub struct AuthorizeOptions {
pub(crate) user_id: String,
pub(crate) account: Option<Account>,
pub(crate) ip_address: String,
pub(crate) user_agent: String,
pub(crate) content: JsonbAny,
pub(crate) roles: JsonbArray,
pub(crate) method: String,
}
impl Default for AuthorizeOptions {
fn default() -> Self {
Self {
user_id: String::new(),
account: None,
ip_address: String::new(),
user_agent: String::new(),
content: JsonbAny::new(),
roles: JsonbArray::new(),
method: "credentials".to_string(),
}
}
}
impl AuthorizeOptions {
pub fn user_id(&self) -> &str {
&self.user_id
}
pub fn roles(&self) -> &JsonbArray {
&self.roles
}
pub fn content(&self) -> &JsonbAny {
&self.content
}
}
pub type AuthorizeOptionsFunc = Box<dyn FnOnce(&mut AuthorizeOptions) + Send>;
pub fn new_authorize_options(
opts: impl IntoIterator<Item = AuthorizeOptionsFunc>,
) -> AuthorizeOptions {
let mut o = AuthorizeOptions::default();
for opt in opts {
opt(&mut o);
}
o
}
impl Authorization {
pub async fn authorize(
&self,
opts: impl IntoIterator<Item = AuthorizeOptionsFunc>,
) -> Result<(Tokens, String)> {
let mut options = new_authorize_options(opts);
if !options.user_id.is_empty() {
if let Ok(roles) = self.get_user_roles_from_db(&options.user_id).await {
options.roles = roles;
}
}
if !is_valid_json_payload(&options.content.to_string()) {
return Err(Error::msg("invalid content JSON payload"));
}
if !is_valid_json_payload(&options.roles.to_string()) {
return Err(Error::msg("invalid roles JSON payload"));
}
let session_id = self
.create_session(&options)
.await
.map_err(|err| Error::msg(format!("create session: {err}")))?;
let (access_token, refresh_token) = self.sign_token_pair(&options, &session_id)?;
Ok((
Tokens {
access_token,
refresh_token,
},
session_id,
))
}
}
fn is_valid_json_payload(raw: &str) -> bool {
serde_json::from_str::<serde_json::Value>(raw).is_ok()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::authorization::Config;
fn test_auth() -> Authorization {
Authorization::from_config_unchecked(Config {
jwt_secret: "test-secret".into(),
..Config::default()
})
}
#[test]
fn valid_json_payloads_pass() {
assert!(is_valid_json_payload("{}"));
assert!(is_valid_json_payload("[]"));
assert!(is_valid_json_payload(r#"{"a":1}"#));
assert!(!is_valid_json_payload("{"));
assert!(!is_valid_json_payload("not-json"));
}
#[test]
fn with_content_sets_authorize_options() {
let auth = test_auth();
let mut content = JsonbAny::new();
content.insert("plan".into(), serde_json::json!("pro"));
let opts = new_authorize_options([auth.with_content(content.clone())]);
assert_eq!(opts.content, content);
}
}