arcly_http_core/core/

engine.rs

//! Lock-free DI engine + macro registration descriptors.
//!
//! Two-phase lifecycle:
//!
//! 1. **Boot.** `DiContainerBuilder` collects [`ProviderDescriptor`]s emitted
//!    by `#[Injectable]` / `#[Module]`. It topologically sorts them by
//!    `TypeId` dependency edges, detects cycles deterministically, then
//!    invokes each provider's `build` function in dependency order. The
//!    build function receives a `Resolver` view of already-constructed
//!    singletons.
//!
//! 2. **Run.** The container is wrapped in an `Arc<FrozenDiContainer>` shared
//!    by the router, request contexts, gateways, and plugin tasks. Every read
//!    is a single `HashMap::get` + downcast, both inlined. Zero locks, zero
//!    heap allocations on the request path (`Arc::clone` is an atomic bump).
//!    The container drops when the server stops — no per-launch leak.

use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::sync::Arc;

pub type AnyProvider = Arc<dyn Any + Send + Sync>;

/// Build-time resolver passed to each provider's `build` fn. Returns the
/// already-constructed dependency by `TypeId`. Panics if a dependency hasn't
/// been built yet — topological order guarantees this can't happen for a
/// well-formed graph.
pub struct Resolver<'a> {
    map: &'a HashMap<TypeId, AnyProvider>,
}

impl<'a> Resolver<'a> {
    /// Look up a raw provider by `TypeId`. Hidden from user-facing docs; prefer
    /// the typed `get<T>()` accessor.
    #[doc(hidden)]
    #[inline]
    pub fn get_any(&self, ty: TypeId) -> Option<&'a AnyProvider> {
        self.map.get(&ty)
    }

    /// Resolve a singleton by type as an owned `Arc<T>`.
    ///
    /// Clones the `Arc` already held in the resolved map and downcasts it — a
    /// single atomic refcount bump, fully safe (no lifetime laundering). Used
    /// by macro-generated `__arcly_build` fns to populate `Inject<T>` fields.
    /// Panics if the dependency hasn't been built yet — topological order
    /// guarantees this can't happen for a well-formed graph.
    #[doc(hidden)]
    #[inline]
    pub fn get<T: Send + Sync + 'static>(&self) -> Arc<T> {
        self.map
            .get(&TypeId::of::<T>())
            .cloned()
            .and_then(|a| a.downcast::<T>().ok())
            .expect("Arcly DI: dependency requested by a provider was not in the resolved set")
    }
}

/// One row in the dependency graph.
///
/// `deps_fn` returns the declared dependency `TypeId`s. (We use a function
/// pointer rather than a `&'static [TypeId]` because `TypeId::of` is not
/// const on stable.)
pub struct ProviderDescriptor {
    pub name: &'static str,
    pub type_id_fn: fn() -> TypeId,
    pub deps_fn: fn() -> Vec<TypeId>,
    pub build: fn(&Resolver<'_>) -> AnyProvider,
}

/// Emitted by `#[Module]`. Owns its providers, the controllers it exposes,
/// and the imports it pulls in. Used to walk the module DAG at boot.
pub struct ModuleDescriptor {
    pub name: &'static str,
    pub providers: &'static [&'static ProviderDescriptor],
    /// Names of controllers (type idents) belonging to this module. Routes
    /// emitted under these controllers are eligible to mount when this
    /// module is reachable from the root.
    pub controllers: &'static [&'static str],
    /// Submodules to walk transitively. Empty array means "leaf module".
    pub imports: &'static [fn() -> &'static ModuleDescriptor],
    /// Names of real-time gateways (type idents) belonging to this module.
    /// Gateways emitted under these names mount their WebSocket route only
    /// when the owning module is reachable from the root — same encapsulation
    /// rule as controllers.
    pub gateways: &'static [&'static str],
}

/// Implemented by every `#[Module]`-annotated struct so `App::launch::<RootMod>`
/// can find the entry point without a runtime registry lookup.
pub trait Module: 'static {
    fn descriptor() -> &'static ModuleDescriptor;
}

/// Mutable builder used only during boot.
#[derive(Default)]
pub struct DiContainerBuilder {
    providers: Vec<&'static ProviderDescriptor>,
    /// Direct-registered singletons (legacy / hand-wired). Always treated as
    /// dep-less and appended at the front of the build order.
    direct: HashMap<TypeId, AnyProvider>,
    /// Type names of direct registrations, for collision diagnostics.
    direct_names: HashMap<TypeId, &'static str>,
    /// Types whose `#[Injectable]` descriptor is deliberately replaced by a
    /// direct registration (`register_override`). Their descriptors are
    /// dropped before the topological sort.
    overridden: std::collections::HashSet<TypeId>,
}

