1use serde::{Deserialize, Serialize};
2
3#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
5pub struct PresetIr {
6 pub name: String,
7 pub version: u32,
8 pub digest: String,
9}
10
11#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
13pub struct TenantIr {
14 pub enabled: bool,
15}
16
17#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
19pub struct ServerIr {
20 pub security_headers: SecurityHeadersIr,
21}
22
23impl ServerIr {
24 #[must_use]
25 pub fn is_default(&self) -> bool {
26 *self == Self::default()
27 }
28}
29
30#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
32pub struct SecurityHeadersIr {
33 pub enabled: bool,
34 pub hsts: HstsIr,
35 pub frame_options: FrameOptionsIr,
36 pub referrer_policy: ReferrerPolicyIr,
37 #[serde(default, skip_serializing_if = "Option::is_none")]
38 pub content_security_policy: Option<String>,
39 #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
40 pub custom: std::collections::BTreeMap<String, String>,
41}
42
43impl SecurityHeadersIr {
44 #[must_use]
45 pub fn is_default(&self) -> bool {
46 *self == Self::default()
47 }
48}
49
50impl Default for SecurityHeadersIr {
51 fn default() -> Self {
52 Self {
53 enabled: true,
54 hsts: HstsIr::Auto,
55 frame_options: FrameOptionsIr::Deny,
56 referrer_policy: ReferrerPolicyIr::StrictOriginWhenCrossOrigin,
57 content_security_policy: None,
58 custom: std::collections::BTreeMap::new(),
59 }
60 }
61}
62
63#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
65#[serde(rename_all = "snake_case")]
66pub enum HstsIr {
67 Auto,
68 Off,
69 MaxAge(u64),
70}
71
72#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
74#[serde(rename_all = "snake_case")]
75pub enum FrameOptionsIr {
76 Deny,
77 SameOrigin,
78 Off,
79}
80
81#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
83#[serde(rename_all = "snake_case")]
84pub enum ReferrerPolicyIr {
85 NoReferrer,
86 SameOrigin,
87 StrictOriginWhenCrossOrigin,
88 Off,
89}
90
91#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
93pub struct AuditIr {
94 pub enabled: bool,
95 pub reader_roles: Vec<String>,
96}
97
98#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
100pub struct MailIr {
101 pub enabled: bool,
102 pub provider: MailProviderIr,
103 pub from: String,
104 pub templates: Vec<MailTemplateIr>,
105}
106
107#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
108#[serde(rename_all = "snake_case")]
109pub enum MailProviderIr {
110 #[default]
111 Capture,
112 Smtp,
113 Resend,
114}
115
116#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
117pub struct MailTemplateIr {
118 pub name: String,
119 pub subject: String,
120 pub text: String,
121 pub html: Option<String>,
122}
123
124#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
126pub struct JobsIr {
127 pub enabled: bool,
128 pub poll_interval_ms: u64,
129 pub lease_seconds: u64,
130 pub queues: Vec<JobQueueIr>,
131 #[serde(default, skip_serializing_if = "Vec::is_empty")]
132 pub schedules: Vec<JobScheduleIr>,
133}
134
135#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
136pub struct JobQueueIr {
137 pub name: String,
138 pub max_attempts: u32,
139 pub backoff_seconds: u64,
140}
141
142#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
144pub struct JobScheduleIr {
145 pub name: String,
146 pub cron: String,
147 #[serde(default, skip_serializing_if = "Option::is_none")]
148 pub interval_seconds: Option<u64>,
149 pub queue: String,
150 pub kind: String,
151 pub payload: String,
152}
153
154#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
156pub struct WebhooksIr {
157 pub enabled: bool,
158 pub poll_interval_ms: u64,
159 pub connect_timeout_ms: u64,
160 pub read_timeout_ms: u64,
161 pub request_timeout_ms: u64,
162 pub endpoints: Vec<WebhookEndpointIr>,
163}
164
165impl WebhooksIr {
166 #[must_use]
167 pub fn is_disabled(&self) -> bool {
168 !self.enabled && self.endpoints.is_empty()
169 }
170}
171
172#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
173pub struct WebhookEndpointIr {
174 pub name: String,
175 pub url: String,
176 pub secret_env: String,
177 pub events: Vec<String>,
178 pub max_attempts: u32,
179 pub backoff_seconds: u64,
180}
181
182#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
184pub struct RealtimeIr {
185 pub enabled: bool,
186 pub heartbeat_seconds: u64,
187 pub presence_ttl_seconds: u64,
188}
189
190impl RealtimeIr {
191 #[must_use]
192 pub fn is_disabled(&self) -> bool {
193 !self.enabled
194 }
195}
196
197#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
199pub struct FileIr {
200 pub enabled: bool,
201 pub provider: FileProviderIr,
202 pub local_root: String,
203 pub max_bytes: u64,
204 pub allowed_content_types: Vec<String>,
205}
206
207#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
208pub struct ReportIr {
209 pub enabled: bool,
210 #[serde(default, skip_serializing_if = "ReportRendererIr::is_capture")]
211 pub renderer: ReportRendererIr,
212 pub queue: String,
213 pub max_input_bytes: u64,
214 pub retention_days: u32,
215 pub reader_roles: Vec<String>,
216 pub templates: Vec<ReportTemplateIr>,
217}
218
219#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
220#[serde(rename_all = "snake_case")]
221pub enum ReportRendererIr {
222 #[default]
223 Capture,
224 Chromium,
225}
226
227impl ReportRendererIr {
228 #[must_use]
229 pub const fn version(self) -> &'static str {
230 match self {
231 Self::Capture => "capture-v1",
232 Self::Chromium => "chromium-v1",
233 }
234 }
235 #[allow(clippy::trivially_copy_pass_by_ref)]
236 const fn is_capture(&self) -> bool {
237 matches!(self, Self::Capture)
238 }
239}
240
241impl ReportIr {
242 #[must_use]
243 pub fn is_disabled(&self) -> bool {
244 !self.enabled && self.templates.is_empty()
245 }
246}
247
248#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
249pub struct ReportTemplateIr {
250 pub name: String,
251 pub version: u32,
252 pub document_type: String,
253 pub body: String,
254 pub artifact_digest: String,
255 pub input_schema: String,
256 pub data_schema_version: u32,
257}
258
259#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
261pub struct ActivityIr {
262 pub enabled: bool,
263 pub max_comment_bytes: u32,
264 pub attachments: bool,
265 pub admin_roles: Vec<String>,
266 pub resources: Vec<ActivityResourceIr>,
267}
268
269impl ActivityIr {
270 #[must_use]
271 pub fn is_disabled(&self) -> bool {
272 !self.enabled && self.resources.is_empty()
273 }
274
275 #[must_use]
276 pub fn resource_for_entity(&self, entity: &crate::EntityId) -> Option<&ActivityResourceIr> {
277 self.resources
278 .iter()
279 .find(|resource| resource.entity == *entity)
280 }
281
282 #[must_use]
283 pub fn resource(&self, key: &str) -> Option<&ActivityResourceIr> {
284 self.resources
285 .iter()
286 .find(|resource| resource.resource == key)
287 }
288}
289
290#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
291pub struct ActivityResourceIr {
292 pub entity: crate::EntityId,
293 pub resource: String,
294}
295
296#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
297#[serde(rename_all = "snake_case")]
298pub enum FileProviderIr {
299 #[default]
300 Local,
301 S3,
302}