foundation_toolings 0.0.1

Development tooling server: reverse proxy, file watcher, hot reload — built on valtron and native APIs, zero async runtime deps
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

// Public API types — preserved signatures for compatibility with ewe_devserver consumers.
// Uses foundation_http/foundation_netio types internally.

use std::time;

use derive_more::{Debug, From};

// -- Proxy configuration

#[derive(Debug, Default, Clone, From)]
pub struct ProxyRemoteConfig {
    pub addr: String,
    pub port: usize,
}

impl ProxyRemoteConfig {
    #[must_use]
    pub fn new(addr: String, port: usize) -> Self {
        Self { addr, port }
    }
}

impl core::fmt::Display for ProxyRemoteConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}:{}", self.addr, self.port)
    }
}

// -- Tunnel

#[derive(Debug, Clone, From)]
pub struct Tunnel {
    pub source: ProxyRemoteConfig,
    pub destination: ProxyRemoteConfig,
}

impl core::fmt::Display for Tunnel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}

impl Tunnel {
    #[must_use]
    pub fn new(source: ProxyRemoteConfig, destination: ProxyRemoteConfig) -> Self {
        Self { source, destination }
    }
}

// -- Proxy transport protocols

#[derive(Debug, Clone)]
pub enum ProxyType {
    Tunnel(Tunnel),
    Http1(Http1),
    Http2(Http2),
    Http3(Http3),
}

impl core::fmt::Display for ProxyType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}

impl ProxyType {
    pub fn and_routes(&mut self, _mutator: impl Fn(&mut std::collections::HashMap<String, String>)) {
        // Routes are handled by foundation_http HttpApp + Serve handlers.
        // This method exists for API compat with old ewe_devserver consumers.
    }
}

// -- Http1

#[derive(Debug, Clone, From)]
pub struct Http1 {
    pub source: ProxyRemoteConfig,
    pub destination: ProxyRemoteConfig,
}

impl Http1 {
    #[must_use]
    pub fn new(source: ProxyRemoteConfig, destination: ProxyRemoteConfig) -> Self {
        Self { source, destination }
    }
}

impl core::fmt::Display for Http1 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Http1(source: {:?}, destination: {:?})", self.source, self.destination)
    }
}

// -- Http2 (stub — not implemented)

#[derive(Debug, Clone, From)]
pub struct Http2 {
    pub source: ProxyRemoteConfig,
    pub destination: ProxyRemoteConfig,
}

impl Http2 {
    #[must_use]
    pub fn new(source: ProxyRemoteConfig, destination: ProxyRemoteConfig) -> Self {
        Self { source, destination }
    }
}

impl core::fmt::Display for Http2 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Http2(source: {:?}, destination: {:?})", self.source, self.destination)
    }
}

// -- Http3 (stub — not implemented)

#[derive(Debug, Clone, From)]
pub struct Http3 {
    pub source: ProxyRemoteConfig,
    pub destination: ProxyRemoteConfig,
}

impl Http3 {
    #[must_use]
    pub fn new(source: ProxyRemoteConfig, destination: ProxyRemoteConfig) -> Self {
        Self { source, destination }
    }
}

impl core::fmt::Display for Http3 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Http3(source: {:?}, destination: {:?})", self.source, self.destination)
    }
}

// -- ProjectDefinition

#[derive(Clone, Debug, From)]
pub struct ProjectDefinition {
    pub proxy: ProxyType,
    pub target_directory: String,
    pub workspace_root: String,
    pub crate_name: String,
    pub skip_rust_checks: bool,
    pub stop_on_failure: bool,
    pub reload_directories: Vec<String>,
    pub build_directories: Vec<String>,
    pub build_arguments: Vec<String>,
    pub run_arguments: Vec<String>,
    pub wait_before_reload: time::Duration,
}

impl core::fmt::Display for ProjectDefinition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}