Function build_request

modules/llrt_http/src/fetch.rs:167–216

(
    ctx: &Ctx<'_>,
    method: &hyper::Method,
    uri: &Uri,
    headers: Option<&Headers>,
    body: Option<&BodyBytes>,
    prev_status: &u16,
    initial_uri: &Uri,
)

}

fn build_request(
    ctx: &Ctx<'_>,
    method: &hyper::Method,
    uri: &Uri,
    headers: Option<&Headers>,
    body: Option<&BodyBytes>,
    prev_status: &u16,
    initial_uri: &Uri,
) -> Result<Request<BoxBody<Bytes, Infallible>>> {
    let same_origin = is_same_origin(uri, initial_uri);

    let change_method = should_change_method(*prev_status, method);

    let (method_to_use, body) = if change_method {
        (Method::GET, None)
    } else {
        (method.clone(), body)
    };

    let mut req = Request::builder().method(method_to_use).uri(uri.clone());

    let mut detected_headers = HashSet::new();

    if let Some(headers) = headers {
        for (header_name, value) in headers.iter() {
            detected_headers.insert(header_name);
            if change_method && is_request_body_header_name(header_name) {
                continue;
            }
            if !same_origin && is_cors_non_wildcard_request_header_name(header_name) {
                continue;
            }
            req = req.header(header_name, value)
        }
    }

    if !detected_headers.contains("user-agent") {
        req = req.header("user-agent", ["llrt ", VERSION].concat());
    }
    if !detected_headers.contains("accept-encoding") {
        req = req.header("accept-encoding", "zstd, br, gzip, deflate");
    }
    if !detected_headers.contains("accept") {
        req = req.header("accept", "*/*");
    }
    req.body(BoxBody::new(
        body.map(|b| b.body.clone()).unwrap_or_default(),
    ))
    .or_throw(ctx)
}

fn is_same_origin(uri: &Uri, initial_uri: &Uri) -> bool {
    is_same_scheme(uri, initial_uri)