nestrs 0.3.8

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

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

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

#[dto]
struct StrictDto {
    #[IsString]
    value: String,
}

#[dto]
struct NestedStrictInnerDto {
    #[IsString]
    label: String,
}

#[dto]
struct NestedStrictDto {
    #[ValidateNested]
    inner: NestedStrictInnerDto,
    #[IsOptional]
    #[ValidateNested]
    optional_inner: Option<NestedStrictInnerDto>,
}

#[dto(allow_unknown_fields)]
struct LooseDto {
    #[IsString]
    value: String,
}

#[controller(prefix = "/dto", version = "v1")]
struct DtoController;

#[routes(state = AppState)]
impl DtoController {
    #[post("/strict")]
    async fn strict(ValidatedBody(dto): ValidatedBody<StrictDto>) -> String {
        dto.value
    }

    #[post("/nested")]
    async fn nested(ValidatedBody(dto): ValidatedBody<NestedStrictDto>) -> String {
        dto.inner.label
    }

    #[post("/loose")]
    async fn loose(ValidatedBody(dto): ValidatedBody<LooseDto>) -> String {
        dto.value
    }
}

#[module(controllers = [DtoController], providers = [AppState])]
struct AppModule;

#[tokio::test]
async fn dto_rejects_unknown_top_level_fields_by_default() {
    let router = NestFactory::create::<AppModule>().into_router();

    let response = router
        .oneshot(
            Request::builder()
                .uri("/v1/dto/strict")
                .method("POST")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(r#"{"value":"ok","extra":"boom"}"#))
                .expect("request"),
        )
        .await
        .expect("serve");

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}

#[tokio::test]
async fn dto_rejects_unknown_nested_fields() {
    let router = NestFactory::create::<AppModule>().into_router();

    let response = router
        .oneshot(
            Request::builder()
                .uri("/v1/dto/nested")
                .method("POST")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(
                    r#"{"inner":{"label":"ok","extra":"boom"},"optional_inner":null}"#,
                ))
                .expect("request"),
        )
        .await
        .expect("serve");

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}

#[tokio::test]
async fn dto_allows_optional_nested_fields_when_omitted() {
    let router = NestFactory::create::<AppModule>().into_router();

    let response = router
        .oneshot(
            Request::builder()
                .uri("/v1/dto/nested")
                .method("POST")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(r#"{"inner":{"label":"ok"}}"#))
                .expect("request"),
        )
        .await
        .expect("serve");

    assert_eq!(response.status(), StatusCode::OK);
}

#[tokio::test]
async fn dto_allow_unknown_fields_option_allows_extra_keys() {
    let router = NestFactory::create::<AppModule>().into_router();

    let response = router
        .oneshot(
            Request::builder()
                .uri("/v1/dto/loose")
                .method("POST")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(r#"{"value":"ok","extra":"allowed"}"#))
                .expect("request"),
        )
        .await
        .expect("serve");

    assert_eq!(response.status(), StatusCode::OK);
}