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
101
102
103
104
105

//! Development mode configuration

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

/// Development mode configuration
///
/// Controls development-specific features like enhanced error responses
/// and request/response dumping.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DevConfig {
    /// Enable development mode (enhanced errors, request dumper, etc.)
    #[serde(default)]
    pub enabled: bool,
    /// Include stack traces in error responses
    #[serde(default)]
    pub include_stack_traces: bool,
    /// Enable request/response dumper middleware
    #[serde(default)]
    pub enable_request_dumper: bool,
    /// Only dump requests matching this path pattern (empty = all)
    #[serde(default)]
    pub dump_path_pattern: Option<String>,
}

impl DevConfig {
    /// Create dev config from environment variables
    ///
    /// Environment variables:
    /// - `TIDEWAY_DEV_MODE`: Enable dev mode (default: false)
    /// - `TIDEWAY_DEV_STACK_TRACES`: Include stack traces (default: false)
    /// - `TIDEWAY_DEV_DUMP_REQUESTS`: Enable request dumper (default: false)
    /// - `TIDEWAY_DEV_DUMP_PATH`: Path pattern to dump (default: all)
    pub fn from_env() -> Self {
        let enabled = get_env_with_prefix("DEV_MODE")
            .map(|v| v.parse().unwrap_or(false))
            .unwrap_or(false);

        let include_stack_traces = get_env_with_prefix("DEV_STACK_TRACES")
            .map(|v| v.parse().unwrap_or(false))
            .unwrap_or(false);

        let enable_request_dumper = get_env_with_prefix("DEV_DUMP_REQUESTS")
            .map(|v| v.parse().unwrap_or(false))
            .unwrap_or(false);

        let dump_path_pattern = get_env_with_prefix("DEV_DUMP_PATH");

        Self {
            enabled,
            include_stack_traces,
            enable_request_dumper,
            dump_path_pattern,
        }
    }

    /// Check if dev mode is enabled
    pub fn is_dev_mode(&self) -> bool {
        self.enabled
    }
}

/// Builder for DevConfig
#[must_use = "builder does nothing until you call build()"]
pub struct DevConfigBuilder {
    config: DevConfig,
}

impl DevConfigBuilder {
    pub fn new() -> Self {
        Self {
            config: DevConfig::default(),
        }
    }

    pub fn enabled(mut self, enabled: bool) -> Self {
        self.config.enabled = enabled;
        self
    }

    pub fn with_stack_traces(mut self, include: bool) -> Self {
        self.config.include_stack_traces = include;
        self
    }

    pub fn with_request_dumper(mut self, enabled: bool) -> Self {
        self.config.enable_request_dumper = enabled;
        self
    }

    pub fn with_dump_path_pattern(mut self, pattern: Option<String>) -> Self {
        self.config.dump_path_pattern = pattern;
        self
    }

    pub fn build(self) -> DevConfig {
        self.config
    }
}

impl Default for DevConfigBuilder {
    fn default() -> Self {
        Self::new()
    }
}