mrapids 0.1.7

Your OpenAPI, but executable
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

//! Minimal WASM library for MicroRapids
//! This is a standalone WASM module without dependencies on the main library

use wasm_bindgen::prelude::*;
use serde::{Deserialize, Serialize};
use web_sys::console;

#[wasm_bindgen]
pub struct MicroRapidsClient {
    base_url: String,
}

#[derive(Serialize, Deserialize)]
pub struct RequestOptions {
    pub method: String,
    pub headers: Option<std::collections::HashMap<String, String>>,
    pub body: Option<String>,
}

#[wasm_bindgen]
impl MicroRapidsClient {
    #[wasm_bindgen(constructor)]
    pub fn new(base_url: String) -> MicroRapidsClient {
        console::log_1(&"MicroRapids WASM client initialized".into());
        MicroRapidsClient { base_url }
    }

    #[wasm_bindgen(js_name = healthCheck)]
    pub fn health_check(&self) -> String {
        format!("Healthy: {}", self.base_url)
    }

    #[wasm_bindgen(js_name = executeRequest)]
    pub async fn execute_request(&self, endpoint: &str, _options_json: Option<String>) -> Result<String, JsValue> {
        let url = format!("{}{}", self.base_url, endpoint);
        
        let window = web_sys::window().ok_or("No window object")?;
        let resp_value = wasm_bindgen_futures::JsFuture::from(
            window.fetch_with_str(&url)
        ).await?;
        
        let resp: web_sys::Response = resp_value.dyn_into()?;
        let text = wasm_bindgen_futures::JsFuture::from(resp.text()?).await?;
        
        Ok(text.as_string().unwrap_or_default())
    }
    
    #[wasm_bindgen(getter)]
    pub fn version(&self) -> String {
        env!("CARGO_PKG_VERSION").to_string()
    }

    #[wasm_bindgen(js_name = parseOpenAPI)]
    pub fn parse_openapi(&self, spec_json: &str) -> Result<String, JsValue> {
        match serde_json::from_str::<serde_json::Value>(spec_json) {
            Ok(spec) => {
                let info = spec.get("info")
                    .and_then(|i| i.get("title"))
                    .and_then(|t| t.as_str())
                    .unwrap_or("Unknown API");
                Ok(format!("Parsed OpenAPI: {}", info))
            }
            Err(e) => Err(JsValue::from_str(&format!("Parse error: {}", e)))
        }
    }
}

#[wasm_bindgen(start)]
pub fn init() {
    console::log_1(&"MicroRapids WASM module loaded".into());
}