impl DiContainerBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    /// Register a fully-constructed singleton. Useful for primitives and
    /// configuration values that aren't `#[Injectable]`.
    ///
    /// If an `#[Injectable]` provider for the same type also exists, `freeze`
    /// panics — a silent winner would mask which instance the app runs with.
    /// Use [`register_override`](Self::register_override) to intentionally
    /// replace a descriptor-built provider.
    #[inline]
    pub fn register<T: Send + Sync + 'static>(&mut self, v: T) -> &mut Self {
        self.direct.insert(TypeId::of::<T>(), Arc::new(v));
        self.direct_names
            .insert(TypeId::of::<T>(), std::any::type_name::<T>());
        self
    }

    /// Register a singleton that *replaces* any `#[Injectable]` provider of
    /// the same type. The descriptor is discarded; everything that depends on
    /// `T` resolves to this instance. Intended for plugins swapping a core
    /// service (e.g. a custom `SessionStore`) — explicit, not accidental.
    #[inline]
    pub fn register_override<T: Send + Sync + 'static>(&mut self, v: T) -> &mut Self {
        self.overridden.insert(TypeId::of::<T>());
        self.register(v)
    }

    /// Register a provider descriptor (emitted by `#[Injectable]`).
    #[inline]
    pub fn add_provider(&mut self, d: &'static ProviderDescriptor) -> &mut Self {
        self.providers.push(d);
        self
    }

    /// Run topological sort, detect cycles, build providers in dependency
    /// order, then hand back a shared `Arc<FrozenDiContainer>`.
    ///
    /// The container is reference-counted rather than `Box::leak`-ed: it lives
    /// exactly as long as the running server holds a clone (router state,
    /// request contexts, gateway runtimes, plugin background tasks) and is
    /// dropped when `App::launch_on_listener` returns — so repeatedly launching
    /// in one process (tests) no longer accumulates leaked containers.
    ///
    /// Panics if a direct registration collides with an `#[Injectable]`
    /// descriptor without an explicit override — previously the descriptor
    /// silently won, which made plugin-side "overrides" no-ops.
    pub fn freeze(self) -> Arc<FrozenDiContainer> {
        let providers: Vec<&'static ProviderDescriptor> = self
            .providers
            .into_iter()
            .filter(|d| !self.overridden.contains(&(d.type_id_fn)()))
            .collect();

        for d in &providers {
            let ty = (d.type_id_fn)();
            if self.direct.contains_key(&ty) {
                let direct_name = self.direct_names.get(&ty).copied().unwrap_or("<unknown>");
                panic!(
                    "Arcly DI: `{}` is registered both directly (as `{direct_name}`) and \
                     via #[Injectable] `{}`. Use `register_override` (plugins: \
                     `ArclyPluginContext::override_provider`) to replace the injectable, \
                     or drop one of the registrations.",
                    d.name, d.name
                );
            }
        }

        let order = Self::topo_sort(&providers, &self.direct);

        let mut map: HashMap<TypeId, AnyProvider> = self.direct;
        for d in order {
            let resolver = Resolver { map: &map };
            let instance = (d.build)(&resolver);
            map.insert((d.type_id_fn)(), instance);
        }

        Arc::new(FrozenDiContainer { map })
    }

    /// Kahn's algorithm with deterministic ordering for stable build traces.
    fn topo_sort(
        providers: &[&'static ProviderDescriptor],
        direct: &HashMap<TypeId, AnyProvider>,
    ) -> Vec<&'static ProviderDescriptor> {
        use std::collections::VecDeque;

        // Index providers by their produced TypeId.
        let mut by_ty: HashMap<TypeId, &'static ProviderDescriptor> = HashMap::new();
        for p in providers {
            let prev = by_ty.insert((p.type_id_fn)(), *p);
            if prev.is_some() {
                panic!("Arcly DI: provider for `{}` registered twice", p.name);
            }
        }

        // Compute in-degree: number of deps that are themselves providers.
        // Deps satisfied by direct-registered singletons are free.
        let mut indeg: HashMap<TypeId, usize> = HashMap::new();
        let mut adj: HashMap<TypeId, Vec<TypeId>> = HashMap::new();
        for p in providers {
            let ty = (p.type_id_fn)();
            let mut d = 0usize;
            for dep in (p.deps_fn)() {
                if by_ty.contains_key(&dep) {
                    d += 1;
                    adj.entry(dep).or_default().push(ty);
                } else if direct.contains_key(&dep) {
                    // satisfied by direct singleton — no edge
                } else {
                    panic!(
                        "Arcly DI: provider `{}` depends on type `{:?}` which has no registered provider",
                        p.name, dep
                    );
                }
            }
            indeg.insert(ty, d);
        }

        let mut q: VecDeque<TypeId> = indeg
            .iter()
            .filter_map(|(k, &v)| (v == 0).then_some(*k))
            .collect();
        let mut order: Vec<&'static ProviderDescriptor> = Vec::with_capacity(providers.len());

        while let Some(ty) = q.pop_front() {
            order.push(by_ty[&ty]);
            if let Some(children) = adj.get(&ty) {
                for c in children {
                    let e = indeg.get_mut(c).unwrap();
                    *e -= 1;
                    if *e == 0 {
                        q.push_back(*c);
                    }
                }
            }
        }

        if order.len() != providers.len() {
            let unresolved: Vec<&'static str> = providers
                .iter()
                .filter(|p| !order.iter().any(|q| (q.type_id_fn)() == (p.type_id_fn)()))
                .map(|p| p.name)
                .collect();
            panic!("Arcly DI: dependency cycle detected. Unresolved providers: {unresolved:?}");
        }
        order
    }
}

