rusty-ssr 0.1.0

High-performance SSR engine for Rust with V8 isolate pool and multi-tier caching
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

//! HTML rendering via V8 runtime

use deno_core::{v8, JsRuntime};

/// Render HTML via V8 runtime
///
/// Calls `globalThis.{render_function}(url, data)` and returns the result.
///
/// # Arguments
/// * `url` - The URL path to render
/// * `data` - JSON string with data to pass to the render function
/// * `render_function` - Name of the global render function
/// * `js_runtime` - The V8 runtime to use
pub fn render_html(
    url: &str,
    data: Option<&str>,
    render_function: &str,
    js_runtime: &mut JsRuntime,
) -> Result<String, String> {
    let data = data.unwrap_or("{}");

    // Validate data is valid JSON to prevent code injection.
    // Raw interpolation of untrusted strings into JS would allow arbitrary execution.
    let safe_data: serde_json::Value = serde_json::from_str(data)
        .map_err(|e| format!("Invalid JSON data: {}", e))?;

    // Escape URL for JavaScript string
    let escaped_url = url.replace('\\', "\\\\").replace('"', "\\\"");

    let render_code = format!(
        r#"
        (async function() {{
            try {{
                if (typeof globalThis.{fn} !== 'function') {{
                    throw new Error('Render function globalThis.{fn} not found');
                }}
                return await globalThis.{fn}("{url}", {data});
            }} catch (error) {{
                console.error("Render error:", error);
                return `<html><body><h1>SSR Error</h1><pre>${{error.stack || error.message}}</pre></body></html>`;
            }}
        }})()
        "#,
        fn = render_function,
        url = escaped_url,
        data = safe_data
    );

    // Execute the JS code
    let global = js_runtime
        .execute_script("<render>", render_code)
        .map_err(|e| format!("JS execute error: {}", e))?;

    // Wait for the promise to resolve
    #[allow(deprecated)]
    let resolved = futures::executor::block_on(js_runtime.resolve_value(global))
        .map_err(|e| format!("Promise resolution error: {}", e))?;

    // Deserialize the result
    let scope = &mut js_runtime.handle_scope();
    let local = v8::Local::new(scope, resolved);

    serde_v8::from_v8::<String>(scope, local)
        .map_err(|e| format!("Result deserialization error: {}", e))
}