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

crates/el-aop/src/lib.rs

@@ -0,0 +1,146 @@
+//! el-aop — Aspect-Oriented Programming for el-ui.
+//!
+//! Cross-cutting concerns as first-class language features. Not a library you
+//! import. Built into the framework. Applied as decorators:
+//!
+//! ```text
+//! @authenticate
+//! @authorize(role: "admin")
+//! @cache(ttl: 300)
+//! @rate_limit(requests: 100, per: 60)
+//! component AdminDashboard { ... }
+//! ```
+
+pub mod aspects;
+pub mod chain;
+pub mod registry;
+
+pub use aspects::{
+    AuthenticateAspect, AuthorizeAspect, CacheAspect, LogAspect, RateLimitAspect, RetryAspect,
+    TraceAspect, ValidateAspect,
+};
+pub use chain::AspectChain;
+pub use registry::AspectRegistry;
+
+#[cfg(test)]
+mod tests;
+
+use std::collections::HashMap;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum AopError {
+    #[error("authentication required")]
+    Unauthenticated,
+    #[error("forbidden: requires role '{role}'")]
+    Forbidden { role: String },
+    #[error("rate limit exceeded: {requests} requests per {per}s")]
+    RateLimited { requests: u32, per: u64 },
+    #[error("validation failed: {0}")]
+    ValidationFailed(String),
+    #[error("aspect error: {0}")]
+    Aspect(String),
+    #[error("all {attempts} retry attempts failed: {last_error}")]
+    RetriesExhausted { attempts: u32, last_error: String },
+}
+
+pub type AopResult<T> = Result<T, AopError>;
+
+/// Context passed through the aspect chain.
+///
+/// Contains the incoming arguments and metadata about the call.
+/// Aspects can read and mutate this context as they execute.
+#[derive(Debug, Clone)]
+pub struct InvocationContext {
+    /// The component or service being called.
+    pub target: String,
+    /// The method being called.
+    pub method: String,
+    /// Arguments passed to the method.
+    pub args: HashMap<String, String>,
+    /// Metadata added by aspects (e.g., the authenticated user, trace ID).
+    pub metadata: HashMap<String, String>,
+}
+
+impl InvocationContext {
+    pub fn new(target: impl Into<String>, method: impl Into<String>) -> Self {
+        Self {
+            target: target.into(),
+            method: method.into(),
+            args: HashMap::new(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    pub fn with_arg(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.args.insert(key.into(), value.into());
+        self
+    }
+
+    pub fn with_meta(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.metadata.insert(key.into(), value.into());
+        self
+    }
+
+    pub fn get_meta(&self, key: &str) -> Option<&str> {
+        self.metadata.get(key).map(|s| s.as_str())
+    }
+}
+
+/// The result of invoking a method through an aspect chain.
+#[derive(Debug, Clone)]
+pub struct InvocationResult {
+    pub value: String,
+    pub metadata: HashMap<String, String>,
+}
+
+impl InvocationResult {
+    pub fn new(value: impl Into<String>) -> Self {
+        Self {
+            value: value.into(),
+            metadata: HashMap::new(),
+        }
+    }
+}
+
+/// A handler that performs the actual method invocation.
+/// Aspects wrap around this.
+pub type ProceedFn = Box<dyn Fn(InvocationContext) -> AopResult<InvocationResult> + Send + Sync>;
+
+/// The core Aspect trait.
+///
+/// Each aspect implements `before`, `after`, or `around` advice.
+/// The default implementations are no-ops — only override what you need.
+pub trait Aspect: Send + Sync {
+    /// The aspect's name (used for debugging and registry lookup).
+    fn name(&self) -> &'static str;
+
+    /// Before advice — runs before the method. Can reject the call.
+    fn before(&self, ctx: &mut InvocationContext) -> AopResult<()> {
+        let _ = ctx;
+        Ok(())
+    }
+
+    /// After advice — runs after the method. Receives the result.
+    /// Can modify the result or perform cleanup.
+    fn after(
+        &self,
+        ctx: &InvocationContext,
+        result: AopResult<InvocationResult>,
+    ) -> AopResult<InvocationResult> {
+        let _ = ctx;
+        result
+    }
+
+    /// Around advice — wraps the entire invocation.
+    /// The default implementation calls `before`, then `proceed`, then `after`.
+    fn around(
+        &self,
+        mut ctx: InvocationContext,
+        proceed: &ProceedFn,
+    ) -> AopResult<InvocationResult> {
+        self.before(&mut ctx)?;
+        let result = proceed(ctx.clone());
+        self.after(&ctx, result)
+    }
+}