ferripfs-config 0.1.0

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

//! Configuration types for ferripfs, ported from Kubo's config package.

mod addresses;
mod api;
mod datastore;
mod gateway;
mod identity;
mod profile;
mod routing;
mod swarm;
mod types;

pub use addresses::*;
pub use api::*;
pub use datastore::*;
pub use gateway::*;
pub use identity::*;
pub use profile::*;
pub use routing::*;
pub use swarm::*;
pub use types::*;

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Default IPFS path name
pub const DEFAULT_PATH_NAME: &str = ".ipfs";

/// Default IPFS path root
pub const DEFAULT_PATH_ROOT: &str = "~/.ipfs";

/// Default config file name
pub const DEFAULT_CONFIG_FILE: &str = "config";

/// Environment variable for IPFS path
pub const ENV_DIR: &str = "IPFS_PATH";

/// Main configuration struct, matching Kubo's Config
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Config {
    /// Node identity (PeerID and private key)
    #[serde(default)]
    pub identity: Identity,

    /// Datastore configuration
    #[serde(default)]
    pub datastore: Datastore,

    /// Network addresses
    #[serde(default)]
    pub addresses: Addresses,

    /// Mount points configuration
    #[serde(default)]
    pub mounts: Mounts,

    /// Discovery settings
    #[serde(default)]
    pub discovery: Discovery,

    /// Routing configuration
    #[serde(default)]
    pub routing: Routing,

    /// IPNS settings
    #[serde(default, rename = "Ipns")]
    pub ipns: Ipns,

    /// Bootstrap peers (multiaddrs)
    #[serde(default, rename = "Bootstrap")]
    pub bootstrap: Vec<String>,

    /// Gateway configuration
    #[serde(default)]
    pub gateway: Gateway,

    /// API configuration
    #[serde(default, rename = "API")]
    pub api: Api,

    /// Swarm configuration
    #[serde(default)]
    pub swarm: SwarmConfig,

    /// AutoNAT configuration
    #[serde(default, rename = "AutoNAT")]
    pub auto_nat: AutoNatConfig,

    /// Pubsub configuration
    #[serde(default)]
    pub pubsub: PubsubConfig,

    /// Peering configuration
    #[serde(default)]
    pub peering: Peering,

    /// DNS configuration
    #[serde(default, rename = "DNS")]
    pub dns: DnsConfig,

    /// Migration settings
    #[serde(default)]
    pub migration: Migration,

    /// Experimental features
    #[serde(default)]
    pub experimental: Experiments,

    /// Pinning configuration
    #[serde(default)]
    pub pinning: Pinning,

    /// Import settings
    #[serde(default)]
    pub import: Import,

    /// Internal settings
    #[serde(default)]
    pub internal: Internal,
}

impl Config {
    /// Parse config from JSON string.
    ///
    /// # Security
    ///
    /// This performs only JSON deserialization. Call `validate()` after
    /// deserialization to perform security-relevant validation.
    pub fn parse(s: &str) -> Result<Self, serde_json::Error> {
        serde_json::from_str(s)
    }

    /// Parse config from reader.
    ///
    /// # Security
    ///
    /// This performs only JSON deserialization. Call `validate()` after
    /// deserialization to perform security-relevant validation.
    pub fn from_reader<R: std::io::Read>(reader: R) -> Result<Self, serde_json::Error> {
        serde_json::from_reader(reader)
    }

