todors 0.10.7

todo app with CLI, REST & gRPC interfaces
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

use std::sync::Arc;

use crate::entities;
use crate::logging::Logger;
use crate::traits::Controller;

pub use actix_web::dev::Server;
use actix_web::web;
pub use actix_web::{App, HttpServer};

use utoipa::OpenApi;
use utoipa_swagger_ui::{Config, SwaggerUi};

mod index;
mod logging;
mod metrics;
mod middleware;
mod todo;

pub struct AppState<T>
where
    T: Controller,
{
    controller: T,
    logger: Arc<Logger>,
}

impl<T> AppState<T>
where
    T: Controller,
{
    pub fn new(controller: T, logger: Arc<Logger>) -> web::Data<AppState<T>> {
        web::Data::new(AppState { controller, logger })
    }
}

pub fn build_server<T>(state: web::Data<AppState<T>>, addr: String, num_workers: usize) -> Server
where
    T: Controller<
        Input = entities::TodoWrite,
        Output = entities::TodoRead,
        Id = entities::Id,
        OptionalInput = entities::TodoUpdate,
    >,
{
    let metrics = metrics::build_metrics();

    HttpServer::new(move || {
        App::new()
            .wrap(metrics.clone())
            .app_data(state.clone())
            .configure(configure::<T>)
            .wrap(logging::LogMiddleware)
    })
    .bind(addr)
    .unwrap()
    .workers(num_workers)
    .run()
}

fn configure<T>(cfg: &mut web::ServiceConfig)
where
    T: Controller<
            Input = entities::TodoWrite,
            Output = entities::TodoRead,
            Id = entities::Id,
            OptionalInput = entities::TodoUpdate,
        > + 'static,
{
    cfg.service(index::index)
        .service(
            web::scope("/api/v1")
                .route("/todos", web::post().to(todo::Api::<T>::create_todo))
                .route("/todos", web::put().to(todo::Api::<T>::create_batch))
                .route("/todos/{id}", web::get().to(todo::Api::<T>::get_todo))
                .route("/todos/{id}", web::delete().to(todo::Api::<T>::delete_todo))
                .route("/todos", web::get().to(todo::Api::<T>::list_todos))
                .route("/todos/{id}", web::patch().to(todo::Api::<T>::update_todo)),
        )
        .service(
            SwaggerUi::new("/docs/{_:.*}")
                .url("/openapi.json", build_apidoc())
                .config(build_apidoc_config()),
        );
}

fn build_apidoc() -> utoipa::openapi::OpenApi {
    #[derive(OpenApi)]
    #[openapi(
        info(description = "TODO app HTTP REST API."),
        paths(
            index::index,
            todo::create_todo,
            todo::create_batch,
            todo::delete_todo,
            todo::get_todo,
            todo::list_todos,
            todo::update_todo,
            metrics::metrics_api,
        ),
        components(
            schemas(entities::TodoRead, entities::TodoWrite, entities::TodoUpdate),
        ),
        tags(
            (name = "todo", description = "Todo management endpoints."),
            (name = "index", description = "Index endpoint."),
        ),
    )]
    struct ApiDoc;

    ApiDoc::openapi()
}

fn build_apidoc_config<'a>() -> Config<'a> {
    Config::default()
        .try_it_out_enabled(true)
        .default_models_expand_depth(2)
        .display_request_duration(true)
        .filter(true)
        .show_common_extensions(true)
        .request_snippets_enabled(true)
        .persist_authorization(true)
        .display_operation_id(true)
}