ferripfs-config 0.1.0

IPFS node configuration types, compatible with Kubo config format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

// Ported from: kubo/config/gateway.go
// Kubo version: v0.39.0
// Original: https://github.com/ipfs/kubo/blob/v0.39.0/config/gateway.go
//
// Original work: Copyright (c) Protocol Labs, Inc.
// Port: Copyright (c) 2026 ferripfs contributors
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Gateway configuration for HTTP gateway.

use crate::{Flag, OptionalDuration, OptionalInteger, OptionalString};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Gateway configuration section
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Gateway {
    /// HTTP headers to include in responses
    #[serde(default, rename = "HTTPHeaders")]
    pub http_headers: HashMap<String, Vec<String>>,

    /// Root redirect URL
    #[serde(default)]
    pub root_redirect: String,

    /// Disable fetching content from network
    #[serde(default)]
    pub no_fetch: bool,

    /// Disable DNSLink resolution
    #[serde(default, rename = "NoDNSLink")]
    pub no_dns_link: bool,

    /// Enable deserialized responses
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deserialized_responses: Option<Flag>,

    /// Disable HTML error pages
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "DisableHTMLErrors"
    )]
    pub disable_html_errors: Option<Flag>,

    /// Public gateway configurations by hostname
    #[serde(default)]
    pub public_gateways: HashMap<String, GatewaySpec>,

    /// Expose routing API
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "ExposeRoutingAPI"
    )]
    pub expose_routing_api: Option<Flag>,

    /// Content retrieval timeout
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retrieval_timeout: Option<OptionalDuration>,

    /// Maximum concurrent requests
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_requests: Option<OptionalInteger>,

    /// Maximum file size for range requests
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_range_request_file_size: Option<OptionalString>,

    /// Diagnostic service URL
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "DiagnosticServiceURL"
    )]
    pub diagnostic_service_url: Option<OptionalString>,
}

/// Gateway specification for public gateways
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct GatewaySpec {
    /// Paths to serve (e.g., "/ipfs", "/ipns")
    #[serde(default)]
    pub paths: Vec<String>,

    /// Use subdomain-based gateway
    #[serde(default)]
    pub use_subdomains: bool,

    /// Disable DNSLink for this gateway
    #[serde(default, rename = "NoDNSLink")]
    pub no_dns_link: bool,

    /// Inline DNSLink resolution
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "InlineDNSLink"
    )]
    pub inline_dns_link: Option<Flag>,

    /// Enable deserialized responses for this gateway
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deserialized_responses: Option<Flag>,
}

impl Gateway {
    /// Default paths for public gateways
    pub fn default_paths() -> Vec<String> {
        vec!["/ipfs".to_string(), "/ipns".to_string()]
    }

    /// Get default HTTP headers
    pub fn default_http_headers() -> HashMap<String, Vec<String>> {
        let mut headers = HashMap::new();
        headers.insert(
            "Access-Control-Allow-Origin".to_string(),
            vec!["*".to_string()],
        );
        headers.insert(
            "Access-Control-Allow-Methods".to_string(),
            vec!["GET".to_string()],
        );
        headers.insert(
            "Access-Control-Allow-Headers".to_string(),
            vec![
                "X-Requested-With".to_string(),
                "Range".to_string(),
                "User-Agent".to_string(),
            ],
        );
        headers.insert(
            "Access-Control-Expose-Headers".to_string(),
            vec![
                "Content-Range".to_string(),
                "X-Chunked-Output".to_string(),
                "X-Stream-Output".to_string(),
            ],
        );
        headers
    }
}

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

    #[test]
    fn test_gateway_default() {
        let gw = Gateway::default();
        assert!(gw.http_headers.is_empty());
        assert!(!gw.no_fetch);
    }

    #[test]
    fn test_default_paths() {
        let paths = Gateway::default_paths();
        assert!(paths.contains(&"/ipfs".to_string()));
        assert!(paths.contains(&"/ipns".to_string()));
    }

    #[test]
    fn test_default_headers() {
        let headers = Gateway::default_http_headers();
        assert!(headers.contains_key("Access-Control-Allow-Origin"));
    }
}