Struct Response 

pub struct Response {
    pub status: u16,
    pub body: String,
    pub headers: HashMap<String, String>,
}

Fields

status: u16

body: String

headers: HashMap<String, String>

Implementations

impl Response

pub fn new(status: u16) -> Response

pub fn status(&mut self, status: u16) -> &mut Self

pub fn body<T: AsRef<str>>(&mut self, body: T) -> &mut Self

pub fn header<K: AsRef<str>, V: AsRef<str>>( &mut self, name: K, value: V, ) -> &mut Self

pub fn headers(&mut self, headers: HashMap<String, String>) -> &mut Self

pub fn ok<T: Serialize>(data: &T) -> Result<Response, ServerError>

Examples found in repository

examples/routing.rs (line 35)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn created<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn accepted<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn no_content() -> Response

pub fn bad_request<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn unauthorized<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn forbidden<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn not_found<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn error(err: ServerError) -> Response

pub fn stream(&mut self, content_type: &str) -> &mut Self

pub fn with_cors(&mut self, origin: &str) -> &mut Self

pub fn send(&self)

pub fn text<T: AsRef<str>>(content: T) -> Result<Response, ServerError>

Examples found in repository

examples/hello_world.rs (line 12)

fn main() {
    let mut app = Server::new();

    // Add a route that handles GET requests to "/"
    app.get("/", |_req| async { Response::text("Hello, World!") });

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/middleware.rs (line 65)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (line 23)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn html<T: AsRef<str>>(content: T) -> Result<Response, ServerError>

pub fn xml<T: AsRef<str>>(content: T) -> Result<Response, ServerError>

pub fn redirect(location: &str) -> Result<Response, ServerError>

pub fn permanent_redirect(location: &str) -> Result<Response, ServerError>

pub fn method_not_allowed( allowed_methods: &[&str], ) -> Result<Response, ServerError>

pub fn with_cache_control(&mut self, directive: &str) -> &mut Self

pub fn no_cache(&mut self) -> &mut Self

pub fn with_security_headers(&mut self) -> &mut Self

pub fn conflict<T: Serialize>(data: &T) -> Result<Response, ServerError>

pub fn unprocessable_entity<T: Serialize>( data: &T, ) -> Result<Response, ServerError>

pub fn too_many_requests<T: Serialize>( data: &T, ) -> Result<Response, ServerError>

pub fn service_unavailable<T: Serialize>( data: &T, ) -> Result<Response, ServerError>

pub fn file_download(&mut self, filename: &str, content_type: &str) -> &mut Self

pub fn vary(&mut self, headers: &[&str]) -> &mut Self

pub fn with_gzip(&mut self) -> &mut Self

pub fn with_brotli(&mut self) -> &mut Self

pub fn with_language(&mut self, lang: &str) -> &mut Self

pub fn with_api_version(&mut self, version: &str) -> &mut Self

Trait Implementations

impl Debug for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.