openauth_core/api/
output.rs1use 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}