    /// Validate configuration values.
    ///
    /// # Security
    ///
    /// This validates:
    /// - Address formats (API, Gateway, Swarm)
    /// - Bootstrap peer multiaddrs
    /// - Peer ID format (when present)
    /// - Numeric values are within reasonable ranges
    ///
    /// Returns a list of validation warnings (non-fatal issues) and
    /// returns an error for critical validation failures.
    pub fn validate(&self) -> Result<Vec<String>, ConfigError> {
        let mut warnings = Vec::new();

        // Validate swarm addresses
        for addr in &self.addresses.swarm {
            if !Self::is_valid_multiaddr_format(addr) {
                warnings.push(format!("Swarm address may be malformed: {}", addr));
            }
        }

        // Validate API addresses
        for addr in self.addresses.api.iter() {
            if !Self::is_valid_multiaddr_format(addr) {
                warnings.push(format!("API address may be malformed: {}", addr));
            }
        }

        // Validate Gateway addresses
        for addr in self.addresses.gateway.iter() {
            if !Self::is_valid_multiaddr_format(addr) {
                warnings.push(format!("Gateway address may be malformed: {}", addr));
            }
        }

        // Validate bootstrap peers
        for addr in &self.bootstrap {
            if !Self::is_valid_multiaddr_format(addr) {
                warnings.push(format!("Bootstrap address may be malformed: {}", addr));
            }
        }

        // Validate peer ID format (should be base58 encoded)
        if !self.identity.peer_id.is_empty()
            && !Self::is_valid_peer_id_format(&self.identity.peer_id)
        {
            return Err(ConfigError::InvalidKey(format!(
                "Invalid PeerID format: {}",
                self.identity.peer_id
            )));
        }

        // Validate connection manager values if present
        let conn_mgr = &self.swarm.conn_mgr;
        if let (Some(ref low), Some(ref high)) = (&conn_mgr.low_water, &conn_mgr.high_water) {
            if let (Some(low_val), Some(high_val)) = (low.value(), high.value()) {
                if low_val > high_val {
                    warnings.push(format!(
                        "ConnMgr.LowWater ({}) > HighWater ({})",
                        low_val, high_val
                    ));
                }
            }
        }

        Ok(warnings)
    }

    /// Check if a string looks like a valid multiaddr format.
    ///
    /// This is a basic format check, not full multiaddr validation.
    fn is_valid_multiaddr_format(addr: &str) -> bool {
        // Basic checks: must start with /, contain valid protocol names
        if !addr.starts_with('/') {
            return false;
        }
        // Should contain at least one known protocol
        let known_protocols = [
            "/ip4/",
            "/ip6/",
            "/tcp/",
            "/udp/",
            "/quic/",
            "/quic-v1/",
            "/ws/",
            "/wss/",
            "/p2p/",
            "/ipfs/",
            "/dns/",
            "/dns4/",
            "/dns6/",
            "/dnsaddr/",
            "/unix/",
        ];
        known_protocols.iter().any(|p| addr.contains(p))
    }

    /// Check if a string looks like a valid peer ID format.
    ///
    /// Peer IDs are typically base58-encoded multihashes starting with "12D3" or "Qm".
    fn is_valid_peer_id_format(peer_id: &str) -> bool {
        // Peer IDs are base58 encoded, common prefixes are:
        // - "12D3K" for Ed25519 keys
        // - "Qm" for RSA keys (sha256)
        // - "16U" for secp256k1
        if peer_id.is_empty() {
            return false;
        }
        // Must be valid base58 characters
        peer_id
            .chars()
            .all(|c| c.is_ascii_alphanumeric() && c != '0' && c != 'O' && c != 'I' && c != 'l')
    }

    /// Serialize config to JSON string
    pub fn to_string_pretty(&self) -> Result<String, serde_json::Error> {
        serde_json::to_string_pretty(self)
    }

    /// Get a config value by dot-separated key path
    pub fn get_key(&self, key: &str) -> Option<serde_json::Value> {
        let json = serde_json::to_value(self).ok()?;
        let parts: Vec<&str> = key.split('.').collect();
        let mut current = &json;

        for part in parts {
            current = current.get(part)?;
        }

        Some(current.clone())
    }

    /// Set a config value by dot-separated key path
    pub fn set_key(&mut self, key: &str, value: serde_json::Value) -> Result<(), ConfigError> {
        let mut json = serde_json::to_value(&self)?;
        let parts: Vec<&str> = key.split('.').collect();

        if parts.is_empty() {
            return Err(ConfigError::InvalidKey(key.to_string()));
        }

        // Navigate to the parent object
        let mut current = &mut json;
        for part in &parts[..parts.len() - 1] {
            current = current
                .get_mut(*part)
                .ok_or_else(|| ConfigError::InvalidKey(key.to_string()))?;
        }

        // Set the final value
        let last_part = parts.last().unwrap();
        if let Some(obj) = current.as_object_mut() {
            obj.insert(last_part.to_string(), value);
        } else {
            return Err(ConfigError::InvalidKey(key.to_string()));
        }

        *self = serde_json::from_value(json)?;
        Ok(())
    }
}

/// Mount points configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Mounts {
    #[serde(default, rename = "IPFS")]
    pub ipfs: String,
    #[serde(default, rename = "IPNS")]
    pub ipns: String,
    #[serde(default, rename = "FuseAllowOther")]
    pub fuse_allow_other: bool,
}

