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

use crate::*;

/// A HttpResponse is used to wrap the memory returned by
/// `extism_pdk::http::request`
pub struct HttpResponse {
    memory: Memory,
    status: u16,
}

impl HttpResponse {
    pub fn into_memory(self) -> Memory {
        self.memory
    }

    pub fn status_code(&self) -> u16 {
        self.status
    }

    pub fn as_memory(&self) -> &Memory {
        &self.memory
    }

    pub fn body(&self) -> Vec<u8> {
        self.memory.to_vec()
    }

    pub fn json<T: serde::de::DeserializeOwned>(&self) -> Result<T, Error> {
        let x = serde_json::from_slice(&self.body())?;
        Ok(x)
    }
}

/// Execute `HttpRequest`, if `body` is not `None` then it will be sent as the
/// request body.
pub fn request<T: ToMemory>(
    req: &extism_manifest::HttpRequest,
    body: Option<T>,
) -> Result<HttpResponse, Error> {
    let enc = serde_json::to_vec(req)?;
    let req = Memory::from_bytes(enc)?;
    let body = match body {
        Some(b) => Some(b.to_memory()?),
        None => None,
    };
    let data = body.as_ref().map(|x| x.offset()).unwrap_or(0);
    let offs = unsafe { extism::http_request(req.offset(), data) };
    let status = unsafe { extism::http_status_code() };
    let len = unsafe { extism::length_unsafe(offs) };
    Ok(HttpResponse {
        memory: Memory(MemoryHandle {
            offset: offs,
            length: len,
        }),
        status: status as u16,
    })
}