nestrs 0.3.2

NestJS-like API framework for Rust on top of Axum and Tower.
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

use axum::body::Body;
use axum::http::{Request, StatusCode};
use nestrs::prelude::*;
use tower::util::ServiceExt;

#[derive(Default)]
#[injectable]
struct AppState;

#[controller(prefix = "/root", version = "v1")]
struct RootController;

impl RootController {
    #[get("/")]
    async fn root() -> &'static str {
        "root"
    }
}

impl_routes!(RootController, state AppState => [
    GET "/" with () => RootController::root,
]);

#[module(
    controllers = [RootController],
    providers = [AppState],
)]
struct RootModule;

#[derive(Default)]
#[injectable]
struct FeatureState;

#[controller(prefix = "/feature", version = "v1")]
struct FeatureController;

impl FeatureController {
    #[get("/")]
    async fn feature() -> &'static str {
        "feature"
    }
}

impl_routes!(FeatureController, state FeatureState => [
    GET "/" with () => FeatureController::feature,
]);

#[module(
    controllers = [FeatureController],
    providers = [FeatureState],
)]
struct FeatureModule;

#[tokio::test]
async fn create_with_modules_merges_dynamic_feature_router() {
    let router = NestFactory::create_with_modules::<RootModule, _>([DynamicModule::from_module::<
        FeatureModule,
    >()])
    .into_router();

    let root = router
        .clone()
        .oneshot(
            Request::builder()
                .uri("/v1/root")
                .method("GET")
                .body(Body::empty())
                .expect("request should be valid"),
        )
        .await
        .expect("router should serve request");
    assert_eq!(root.status(), StatusCode::OK);

    let feature = router
        .oneshot(
            Request::builder()
                .uri("/v1/feature")
                .method("GET")
                .body(Body::empty())
                .expect("request should be valid"),
        )
        .await
        .expect("router should serve request");
    assert_eq!(feature.status(), StatusCode::OK);
}

#[derive(Default)]
#[injectable]
struct FeatureService;

#[module(
    providers = [FeatureService],
    exports = [FeatureService],
)]
struct FeatureProvidersModule;

#[derive(Default)]
#[injectable]
struct RootState {
    feature: std::sync::Arc<FeatureService>,
}

#[module(
    imports = [DynamicModule::from_module::<FeatureProvidersModule>()],
    providers = [RootState],
)]
struct RootProvidersModule;

#[test]
fn dynamic_module_imports_can_export_providers() {
    let (registry, _) = <RootProvidersModule as Module>::build();

    let state = registry.get::<RootState>();
    let feature = registry.get::<FeatureService>();
    assert!(std::sync::Arc::ptr_eq(&state.feature, &feature));
}