/// Discovery configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Discovery {
    #[serde(default, rename = "MDNS")]
    pub mdns: Mdns,
}

/// mDNS discovery settings
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Mdns {
    #[serde(default)]
    pub enabled: bool,
}

/// IPNS configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Ipns {
    #[serde(default)]
    pub republish_period: String,
    #[serde(default)]
    pub record_lifetime: String,
    #[serde(default)]
    pub resolve_cache_size: i32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_cache_ttl: Option<OptionalDuration>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub use_pubsub: Option<Flag>,
}

/// AutoNAT configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AutoNatConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub throttle: Option<AutoNatThrottle>,
}

/// AutoNAT throttle settings
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AutoNatThrottle {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub global_limit: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub peer_limit: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interval: Option<OptionalDuration>,
}

/// Pubsub configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PubsubConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<Flag>,
    #[serde(default)]
    pub router: String,
}

/// Peering configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Peering {
    #[serde(default)]
    pub peers: Vec<PeeringPeer>,
}

/// A peer in the peering list
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PeeringPeer {
    #[serde(default, rename = "ID")]
    pub id: String,
    #[serde(default)]
    pub addrs: Vec<String>,
}

/// DNS configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct DnsConfig {
    #[serde(default)]
    pub resolvers: HashMap<String, String>,
}

/// Migration settings
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Migration {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub download_sources: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub keep: Option<String>,
}

/// Experimental features
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Experiments {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filestore_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url_store_enabled: Option<bool>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "GraphsyncEnabled"
    )]
    pub graphsync_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub libp2p_stream_mounting: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub p2p_http_proxy: Option<bool>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "OptimisticProvide"
    )]
    pub optimistic_provide: Option<bool>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "OptimisticProvideJobsPoolSize"
    )]
    pub optimistic_provide_jobs_pool_size: Option<i32>,
}

/// Pinning configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Pinning {
    #[serde(default)]
    pub remote_services: HashMap<String, RemotePinningService>,
}

/// Remote pinning service configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct RemotePinningService {
    #[serde(default, rename = "API")]
    pub api: RemotePinningApi,
    #[serde(default)]
    pub policies: RemotePinningPolicies,
}

/// Remote pinning API settings
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct RemotePinningApi {
    #[serde(default)]
    pub endpoint: String,
    #[serde(default)]
    pub key: String,
}

/// Remote pinning policies
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct RemotePinningPolicies {
    #[serde(default, rename = "MFS")]
    pub mfs: MfsPinPolicy,
}

/// MFS pin policy
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct MfsPinPolicy {
    #[serde(default)]
    pub enabled: bool,
    #[serde(default)]
    pub pin_name: String,
    #[serde(default)]
    pub repinning_interval: String,
}

/// Import configuration
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Import {
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "CidVersion"
    )]
    pub cid_version: Option<OptionalInteger>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hash_function: Option<OptionalString>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unixfs_raw_leaves: Option<Flag>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "UnixFSChunker"
    )]
    pub unixfs_chunker: Option<OptionalString>,
}

/// Internal settings
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Internal {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bitswap: Option<InternalBitswap>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "UnixFSShardingSizeThreshold"
    )]
    pub unixfs_sharding_size_threshold: Option<OptionalString>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub libp2p_force_pnet: Option<Flag>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub backoff_init: Option<OptionalDuration>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub backoff_max: Option<OptionalDuration>,
}

/// Internal bitswap settings
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct InternalBitswap {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_worker_count: Option<OptionalInteger>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub engine_block_store_worker_count: Option<OptionalInteger>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub engine_task_worker_count: Option<OptionalInteger>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_outstanding_bytes_per_peer: Option<OptionalInteger>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provide_enabled: Option<Flag>,
}

/// Configuration error type
#[derive(Debug, thiserror::Error)]
pub enum ConfigError {
    #[error("JSON error: {0}")]
    Json(#[from] serde_json::Error),
    #[error("Invalid key: {0}")]
    InvalidKey(String),
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
}

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

    #[test]
    fn test_default_config() {
        let config = Config::default();
        let json = config.to_string_pretty().unwrap();
        assert!(json.contains("Identity"));
    }

    #[test]
    fn test_config_roundtrip() {
        let config = Config::default();
        let json = config.to_string_pretty().unwrap();
        let parsed: Config = Config::parse(&json).unwrap();
        assert_eq!(config.identity.peer_id, parsed.identity.peer_id);
    }
}