Skip to main content

openauth_core/api/
output.rs

1//! Shared API output helpers for core routes and server-side plugins.
2
3use serde::Serialize;
4use serde_json::Value;
5use time::OffsetDateTime;
6
7use crate::api::additional_fields::insert_returned_fields;
8use crate::context::AuthContext;
9use crate::cookies::{
10    set_cookie_cache, set_session_cookie, Cookie, CookieCachePayload, CookieOptions,
11    SessionCookieOptions,
12};
13use crate::db::{DbAdapter, DbRecord, DbValue, FindOne, Session, User, Where};
14use crate::error::OpenAuthError;
15
16#[derive(Debug, Serialize)]
17pub struct SessionUserOutput {
18    pub session: Value,
19    pub user: Value,
20}
21
22pub async fn session_user_output(
23    adapter: &dyn DbAdapter,
24    context: &AuthContext,
25    session: &Session,
26    user: &User,
27) -> Result<SessionUserOutput, OpenAuthError> {
28    Ok(SessionUserOutput {
29        session: session_output_value(adapter, context, session).await?,
30        user: user_output_value(adapter, context, user).await?,
31    })
32}
33
34pub async fn user_output_value(
35    adapter: &dyn DbAdapter,
36    context: &AuthContext,
37    user: &User,
38) -> Result<Value, OpenAuthError> {
39    if context.options.user.additional_fields.is_empty() {
40        return serde_json::to_value(user).map_err(|error| OpenAuthError::Serialization {
41            context: "serializing user output",
42            message: error.to_string(),
43        });
44    }
45    let record = adapter
46        .find_one(
47            FindOne::new("user").where_clause(Where::new("id", DbValue::String(user.id.clone()))),
48        )
49        .await?;
50    let mut value = serde_json::to_value(user).map_err(|error| OpenAuthError::Serialization {
51        context: "serializing user output",
52        message: error.to_string(),
53    })?;
54    let Some(object) = value.as_object_mut() else {
55        return Err(OpenAuthError::Serialization {
56            context: "serializing user output",
57            message: "expected JSON object".to_owned(),
58        });
59    };
60    if let Some(record) = record {
61        insert_returned_fields(object, &context.options.user.additional_fields, &record)?;
62    }
63    Ok(value)
64}
65
66pub async fn session_output_value(
67    adapter: &dyn DbAdapter,
68    context: &AuthContext,
69    session: &Session,
70) -> Result<Value, OpenAuthError> {
71    if context.options.session.additional_fields.is_empty() {
72        return serde_json::to_value(session).map_err(|error| OpenAuthError::Serialization {
73            context: "serializing session output",
74            message: error.to_string(),
75        });
76    }
77    let record = adapter
78        .find_one(
79            FindOne::new("session")
80                .where_clause(Where::new("token", DbValue::String(session.token.clone()))),
81        )
82        .await?;
83    match record {
84        Some(record) => session_value_from_record(context, &record, session),
85        None => serde_json::to_value(session).map_err(|error| OpenAuthError::Serialization {
86            context: "serializing session output",
87            message: error.to_string(),
88        }),
89    }
90}
91
92pub fn session_value_from_record(
93    context: &AuthContext,
94    record: &DbRecord,
95    session: &Session,
96) -> Result<Value, OpenAuthError> {
97    let mut value =
98        serde_json::to_value(session).map_err(|error| OpenAuthError::Serialization {
99            context: "serializing session output",
100            message: error.to_string(),
101        })?;
102    let Some(object) = value.as_object_mut() else {
103        return Err(OpenAuthError::Serialization {
104            context: "serializing session output",
105            message: "expected JSON object".to_owned(),
106        });
107    };
108    insert_returned_fields(object, &context.options.session.additional_fields, record)?;
109    Ok(value)
110}
111
112pub fn session_response_cookies(
113    context: &AuthContext,
114    session: &Session,
115    user: &User,
116    dont_remember: bool,
117) -> Result<Vec<Cookie>, OpenAuthError> {
118    let mut cookies = set_session_cookie(
119        &context.auth_cookies,
120        &context.secret,
121        &session.token,
122        SessionCookieOptions {
123            dont_remember,
124            overrides: CookieOptions::default(),
125        },
126    )?;
127    if context.options.session.cookie_cache.enabled {
128        let max_age = context
129            .options
130            .session
131            .cookie_cache
132            .max_age
133            .unwrap_or(60 * 5);
134        cookies.extend(set_cookie_cache(
135            &context.auth_cookies,
136            &context.secret,
137            &CookieCachePayload {
138                session: session.clone(),
139                user: user.clone(),
140                updated_at: OffsetDateTime::now_utc().unix_timestamp(),
141                version: context
142                    .options
143                    .session
144                    .cookie_cache
145                    .version
146                    .clone()
147                    .unwrap_or_else(|| "1".to_owned()),
148            },
149            context.options.session.cookie_cache.strategy,
150            max_age,
151        )?);
152    }
153    Ok(cookies)
154}