@@ -6,12 +6,15 @@ use std::sync::Arc;
66use zen_engine:: { DecisionEngine , EvaluationOptions } ;
77
88use crate :: custom_node:: DynamicCustomNode ;
9+ use crate :: custom_node:: ZenCustomNodeResult ;
910use crate :: decision:: { ZenDecision , ZenDecisionStruct } ;
1011use crate :: error:: ZenError ;
1112use 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} ;
1416use crate :: result:: ZenResult ;
17+ use serde_json:: json;
1518
1619pub ( 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]
77103pub 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+ }
0 commit comments