Skip to main content

fraiseql_cli/config/toml_schema/
federation.rs

1//! Apollo Federation configuration types.
2
3use serde::{Deserialize, Serialize};
4
5/// Circuit breaker configuration for a specific federated database/service
6#[derive(Debug, Clone, Deserialize, Serialize)]
7#[serde(deny_unknown_fields)]
8pub struct PerDatabaseCircuitBreakerOverride {
9    /// Database or service name matching a federation entity
10    pub database:              String,
11    /// Override: number of consecutive failures before opening (must be > 0)
12    pub failure_threshold:     Option<u32>,
13    /// Override: seconds to wait before attempting recovery (must be > 0)
14    pub recovery_timeout_secs: Option<u64>,
15    /// Override: successes required in half-open state to close the breaker (must be > 0)
16    pub success_threshold:     Option<u32>,
17}
18
19/// Circuit breaker configuration for Apollo Federation fan-out requests
20#[derive(Debug, Clone, Deserialize, Serialize)]
21#[serde(default, deny_unknown_fields)]
22pub struct FederationCircuitBreakerConfig {
23    /// Enable circuit breaker protection on federation fan-out
24    pub enabled:               bool,
25    /// Consecutive failures before the breaker opens (default: 5, must be > 0)
26    pub failure_threshold:     u32,
27    /// Seconds to wait before attempting a probe request (default: 30, must be > 0)
28    pub recovery_timeout_secs: u64,
29    /// Probe successes needed to transition from half-open to closed (default: 2, must be > 0)
30    pub success_threshold:     u32,
31    /// Per-database overrides (database name must match a defined federation entity)
32    pub per_database:          Vec<PerDatabaseCircuitBreakerOverride>,
33}
34
35impl Default for FederationCircuitBreakerConfig {
36    fn default() -> Self {
37        Self {
38            enabled:               true,
39            failure_threshold:     5,
40            recovery_timeout_secs: 30,
41            success_threshold:     2,
42            per_database:          vec![],
43        }
44    }
45}
46
47/// Federation configuration
48#[derive(Debug, Clone, Deserialize, Serialize)]
49#[serde(default, deny_unknown_fields)]
50pub struct FederationConfig {
51    /// Enable Apollo federation
52    #[serde(default)]
53    pub enabled:         bool,
54    /// Apollo federation version
55    pub apollo_version:  Option<u32>,
56    /// Federated entities
57    pub entities:        Vec<FederationEntity>,
58    /// Circuit breaker configuration for federation fan-out requests
59    pub circuit_breaker: Option<FederationCircuitBreakerConfig>,
60}
61
62impl Default for FederationConfig {
63    fn default() -> Self {
64        Self {
65            enabled:         false,
66            apollo_version:  Some(2),
67            entities:        vec![],
68            circuit_breaker: None,
69        }
70    }
71}
72
73/// Federation entity
74#[derive(Debug, Clone, Deserialize, Serialize)]
75#[serde(deny_unknown_fields)]
76pub struct FederationEntity {
77    /// Entity name
78    pub name:       String,
79    /// Key fields for entity resolution
80    pub key_fields: Vec<String>,
81}