Function fetch_ws_token

sdks/rust/src/websocket.rs:263–307

(host: &Uri, auth_token: &str)

#[cfg(feature = "browser")]
async fn fetch_ws_token(host: &Uri, auth_token: &str) -> Result<String, WsError> {
    use gloo_net::http::{Method, RequestBuilder};
    use js_sys::{Reflect, JSON};
    use wasm_bindgen::{JsCast, JsValue};

    let url = format!("{host}v1/identity/websocket-token");

    // helpers to convert gloo_net::Error or JsValue into WsError::TokenVerification
    let gloo_to_ws_err = |e: gloo_net::Error| match e {
        gloo_net::Error::JsError(js_err) => WsError::TokenVerification(js_err.message),
        gloo_net::Error::SerdeError(e) => WsError::TokenVerification(e.to_string()),
        gloo_net::Error::GlooError(msg) => WsError::TokenVerification(msg),
    };
    let js_to_ws_err = |e: JsValue| {
        if let Some(err) = e.dyn_ref::<js_sys::Error>() {
            WsError::TokenVerification(err.message().into())
        } else if let Some(s) = e.as_string() {
            WsError::TokenVerification(s)
        } else {
            WsError::TokenVerification(format!("{e:?}"))
        }
    };

    let res = RequestBuilder::new(&url)
        .method(Method::POST)
        .header("Authorization", &format!("Bearer {auth_token}"))
        .send()
        .await
        .map_err(gloo_to_ws_err)?;

    if !res.ok() {
        return Err(WsError::TokenVerification(format!(
            "HTTP error: {} {}",
            res.status(),
            res.status_text()
        )));
    }

    let body = res.text().await.map_err(gloo_to_ws_err)?;
    let json = JSON::parse(&body).map_err(js_to_ws_err)?;
    let token_js = Reflect::get(&json, &JsValue::from_str("token")).map_err(js_to_ws_err)?;
    token_js
        .as_string()
        .ok_or_else(|| WsError::TokenVerification("`token` parsing failed".into()))
}

/// If `res` evaluates to `Err(e)`, log a warning in the form `"{}: {:?}", $cause, e`.
///