mockforge_grpc/reflection/
config.rs

1//! Configuration for the reflection proxy
2
3use crate::reflection::error_handling::ErrorConfig;
4use mockforge_core::{openapi_routes::ValidationMode, overrides::Overrides};
5use serde::{Deserialize, Serialize};
6use std::collections::{HashMap, HashSet};
7
8/// Configuration for the reflection proxy
9#[derive(Debug, Clone, Deserialize, Serialize)]
10pub struct ProxyConfig {
11    /// List of allowed services (if empty, all services are allowed)
12    pub allowlist: HashSet<String>,
13    /// List of denied services (takes precedence over allowlist)
14    pub denylist: HashSet<String>,
15    /// Whether to require services to be explicitly allowed
16    pub require_explicit_allow: bool,
17    /// gRPC port for connection pooling
18    pub grpc_port: u16,
19    /// Error handling configuration
20    pub error_config: Option<ErrorConfig>,
21    /// Response transformation configuration
22    pub response_transform: ResponseTransformConfig,
23    /// Upstream endpoint for request forwarding
24    pub upstream_endpoint: Option<String>,
25    /// Seed for deterministic mock data generation
26    pub mock_seed: Option<u64>,
27    /// Request timeout in seconds
28    pub request_timeout_seconds: u64,
29    /// Admin skip prefixes
30    pub admin_skip_prefixes: Vec<String>,
31    /// Validation mode overrides
32    pub overrides: HashMap<String, ValidationMode>,
33    /// Default request mode
34    pub request_mode: ValidationMode,
35}
36
37impl Default for ProxyConfig {
38    fn default() -> Self {
39        Self {
40            allowlist: HashSet::new(),
41            denylist: HashSet::new(),
42            require_explicit_allow: false,
43            grpc_port: default_grpc_port(),
44            error_config: None,
45            response_transform: ResponseTransformConfig::default(),
46            upstream_endpoint: None,
47            mock_seed: None,
48            request_timeout_seconds: default_request_timeout_seconds(),
49            admin_skip_prefixes: Vec::new(),
50            overrides: HashMap::new(),
51            request_mode: ValidationMode::default(),
52        }
53    }
54}
55
56/// Default gRPC port
57fn default_grpc_port() -> u16 {
58    50051
59}
60
61/// Default request timeout in seconds
62fn default_request_timeout_seconds() -> u64 {
63    30
64}
65
66/// Configuration for response transformations
67#[derive(Debug, Clone, Deserialize, Serialize, Default)]
68pub struct ResponseTransformConfig {
69    /// Enable response transformations
70    pub enabled: bool,
71    /// Custom headers to add to all responses
72    pub custom_headers: std::collections::HashMap<String, String>,
73    /// Response body overrides using the override system
74    pub overrides: Option<Overrides>,
75    /// Enable response validation
76    pub validate_responses: bool,
77}
78
79impl ProxyConfig {
80    /// Check if a service is allowed
81    pub fn is_service_allowed(&self, service_name: &str) -> bool {
82        // If service is explicitly denied, it's not allowed
83        if self.denylist.contains(service_name) {
84            return false;
85        }
86
87        // If we require explicit allow and service is not in allowlist, it's not allowed
88        if self.require_explicit_allow
89            && !self.allowlist.is_empty()
90            && !self.allowlist.contains(service_name)
91        {
92            return false;
93        }
94
95        true
96    }
97
98    /// Check if a service is denied
99    pub fn is_service_denied(&self, service_name: &str) -> bool {
100        self.denylist.contains(service_name)
101    }
102}
103
104#[cfg(test)]
105mod tests {
106
107    #[test]
108    fn test_module_compiles() {}
109}