zebflow 0.10.7

Reactive web automation platform — pipelines, templates, and real-time collaboration in a single binary.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use serde_json::json;
use zebflow::rwe::{
    CompileTemplateRequest, CompileTemplateResponse, ProtocolMeta, RenderTemplateRequest,
    RenderTemplateResponse, TemplateSource,
};

#[test]
fn rwe_protocol_envelopes_are_json_roundtrip_friendly() {
    let compile_req = CompileTemplateRequest {
        meta: ProtocolMeta::default(),
        template: TemplateSource {
            id: "page.api".to_string(),
            source_path: None,
            markup: r#"
export const page = {
  head: { title: "Protocol Test" },
  navigation: "history"
};

export default function Page(input) {
  return (
    <Page>
      <h1>{input.title}</h1>
    </Page>
  );
}
"#
            .to_string(),
        },
        options: Default::default(),
    };

    let encoded = serde_json::to_value(&compile_req).expect("encode compile request");
    assert_eq!(
        encoded
            .get("meta")
            .and_then(|v| v.get("version"))
            .and_then(|v| v.as_str()),
        Some("rwe.v1")
    );
    let decoded: CompileTemplateRequest =
        serde_json::from_value(encoded).expect("decode compile request");
    assert_eq!(decoded.template.id, "page.api");

    let compile_resp = CompileTemplateResponse {
        meta: decoded.meta.clone(),
        compiled: zebflow::rwe::CompiledTemplate {
            engine_id: "rwe".to_string(),
            template_id: "page.api".to_string(),
            html_ir: "<html></html>".to_string(),
            control_script_source: Some("return { state: {} };".to_string()),
            compiled_logic: None,
            runtime_bundle: zebflow::rwe::RuntimeBundle {
                name: "rwe-runtime.js".to_string(),
                source: "window.__ZEBFLOW_RWE__={};".to_string(),
            },
            reactive_bindings: Vec::new(),
            diagnostics: Vec::new(),
            needs_runtime_tailwind_rebuild: false,
            tailwind_variant_exact_tokens: Vec::new(),
            tailwind_variant_patterns: Vec::new(),
            options: Default::default(),
            engine_payload: None,
            dependency_paths: Default::default(),
        },
    };
    let compile_resp_json = serde_json::to_string(&compile_resp).expect("encode compile response");
    assert!(compile_resp_json.contains("\"rwe\""));

    let render_req = RenderTemplateRequest {
        meta: compile_resp.meta.clone(),
        compiled: compile_resp.compiled.clone(),
        state: json!({ "title": "Hello Adapter" }),
        ctx: zebflow::rwe::RenderContext {
            route: "/api-preview".to_string(),
            request_id: "req-adapter-1".to_string(),
            metadata: json!({ "from": "fastapi" }),
            enabled_libraries: Vec::new(),
        },
    };
    let render_req_json = serde_json::to_value(&render_req).expect("encode render request");
    assert_eq!(
        render_req_json
            .get("ctx")
            .and_then(|v| v.get("route"))
            .and_then(|v| v.as_str()),
        Some("/api-preview")
    );

    let render_resp = RenderTemplateResponse {
        meta: render_req.meta.clone(),
        output: zebflow::rwe::RenderOutput {
            html: "<h1>Hello Adapter</h1>".to_string(),
            compiled_scripts: Vec::new(),
            hydration_payload: json!({ "input": { "title": "Hello Adapter" } }),
            trace: vec!["engine=rwe".to_string()],
        },
    };
    let render_resp_json = serde_json::to_string(&render_resp).expect("encode render response");
    assert!(render_resp_json.contains("Hello Adapter"));
}