/// Immutable, lock-free DI container. Reads are O(1) and inlined.
pub struct FrozenDiContainer {
    map: HashMap<TypeId, AnyProvider>,
}

impl FrozenDiContainer {
    #[inline(always)]
    pub fn get<T: Send + Sync + 'static>(&self) -> &T {
        self.map
            .get(&TypeId::of::<T>())
            .and_then(|a| a.downcast_ref::<T>())
            .expect("Arcly DI: missing provider")
    }

    /// Non-panicking variant. Returns `None` when the type has not been provided.
    /// Used in `boundary.rs` to skip JWT decoding when no `JwtService` is registered.
    #[inline]
    pub fn try_get<T: Send + Sync + 'static>(&self) -> Option<&T> {
        self.map
            .get(&TypeId::of::<T>())
            .and_then(|a| a.downcast_ref::<T>())
    }

    /// Resolve a singleton as an owned `Arc<T>` (one atomic refcount bump).
    /// Backs `Inject<T>` resolution at request entry — owned handle, no
    /// lifetime laundering. Panics if the type was never provided.
    #[inline]
    pub fn get_arc<T: Send + Sync + 'static>(&self) -> Arc<T> {
        self.map
            .get(&TypeId::of::<T>())
            .cloned()
            .and_then(|a| a.downcast::<T>().ok())
            .expect("Arcly DI: missing provider")
    }

    /// Produce a borrowing [`Resolver`] view over the frozen singleton set.
    ///
    /// `Resolver::get<T>` clones the `Arc<T>` held in the map — fully safe, no
    /// lifetime laundering. Only macro-generated `__arcly_build` functions call
    /// this; it is `#[doc(hidden)]` to keep it out of application code.
    #[doc(hidden)]
    #[inline]
    pub fn resolver(&self) -> Resolver<'_> {
        Resolver { map: &self.map }
    }
}

// ─── HTTP method + route descriptors (unchanged shape) ───────────────────

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum HttpMethod {
    GET,
    POST,
    PUT,
    DELETE,
    PATCH,
}

impl From<HttpMethod> for axum::http::Method {
    #[inline]
    fn from(m: HttpMethod) -> Self {
        match m {
            HttpMethod::GET => axum::http::Method::GET,
            HttpMethod::POST => axum::http::Method::POST,
            HttpMethod::PUT => axum::http::Method::PUT,
            HttpMethod::DELETE => axum::http::Method::DELETE,
            HttpMethod::PATCH => axum::http::Method::PATCH,
        }
    }
}

#[derive(Clone, Copy, Debug)]
pub enum ParamLoc {
    Path,
    Query,
    Header,
}

pub struct ParamSpec {
    pub name: &'static str,
    pub loc: ParamLoc,
    pub required: bool,
    pub schema: fn() -> serde_json::Value,
}

