openauth_core/api/
additional_fields.rs

1use std::collections::BTreeMap;
2
3use serde_json::Value;
4
5use crate::db::{DbAdapter, DbFieldType, DbRecord, DbValue, FindOne, User, Where};
6use crate::error::OpenAuthError;
7use crate::options::{SessionAdditionalField, UserAdditionalField};
8
9pub trait AdditionalField {
10    fn field_type(&self) -> &DbFieldType;
11    fn required(&self) -> bool;
12    fn input(&self) -> bool;
13    fn returned(&self) -> bool;
14    fn default_value(&self) -> Option<&DbValue>;
15    fn db_name(&self) -> Option<&str>;
16}
17
18impl AdditionalField for UserAdditionalField {
19    fn field_type(&self) -> &DbFieldType {
20        &self.field_type
21    }
22
23    fn required(&self) -> bool {
24        self.required
25    }
26
27    fn input(&self) -> bool {
28        self.input
29    }
30
31    fn returned(&self) -> bool {
32        self.returned
33    }
34
35    fn default_value(&self) -> Option<&DbValue> {
36        self.default_value.as_ref()
37    }
38
39    fn db_name(&self) -> Option<&str> {
40        self.db_name.as_deref()
41    }
42}
43
44impl AdditionalField for SessionAdditionalField {
45    fn field_type(&self) -> &DbFieldType {
46        &self.field_type
47    }
48
49    fn required(&self) -> bool {
50        self.required
51    }
52
53    fn input(&self) -> bool {
54        self.input
55    }
56
57    fn returned(&self) -> bool {
58        self.returned
59    }
60
61    fn default_value(&self) -> Option<&DbValue> {
62        self.default_value.as_ref()
63    }
64
65    fn db_name(&self) -> Option<&str> {
66        self.db_name.as_deref()
67    }
68}
69
70pub fn create_values<F>(
71    fields: &BTreeMap<String, F>,
72    body: &serde_json::Map<String, Value>,
73) -> Result<DbRecord, AdditionalFieldError>
74where
75    F: AdditionalField,
76{
77    let mut values = DbRecord::new();
78    for (name, field) in fields {
79        match body.get(name) {
80            Some(value) => {
81                if !field.input() {
82                    return Err(AdditionalFieldError::NotInput(name.clone()));
83                }
84                values.insert(
85                    storage_name(name, field),
86                    json_to_db_value(name, field.field_type(), value)
87                        .map_err(AdditionalFieldError::InvalidType)?,
88                );
89            }
90            None => {
91                if let Some(value) = field.default_value() {
92                    values.insert(storage_name(name, field), value.clone());
93                } else if field.required() {
94                    return Err(AdditionalFieldError::MissingRequired(name.clone()));
95                } else {
96                    values.insert(storage_name(name, field), DbValue::Null);
97                }
98            }
99        }
100    }
101    Ok(values)
102}
103
104pub fn update_values<F>(
105    fields: &BTreeMap<String, F>,
106    body: &serde_json::Map<String, Value>,
107) -> Result<DbRecord, AdditionalFieldError>
108where
109    F: AdditionalField,
110{
111    let mut values = DbRecord::new();
112    for (name, value) in body {
113        let Some(field) = fields.get(name) else {
114            continue;
115        };
116        if !field.input() {
117            return Err(AdditionalFieldError::NotInput(name.clone()));
118        }
119        values.insert(
120            storage_name(name, field),
121            json_to_db_value(name, field.field_type(), value)
122                .map_err(AdditionalFieldError::InvalidType)?,
123        );
124    }
125    Ok(values)
126}
127
128pub fn insert_returned_fields<F>(
129    object: &mut serde_json::Map<String, Value>,
130    fields: &BTreeMap<String, F>,
131    record: &DbRecord,
132) -> Result<(), OpenAuthError>
133where
134    F: AdditionalField,
135{
136    for (name, field) in fields {
137        if !field.returned() {
138            continue;
139        }
140        let value = record
141            .get(name)
142            .or_else(|| field.db_name().and_then(|db_name| record.get(db_name)))
143            .or_else(|| field.default_value())
144            .unwrap_or(&DbValue::Null);
145        object.insert(name.clone(), db_value_to_json(value)?);
146    }
147    Ok(())
148}
149
150fn storage_name<F>(logical_name: &str, field: &F) -> String
151where
152    F: AdditionalField,
153{
154    field
155        .db_name()
156        .map(str::to_owned)
157        .unwrap_or_else(|| logical_name.to_owned())
158}
159
160pub fn db_value_to_json(value: &DbValue) -> Result<Value, OpenAuthError> {
161    match value {
162        DbValue::String(value) => Ok(Value::String(value.clone())),
163        DbValue::Number(value) => Ok(Value::Number((*value).into())),
164        DbValue::Boolean(value) => Ok(Value::Bool(*value)),
165        DbValue::Timestamp(value) => {
166            serde_json::to_value(value).map_err(|error| OpenAuthError::Api(error.to_string()))
167        }
168        DbValue::Json(value) => Ok(value.clone()),
169        DbValue::StringArray(values) => Ok(Value::Array(
170            values.iter().cloned().map(Value::String).collect(),
171        )),
172        DbValue::NumberArray(values) => Ok(Value::Array(
173            values
174                .iter()
175                .map(|value| Value::Number((*value).into()))
176                .collect(),
177        )),
178        DbValue::Record(record) => db_record_to_json(record),
179        DbValue::RecordArray(records) => records
180            .iter()
181            .map(db_record_to_json)
182            .collect::<Result<Vec<_>, _>>()
183            .map(Value::Array),
184        DbValue::Null => Ok(Value::Null),
185    }
186}
187
188pub fn json_to_db_value(
189    name: &str,
190    field_type: &DbFieldType,
191    value: &Value,
192) -> Result<DbValue, String> {
193    if value.is_null() {
194        return Ok(DbValue::Null);
195    }
196    match field_type {
197        DbFieldType::String => value
198            .as_str()
199            .map(|value| DbValue::String(value.to_owned())),
200        DbFieldType::Number => value.as_i64().map(DbValue::Number),
201        DbFieldType::Boolean => value.as_bool().map(DbValue::Boolean),
202        DbFieldType::Json => Some(DbValue::Json(value.clone())),
203        DbFieldType::StringArray => value.as_array().and_then(|values| {
204            values
205                .iter()
206                .map(|value| value.as_str().map(str::to_owned))
207                .collect::<Option<Vec<_>>>()
208                .map(DbValue::StringArray)
209        }),
210        DbFieldType::NumberArray => value.as_array().and_then(|values| {
211            values
212                .iter()
213                .map(Value::as_i64)
214                .collect::<Option<Vec<_>>>()
215                .map(DbValue::NumberArray)
216        }),
217        DbFieldType::Timestamp => None,
218    }
219    .ok_or_else(|| format!("invalid value for additional field `{name}`"))
220}
221
222#[derive(Debug, Clone, PartialEq, Eq)]
223pub enum AdditionalFieldError {
224    MissingRequired(String),
225    NotInput(String),
226    InvalidType(String),
227}
228
229impl AdditionalFieldError {
230    pub fn message(&self) -> String {
231        match self {
232            Self::MissingRequired(name) => format!("missing required additional field `{name}`"),
233            Self::NotInput(name) => format!("additional field `{name}` is not accepted as input"),
234            Self::InvalidType(message) => message.clone(),
235        }
236    }
237}
238
239pub async fn user_response_value(
240    adapter: &dyn DbAdapter,
241    fields: &BTreeMap<String, UserAdditionalField>,
242    user: &User,
243) -> Result<Value, OpenAuthError> {
244    if fields.is_empty() {
245        return serde_json::to_value(user).map_err(|error| OpenAuthError::Api(error.to_string()));
246    }
247    let record = adapter
248        .find_one(
249            FindOne::new("user").where_clause(Where::new("id", DbValue::String(user.id.clone()))),
250        )
251        .await?;
252    let mut value =
253        serde_json::to_value(user).map_err(|error| OpenAuthError::Api(error.to_string()))?;
254    let Some(object) = value.as_object_mut() else {
255        return Err(OpenAuthError::Api(
256            "could not serialize user as an object".to_owned(),
257        ));
258    };
259    if let Some(record) = record {
260        insert_returned_fields(object, fields, &record)?;
261    }
262    Ok(value)
263}
264
265fn db_record_to_json(record: &DbRecord) -> Result<Value, OpenAuthError> {
266    record
267        .iter()
268        .map(|(field, value)| db_value_to_json(value).map(|value| (field.clone(), value)))
269        .collect::<Result<serde_json::Map<_, _>, _>>()
270        .map(Value::Object)
271}
openauth_core/api/additional_fields.rs

openauth_core/api/
additional_fields.rs
