fluxdi 1.2.0

FluxDI - Semi-Automatic Dependency Injector
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Actix-web integration for FluxDI.
//!
//! This module provides a state wrapper, service config extension, and an
//! extractor that resolves dependencies directly from an `Injector`.

use std::{
    future::{Ready, ready},
    ops::Deref,
};

use ::actix_web::{
    Error as ActixError, FromRequest, HttpRequest, HttpResponse, ResponseError,
    dev::Payload,
    http::StatusCode,
    web::{self, ServiceConfig},
};

use crate::{Error, Injector, runtime::Shared};

/// Actix state wrapper that stores a shared injector reference.
#[derive(Clone)]
pub struct InjectorState {
    injector: Shared<Injector>,
}

impl InjectorState {
    /// Builds state from a shared injector.
    pub fn new(injector: Shared<Injector>) -> Self {
        Self { injector }
    }

    /// Returns a cloned shared injector handle.
    pub fn injector(&self) -> Shared<Injector> {
        self.injector.clone()
    }
}

/// Builds typed app data for `actix_web::App::app_data(...)`.
pub fn injector_data(injector: Shared<Injector>) -> web::Data<InjectorState> {
    web::Data::new(InjectorState::new(injector))
}

/// Extension trait that wires injector state into `ServiceConfig`.
pub trait ServiceConfigExt {
    fn with_injector(&mut self, injector: Shared<Injector>) -> &mut Self;
}

impl ServiceConfigExt for ServiceConfig {
    fn with_injector(&mut self, injector: Shared<Injector>) -> &mut Self {
        self.app_data(injector_data(injector))
    }
}

/// Rejection type used by [`Resolved`].
#[derive(Debug)]
pub struct ResolveRejection {
    pub status: StatusCode,
    pub message: String,
}

impl ResolveRejection {
    fn internal(message: String) -> Self {
        Self {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            message,
        }
    }
}

impl From<Error> for ResolveRejection {
    fn from(value: Error) -> Self {
        Self::internal(value.to_string())
    }
}

impl std::fmt::Display for ResolveRejection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.message)
    }
}

impl ResponseError for ResolveRejection {
    fn status_code(&self) -> StatusCode {
        self.status
    }

    fn error_response(&self) -> HttpResponse {
        HttpResponse::build(self.status).body(self.message.clone())
    }
}

/// Actix extractor that resolves `T` from [`InjectorState`].
pub struct Resolved<T: ?Sized + Send + Sync + 'static>(pub Shared<T>);

impl<T: ?Sized + Send + Sync + 'static> Resolved<T> {
    pub fn into_shared(self) -> Shared<T> {
        self.0
    }
}

impl<T: ?Sized + Send + Sync + 'static> Deref for Resolved<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.0.as_ref()
    }
}

impl<T: ?Sized + Send + Sync + 'static> From<Resolved<T>> for Shared<T> {
    fn from(value: Resolved<T>) -> Self {
        value.0
    }
}

impl<T> FromRequest for Resolved<T>
where
    T: ?Sized + Send + Sync + 'static,
{
    type Error = ActixError;
    type Future = Ready<Result<Self, Self::Error>>;

    fn from_request(req: &HttpRequest, _payload: &mut Payload) -> Self::Future {
        let result = req
            .app_data::<web::Data<InjectorState>>()
            .cloned()
            .ok_or_else(|| {
                ResolveRejection::internal(
                    "InjectorState is not configured in app_data".to_string(),
                )
            })
            .and_then(|state| {
                state
                    .injector()
                    .try_resolve::<T>()
                    .map_err(ResolveRejection::from)
            })
            .map(Self)
            .map_err(ActixError::from);

        ready(result)
    }
}