aura_composition/adapters/
console.rs

1//! Console handler adapter
2
3use crate::adapters::collect_ops;
4use crate::adapters::utils::deserialize_operation_params;
5use crate::registry::{HandlerContext, HandlerError, RegistrableHandler};
6use async_trait::async_trait;
7use aura_core::effects::ConsoleEffects;
8use aura_core::{EffectType, ExecutionMode};
9use aura_effects::console::RealConsoleHandler;
10
11/// Adapter for RealConsoleHandler
12pub struct ConsoleHandlerAdapter {
13    handler: RealConsoleHandler,
14}
15
16impl ConsoleHandlerAdapter {
17    pub fn new(handler: RealConsoleHandler) -> Self {
18        Self { handler }
19    }
20}
21
22#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
23#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
24impl RegistrableHandler for ConsoleHandlerAdapter {
25    async fn execute_operation_bytes(
26        &self,
27        effect_type: EffectType,
28        operation: &str,
29        parameters: &[u8],
30        _ctx: &HandlerContext,
31    ) -> Result<Vec<u8>, HandlerError> {
32        if effect_type != EffectType::Console {
33            return Err(HandlerError::UnsupportedEffect { effect_type });
34        }
35
36        match operation {
37            "log_info" => {
38                let message = decode_console_message(effect_type, operation, parameters)?;
39                self.handler.log_info(&message).await.map_err(|e| {
40                    HandlerError::ExecutionFailed {
41                        source: Box::new(e),
42                    }
43                })?;
44                Ok(Vec::new()) // Console operations return void
45            }
46            "log_warn" => {
47                let message = decode_console_message(effect_type, operation, parameters)?;
48                self.handler.log_warn(&message).await.map_err(|e| {
49                    HandlerError::ExecutionFailed {
50                        source: Box::new(e),
51                    }
52                })?;
53                Ok(Vec::new())
54            }
55            "log_error" => {
56                let message = decode_console_message(effect_type, operation, parameters)?;
57                self.handler.log_error(&message).await.map_err(|e| {
58                    HandlerError::ExecutionFailed {
59                        source: Box::new(e),
60                    }
61                })?;
62                Ok(Vec::new())
63            }
64            "log_debug" => {
65                let message = decode_console_message(effect_type, operation, parameters)?;
66                self.handler.log_debug(&message).await.map_err(|e| {
67                    HandlerError::ExecutionFailed {
68                        source: Box::new(e),
69                    }
70                })?;
71                Ok(Vec::new())
72            }
73            _ => Err(HandlerError::UnknownOperation {
74                effect_type,
75                operation: operation.to_string(),
76            }),
77        }
78    }
79
80    fn supported_operations(&self, effect_type: EffectType) -> Vec<String> {
81        collect_ops(effect_type, false) // Console has no extended operations
82    }
83
84    fn supports_effect(&self, effect_type: EffectType) -> bool {
85        effect_type == EffectType::Console
86    }
87
88    fn execution_mode(&self) -> ExecutionMode {
89        ExecutionMode::Production
90    }
91}
92
93fn decode_console_message(
94    effect_type: EffectType,
95    operation: &str,
96    parameters: &[u8],
97) -> Result<String, HandlerError> {
98    match deserialize_operation_params(effect_type, operation, parameters) {
99        Ok(message) => Ok(message),
100        Err(_) => String::from_utf8(parameters.to_vec()).map_err(|e| {
101            HandlerError::EffectDeserialization {
102                effect_type,
103                operation: operation.to_string(),
104                source: Box::new(e),
105            }
106        }),
107    }
108}
aura_composition/adapters/console.rs

aura_composition/adapters/
console.rs
