rustisan_core/

http.rs

//! HTTP module for the Rustisan framework
//!
//! This module contains the HTTP abstractions for requests and responses.

use std::fmt;
use std::str::FromStr;
use std::collections::HashMap;

use axum::{
    body::Bytes,
    extract::Request as AxumRequest,
    http::{HeaderMap, HeaderValue, Method, StatusCode, Uri, Version},
    response::{IntoResponse, Response as AxumResponse},
    Json,
};
use serde::{de::DeserializeOwned, Serialize};
use serde_json::{json, Value};

use crate::errors::{Result, RustisanError};

/// Wrapper for HTTP requests
pub struct Request {
    /// The HTTP method
    pub method: Method,
    /// The request URI
    pub uri: Uri,
    /// The HTTP version
    pub version: Version,
    /// The request headers
    pub headers: HeaderMap,
    /// The request path parameters
    pub path_params: HashMap<String, String>,
    /// The request query parameters
    pub query_params: HashMap<String, String>,
    /// The request cookies
    pub cookies: HashMap<String, String>,
    /// The request body as bytes
    body: Option<Bytes>,
    /// The inner Axum request
    inner: AxumRequest,
}

impl Request {
    /// Creates a new request from an Axum request
    pub async fn from_axum(mut req: AxumRequest) -> Self {
        let method = req.method().clone();
        let uri = req.uri().clone();
        let version = req.version();
        let headers = req.headers().clone();

        // Extract cookies
        let cookies = Self::extract_cookies(&headers);

        // Extract query parameters
        let query_params = Self::extract_query_params(uri.query());

        // For now, just set body to None - in a real implementation we'd extract it properly
        let body = None;

        Self {
            method,
            uri,
            version,
            headers,
            path_params: HashMap::new(),
            query_params,
            cookies,
            body,
            inner: req,
        }
    }

    /// Extracts cookies from headers
    fn extract_cookies(headers: &HeaderMap) -> HashMap<String, String> {
        let mut cookies = HashMap::new();

        if let Some(cookie_header) = headers.get("cookie") {
            if let Ok(cookie_str) = cookie_header.to_str() {
                for cookie in cookie_str.split(';') {
                    let cookie = cookie.trim();
                    if let Some(idx) = cookie.find('=') {
                        let (key, value) = cookie.split_at(idx);
                        cookies.insert(key.trim().to_owned(), value[1..].trim().to_owned());
                    }
                }
            }
        }

        cookies
    }

    /// Extracts query parameters from a query string
    fn extract_query_params(query: Option<&str>) -> HashMap<String, String> {
        let mut params = HashMap::new();

        if let Some(query_str) = query {
            for param in query_str.split('&') {
                if let Some(idx) = param.find('=') {
                    let (key, value) = param.split_at(idx);
                    params.insert(key.to_owned(), value[1..].to_owned());
                } else {
                    params.insert(param.to_owned(), String::new());
                }
            }
        }

        params
    }

    /// Gets a path parameter
    pub fn param<T: FromStr>(&self, name: &str) -> Result<T> {
        self.path_params
            .get(name)
            .ok_or_else(|| RustisanError::BadRequest(format!("Missing path parameter: {}", name)))
            .and_then(|s| {
                s.parse::<T>().map_err(|_| {
                    RustisanError::BadRequest(format!("Invalid path parameter: {}", name))
                })
            })
    }

    /// Gets a query parameter
    pub fn query<T: FromStr>(&self, name: &str) -> Result<T> {
        self.query_params
            .get(name)
            .ok_or_else(|| {
                RustisanError::BadRequest(format!("Missing query parameter: {}", name))
            })
            .and_then(|s| {
                s.parse::<T>().map_err(|_| {
                    RustisanError::BadRequest(format!("Invalid query parameter: {}", name))
                })
            })
    }

    /// Gets a query parameter with a default value
    pub fn query_or<T: FromStr>(&self, name: &str, default: T) -> T {
        self.query(name).unwrap_or(default)
    }

    /// Gets a cookie
    pub fn cookie(&self, name: &str) -> Option<&String> {
        self.cookies.get(name)
    }

    /// Gets a header
    pub fn header(&self, name: &str) -> Option<&HeaderValue> {
        self.headers.get(name)
    }

    /// Checks if the request has JSON content
    pub fn is_json(&self) -> bool {
        self.headers
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .map(|s| s.starts_with("application/json"))
            .unwrap_or(false)
    }

    /// Deserializes the request body as JSON
    pub async fn json<T: DeserializeOwned>(&self) -> Result<T> {
        if !self.is_json() {
            return Err(RustisanError::BadRequest(
                "Content-Type must be application/json".to_string(),
            ));
        }

        match &self.body {
            Some(bytes) => serde_json::from_slice(bytes)
                .map_err(|e| RustisanError::BadRequest(format!("Invalid JSON: {}", e))),
            None => Err(RustisanError::BadRequest("Empty request body".to_string())),
        }
    }

    /// Gets the request body as bytes
    pub fn body(&self) -> Option<&Bytes> {
        self.body.as_ref()
    }