pub struct RouteSpec {
    pub summary: &'static str,
    pub description: &'static str,
    pub operation_id: &'static str,
    pub tags: &'static [&'static str],
    pub security: &'static [&'static str],
    pub status_code: Option<u16>,
    pub deprecated: bool,
    pub params: &'static [ParamSpec],
    pub has_body: bool,
    pub body_schema: Option<fn() -> serde_json::Value>,
    /// Request-body media type for OpenAPI (`requestBody.content` key).
    /// Defaults to `application/json`; `#[Multipart]` sets it to
    /// `multipart/form-data`.
    pub consumes: &'static str,
    pub query_schema: Option<fn() -> serde_json::Value>,
    pub response_schema: Option<fn() -> serde_json::Value>,
    /// `#[CacheTTL(N)]` — seconds. 0/None disables the cache interceptor for
    /// this route regardless of `#[UseInterceptors(CacheInterceptor)]`.
    pub cache_ttl_secs: u64,
    /// `#[CacheKey("template")]` — empty string falls back to
    /// `method + ' ' + path + '?' + query`.
    pub cache_key: &'static str,
    /// `#[Version("v1")]` on the controller — empty string = unversioned.
    /// The version is also baked into the mounted path (`/v1/...`).
    pub api_version: &'static str,
    /// `#[Deprecated(sunset = "YYYY-MM-DD")]` — when non-empty the boundary
    /// adds RFC 8594 `Deprecation`/`Sunset` response headers.
    pub sunset: &'static str,
    /// `#[Idempotent(ttl = "…")]` — TTL seconds; 0 = not idempotent.
    /// Surfaces the `Idempotency-Key` header + 409 + replay header in OpenAPI.
    pub idempotent_ttl_secs: u64,
    /// `#[RequirePolicies("…")]` — ABAC actions gating this route.
    pub policies: &'static [&'static str],
    /// `#[AuditLog(action, resource)]` — empty action = no audit.
    pub audit_action: &'static str,
    pub audit_resource: &'static str,
    /// `#[Timeout("…")]` — milliseconds; 0 = no route deadline.
    pub timeout_ms: u64,
    /// `#[Transactional]` present on the handler.
    pub transactional: bool,
    /// `#[MaskFields("…")]` — route-local PII rules (surfaced in OpenAPI).
    pub mask_fields: &'static [&'static str],
}

pub struct RouteDescriptor {
    pub method: HttpMethod,
    pub path: &'static str,
    pub handler: fn(
        crate::web::context::RequestContext,
    ) -> futures::future::BoxFuture<'static, axum::response::Response>,
    pub spec: &'static RouteSpec,
    /// Owning controller's type name. Empty string for free-fn routes (those
    /// always mount). Routes whose controller is not in the reachable module
    /// DAG are skipped at launch — enforcing NestJS-style encapsulation.
    pub controller: &'static str,
}

inventory::collect!(&'static ModuleDescriptor);
inventory::collect!(&'static RouteDescriptor);

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Weak;

    // Holds the canary alive; the field is read only via the `Weak` upgrade.
    #[allow(dead_code)]
    struct Marker(Arc<()>);

    /// The frozen container is reference-counted, not leaked: once the last
    /// `Arc` clone is dropped (server stopped), the container and every
    /// singleton it owns are freed. This is the regression guard for the
    /// pre-0.6 `Box::leak` that accumulated a container per launch.
    #[test]
    fn frozen_container_drops_with_its_singletons() {
        let canary = Arc::new(());
        let weak: Weak<()> = Arc::downgrade(&canary);

        let mut b = DiContainerBuilder::new();
        b.register(Marker(canary)); // singleton owns the only strong ref
        let container = b.freeze();

        // While the container lives, the singleton (and its canary) live.
        assert!(
            weak.upgrade().is_some(),
            "singleton alive while container held"
        );
        assert_eq!(Arc::strong_count(&container), 1);

        drop(container);

        // Container gone → singleton dropped → no leak.
        assert!(
            weak.upgrade().is_none(),
            "container drop must free its singletons (no per-launch leak)"
        );
    }

    /// `get_arc` yields an owned clone whose lifetime is independent of the
    /// container borrow — the safe replacement for the old `&'static` laundering.
    #[test]
    fn get_arc_returns_independent_owned_handle() {
        let mut b = DiContainerBuilder::new();
        b.register(7u32);
        let container = b.freeze();
        let handle: Arc<u32> = container.get_arc::<u32>();
        assert_eq!(*handle, 7);
        assert_eq!(Arc::strong_count(&handle), 2); // map + handle
    }
}