vantus 0.3.0

Macro-first async Rust backend framework with explicit composition, typed extraction, and hardened HTTP defaults.
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

//! Public entrypoint for the Vantus framework.
//!
//! Most application code only needs the re-exports from this file:
//! `HostBuilder` for bootstrapping, `#[module]` / `#[controller]`
//! for structure, and the typed request extractors for handlers.
//!
//! ```no_run
//! use vantus::{HostBuilder, RequestContext, Response, module};
//!
//! #[derive(Clone)]
//! struct HealthModule;
//!
//! #[module]
//! impl HealthModule {
//!     #[vantus::get("/health")]
//!     fn health(&self, ctx: RequestContext) -> Response {
//!         Response::json_value(serde_json::json!({
//!             "service": ctx.app_config().service_name,
//!             "status": "ok",
//!         }))
//!     }
//! }
//!
//! fn main() {
//!     let mut builder = HostBuilder::new();
//!     builder.compose_with_config(|_configuration, _app, context| {
//!         context.module(HealthModule);
//!         Ok(())
//!     });
//!     builder.build().run_blocking();
//! }
//! ```

extern crate self as vantus;

mod app;
#[cfg(feature = "cli")]
mod cli;
mod config;
mod core;
mod di;
mod error_conversions;
mod id;
mod logging;
mod middleware;
mod routing;
mod runtime;

pub use app::{
    ApplicationHost, Controller, HealthModule, HostBuildError, HostBuilder, HostContext, HostError,
    InfoModule, Module, ObservabilityModule, PanicRecovery, ReadinessCheck, ReadinessContributor,
    ReadinessRegistry, RequestId, RequestLogger, RuntimeModule, SecurityHeaders, WebPlatformModule,
};
pub use async_trait::async_trait;
#[cfg(feature = "cli")]
pub use cli::{CliError, CliFeatureDefaults, IdGeneratorKind, RuntimeMode, ServerCli};
pub use config::{
    AppConfig, ConfigError, Configuration, ConfigurationBuilder, FromConfig, FromConfiguration,
    ServerConfig, ServerOptions, ServerProtocol,
};
pub use core::{FrameworkError, HttpError, Method, ParseError, Request, Response};
pub use di::{
    BodyBytes, ExtractorError, FromRequest, Header, IdentityState, IntoHandlerResult, IntoResponse,
    JsonBody, NamedFromRequest, NamedOptionalFromRequest, OptionalFromRequest, Path, Query,
    QueryMap, RequestState, TextBody,
};
pub use id::{AtomicIdGenerator, IdGenerator, UuidIdGenerator};
pub use logging::{
    LogLevel, LogSink, RequestLogEvent, StdIoLogSink, emit_default_log, redact_headers,
    sanitize_log_message, sanitize_path_for_logs,
};
pub use middleware::{Middleware, MiddlewareFuture, MiddlewareStage};
pub use routing::{Identity, RequestContext};
pub use runtime::{GlobalRateLimiter, RuntimeSnapshot, RuntimeState, ServerHandle};

/// Attribute macros used to define route-bearing modules and controllers.
pub use vantus_macros::{
    controller, delete, get, head, middleware, module, options, patch, post, put,
};

#[doc(hidden)]
pub mod __private {
    pub use crate::async_trait;
    pub use crate::di::{
        IntoHandlerResult, IntoResponse, NamedFromRequest, NamedOptionalFromRequest,
        OptionalFromRequest,
    };
    pub use crate::middleware::{MiddlewareStack, Next};
    pub use crate::routing::{
        Handler, HandlerResult, RequestBodyKind, RequestContext, RouteContract, RouteDefinition,
        RouteRegistrar, Router,
    };
}