elif_http/routing/

params.rs

//! Route parameter extraction and validation

use axum::extract::Path;
use serde::de::DeserializeOwned;
use std::collections::HashMap;
use thiserror::Error;

/// Errors that can occur during parameter extraction
#[derive(Error, Debug)]
pub enum ParamError {
    #[error("Missing parameter: {0}")]
    Missing(String),
    #[error("Invalid parameter format: {0}")]
    InvalidFormat(String),
    #[error("Parameter validation failed: {0}")]
    ValidationFailed(String),
    #[error("Deserialization error: {0}")]
    DeserializationError(String),
}

/// A single route parameter with validation
#[derive(Debug, Clone)]
pub struct RouteParam {
    pub name: String,
    pub value: String,
    pub param_type: ParamType,
}

/// Supported parameter types
#[derive(Debug, Clone, PartialEq)]
pub enum ParamType {
    String,
    Integer,
    Uuid,
    Custom(String), // For custom validation patterns
}

impl RouteParam {
    pub fn new(name: String, value: String, param_type: ParamType) -> Self {
        Self {
            name,
            value,
            param_type,
        }
    }

    /// Validate the parameter value against its type
    pub fn validate(&self) -> Result<(), ParamError> {
        match &self.param_type {
            ParamType::String => Ok(()), // Strings are always valid
            ParamType::Integer => {
                self.value.parse::<i64>()
                    .map(|_| ())
                    .map_err(|_| ParamError::ValidationFailed(
                        format!("Parameter '{}' must be an integer", self.name)
                    ))
            }
            ParamType::Uuid => {
                uuid::Uuid::parse_str(&self.value)
                    .map(|_| ())
                    .map_err(|_| ParamError::ValidationFailed(
                        format!("Parameter '{}' must be a valid UUID", self.name)
                    ))
            }
            ParamType::Custom(_pattern) => {
                // TODO: Implement regex validation for custom patterns
                Ok(())
            }
        }
    }

    /// Get the typed value as T
    pub fn as_typed<T>(&self) -> Result<T, ParamError> 
    where
        T: std::str::FromStr,
        T::Err: std::fmt::Display,
    {
        self.validate()?;
        self.value.parse::<T>()
            .map_err(|e| ParamError::InvalidFormat(format!("Cannot convert '{}' to target type: {}", self.value, e)))
    }
}

/// Container for extracted path parameters
#[derive(Debug, Default)]
pub struct PathParams {
    params: HashMap<String, RouteParam>,
}

impl PathParams {
    pub fn new() -> Self {
        Self {
            params: HashMap::new(),
        }
    }

    pub fn add_param(&mut self, param: RouteParam) {
        self.params.insert(param.name.clone(), param);
    }

    /// Get a parameter by name
    pub fn get(&self, name: &str) -> Option<&RouteParam> {
        self.params.get(name)
    }

    /// Get parameter value as string
    pub fn get_str(&self, name: &str) -> Option<&str> {
        self.params.get(name).map(|p| p.value.as_str())
    }

    /// Get parameter value as typed value
    pub fn get_typed<T>(&self, name: &str) -> Result<T, ParamError>
    where
        T: std::str::FromStr,
        T::Err: std::fmt::Display,
    {
        self.get(name)
            .ok_or_else(|| ParamError::Missing(name.to_string()))?
            .as_typed()
    }

    /// Get all parameters
    pub fn all(&self) -> &HashMap<String, RouteParam> {
        &self.params
    }

    /// Validate all parameters
    pub fn validate_all(&self) -> Result<(), ParamError> {
        for param in self.params.values() {
            param.validate()?;
        }
        Ok(())
    }
}

/// Extract path parameters from axum Path
impl<T> From<Path<T>> for PathParams 
where
    T: DeserializeOwned + Send + 'static,
{
    fn from(_path: Path<T>) -> Self {
        // This is a placeholder implementation
        // In practice, we'd need to work with the actual extracted values
        PathParams::new()
    }
}

/// Builder for creating typed parameter extractors
#[derive(Debug)]
pub struct ParamExtractor {
    param_specs: HashMap<String, ParamType>,
}

impl ParamExtractor {
    pub fn new() -> Self {
        Self {
            param_specs: HashMap::new(),
        }
    }

    /// Specify a parameter type
    pub fn param(mut self, name: &str, param_type: ParamType) -> Self {
        self.param_specs.insert(name.to_string(), param_type);
        self
    }

    /// Extract and validate parameters from a path
    pub fn extract_from_path(&self, path: &str, route_pattern: &str) -> Result<PathParams, ParamError> {
        let mut params = PathParams::new();
        
        // Parse route pattern to find parameter names
        let pattern_parts: Vec<&str> = route_pattern.split('/').collect();
        let path_parts: Vec<&str> = path.split('/').collect();
        
        if pattern_parts.len() != path_parts.len() {
            return Err(ParamError::InvalidFormat("Path structure mismatch".to_string()));
        }
        
        for (pattern_part, path_part) in pattern_parts.iter().zip(path_parts.iter()) {
            if pattern_part.starts_with('{') && pattern_part.ends_with('}') {
                let param_name = &pattern_part[1..pattern_part.len()-1];
                let param_type = self.param_specs.get(param_name)
                    .cloned()
                    .unwrap_or(ParamType::String);
                
                let param = RouteParam::new(
                    param_name.to_string(),
                    path_part.to_string(),
                    param_type,
                );
                
                param.validate()?;
                params.add_param(param);
            }
        }
        
        Ok(params)
    }
}

impl Default for ParamExtractor {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_route_param_validation() {
        let param = RouteParam::new("id".to_string(), "123".to_string(), ParamType::Integer);
        assert!(param.validate().is_ok());
        
        let invalid_param = RouteParam::new("id".to_string(), "abc".to_string(), ParamType::Integer);
        assert!(invalid_param.validate().is_err());
    }

    #[test]
    fn test_param_extractor() {
        let extractor = ParamExtractor::new()
            .param("id", ParamType::Integer)
            .param("slug", ParamType::String);
        
        let params = extractor.extract_from_path("/users/123/posts/hello", "/users/{id}/posts/{slug}").unwrap();
        
        assert_eq!(params.get_str("id"), Some("123"));
        assert_eq!(params.get_str("slug"), Some("hello"));
        assert_eq!(params.get_typed::<i64>("id").unwrap(), 123);
    }
}