Skip to main content

appstruct_schema/schema/
mod.rs

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
118/// Extract a database schema from semantically valid IR.
119///
120/// # Errors
121///
122/// Returns all IR invariant violations before schema traversal begins.
123pub 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;