Skip to content

Commit 1818371

Browse files
feat: implement new loaders across languages (#487)
1 parent fe4790b commit 1818371

19 files changed

Lines changed: 938 additions & 43 deletions

File tree

‎Cargo.lock‎

Lines changed: 1 addition & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎bindings/c/Cargo.toml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ serde = { workspace = true }
1212
serde_json = { workspace = true }
1313
strum = { workspace = true, features = ["derive"] }
1414
tokio = { workspace = true, features = ["rt"] }
15+
tokio-util = { workspace = true, features = ["rt"] }
1516
zen-engine = { path = "../../core/engine", features = ["arbitrary_precision"] }
1617
zen-expression = { path = "../../core/expression", features = ["arbitrary_precision"] }
1718
zen-tmpl = { path = "../../core/template" }

‎bindings/c/build.rs‎

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,17 @@ use std::env;
33
fn main() {
44
let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
55

6+
let config = cbindgen::Config {
7+
language: cbindgen::Language::C,
8+
enumeration: cbindgen::EnumConfig {
9+
prefix_with_name: true,
10+
..Default::default()
11+
},
12+
..Default::default()
13+
};
14+
615
cbindgen::Builder::new()
7-
.with_language(cbindgen::Language::C)
16+
.with_config(config)
817
.with_crate(crate_dir)
918
.generate()
1019
.expect("Unable to generate bindings")

‎bindings/c/src/engine.rs‎

Lines changed: 268 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,15 @@ use std::sync::Arc;
66
use zen_engine::{DecisionEngine, EvaluationOptions};
77

88
use crate::custom_node::DynamicCustomNode;
9+
use crate::custom_node::ZenCustomNodeResult;
910
use crate::decision::{ZenDecision, ZenDecisionStruct};
1011
use crate::error::ZenError;
1112
use crate::helper::safe_str_from_ptr;
12-
use crate::loader::DynamicDecisionLoader;
13-
use crate::mt::tokio_runtime;
13+
use crate::languages::native::NativeCustomNode;
14+
use crate::loader::{DynamicDecisionLoader, ZenEngineLoaderConfig};
15+
use crate::mt::{tokio_runtime, worker_pool};
1416
use crate::result::ZenResult;
17+
use serde_json::json;
1518

1619
pub(crate) struct ZenEngine(DecisionEngine);
1720

@@ -72,6 +75,29 @@ pub extern "C" fn zen_engine_new() -> *mut ZenEngineStruct {
7275
Box::into_raw(Box::new(ZenEngine::default())) as *mut ZenEngineStruct
7376
}
7477

78+
/// Creates a new ZenEngine instance from a loader configuration, caller is responsible for
79+
/// freeing the returned reference by calling zen_engine_free.
80+
#[no_mangle]
81+
pub extern "C" fn zen_engine_new_with_loader_config(
82+
config: ZenEngineLoaderConfig,
83+
maybe_custom_node: Option<extern "C" fn(request: *const c_char) -> ZenCustomNodeResult>,
84+
) -> ZenResult<ZenEngineStruct> {
85+
let loader = match config.to_dynamic_loader() {
86+
Ok(loader) => loader,
87+
Err(error) => return ZenResult::error(error),
88+
};
89+
90+
let custom_node = match maybe_custom_node {
91+
Some(callback) => DynamicCustomNode::Native(NativeCustomNode::new(callback)),
92+
None => DynamicCustomNode::default(),
93+
};
94+
95+
let engine = ZenEngine::new(DynamicDecisionLoader::Config(loader), custom_node);
96+
engine.compile();
97+
98+
ZenResult::ok(Box::into_raw(Box::new(engine)) as *mut ZenEngineStruct)
99+
}
100+
75101
/// Frees the ZenEngine instance reference from the memory
76102
#[no_mangle]
77103
pub extern "C" fn zen_engine_free(engine: *mut ZenEngineStruct) {
@@ -148,6 +174,102 @@ pub extern "C" fn zen_engine_evaluate(
148174
ZenResult::ok(cstring_result.into_raw())
149175
}
150176

177+
#[repr(C)]
178+
pub struct ZenEngineEvaluateBatchRequest {
179+
key: *const c_char,
180+
context: *const c_char,
181+
}
182+
183+
enum BatchTask {
184+
Failed(serde_json::Value),
185+
Pending(tokio::task::JoinHandle<Result<serde_json::Value, serde_json::Value>>),
186+
}
187+
188+
/// Evaluates a batch of requests in parallel using a DecisionEngine reference via loader.
189+
/// Returns a JSON array of { success, data?, error? } envelopes in request order.
190+
/// Caller is responsible for freeing: requests and ZenResult.
191+
#[no_mangle]
192+
pub extern "C" fn zen_engine_evaluate_batch(
193+
engine: *const ZenEngineStruct,
194+
requests: *const ZenEngineEvaluateBatchRequest,
195+
requests_len: usize,
196+
options: ZenEngineEvaluationOptions,
197+
) -> ZenResult<c_char> {
198+
if engine.is_null() || (requests.is_null() && requests_len > 0) {
199+
return ZenResult::error(ZenError::InvalidArgument);
200+
}
201+
202+
let request_slice = match requests_len {
203+
0 => &[],
204+
_ => unsafe { std::slice::from_raw_parts(requests, requests_len) },
205+
};
206+
207+
let mut parsed: Vec<(String, Result<Value, String>)> = Vec::with_capacity(requests_len);
208+
for request in request_slice {
209+
let Some(key) = safe_str_from_ptr(request.key) else {
210+
return ZenResult::error(ZenError::InvalidArgument);
211+
};
212+
213+
if request.context.is_null() {
214+
return ZenResult::error(ZenError::InvalidArgument);
215+
}
216+
217+
let cstr_context = unsafe { CStr::from_ptr(request.context) };
218+
let context =
219+
serde_json::from_slice::<Value>(cstr_context.to_bytes()).map_err(|e| e.to_string());
220+
parsed.push((key.to_string(), context));
221+
}
222+
223+
let zen_engine = unsafe { &*(engine as *const ZenEngine) };
224+
let decision_engine: DecisionEngine = DecisionEngine::clone(zen_engine);
225+
let eval_options: EvaluationOptions = options.into();
226+
227+
let pool = worker_pool();
228+
let tasks: Vec<BatchTask> = parsed
229+
.into_iter()
230+
.map(|(key, context)| match context {
231+
Err(message) => BatchTask::Failed(json!(format!("invalid context: {message}"))),
232+
Ok(value) => {
233+
let engine = decision_engine.clone();
234+
BatchTask::Pending(pool.spawn_pinned(move || async move {
235+
engine
236+
.evaluate_with_opts(key, value.into(), eval_options)
237+
.await
238+
.map(|response| serde_json::to_value(&response).unwrap_or(Value::Null))
239+
.map_err(|e| {
240+
serde_json::to_value(&e).unwrap_or_else(|_| json!(e.to_string()))
241+
})
242+
}))
243+
}
244+
})
245+
.collect();
246+
247+
let results = tokio_runtime().block_on(async move {
248+
let mut items = Vec::with_capacity(tasks.len());
249+
for task in tasks {
250+
let item = match task {
251+
BatchTask::Failed(error) => json!({ "success": false, "error": error }),
252+
BatchTask::Pending(handle) => match handle.await {
253+
Ok(Ok(data)) => json!({ "success": true, "data": data }),
254+
Ok(Err(error)) => json!({ "success": false, "error": error }),
255+
Err(_) => {
256+
json!({ "success": false, "error": "evaluation worker panicked" })
257+
}
258+
},
259+
};
260+
items.push(item);
261+
}
262+
Value::Array(items)
263+
});
264+
265+
let Ok(serialized_results) = serde_json::to_string(&results) else {
266+
return ZenResult::error(ZenError::JsonSerializationFailed);
267+
};
268+
269+
let cstring_result = unsafe { CString::from_vec_unchecked(serialized_results.into_bytes()) };
270+
ZenResult::ok(cstring_result.into_raw())
271+
}
272+
151273
/// Loads a Decision through DecisionEngine
152274
/// Caller is responsible for freeing: key and ZenResult.
153275
#[no_mangle]
@@ -174,3 +296,147 @@ pub extern "C" fn zen_engine_get_decision(
174296
let zen_decision = ZenDecision::from(decision);
175297
ZenResult::ok(Box::into_raw(Box::new(zen_decision)) as *mut ZenDecisionStruct)
176298
}
299+
300+
#[cfg(test)]
301+
mod tests {
302+
use super::*;
303+
use crate::error::ZenErrorDiscriminants;
304+
use crate::loader::ZenLoaderConfigKind;
305+
use std::ffi::CString;
306+
use std::ptr::null;
307+
308+
fn evaluate_table(engine: *mut ZenEngineStruct) -> Value {
309+
let key = CString::new("table.json").unwrap();
310+
let context = CString::new(r#"{"input":12}"#).unwrap();
311+
let result = zen_engine_evaluate(
312+
engine,
313+
key.as_ptr(),
314+
context.as_ptr(),
315+
ZenEngineEvaluationOptions {
316+
trace: false,
317+
max_depth: 5,
318+
},
319+
);
320+
321+
assert_eq!(result.error_code(), 0);
322+
let response = unsafe { CString::from_raw(result.result_ptr()) };
323+
serde_json::from_slice(response.to_bytes()).unwrap()
324+
}
325+
326+
#[test]
327+
fn engine_from_static_loader_config() {
328+
let content = CString::new(format!(
329+
r#"{{"table.json": {}}}"#,
330+
include_str!("../../../test-data/table.json")
331+
))
332+
.unwrap();
333+
334+
let config = ZenEngineLoaderConfig {
335+
kind: ZenLoaderConfigKind::Static,
336+
content: content.as_ptr(),
337+
bytes: null(),
338+
bytes_len: 0,
339+
};
340+
341+
let result = zen_engine_new_with_loader_config(config, None);
342+
assert_eq!(result.error_code(), 0);
343+
344+
let engine = result.result_ptr();
345+
let response = evaluate_table(engine);
346+
assert_eq!(response["result"]["output"], serde_json::json!(10));
347+
348+
zen_engine_free(engine);
349+
}
350+
351+
#[test]
352+
fn engine_from_fs_loader_config() {
353+
let path = CString::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../test-data")).unwrap();
354+
355+
let config = ZenEngineLoaderConfig {
356+
kind: ZenLoaderConfigKind::Filesystem,
357+
content: path.as_ptr(),
358+
bytes: null(),
359+
bytes_len: 0,
360+
};
361+
362+
let result = zen_engine_new_with_loader_config(config, None);
363+
assert_eq!(result.error_code(), 0);
364+
365+
let engine = result.result_ptr();
366+
let response = evaluate_table(engine);
367+
assert_eq!(response["result"]["output"], serde_json::json!(10));
368+
369+
zen_engine_free(engine);
370+
}
371+
372+
#[test]
373+
fn engine_evaluate_batch_mixed_results() {
374+
let path = CString::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../test-data")).unwrap();
375+
let config = ZenEngineLoaderConfig {
376+
kind: ZenLoaderConfigKind::Filesystem,
377+
content: path.as_ptr(),
378+
bytes: null(),
379+
bytes_len: 0,
380+
};
381+
let engine = zen_engine_new_with_loader_config(config, None).result_ptr();
382+
383+
let keys = [
384+
CString::new("table.json").unwrap(),
385+
CString::new("missing.json").unwrap(),
386+
CString::new("table.json").unwrap(),
387+
];
388+
let contexts = [
389+
CString::new(r#"{"input":12}"#).unwrap(),
390+
CString::new(r#"{}"#).unwrap(),
391+
CString::new(r#"{"input":5}"#).unwrap(),
392+
];
393+
let requests: Vec<ZenEngineEvaluateBatchRequest> = keys
394+
.iter()
395+
.zip(contexts.iter())
396+
.map(|(key, context)| ZenEngineEvaluateBatchRequest {
397+
key: key.as_ptr(),
398+
context: context.as_ptr(),
399+
})
400+
.collect();
401+
402+
let result = zen_engine_evaluate_batch(
403+
engine,
404+
requests.as_ptr(),
405+
requests.len(),
406+
ZenEngineEvaluationOptions {
407+
trace: false,
408+
max_depth: 5,
409+
},
410+
);
411+
412+
assert_eq!(result.error_code(), 0);
413+
let response = unsafe { CString::from_raw(result.result_ptr()) };
414+
let items: Value = serde_json::from_slice(response.to_bytes()).unwrap();
415+
416+
assert_eq!(items[0]["success"], serde_json::json!(true));
417+
assert_eq!(items[0]["data"]["result"]["output"], serde_json::json!(10));
418+
assert_eq!(items[1]["success"], serde_json::json!(false));
419+
assert_eq!(items[2]["success"], serde_json::json!(true));
420+
assert_eq!(items[2]["data"]["result"]["output"], serde_json::json!(0));
421+
422+
zen_engine_free(engine);
423+
}
424+
425+
#[test]
426+
fn engine_from_invalid_zip_loader_config() {
427+
let bytes = [0u8; 4];
428+
let config = ZenEngineLoaderConfig {
429+
kind: ZenLoaderConfigKind::Zip,
430+
content: null(),
431+
bytes: bytes.as_ptr(),
432+
bytes_len: bytes.len(),
433+
};
434+
435+
let result = zen_engine_new_with_loader_config(config, None);
436+
assert_eq!(
437+
result.error_code(),
438+
ZenErrorDiscriminants::LoaderConfigError as u8
439+
);
440+
assert!(result.result_ptr().is_null());
441+
}
442+
}

‎bindings/c/src/error.rs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,8 @@ pub enum ZenError {
2121
LoaderInternalError { key: String, message: String },
2222

2323
TemplateEngineError { template: String, message: String },
24+
25+
LoaderConfigError { message: String },
2426
}
2527

2628
impl ZenError {
@@ -35,6 +37,9 @@ impl ZenError {
3537
ZenError::TemplateEngineError { template, message } => {
3638
Some(json!({ "template": template, "message": message }).to_string())
3739
}
40+
ZenError::LoaderConfigError { message } => {
41+
Some(json!({ "message": message }).to_string())
42+
}
3843
_ => None,
3944
}
4045
}

‎bindings/c/src/languages/go.rs‎

Lines changed: 23 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
use crate::custom_node::{DynamicCustomNode, ZenCustomNodeResult};
22
use crate::engine::{ZenEngine, ZenEngineStruct};
3-
use crate::loader::{DynamicDecisionLoader, ZenDecisionLoaderResult};
3+
use crate::loader::{DynamicDecisionLoader, ZenDecisionLoaderResult, ZenEngineLoaderConfig};
4+
use crate::result::ZenResult;
45
use std::ffi::{c_char, CString};
56
use std::future::Future;
67
use std::pin::Pin;
@@ -103,6 +104,27 @@ pub extern "C" fn zen_engine_new_golang(
103104
Box::into_raw(Box::new(engine)) as *mut ZenEngineStruct
104105
}
105106

107+
/// Creates a DecisionEngine from a loader configuration using GoLang handler (optional). Caller is responsible for freeing DecisionEngine.
108+
#[no_mangle]
109+
pub extern "C" fn zen_engine_new_golang_with_loader_config(
110+
config: ZenEngineLoaderConfig,
111+
maybe_custom_node: Option<&usize>,
112+
) -> ZenResult<ZenEngineStruct> {
113+
let loader = match config.to_dynamic_loader() {
114+
Ok(loader) => loader,
115+
Err(error) => return ZenResult::error(error),
116+
};
117+
118+
let custom_node = GoCustomNode::new(map_handler(maybe_custom_node.cloned()));
119+
let engine = ZenEngine::new(
120+
DynamicDecisionLoader::Config(loader),
121+
DynamicCustomNode::Go(custom_node),
122+
);
123+
engine.compile();
124+
125+
ZenResult::ok(Box::into_raw(Box::new(engine)) as *mut ZenEngineStruct)
126+
}
127+
106128
#[allow(unused_doc_comments)]
107129
/// cbindgen:ignore
108130
extern "C" {

0 commit comments

Comments
 (0)