    /// Gets the request body as a string
    pub fn body_string(&self) -> Result<String> {
        match &self.body {
            Some(bytes) => String::from_utf8(bytes.to_vec())
                .map_err(|e| RustisanError::BadRequest(format!("Invalid UTF-8: {}", e))),
            None => Err(RustisanError::BadRequest("Empty request body".to_string())),
        }
    }

    /// Gets the inner Axum request
    pub fn inner(&self) -> &AxumRequest {
        &self.inner
    }
}

/// HTTP response wrapper
#[derive(Debug, Clone, Serialize)]
pub struct Response {
    /// The response status code
    #[serde(skip)]
    pub status: StatusCode,
    /// The response data
    #[serde(flatten)]
    pub data: Value,
    /// Optional success message
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

impl Response {
    /// Creates a new response
    pub fn new(status: StatusCode, data: Value) -> Self {
        Self {
            status,
            data,
            message: None,
        }
    }

    /// Creates a new response with a message
    pub fn with_message(status: StatusCode, data: Value, message: String) -> Self {
        Self {
            status,
            data,
            message: Some(message),
        }
    }

    /// Creates a successful response (200 OK)
    pub fn ok<S: Into<String>>(body: S) -> Result<Self> {
        Ok(Self {
            status: StatusCode::OK,
            data: json!({"data": body.into()}),
            message: None,
        })
    }

    /// Creates a JSON response (200 OK)
    pub fn json(data: Value) -> Result<Self> {
        Ok(Self {
            status: StatusCode::OK,
            data,
            message: None,
        })
    }

    /// Creates a successful response with message
    pub fn success(data: Value, message: Option<String>) -> Result<Self> {
        Ok(Self {
            status: StatusCode::OK,
            data,
            message,
        })
    }

    /// Creates a created response (201 Created)
    pub fn created(data: Value) -> Result<Self> {
        Ok(Self {
            status: StatusCode::CREATED,
            data,
            message: None,
        })
    }

    /// Creates a no content response (204 No Content)
    pub fn no_content() -> Result<Self> {
        Ok(Self {
            status: StatusCode::NO_CONTENT,
            data: json!({}),
            message: None,
        })
    }

    /// Creates a bad request response (400 Bad Request)
    pub fn bad_request<S: Into<String>>(message: S) -> Result<Self> {
        Ok(Self {
            status: StatusCode::BAD_REQUEST,
            data: json!({"error": message.into()}),
            message: None,
        })
    }

    /// Creates an unauthorized response (401 Unauthorized)
    pub fn unauthorized<S: Into<String>>(message: S) -> Result<Self> {
        Ok(Self {
            status: StatusCode::UNAUTHORIZED,
            data: json!({"error": message.into()}),
            message: None,
        })
    }

    /// Creates a forbidden response (403 Forbidden)
    pub fn forbidden<S: Into<String>>(message: S) -> Result<Self> {
        Ok(Self {
            status: StatusCode::FORBIDDEN,
            data: json!({"error": message.into()}),
            message: None,
        })
    }

    /// Creates a not found response (404 Not Found)
    pub fn not_found<S: Into<String>>(message: S) -> Result<Self> {
        Ok(Self {
            status: StatusCode::NOT_FOUND,
            data: json!({"error": message.into()}),
            message: None,
        })
    }

    /// Creates an internal server error response (500 Internal Server Error)
    pub fn internal_error<S: Into<String>>(message: S) -> Result<Self> {
        Ok(Self {
            status: StatusCode::INTERNAL_SERVER_ERROR,
            data: json!({"error": message.into()}),
            message: None,
        })
    }

    /// Adds a message to the response
    pub fn with_message_str<S: Into<String>>(mut self, message: S) -> Self {
        self.message = Some(message.into());
        self
    }
}

impl IntoResponse for Response {
    fn into_response(self) -> AxumResponse {
        (StatusCode::OK, Json(self)).into_response()
    }
}

impl fmt::Debug for Request {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Request")
            .field("method", &self.method)
            .field("uri", &self.uri)
            .field("version", &self.version)
            .field("headers", &self.headers)
            .field("path_params", &self.path_params)
            .field("query_params", &self.query_params)
            .field("cookies", &self.cookies)
            .field("body", &self.body.as_ref().map(|_| "[bytes]"))
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_response_creation() {
        let resp = Response::ok("Hello").unwrap();
        assert_eq!(resp.status, StatusCode::OK);

        let resp = Response::json(json!({"name": "John"})).unwrap();
        assert_eq!(resp.status, StatusCode::OK);

        let resp = Response::created(json!({"id": 1})).unwrap();
        assert_eq!(resp.status, StatusCode::CREATED);
    }

    #[test]
    fn test_error_responses() {
        let resp = Response::not_found("User not found").unwrap();
        assert_eq!(resp.status, StatusCode::NOT_FOUND);

        let resp = Response::bad_request("Invalid input").unwrap();
        assert_eq!(resp.status, StatusCode::BAD_REQUEST);
    }

    #[test]
    fn test_response_with_message() {
        let resp = Response::success(json!({"result": true}), Some("Operation successful".to_string())).unwrap();
        assert_eq!(resp.status, StatusCode::OK);
        assert_eq!(resp.message, Some("Operation successful".to_string()));
    }
}