el-ui v2: universal platform, service bindings, AOP, auth, publish pipeline

ui/crates/el-aop/src/registry.rs

@@ -0,0 +1,149 @@
+//! Aspect registry — register built-in and custom aspects by name.
+//!
+//! The compiler's AOP codegen uses the registry to look up aspect implementations
+//! by their decorator name (e.g., `"authenticate"` → `AuthenticateAspect`).
+
+use crate::Aspect;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+type AspectFactory = Box<dyn Fn(&HashMap<String, String>) -> Arc<dyn Aspect> + Send + Sync>;
+
+/// Registry of aspect factories, indexed by decorator name.
+pub struct AspectRegistry {
+    factories: RwLock<HashMap<String, AspectFactory>>,
+}
+
+impl AspectRegistry {
+    pub fn new() -> Self {
+        Self {
+            factories: RwLock::new(HashMap::new()),
+        }
+    }
+
+    /// Create a registry with all built-in aspects registered.
+    pub fn with_builtins() -> Self {
+        let registry = Self::new();
+        registry.register_builtins();
+        registry
+    }
+
+    /// Register all built-in aspects.
+    pub fn register_builtins(&self) {
+        use crate::aspects::*;
+
+        self.register("authenticate", |_params| {
+            Arc::new(AuthenticateAspect)
+        });
+
+        self.register("authorize", |params| {
+            let role = params
+                .get("role")
+                .cloned()
+                .unwrap_or_else(|| "user".to_string());
+            Arc::new(AuthorizeAspect::new(role))
+        });
+
+        self.register("cache", |params| {
+            let ttl: u64 = params
+                .get("ttl")
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(300);
+            Arc::new(CacheAspect::new(ttl))
+        });
+
+        self.register("rate_limit", |params| {
+            let requests: u32 = params
+                .get("requests")
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(100);
+            let per: u64 = params
+                .get("per")
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(60);
+            Arc::new(RateLimitAspect::new(requests, per))
+        });
+
+        self.register("log", |params| {
+            let level = params
+                .get("level")
+                .cloned()
+                .unwrap_or_else(|| "info".to_string());
+            Arc::new(LogAspect::new(level))
+        });
+
+        self.register("validate", |_params| Arc::new(ValidateAspect::new()));
+
+        self.register("retry", |params| {
+            let attempts: u32 = params
+                .get("attempts")
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(3);
+            let backoff = params
+                .get("backoff")
+                .map(|s| s.as_str())
+                .unwrap_or("none");
+            let aspect = RetryAspect::new(attempts);
+            let aspect = match backoff {
+                "exponential" => aspect.with_exponential_backoff(100),
+                "fixed" => aspect.with_fixed_backoff(500),
+                _ => aspect,
+            };
+            Arc::new(aspect)
+        });
+
+        self.register("trace", |params| {
+            let service = params
+                .get("service")
+                .cloned()
+                .unwrap_or_else(|| "el-ui".to_string());
+            Arc::new(TraceAspect::new(service))
+        });
+    }
+
+    /// Register a custom aspect factory.
+    pub fn register(
+        &self,
+        name: &str,
+        factory: impl Fn(&HashMap<String, String>) -> Arc<dyn Aspect> + Send + Sync + 'static,
+    ) {
+        self.factories
+            .write()
+            .expect("registry lock poisoned")
+            .insert(name.to_string(), Box::new(factory));
+    }
+
+    /// Instantiate an aspect by decorator name with the given params.
+    pub fn create(
+        &self,
+        name: &str,
+        params: &HashMap<String, String>,
+    ) -> Option<Arc<dyn Aspect>> {
+        let factories = self.factories.read().expect("registry lock poisoned");
+        factories.get(name).map(|f| f(params))
+    }
+
+    /// List all registered aspect names.
+    pub fn aspect_names(&self) -> Vec<String> {
+        self.factories
+            .read()
+            .expect("registry lock poisoned")
+            .keys()
+            .cloned()
+            .collect()
+    }
+
+    /// Check if an aspect name is registered.
+    pub fn contains(&self, name: &str) -> bool {
+        self.factories
+            .read()
+            .expect("registry lock poisoned")
+            .contains_key(name)
+    }
+}
+
+impl Default for AspectRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}