idemio 0.1.1

Core framework for idemio products
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use async_trait::async_trait;
use thiserror::Error;

pub struct RouteInfo<'a> {
    pub path: Option<&'a str>,
    pub method: Option<&'a str>,
}

impl<'a> RouteInfo<'a> {
    pub fn new(path: &'a str, method: &'a str) -> Self {
        Self { path: Some(path), method: Some(method) }
    }
}

#[async_trait]
pub trait ExchangeFactory<Request, E>
where
    Self: Send + Sync,
    Request: Send + Sync,
    E: Send + Sync,
{

    async fn extract_route_info<'a>(
        &self,
        request: &'a Request,
    ) -> Result<RouteInfo<'a>, ExchangeFactoryError>;

    async fn create_exchange<'req>(
        &self,
        request: Request,
    ) -> Result<E, ExchangeFactoryError>;
}

#[derive(Error, Debug)]
pub enum ExchangeFactoryError {
    #[error("{message}")]
    MissingRouteInfo { message: String },
    #[error("{message}")]
    InvalidExchange { message: String },
}

impl ExchangeFactoryError {
    #[inline]
    pub(crate) fn missing_route_info(msg: impl Into<String>) -> Self {
        ExchangeFactoryError::MissingRouteInfo {
            message: msg.into(),
        }
    }
    #[inline]
    pub(crate) fn invalid_exchange(msg: impl Into<String>) -> Self {
        ExchangeFactoryError::InvalidExchange {
            message: msg.into(),
        }
    }
}

#[cfg(feature = "hyper")]
pub mod hyper {
    use crate::exchange::Exchange;
    use crate::router::factory::{ExchangeFactory, ExchangeFactoryError, RouteInfo};
    use async_trait::async_trait;
    use futures_util::StreamExt;
    use http_body_util::BodyExt;
    use http_body_util::combinators::BoxBody;
    use hyper::Request;
    use hyper::body::{Bytes, Incoming};
    use hyper::http::request::Parts;
    use std::error::Error;
    use std::marker::PhantomData;
    use crate::router::path::http::HttpPathMethodKey;

    /// Factory implementation for creating exchanges from Hyper HTTP requests.
    pub struct HyperExchangeFactory;

    #[async_trait]
    impl ExchangeFactory<Request<Incoming>, Exchange<BoxBody<Bytes, std::io::Error>, BoxBody<Bytes, std::io::Error>, Parts>>
    for HyperExchangeFactory
    {
        /// Extracts HTTP method and path from a Hyper request.
        async fn extract_route_info<'a>(
            &self,
            request: &'a Request<Incoming>,
        ) -> Result<RouteInfo<'a>, ExchangeFactoryError> {
            Ok(RouteInfo {
                path: Some(request.uri().path()),
                method: Some(request.method().as_str()),
            })
        }

        async fn create_exchange<'req>(
            &self,
            request: Request<Incoming>,
        ) -> Result<
            Exchange<BoxBody<Bytes, std::io::Error>, BoxBody<Bytes, std::io::Error>, Parts>,
            ExchangeFactoryError,
        > {
            let mut exchange = Exchange::new();
            let (parts, body) = request.into_parts();
            let boxed_body = body.map_err(|e| todo!("Convert to correct error type")).boxed();
            exchange.set_input(boxed_body);
            exchange.set_metadata(parts);
            Ok(exchange)
        }
    }
}