at-jet 0.7.2

High-performance HTTP + Protobuf API framework for mobile services
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
139
140
141
142
143
144
145
146
147

//! # AT-Jet
//!
//! High-performance HTTP + Protobuf API framework for mobile services.

// Deny unwrap() and expect() in non-test code to prevent panics
#![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::expect_used))]
//! AT-Jet provides a clean, ergonomic way to build HTTP APIs that use Protocol Buffers
//! for serialization - ideal for mobile clients that need efficient bandwidth usage
//! and strong schema evolution guarantees.
//!
//! ## Features
//!
//! - **HTTP/1.1 and HTTP/2 support** via axum
//! - **Protobuf request/response handling** with automatic content negotiation
//! - **Dual-format support** - Protobuf for production, JSON for debugging
//! - **CDN-friendly** design for global mobile users
//! - **Middleware support** for authentication, logging, compression
//! - **Type-safe routing** with compile-time guarantees
//!
//! ## Quick Start
//!
//! ```rust,ignore
//! use at_jet::prelude::*;
//! use bytes::Bytes;
//!
//! #[tokio::main]
//! async fn main() -> anyhow::Result<()> {
//!     let app = JetServer::new()
//!         .route("/api/user/:id", get(get_user))
//!         .route("/api/user", post(create_user));
//!
//!     app.serve("0.0.0.0:8080").await?;
//!     Ok(())
//! }
//!
//! // Dual-format: accepts both protobuf and JSON, responds based on Accept header
//! async fn get_user(Path(id): Path<i32>) -> ProtobufResponse<User> {
//!     let user = User { id, name: "John".to_string() };
//!     ProtobufResponse::ok(user)
//! }
//!
//! async fn create_user(ApiRequest { body, format }: ApiRequest<CreateUserRequest>) -> ApiResponse<User> {
//!     // body is decoded from either protobuf or JSON based on Content-Type
//!     // response format matches the Accept header
//!     ApiResponse::ok(format, user)
//! }
//! ```

pub mod client;
pub mod dual_format;
pub mod error;
pub mod extractors;
#[cfg(feature = "metrics")]
pub mod metrics;
pub mod middleware;
pub mod response;
pub mod server;
#[cfg(feature = "session")]
pub mod session;
pub mod startup;
pub mod tracing_init;

/// Re-exports for convenient usage
pub mod prelude {
  pub use crate::{client::JetClient,
                  dual_format::{AcceptFormat,
                                ApiRequest,
                                ApiResponse,
                                ApiResult,
                                DEBUG_FORMAT_HEADER,
                                ResponseFormat,
                                configure_debug_keys},
                  error::{JetError,
                          Result},
                  extractors::ProtobufRequest,
                  response::ProtobufResponse,
                  server::JetServer};

  // Re-export common axum types
  pub use axum::{Router,
                 extract::Path,
                 routing::{delete,
                           get,
                           patch,
                           post,
                           put}};

  // Re-export prost for protobuf
  pub use prost::Message;

  // Re-export serde for JSON support
  pub use serde::{Deserialize,
                  Serialize};

  // Re-export async_trait
  pub use async_trait::async_trait;

  // Re-export CORS types for server configuration
  pub use tower_http::cors::CorsLayer;

  // Re-export tracing middleware
  pub use crate::middleware::{SmartSpanMaker,
                              smart_trace_layer};

  // Re-export request ID middleware
  pub use crate::middleware::{RequestId,
                              RequestIdLayer,
                              X_REQUEST_ID};

  // Re-export startup utilities
  pub use crate::startup::{StartupBanner,
                           mask_secret,
                           mask_url_credentials};

  // Re-export tracing initialization (always available)
  pub use crate::tracing_init::{TracingConfig,
                                TracingGuard,
                                init_tracing};

  // Re-export metrics types (when feature enabled)
  #[cfg(feature = "metrics")]
  pub use crate::metrics::{MetricsConfig,
                           MetricsGuard,
                           init_metrics,
                           metrics_router,
                           record_app_info};
  #[cfg(feature = "metrics")]
  pub use crate::middleware::HttpMetricsLayer;

  // Re-export JWT types (when feature enabled)
  #[cfg(feature = "jwt")]
  pub use crate::middleware::{JwtAuthError,
                              JwtAuthLayer,
                              JwtConfig,
                              JwtValidator};

  // Re-export session types (when feature enabled)
  #[cfg(feature = "session")]
  pub use crate::session::{Session,
                           SessionStore};
}

/// Content types used by AT-Jet
pub mod content_types {
  pub const APPLICATION_PROTOBUF: &str = "application/x-protobuf";
  pub const APPLICATION_JSON: &str = "application/json";
}