aver/services/
http_server.rs

1use std::collections::HashMap;
2
3use aver_rt::{AverList, Header, HttpRequest, HttpResponse};
4
5use crate::value::{RuntimeError, Value, list_from_vec, list_view};
6
7pub fn register(global: &mut HashMap<String, Value>) {
8    let mut members = HashMap::new();
9    members.insert(
10        "listen".to_string(),
11        Value::Builtin("HttpServer.listen".to_string()),
12    );
13    members.insert(
14        "listenWith".to_string(),
15        Value::Builtin("HttpServer.listenWith".to_string()),
16    );
17    global.insert(
18        "HttpServer".to_string(),
19        Value::Namespace {
20            name: "HttpServer".to_string(),
21            members,
22        },
23    );
24}
25
26pub fn effects(name: &str) -> &'static [&'static str] {
27    match name {
28        "HttpServer.listen" => &["HttpServer.listen"],
29        "HttpServer.listenWith" => &["HttpServer.listenWith"],
30        _ => &[],
31    }
32}
33
34pub fn call(_name: &str, _args: &[Value]) -> Option<Result<Value, RuntimeError>> {
35    None
36}
37
38pub fn call_with_runtime<F>(
39    name: &str,
40    args: &[Value],
41    mut invoke_handler: F,
42    skip_server: bool,
43) -> Option<Result<Value, RuntimeError>>
44where
45    F: FnMut(Value, Vec<Value>, String) -> Result<Value, RuntimeError>,
46{
47    match name {
48        "HttpServer.listen" => Some(listen(args, false, &mut invoke_handler, skip_server)),
49        "HttpServer.listenWith" => Some(listen(args, true, &mut invoke_handler, skip_server)),
50        _ => None,
51    }
52}
53
54fn listen<F>(
55    args: &[Value],
56    with_context: bool,
57    invoke_handler: &mut F,
58    skip_server: bool,
59) -> Result<Value, RuntimeError>
60where
61    F: FnMut(Value, Vec<Value>, String) -> Result<Value, RuntimeError>,
62{
63    let expected = if with_context { 3 } else { 2 };
64    if args.len() != expected {
65        let sig = if with_context {
66            "HttpServer.listenWith(port, context, handler)"
67        } else {
68            "HttpServer.listen(port, handler)"
69        };
70        return Err(RuntimeError::Error(format!(
71            "{} expects {} arguments, got {}",
72            sig,
73            expected,
74            args.len()
75        )));
76    }
77
78    if skip_server {
79        return Ok(Value::Unit);
80    }
81
82    let port = match &args[0] {
83        Value::Int(n) if (0..=65535).contains(n) => *n,
84        Value::Int(n) => {
85            return Err(RuntimeError::Error(format!(
86                "HttpServer.listen: port {} is out of range (0-65535)",
87                n
88            )));
89        }
90        _ => {
91            return Err(RuntimeError::Error(
92                "HttpServer.listen: port must be an Int".to_string(),
93            ));
94        }
95    };
96    let handler = if with_context {
97        args[2].clone()
98    } else {
99        args[1].clone()
100    };
101
102    let result = if with_context {
103        let context = args[1].clone();
104        aver_rt::http_server::listen_with(port, context, |ctx, request| {
105            dispatch_handler(&handler, Some(ctx), request, invoke_handler)
106        })
107    } else {
108        aver_rt::http_server::listen(port, |request| {
109            dispatch_handler(&handler, None, request, invoke_handler)
110        })
111    };
112
113    result.map_err(RuntimeError::Error)?;
114    Ok(Value::Unit)
115}
116
117fn dispatch_handler<F>(
118    handler: &Value,
119    context: Option<Value>,
120    request: HttpRequest,
121    invoke_handler: &mut F,
122) -> HttpResponse
123where
124    F: FnMut(Value, Vec<Value>, String) -> Result<Value, RuntimeError>,
125{
126    let callback_entry = format!("<HttpServer {} {}>", request.method, request.path);
127    let mut callback_args = Vec::new();
128    if let Some(ctx) = context {
129        callback_args.push(ctx);
130    }
131    callback_args.push(http_request_to_value(request));
132
133    let callback_result = invoke_handler(handler.clone(), callback_args, callback_entry);
134    match callback_result {
135        Ok(value) => match http_response_from_value(value) {
136            Ok(resp) => resp,
137            Err(e) => HttpResponse {
138                status: 500,
139                body: format!("HttpServer handler return error: {}", e),
140                headers: AverList::empty(),
141            },
142        },
143        Err(e) => HttpResponse {
144            status: 500,
145            body: format!("HttpServer handler execution error: {}", e),
146            headers: AverList::empty(),
147        },
148    }
149}
150
151fn http_request_to_value(req: HttpRequest) -> Value {
152    let headers = req
153        .headers
154        .into_iter()
155        .map(|header| Value::Record {
156            type_name: "Header".to_string(),
157            fields: vec![
158                ("name".to_string(), Value::Str(header.name)),
159                ("value".to_string(), Value::Str(header.value)),
160            ],
161        })
162        .collect::<Vec<_>>();
163
164    Value::Record {
165        type_name: "HttpRequest".to_string(),
166        fields: vec![
167            ("method".to_string(), Value::Str(req.method)),
168            ("path".to_string(), Value::Str(req.path)),
169            ("body".to_string(), Value::Str(req.body)),
170            ("headers".to_string(), list_from_vec(headers)),
171        ],
172    }
173}
174
175fn http_response_from_value(val: Value) -> Result<HttpResponse, RuntimeError> {
176    let (type_name, fields) = match val {
177        Value::Record { type_name, fields } => (type_name, fields),
178        _ => {
179            return Err(RuntimeError::Error(
180                "HttpServer handler must return HttpResponse record".to_string(),
181            ));
182        }
183    };
184
185    if type_name != "HttpResponse" {
186        return Err(RuntimeError::Error(format!(
187            "HttpServer handler must return HttpResponse, got {}",
188            type_name
189        )));
190    }
191
192    let mut status = None;
193    let mut body = None;
194    let mut headers = AverList::empty();
195
196    for (name, value) in fields {
197        match name.as_str() {
198            "status" => {
199                if let Value::Int(n) = value {
200                    status = Some(n);
201                } else {
202                    return Err(RuntimeError::Error(
203                        "HttpResponse.status must be Int".to_string(),
204                    ));
205                }
206            }
207            "body" => {
208                if let Value::Str(s) = value {
209                    body = Some(s);
210                } else {
211                    return Err(RuntimeError::Error(
212                        "HttpResponse.body must be String".to_string(),
213                    ));
214                }
215            }
216            "headers" => {
217                headers = parse_http_response_headers(value)?;
218            }
219            _ => {}
220        }
221    }
222
223    Ok(HttpResponse {
224        status: status
225            .ok_or_else(|| RuntimeError::Error("HttpResponse.status is required".to_string()))?,
226        body: body
227            .ok_or_else(|| RuntimeError::Error("HttpResponse.body is required".to_string()))?,
228        headers,
229    })
230}
231
232fn parse_http_response_headers(val: Value) -> Result<AverList<Header>, RuntimeError> {
233    let list = list_view(&val).ok_or_else(|| {
234        RuntimeError::Error("HttpResponse.headers must be List<Header>".to_string())
235    })?;
236
237    let mut out = Vec::new();
238    for item in list.iter() {
239        let fields = match item {
240            Value::Record { fields, .. } => fields,
241            _ => {
242                return Err(RuntimeError::Error(
243                    "HttpResponse.headers entries must be Header records".to_string(),
244                ));
245            }
246        };
247
248        let mut name = None;
249        let mut value = None;
250        for (field_name, field_val) in fields {
251            match (field_name.as_str(), field_val) {
252                ("name", Value::Str(s)) => name = Some(s.clone()),
253                ("value", Value::Str(s)) => value = Some(s.clone()),
254                _ => {}
255            }
256        }
257
258        let name = name.ok_or_else(|| {
259            RuntimeError::Error("HttpResponse header missing String 'name'".to_string())
260        })?;
261        let value = value.ok_or_else(|| {
262            RuntimeError::Error("HttpResponse header missing String 'value'".to_string())
263        })?;
264        out.push(Header { name, value });
265    }
266
267    Ok(AverList::from_vec(out))
268}
aver/services/http_server.rs

aver/services/
http_server.rs
