coil-runtime 0.1.1

HTTP runtime and request handling for the Coil framework.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use super::*;
use std::collections::BTreeMap;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FileDeliveryMode {
    PublicCdn,
    SignedUrl,
    AppProxy,
    LocalOnly,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageResponse {
    pub template: String,
    pub status: u16,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FragmentResponse {
    pub template: String,
    pub fragment_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RedirectResponse {
    pub location: String,
    pub status: u16,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct JsonResponse {
    pub status: u16,
    pub payload: BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FileResponse {
    pub logical_path: String,
    pub content_type: String,
    pub delivery_mode: FileDeliveryMode,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum HandlerResponse {
    Page(PageResponse),
    Fragment(FragmentResponse),
    Redirect(RedirectResponse),
    Json(JsonResponse),
    File(FileResponse),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HandlerDefinition {
    pub route_name: String,
    pub response: HandlerResponse,
}

impl HandlerDefinition {
    pub fn page(
        route_name: impl Into<String>,
        template: impl Into<String>,
    ) -> Result<Self, RouteBuildError> {
        Ok(Self {
            route_name: validate_route_name(route_name.into())?,
            response: HandlerResponse::Page(PageResponse {
                template: validate_template_name(template.into())?,
                status: 200,
            }),
        })
    }

    pub fn fragment(
        route_name: impl Into<String>,
        template: impl Into<String>,
        fragment_id: impl Into<String>,
    ) -> Result<Self, RouteBuildError> {
        Ok(Self {
            route_name: validate_route_name(route_name.into())?,
            response: HandlerResponse::Fragment(FragmentResponse {
                template: validate_template_name(template.into())?,
                fragment_id: validate_fragment_id(fragment_id.into())?,
            }),
        })
    }

    pub fn redirect(
        route_name: impl Into<String>,
        location: impl Into<String>,
    ) -> Result<Self, RouteBuildError> {
        Ok(Self {
            route_name: validate_route_name(route_name.into())?,
            response: HandlerResponse::Redirect(RedirectResponse {
                location: validate_route_path(location.into())?,
                status: 303,
            }),
        })
    }

    pub fn json(
        route_name: impl Into<String>,
        payload: BTreeMap<String, String>,
    ) -> Result<Self, RouteBuildError> {
        Ok(Self {
            route_name: validate_route_name(route_name.into())?,
            response: HandlerResponse::Json(JsonResponse {
                status: 200,
                payload,
            }),
        })
    }

    pub fn file(
        route_name: impl Into<String>,
        logical_path: impl Into<String>,
        content_type: impl Into<String>,
        delivery_mode: FileDeliveryMode,
    ) -> Result<Self, RouteBuildError> {
        Ok(Self {
            route_name: validate_route_name(route_name.into())?,
            response: HandlerResponse::File(FileResponse {
                logical_path: validate_template_name(logical_path.into())?,
                content_type: validate_template_name(content_type.into())?,
                delivery_mode,
            }),
        })
    }
}