Skip to main content

alef_adapters/
lib.rs

1//! Adapter layer for connecting language-specific patterns to alef's backend trait.
2//! Handles callback bridges and custom registrations.
3
4pub mod async_method;
5pub mod callback_bridge;
6pub mod streaming;
7pub mod sync_function;
8
9use ahash::AHashMap;
10use alef_core::config::{AdapterPattern, AlefConfig, Language};
11
12/// Key: "TypeName.method_name" for methods, "function_name" for free functions.
13/// For streaming adapters, an additional entry "ItemType.__stream_struct__" holds
14/// the iterator struct definition.
15pub type AdapterBodies = AHashMap<String, String>;
16
17/// Build a map of adapter-generated method/function bodies for a language.
18pub fn build_adapter_bodies(config: &AlefConfig, language: Language) -> anyhow::Result<AdapterBodies> {
19    let mut bodies = AHashMap::new();
20
21    for adapter in &config.adapters {
22        let key = if let Some(owner) = &adapter.owner_type {
23            format!("{}.{}", owner, adapter.name)
24        } else {
25            adapter.name.clone()
26        };
27
28        match adapter.pattern {
29            AdapterPattern::SyncFunction => {
30                let body = sync_function::generate_body(adapter, language, config)?;
31                bodies.insert(key, body);
32            }
33            AdapterPattern::AsyncMethod => {
34                let body = async_method::generate_body(adapter, language, config)?;
35                bodies.insert(key, body);
36            }
37            AdapterPattern::Streaming => {
38                let (method_body, struct_def) = streaming::generate_body(adapter, language, config)?;
39                bodies.insert(key, method_body);
40                if let Some(struct_code) = struct_def {
41                    let item_type = adapter.item_type.as_deref().unwrap_or("");
42                    let struct_key = format!("{}.__stream_struct__", item_type);
43                    bodies.insert(struct_key, struct_code);
44                }
45            }
46            AdapterPattern::CallbackBridge => {
47                let (struct_code, impl_code) = callback_bridge::generate(adapter, language, config)?;
48                let struct_key = format!("{}.__bridge_struct__", adapter.name);
49                bodies.insert(struct_key, struct_code);
50                let impl_key = format!("{}.__bridge_impl__", adapter.name);
51                bodies.insert(impl_key, impl_code);
52                continue; // Don't insert into the normal body map
53            }
54            AdapterPattern::ServerLifecycle => {
55                let body = format!(
56                    "compile_error!(\"adapter pattern not yet implemented: {}\")",
57                    adapter.name
58                );
59                bodies.insert(key, body);
60            }
61        }
62    }
63
64    Ok(bodies)
65}