alien_core/resources/
storage.rs1use crate::error::{ErrorData, Result};
2use crate::resource::{ResourceDefinition, ResourceOutputsDefinition, ResourceRef};
3use crate::ResourceType;
4use alien_error::AlienError;
5use bon::Builder;
6use serde::{Deserialize, Serialize};
7use std::any::Any;
8use std::fmt::Debug;
9
10#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
12#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
13#[serde(rename_all = "camelCase", deny_unknown_fields)]
14pub struct LifecycleRule {
15 pub days: u32,
17 #[serde(default)]
19 pub prefix: Option<String>,
20}
21
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Builder)]
24#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
25#[serde(rename_all = "camelCase", deny_unknown_fields)]
26#[builder(start_fn = new)]
27pub struct Storage {
28 #[builder(start_fn)]
31 pub id: String,
32
33 #[serde(default)]
36 #[builder(default)]
37 pub public_read: bool,
38
39 #[serde(default)]
42 #[builder(default)]
43 pub versioning: bool,
44
45 #[serde(default)]
48 #[builder(default)]
49 pub lifecycle_rules: Vec<LifecycleRule>,
50
51 #[serde(default)]
58 #[builder(default)]
59 pub cors_allowed_origins: Vec<String>,
60
61 #[serde(default, skip_serializing_if = "Option::is_none")]
63 pub encryption_key: Option<ResourceRef>,
64}
65
66impl Storage {
67 pub const RESOURCE_TYPE: ResourceType = ResourceType::from_static("storage");
69
70 pub fn id(&self) -> &str {
72 &self.id
73 }
74}
75
76#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
78#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
79#[serde(rename_all = "camelCase")]
80pub struct StorageOutputs {
81 pub bucket_name: String,
83 }
85
86impl ResourceOutputsDefinition for StorageOutputs {
87 fn get_resource_type(&self) -> ResourceType {
88 Storage::RESOURCE_TYPE.clone()
89 }
90
91 fn as_any(&self) -> &dyn Any {
92 self
93 }
94
95 fn box_clone(&self) -> Box<dyn ResourceOutputsDefinition> {
96 Box::new(self.clone())
97 }
98
99 fn outputs_eq(&self, other: &dyn ResourceOutputsDefinition) -> bool {
100 other.as_any().downcast_ref::<StorageOutputs>() == Some(self)
101 }
102
103 fn to_json_value(&self) -> serde_json::Result<serde_json::Value> {
104 serde_json::to_value(self)
105 }
106}
107
108impl ResourceDefinition for Storage {
110 fn get_resource_type(&self) -> ResourceType {
111 Self::RESOURCE_TYPE
112 }
113
114 fn id(&self) -> &str {
115 &self.id
116 }
117
118 fn replace_after_failed_create_is_safe(&self) -> bool {
119 false
121 }
122
123 fn get_dependencies(&self) -> Vec<ResourceRef> {
124 self.encryption_key.iter().cloned().collect()
125 }
126
127 fn validate_update(&self, new_config: &dyn ResourceDefinition) -> Result<()> {
128 let new_storage = new_config
130 .as_any()
131 .downcast_ref::<Storage>()
132 .ok_or_else(|| {
133 AlienError::new(ErrorData::UnexpectedResourceType {
134 resource_id: self.id.clone(),
135 expected: Self::RESOURCE_TYPE,
136 actual: new_config.get_resource_type(),
137 })
138 })?;
139
140 if self.id != new_storage.id {
141 return Err(AlienError::new(ErrorData::InvalidResourceUpdate {
142 resource_id: self.id.clone(),
143 reason: "the 'id' field is immutable".to_string(),
144 }));
145 }
146 if self.encryption_key != new_storage.encryption_key {
147 return Err(AlienError::new(ErrorData::InvalidResourceUpdate {
148 resource_id: self.id.clone(),
149 reason: "the 'encryptionKey' field is immutable once the resource exists"
150 .to_string(),
151 }));
152 }
153 Ok(())
154 }
155
156 fn as_any(&self) -> &dyn Any {
157 self
158 }
159
160 fn as_any_mut(&mut self) -> &mut dyn Any {
161 self
162 }
163
164 fn box_clone(&self) -> Box<dyn ResourceDefinition> {
165 Box::new(self.clone())
166 }
167
168 fn resource_eq(&self, other: &dyn ResourceDefinition) -> bool {
169 other.as_any().downcast_ref::<Storage>() == Some(self)
170 }
171
172 fn to_json_value(&self) -> serde_json::Result<serde_json::Value> {
173 serde_json::to_value(self)
174 }
175}
176
177#[cfg(test)]
178mod tests {
179 use super::*;
180
181 #[test]
182 fn encryption_key_is_an_implicit_dependency() {
183 let key = ResourceRef::new(crate::Key::RESOURCE_TYPE, "customer-key");
184 let storage = Storage::new("customer-data".to_string())
185 .encryption_key(key.clone())
186 .build();
187
188 assert_eq!(storage.get_dependencies(), vec![key]);
189 }
190}