predawn 0.9.0

Predawn is a Rust web framework like Spring Boot.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

mod de;

use std::collections::BTreeMap;

use predawn_core::{
    api_request::ApiRequestHead,
    from_request::FromRequestHead,
    impl_deref,
    openapi::{Parameter, Schema},
    request::Head,
};
use serde::Deserialize;
use snafu::{IntoError, ResultExt};

use self::de::PathDeserializer;
use crate::{
    path_params::PathParams,
    response_error::{
        DeserializePathSnafu, InvalidUtf8PathParamSnafu, MissingPathParamsSnafu, PathError,
    },
    ToParameters,
};

#[derive(Debug)]
pub struct Path<T>(pub T);

impl_deref!(Path);

impl<'a, T> FromRequestHead<'a> for Path<T>
where
    T: Deserialize<'a>,
{
    type Error = PathError;

    async fn from_request_head(head: &'a mut Head) -> Result<Self, Self::Error> {
        let params = match head.extensions.get::<PathParams>() {
            Some(PathParams::Params(params)) => params,
            Some(PathParams::InvalidUtf8InPathParam(error)) => {
                return Err(InvalidUtf8PathParamSnafu.into_error(error.clone()));
            }
            None => return MissingPathParamsSnafu.fail(),
        };

        let deserializer = PathDeserializer::new(params);

        let path = T::deserialize(deserializer).context(DeserializePathSnafu)?;
        Ok(Path(path))
    }
}

impl<T: ToParameters> ApiRequestHead for Path<T> {
    fn parameters(
        schemas: &mut BTreeMap<String, Schema>,
        schemas_in_progress: &mut Vec<String>,
    ) -> Option<Vec<Parameter>> {
        Some(
            <T as ToParameters>::parameters(schemas, schemas_in_progress)
                .into_iter()
                .map(|parameter_data| Parameter::Path {
                    parameter_data,
                    style: Default::default(),
                })
                .collect(),
        )
    }
}