Function js_queue_config_to_rust

sdk/node/src/lib.rs:2097–2136

(config: &SessionQueueConfig)

}

fn js_queue_config_to_rust(config: &SessionQueueConfig) -> napi::Result<RustSessionQueueConfig> {
    let mut c = if config.enable_all_features.unwrap_or(false) {
        RustSessionQueueConfig::default().with_lane_features()
    } else {
        RustSessionQueueConfig::default()
    };
    if let Some(n) = config.query_concurrency {
        c.query_max_concurrency = n as usize;
    }
    if let Some(n) = config.execute_concurrency {
        c.execute_max_concurrency = n as usize;
    }
    if let Some(n) = config.generate_concurrency {
        c.generate_max_concurrency = n as usize;
    }
    if let Some(true) = config.enable_dlq {
        c = c.with_dlq(config.dlq_max_size.map(|n| n as usize));
    }
    if let Some(true) = config.enable_metrics {
        c = c.with_metrics();
    }
    if let Some(true) = config.enable_alerts {
        c = c.with_alerts();
    }
    if let Some(ms) = config.timeout_ms {
        c = c.with_timeout(ms as u64);
    }
    if let Some(ref handlers) = config.lane_handlers {
        for (lane_str, handler) in handlers {
            let lane = parse_lane(lane_str)?;
            let mode = parse_handler_mode(&handler.mode)?;
            let lane_cfg = RustLaneHandlerConfig {
                mode,
                timeout_ms: handler.timeout_ms.map(|ms| ms as u64).unwrap_or(60_000),
            };
            c.lane_handlers.insert(lane, lane_cfg);
        }
    }
    Ok(c)
}

fn parse_lane(lane: &str) -> napi::Result<RustSessionLane> {
    match lane.trim().to_ascii_lowercase().as_str() {