1use appstruct_ir::{
2 AppIr, DatabaseProvider, FieldTypeIr, GeneratedValueIr, IrValidationErrors, OnDeleteIr,
3 validate_app_ir,
4};
5use serde::{Deserialize, Serialize};
6
7mod activity;
8mod audit;
9mod auth;
10mod billing;
11mod file;
12mod imports;
13mod jobs;
14mod mail;
15mod module_indexes;
16mod realtime;
17mod report;
18mod snapshot;
19mod tenant;
20mod webhooks;
21
22pub const SCHEMA_VERSION: u32 = appstruct_contracts::DATABASE_SCHEMA.current;
23pub use snapshot::{from_json, to_json};
24
25#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
26pub struct DatabaseSchema {
27 pub schema_version: u32,
28 pub provider: DatabaseProvider,
29 pub tables: Vec<TableSchema>,
30 pub unique_constraints: Vec<UniqueConstraintSchema>,
31 #[serde(default, skip_serializing_if = "Vec::is_empty")]
32 pub indexes: Vec<IndexSchema>,
33 #[serde(default, skip_serializing_if = "Vec::is_empty")]
34 pub seeds: Vec<SeedSchema>,
35 pub foreign_keys: Vec<ForeignKeySchema>,
36}
37
38#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
39pub struct TableSchema {
40 pub id: String,
41 pub name: String,
42 pub columns: Vec<ColumnSchema>,
43}
44
45#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
46pub struct ColumnSchema {
47 pub id: String,
48 pub name: String,
49 pub data_type: DatabaseType,
50 pub nullable: bool,
51 pub primary_key: bool,
52 pub unique: bool,
53 pub default: Option<String>,
54 pub generated: Option<GeneratedValueIr>,
55}
56
57#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
58#[serde(tag = "kind", rename_all = "snake_case")]
59pub enum DatabaseType {
60 Uuid,
61 Text,
62 Integer,
63 Bigint,
64 Decimal,
65 Boolean,
66 Date,
67 Datetime,
68 Json,
69 Enum { values: Vec<String> },
70}
71
72#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
73pub struct ForeignKeySchema {
74 pub id: String,
75 pub source_table: String,
76 pub source_columns: Vec<String>,
77 pub target_table: String,
78 pub target_columns: Vec<String>,
79 pub unique: bool,
80 pub on_delete: OnDeleteIr,
81}
82
83#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
84pub struct UniqueConstraintSchema {
85 pub id: String,
86 pub table: String,
87 pub columns: Vec<String>,
88}
89
90#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
91pub struct IndexSchema {
92 pub id: String,
93 pub table: String,
94 pub columns: Vec<String>,
95 pub unique: bool,
96 #[serde(default, skip_serializing_if = "appstruct_ir::IndexMethod::is_default")]
97 pub method: appstruct_ir::IndexMethod,
98 #[serde(default, skip_serializing_if = "Option::is_none")]
99 pub operator_class: Option<appstruct_ir::IndexOperatorClass>,
100 #[serde(default, skip_serializing_if = "Option::is_none")]
101 pub predicate: Option<String>,
102}
103
104#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
105pub struct SeedSchema {
106 pub id: String,
107 pub table: String,
108 pub values: Vec<SeedValueSchema>,
109}
110
111#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
112pub struct SeedValueSchema {
113 pub column: String,
114 pub value: String,
115 pub data_type: DatabaseType,
116}
117
118pub fn extract(ir: &AppIr) -> Result<DatabaseSchema, IrValidationErrors> {
124 validate_app_ir(ir)?;
125 let mut tables = ir
126 .entities
127 .iter()
128 .map(|entity| TableSchema {
129 id: entity.id.0.clone(),
130 name: entity.table_name.clone(),
131 columns: entity
132 .fields
133 .iter()
134 .map(|field| ColumnSchema {
135 id: field.id.0.clone(),
136 name: field.column_name.clone(),
137 data_type: database_type(ir, &field.ty),
138 nullable: field.nullable,
139 primary_key: field.primary_key,
140 unique: field.unique,
141 default: field.default.clone(),
142 generated: field.generated,
143 })
144 .collect(),
145 })
146 .collect::<Vec<_>>();
147 let mut unique_constraints = ir
148 .entities
149 .iter()
150 .filter(|entity| entity.tenant_scoped)
151 .map(tenant_unique_constraint)
152 .collect::<Vec<_>>();
153 tables.push(imports::table());
154 let mut indexes = entity_indexes(ir);
155 indexes.extend(module_indexes::indexes(ir));
156 let seeds = entity_seeds(ir);
157 let mut foreign_keys = ir
158 .relations
159 .iter()
160 .map(|relation| foreign_key(ir, relation))
161 .collect::<Vec<_>>();
162 if ir.auth.enabled {
163 tables.extend(auth::tables());
164 unique_constraints.extend(auth::unique_constraints());
165 foreign_keys.extend(auth::foreign_keys(ir));
166 }
167 if ir.tenant.enabled {
168 tables.extend(tenant::tables());
169 foreign_keys.extend(tenant::foreign_keys(ir));
170 }
171 if ir.audit.enabled {
172 tables.extend(audit::tables());
173 foreign_keys.extend(audit::foreign_keys(ir));
174 }
175 if ir.mail.enabled {
176 tables.extend(mail::tables());
177 foreign_keys.extend(mail::foreign_keys(ir));
178 }
179 if ir.jobs.enabled {
180 tables.extend(jobs::tables());
181 foreign_keys.extend(jobs::foreign_keys(ir));
182 }
183 if ir.webhooks.enabled {
184 tables.extend(webhooks::tables());
185 foreign_keys.extend(webhooks::foreign_keys(ir));
186 }
187 if ir.realtime.enabled {
188 tables.extend(realtime::tables());
189 foreign_keys.extend(realtime::foreign_keys(ir));
190 }
191 if ir.file.enabled {
192 tables.extend(file::tables());
193 foreign_keys.extend(file::foreign_keys(ir));
194 }
195 if ir.report.enabled {
196 tables.extend(report::tables());
197 unique_constraints.extend(report::unique_constraints());
198 foreign_keys.extend(report::foreign_keys(ir));
199 }
200 if ir.activity.enabled {
201 tables.extend(activity::tables());
202 foreign_keys.extend(activity::foreign_keys(ir));
203 }
204 if ir.billing.enabled {
205 tables.extend(billing::tables());
206 unique_constraints.extend(billing::unique_constraints());
207 foreign_keys.extend(billing::foreign_keys());
208 }
209 Ok(DatabaseSchema {
210 schema_version: SCHEMA_VERSION,
211 provider: ir.database.provider,
212 tables,
213 unique_constraints,
214 indexes,
215 seeds,
216 foreign_keys,
217 })
218}
219
220fn entity_indexes(ir: &AppIr) -> Vec<IndexSchema> {
221 ir.entities
222 .iter()
223 .flat_map(|entity| {
224 entity.indexes.iter().map(|index| IndexSchema {
225 id: index.id.clone(),
226 table: entity.table_name.clone(),
227 columns: index
228 .fields
229 .iter()
230 .filter_map(|field_id| {
231 entity
232 .fields
233 .iter()
234 .find(|field| field.id == *field_id)
235 .map(|field| field.column_name.clone())
236 })
237 .collect(),
238 unique: index.unique,
239 method: index.method,
240 operator_class: index.operator_class,
241 predicate: index.predicate.clone(),
242 })
243 })
244 .collect()
245}
246
247fn entity_seeds(ir: &AppIr) -> Vec<SeedSchema> {
248 ir.seeds
249 .iter()
250 .filter_map(|seed| {
251 let entity = ir.entities.iter().find(|entity| entity.id == seed.entity)?;
252 let values = seed
253 .values
254 .iter()
255 .filter_map(|(field_name, value)| {
256 let field = entity.fields.iter().find(|field| {
257 field.api_name == *field_name || field.rust_name == *field_name
258 })?;
259 Some(SeedValueSchema {
260 column: field.column_name.clone(),
261 value: value.clone(),
262 data_type: database_type(ir, &field.ty),
263 })
264 })
265 .collect::<Vec<_>>();
266 (!values.is_empty()).then_some(SeedSchema {
267 id: seed.id.clone(),
268 table: entity.table_name.clone(),
269 values,
270 })
271 })
272 .collect()
273}
274
275fn tenant_unique_constraint(entity: &appstruct_ir::EntityIr) -> UniqueConstraintSchema {
276 let key = entity
277 .fields
278 .iter()
279 .find(|field| field.primary_key)
280 .expect("compiler validated primary key");
281 UniqueConstraintSchema {
282 id: format!("{}.tenant_key", entity.id),
283 table: entity.table_name.clone(),
284 columns: vec!["tenant_id".to_owned(), key.column_name.clone()],
285 }
286}
287
288fn database_type(ir: &AppIr, field_type: &FieldTypeIr) -> DatabaseType {
289 match field_type {
290 FieldTypeIr::Uuid => DatabaseType::Uuid,
291 FieldTypeIr::String | FieldTypeIr::Text => DatabaseType::Text,
292 FieldTypeIr::Integer => DatabaseType::Integer,
293 FieldTypeIr::Bigint => DatabaseType::Bigint,
294 FieldTypeIr::Decimal => DatabaseType::Decimal,
295 FieldTypeIr::Boolean => DatabaseType::Boolean,
296 FieldTypeIr::Date => DatabaseType::Date,
297 FieldTypeIr::Datetime => DatabaseType::Datetime,
298 FieldTypeIr::Json => DatabaseType::Json,
299 FieldTypeIr::Enum { values } => DatabaseType::Enum {
300 values: values.clone(),
301 },
302 FieldTypeIr::Relation { target } => {
303 let target = ir
304 .entities
305 .iter()
306 .find(|entity| entity.id == *target)
307 .expect("compiler resolved relation target");
308 let key = target
309 .fields
310 .iter()
311 .find(|field| field.primary_key)
312 .expect("compiler validated primary key");
313 database_type(ir, &key.ty)
314 }
315 }
316}
317
318fn foreign_key(ir: &AppIr, relation: &appstruct_ir::RelationIr) -> ForeignKeySchema {
319 let source = ir
320 .entities
321 .iter()
322 .find(|entity| entity.id == relation.source)
323 .expect("compiler resolved relation source");
324 let target = ir
325 .entities
326 .iter()
327 .find(|entity| entity.id == relation.target)
328 .expect("compiler resolved relation target");
329 let source_field = source
330 .fields
331 .iter()
332 .find(|field| relation.foreign_key_fields.contains(&field.id))
333 .expect("compiler resolved relation field");
334 let target_field = target
335 .fields
336 .iter()
337 .find(|field| field.primary_key)
338 .expect("compiler validated target key");
339 let tenant_relation = source.tenant_scoped && target.tenant_scoped;
340 ForeignKeySchema {
341 id: relation.id.0.clone(),
342 source_table: source.table_name.clone(),
343 source_columns: if tenant_relation {
344 vec!["tenant_id".to_owned(), source_field.column_name.clone()]
345 } else {
346 vec![source_field.column_name.clone()]
347 },
348 target_table: target.table_name.clone(),
349 target_columns: if tenant_relation {
350 vec!["tenant_id".to_owned(), target_field.column_name.clone()]
351 } else {
352 vec![target_field.column_name.clone()]
353 },
354 unique: relation.unique,
355 on_delete: relation.on_delete,
356 }
357}
358
359#[cfg(test)]
360mod tests;