tideway 0.7.17

A batteries-included Rust web framework built on Axum for building SaaS applications quickly
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

use crate::utils::get_env_with_prefix;
use serde::{Deserialize, Serialize};

/// Cache backend type
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CacheBackend {
    /// In-memory cache (default)
    #[default]
    InMemory,
    /// Redis cache (requires cache-redis feature)
    #[cfg(feature = "cache-redis")]
    Redis,
    /// No-op cache (for testing)
    NoOp,
}

/// Cache configuration
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CacheConfig {
    /// Cache backend type
    #[serde(default)]
    pub backend: CacheBackend,

    /// Redis connection URL (only used for Redis backend)
    #[serde(default)]
    pub redis_url: Option<String>,

    /// Default TTL for cached values (in seconds)
    #[serde(default = "default_ttl_seconds")]
    pub default_ttl_seconds: u64,

    /// Maximum number of entries for in-memory cache
    #[serde(default = "default_max_entries")]
    pub max_entries: usize,
}

impl Default for CacheConfig {
    fn default() -> Self {
        Self {
            backend: CacheBackend::default(),
            redis_url: None,
            default_ttl_seconds: default_ttl_seconds(),
            max_entries: default_max_entries(),
        }
    }
}

impl CacheConfig {
    /// Load cache configuration from environment variables
    pub fn from_env() -> Self {
        let mut config = Self::default();

        if let Some(backend) = get_env_with_prefix("CACHE_BACKEND") {
            config.backend = match backend.to_lowercase().as_str() {
                "redis" => {
                    #[cfg(feature = "cache-redis")]
                    {
                        CacheBackend::Redis
                    }
                    #[cfg(not(feature = "cache-redis"))]
                    {
                        tracing::warn!(
                            "Redis cache requested but cache-redis feature not enabled, using in-memory"
                        );
                        CacheBackend::InMemory
                    }
                }
                "noop" => CacheBackend::NoOp,
                _ => CacheBackend::InMemory,
            };
        }

        if let Some(url) = get_env_with_prefix("CACHE_REDIS_URL") {
            config.redis_url = Some(url);
        }

        if let Some(ttl) = get_env_with_prefix("CACHE_DEFAULT_TTL_SECONDS") {
            if let Ok(seconds) = ttl.parse() {
                config.default_ttl_seconds = seconds;
            }
        }

        if let Some(max) = get_env_with_prefix("CACHE_MAX_ENTRIES") {
            if let Ok(entries) = max.parse() {
                config.max_entries = entries;
            }
        }

        config
    }
}

fn default_ttl_seconds() -> u64 {
    3600 // 1 hour
}

fn default_max_entries() -> usize {
    10000
}