tako-rs-core 2.0.0

Internal core implementation crate for tako-rs. Use the `tako-rs` umbrella crate instead.
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

#![cfg_attr(docsrs, feature(doc_cfg))]
// `FromRequest::from_request` and `FromRequestParts::from_request_parts` use the
// `fn(...) -> impl Future + Send + 'a` shape on purpose: the explicit `+ Send`
// bound is what lets handlers be hosted by the hyper service trait. Rewriting
// these as `async fn` would drop the bound.
#![allow(clippy::manual_async_fn)]

//! Internal core for the Tako framework.
//!
//! This crate hosts the framework primitives shared across all Tako sub-crates:
//! routing, request/response types, body, middleware/plugin traits, extractor
//! traits, state, signals, queue, and a few cross-cutting features such as
//! `graphql`, `grpc`, and `openapi` that interact tightly with the router.
//!
//! Concrete extractors live in `tako-extractors`, server bootstrap code in
//! `tako-server`, streaming/upgrade transports in `tako-streams`, and concrete
//! middleware/plugin implementations in `tako-plugins`. Users should depend on
//! the `tako-rs` umbrella crate, which re-exports everything under the original
//! `tako::*` paths.

/// HTTP request and response body handling utilities.
pub mod body;

/// HTTP client implementation for making outbound requests.
#[cfg(all(feature = "client", not(feature = "compio")))]
#[cfg_attr(docsrs, doc(cfg(feature = "client")))]
pub mod client;

/// Configuration loading from environment variables.
pub mod config;

/// Request data extraction trait + the two extractors (`json`, `params`)
/// whose internal types are referenced by the router and route.
pub mod extractors;

/// Request handler traits and implementations.
pub mod handler;

/// Middleware trait + `Next` execution chain.
pub mod middleware;

/// Plugin system trait (`TakoPlugin`).
#[cfg(feature = "plugins")]
#[cfg_attr(docsrs, doc(cfg(feature = "plugins")))]
pub mod plugins;

/// Response generation utilities and traits.
pub mod responder;

/// RFC 7807 / RFC 9457 `application/problem+json` error responses.
pub mod problem;

/// Unified per-connection metadata extension shared by every transport.
pub mod conn_info;

/// Shared TLS certificate / key PEM loading helpers.
#[cfg(any(feature = "tls", feature = "http3", feature = "client"))]
#[cfg_attr(
  docsrs,
  doc(cfg(any(feature = "tls", feature = "http3", feature = "client")))
)]
pub mod tls;

/// Redirection utilities for handling HTTP redirects.
pub mod redirect;

/// Route definition and matching logic.
pub mod route;

/// Request routing and dispatch functionality.
pub mod router;

/// In-memory background job queue with retry, delayed jobs, and dead letter support.
pub mod queue;

/// Application state management and dependency injection.
pub mod state;

/// Per-router typed state container (instance-scoped, complements `state`).
pub mod router_state;

#[cfg(feature = "signals")]
/// In-process signal arbiter for custom events.
pub mod signals;

/// Distributed tracing integration for observability.
#[cfg(feature = "tako-tracing")]
#[cfg_attr(docsrs, doc(cfg(feature = "tako-tracing")))]
pub mod tracing;

/// Core type definitions used throughout the framework.
pub mod types;

/// `GraphQL` support (request extractors, responses, and subscriptions).
#[cfg(feature = "async-graphql")]
#[cfg_attr(docsrs, doc(cfg(feature = "async-graphql")))]
pub mod graphql;

/// `GraphiQL` UI helpers.
#[cfg(feature = "graphiql")]
#[cfg_attr(docsrs, doc(cfg(feature = "graphiql")))]
pub mod graphiql;

/// `OpenAPI` documentation generation integrations (utoipa, vespera).
#[cfg(any(feature = "utoipa", feature = "vespera"))]
#[cfg_attr(docsrs, doc(cfg(any(feature = "utoipa", feature = "vespera"))))]
pub mod openapi;

/// gRPC support for unary RPCs with protobuf serialization.
#[cfg(feature = "grpc")]
#[cfg_attr(docsrs, doc(cfg(feature = "grpc")))]
pub mod grpc;

pub use bytes::Bytes;
pub use http::Method;
pub use http::StatusCode;
pub use http::header;
pub use http_body_util::Full;
pub use responder::NOT_FOUND;