mf_engine/handler/function/module/
zen.rs

1use std::future::Future;
2use std::pin::Pin;
3use std::sync::Arc;
4
5use crate::handler::custom_node_adapter::CustomNodeAdapter;
6use crate::handler::function::error::{FunctionResult, ResultExt};
7use crate::handler::function::listener::{RuntimeEvent, RuntimeListener};
8use crate::handler::function::module::export_default;
9use crate::handler::function::serde::JsValue;
10use crate::handler::graph::{DecisionGraph, DecisionGraphConfig};
11use crate::loader::DecisionLoader;
12use rquickjs::module::{Declarations, Exports, ModuleDef};
13use rquickjs::prelude::{Async, Func, Opt};
14use rquickjs::{CatchResultExt, Ctx, Function, Object};
15
16pub struct ZenListener<Loader, Adapter> {
17    pub loader: Arc<Loader>,
18    pub adapter: Arc<Adapter>,
19}
20
21impl<Loader: DecisionLoader + 'static, Adapter: CustomNodeAdapter + 'static>
22    RuntimeListener for ZenListener<Loader, Adapter>
23{
24    fn on_event<'js>(
25        &self,
26        ctx: Ctx<'js>,
27        event: RuntimeEvent,
28    ) -> Pin<Box<dyn Future<Output = FunctionResult> + 'js>> {
29        let loader = self.loader.clone();
30        let adapter = self.adapter.clone();
31
32        Box::pin(async move {
33            if event != RuntimeEvent::Startup {
34                return Ok(());
35            };
36
37            ctx.globals()
38                .set(
39                    "__evaluate",
40                    Func::from(Async(
41                        move |ctx: Ctx<'js>,
42                              key: String,
43                              context: JsValue,
44                              opts: Opt<Object<'js>>| {
45                            let loader = loader.clone();
46                            let adapter = adapter.clone();
47
48                            async move {
49                                let config: Object = ctx
50                                    .globals()
51                                    .get("config")
52                                    .or_throw(&ctx)?;
53
54                                let iteration: u8 =
55                                    config.get("iteration").or_throw(&ctx)?;
56                                let max_depth: u8 =
57                                    config.get("maxDepth").or_throw(&ctx)?;
58                                let trace = opts
59                                    .0
60                                    .map(|opt| {
61                                        opt.get::<_, bool>("trace")
62                                            .unwrap_or_default()
63                                    })
64                                    .unwrap_or_default();
65
66                                let load_result =
67                                    loader.load(key.as_str()).await;
68                                let decision_content =
69                                    load_result.or_throw(&ctx)?;
70                                let mut sub_tree = DecisionGraph::try_new(
71                                    DecisionGraphConfig {
72                                        content: decision_content,
73                                        max_depth,
74                                        loader,
75                                        adapter,
76                                        iteration: iteration + 1,
77                                        trace,
78                                        validator_cache: None,
79                                    },
80                                )
81                                .or_throw(&ctx)?;
82
83                                let response = sub_tree
84                                    .evaluate(context.0)
85                                    .await
86                                    .or_throw(&ctx)?;
87                                let k = serde_json::to_value(response)
88                                    .or_throw(&ctx)?
89                                    .into();
90
91                                return rquickjs::Result::Ok(JsValue(k));
92                            }
93                        },
94                    )),
95                )
96                .catch(&ctx)?;
97
98            Ok(())
99        })
100    }
101}
102
103fn evaluate_expression<'js>(
104    ctx: Ctx<'js>,
105    expression: String,
106    context: JsValue,
107) -> rquickjs::Result<JsValue> {
108    let s = mf_expression::evaluate_expression(expression.as_str(), context.0)
109        .or_throw(&ctx)?;
110
111    Ok(JsValue(s))
112}
113
114fn evaluate_unary_expression<'js>(
115    ctx: Ctx<'js>,
116    expression: String,
117    context: JsValue,
118) -> rquickjs::Result<bool> {
119    let s = mf_expression::evaluate_unary_expression(
120        expression.as_str(),
121        context.0,
122    )
123    .or_throw(&ctx)?;
124
125    Ok(s)
126}
127
128fn evaluate<'js>(
129    ctx: Ctx<'js>,
130    key: String,
131    context: JsValue,
132    opts: Opt<Object<'js>>,
133) -> rquickjs::Result<rquickjs::Value<'js>> {
134    let s: Function = ctx.globals().get("__evaluate").or_throw(&ctx)?;
135    let result: rquickjs::Value =
136        s.call((key, context, opts)).or_throw(&ctx)?;
137    Ok(result)
138}
139
140pub struct ZenModule;
141
142impl ModuleDef for ZenModule {
143    fn declare<'js>(decl: &Declarations<'js>) -> rquickjs::Result<()> {
144        decl.declare("evaluateExpression")?;
145        decl.declare("evaluateUnaryExpression")?;
146        decl.declare("evaluate")?;
147
148        decl.declare("default")?;
149
150        Ok(())
151    }
152
153    fn evaluate<'js>(
154        ctx: &Ctx<'js>,
155        exports: &Exports<'js>,
156    ) -> rquickjs::Result<()> {
157        export_default(ctx, exports, |default| {
158            default
159                .set("evaluateExpression", Func::from(evaluate_expression))?;
160            default.set(
161                "evaluateUnaryExpression",
162                Func::from(evaluate_unary_expression),
163            )?;
164            default.set("evaluate", Func::from(evaluate))?;
165
166            Ok(())
167        })
168    }
169}
mf_engine/handler/function/module/zen.rs

mf_engine/handler/function/module/
zen.rs
