Skip to main content

appstruct_ir/
service.rs

1use serde::{Deserialize, Serialize};
2
3/// Locked official preset selected by the root App Spec.
4#[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/// Tenant module settings normalized by the compiler.
12#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
13pub struct TenantIr {
14    pub enabled: bool,
15}
16
17/// Application server settings normalized by the compiler.
18#[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/// Security response headers applied to every generated route.
31#[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/// Strict-Transport-Security policy. `Auto` emits the header only in production.
64#[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/// X-Frame-Options policy.
73#[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/// Referrer-Policy policy.
82#[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/// Audit module settings normalized by the compiler.
92#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
93pub struct AuditIr {
94    pub enabled: bool,
95    pub reader_roles: Vec<String>,
96}
97
98/// Mail module settings and compile-time validated templates.
99#[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/// PostgreSQL-backed job worker settings.
125#[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/// Declarative recurring job schedule.
143#[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/// PostgreSQL outbox-backed signed webhook settings.
155#[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/// Authenticated server-sent events and database-backed online presence.
183#[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/// File metadata and object-storage settings.
198#[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/// Record-scoped collaboration settings and the entities that expose a timeline.
260#[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}