use crate::access::build_access;
use crate::activity::lower_activity;
use crate::audit::lower_audit;
use crate::auth::lower_auth;
use crate::billing::lower_billing;
use crate::extension::{ExtensionContext, lower_extensions};
use crate::file::lower_file;
use crate::jobs::lower_jobs;
use crate::mail::lower_mail;
use crate::module::{LoadedModule, resolve_modules_for_app};
use crate::realtime::lower_realtime;
use crate::report::lower_report;
use appstruct_core::{pluralize, to_snake_case};
mod indexes;
use self::indexes::build_indexes;
mod charts;
use self::charts::build_charts;
mod seeds;
use self::seeds::build_seeds;
use crate::server::lower_server;
use crate::surface::{SurfaceDomain, SurfaceEntity, SurfaceRoot};
use crate::tenant::lower_tenant;
use crate::validation::validate_entity_declarations;
use crate::webhooks::lower_webhooks;
use crate::workflow::lower_workflow;
use appstruct_ir::{
AppIr, AppMeta, AuthIr, ConcurrencyIr, DatabaseDevMode, DatabaseIr, DatabaseMigrationPolicy,
DatabaseProvider, Diagnostic, EntityId, EntityIr, EntityViewsIr, FieldTypeIr, HooksIr,
IR_VERSION, RelationIr,
};
use std::collections::BTreeSet;
mod fields;
use self::fields::{build_fields, revision_field, tenant_field, validate_field_semantics};
#[allow(clippy::too_many_lines)]
pub(crate) fn build_ir(
root: SurfaceRoot,
definitions: SurfaceDomain,
local_modules: Vec<LoadedModule>,
warnings: &mut Vec<Diagnostic>,
) -> Result<AppIr, Vec<Diagnostic>> {
let SurfaceDomain {
entities: mut surface_entities,
value_objects,
commands,
queries,
pages,
} = definitions;
surface_entities.sort_by(|left, right| left.name.value.cmp(&right.name.value));
let mut diagnostics = validate_entity_declarations(&surface_entities);
if !diagnostics.is_empty() {
return Err(diagnostics);
}
let auth = lower_auth(
&root.auth,
&surface_entities,
&root.app_name.span,
&mut diagnostics,
);
let billing = lower_billing(
&root.billing,
auth.enabled,
root.tenant.enabled,
&root.app_name.span,
&mut diagnostics,
);
let tenant = lower_tenant(&root, &surface_entities, &auth, &mut diagnostics);
let server = lower_server(&root, warnings);
let audit = lower_audit(
&root.audit,
&root.auth,
&surface_entities,
&root.app_name.span,
&mut diagnostics,
);
let mail = lower_mail(&root.mail, &root.app_name.span, &mut diagnostics);
let jobs = lower_jobs(&root.jobs, &root.app_name.span, &mut diagnostics);
let webhooks = lower_webhooks(&root.webhooks, &root.app_name.span, &mut diagnostics);
let realtime = lower_realtime(&root.realtime, &auth, &root.app_name.span, &mut diagnostics);
let file = lower_file(&root.file, &root.app_name.span, &mut diagnostics);
let report = lower_report(
&root.report,
&auth,
&jobs,
&file,
&root.app_name.span,
&mut diagnostics,
);
let known_entities = surface_entities
.iter()
.map(|entity| entity.name.value.clone())
.collect::<BTreeSet<_>>();
let known_values = value_objects
.iter()
.map(|value| value.name.value.clone())
.collect::<BTreeSet<_>>();
let (mut entities, mut relations, seeds) = lower_entities(
surface_entities,
&known_entities,
&known_values,
&auth,
&mut diagnostics,
);
if let Err(errors) = appstruct_ir::validate_form_rules(&entities) {
diagnostics.extend(errors.errors().iter().map(|error| {
Diagnostic::error(
"AS2045",
format!("{}: {}", error.path, error.message),
root.app_name.span.clone(),
)
}));
}
let activity = lower_activity(
&root.activity,
&auth,
&audit,
&file,
&entities,
&root.app_name.span,
&mut diagnostics,
);
if let Err(errors) = appstruct_ir::validate_aggregates(&entities) {
diagnostics.extend(errors.errors().iter().map(|error| {
Diagnostic::error(
"AS2043",
format!("{}: {}", error.path, error.message),
root.app_name.span.clone(),
)
}));
}
if let Err(errors) = appstruct_ir::validate_charts(&entities) {
diagnostics.extend(errors.errors().iter().map(|error| {
Diagnostic::error(
"AS2044",
format!("{}: {}", error.path, error.message),
root.app_name.span.clone(),
)
}));
}
let resource_paths = entities
.iter()
.map(|entity| entity.table_name.clone())
.collect::<BTreeSet<_>>();
let extensions = lower_extensions(
value_objects,
commands,
queries,
pages,
&ExtensionContext {
known_entities: &known_entities,
resource_paths: &resource_paths,
auth: &auth,
},
&mut diagnostics,
);
if !diagnostics.is_empty() {
return Err(diagnostics);
}
let modules = resolve_modules_for_app(
&auth,
&tenant,
&audit,
&mail,
&jobs,
&webhooks,
&realtime,
&file,
&report,
&activity,
local_modules,
)
.map_err(|error| {
vec![Diagnostic::error(
"AS3062",
error.to_string(),
root.app_name.span.clone(),
)]
})?;
canonicalize_entities(&mut entities, &mut relations);
let database = lower_database(&root);
Ok(AppIr {
ir_version: IR_VERSION,
app: AppMeta {
name: root.app_name.value,
},
database,
preset: root.preset.map(|preset| appstruct_ir::PresetIr {
name: preset.name.value,
version: u32::try_from(preset.version.value).unwrap_or(u32::MAX),
digest: crate::preset::preset_digest(),
}),
auth,
billing,
server,
tenant,
audit,
mail,
jobs,
webhooks,
realtime,
file,
report,
activity,
enums: Vec::new(),
value_objects: extensions.value_objects,
entities,
seeds,
relations,
commands: extensions.commands,
queries: extensions.queries,
pages: extensions.pages,
modules,
})
}
fn lower_database(root: &SurfaceRoot) -> DatabaseIr {
DatabaseIr {
provider: DatabaseProvider::Postgres,
dev_mode: if root.database_mode.value == "external" {
DatabaseDevMode::External
} else {
DatabaseDevMode::Managed
},
dev_migration: match root.database_migration.value.as_str() {
"auto" => DatabaseMigrationPolicy::Auto,
"never" => DatabaseMigrationPolicy::Never,
"unmanaged" => DatabaseMigrationPolicy::Unmanaged,
_ => DatabaseMigrationPolicy::Prompt,
},
}
}
fn canonicalize_entities(entities: &mut [EntityIr], relations: &mut [RelationIr]) {
for entity in &mut *entities {
entity.fields.sort_by(|left, right| left.id.cmp(&right.id));
entity.indexes.sort_by(|left, right| left.id.cmp(&right.id));
}
entities.sort_by(|left, right| left.id.cmp(&right.id));
relations.sort_by(|left, right| left.id.cmp(&right.id));
}
fn lower_entities(
surface_entities: Vec<SurfaceEntity>,
known_entities: &BTreeSet<String>,
known_values: &BTreeSet<String>,
auth: &AuthIr,
diagnostics: &mut Vec<Diagnostic>,
) -> (Vec<EntityIr>, Vec<RelationIr>, Vec<appstruct_ir::SeedIr>) {
let mut entities = Vec::with_capacity(surface_entities.len());
let mut relations = Vec::new();
let mut seeds = Vec::new();
for entity in surface_entities {
let entity_id = EntityId(format!("app::{}", entity.name.value));
let table_name = entity.table.as_ref().map_or_else(
|| pluralize(&to_snake_case(&entity.name.value)),
|table| table.value.clone(),
);
let access = build_access(&entity, auth, diagnostics);
let (mut fields, mut entity_relations) =
build_fields(&entity, &entity_id, known_entities, auth, diagnostics);
validate_field_semantics(&entity, &fields, diagnostics);
let revision_conflict = entity.fields.iter().find(|field| {
field
.column
.as_ref()
.map_or(field.name.value.as_str(), |column| column.value.as_str())
== "revision"
});
if let Some(field) = revision_conflict {
diagnostics.push(Diagnostic::error(
"AS2012",
"`revision` is reserved for optimistic concurrency control",
field.span.clone(),
));
} else {
fields.push(revision_field(&entity_id));
}
if entity.tenant_scoped {
if let Some(field) = entity.fields.iter().find(|field| {
field
.column
.as_ref()
.map_or(field.name.value.as_str(), |column| column.value.as_str())
== "tenant_id"
}) {
diagnostics.push(Diagnostic::error(
"AS3036",
"`tenant_id` is reserved for tenant isolation",
field.span.clone(),
));
} else {
fields.push(tenant_field(&entity_id));
}
}
if entity.soft_delete
&& !fields.iter().any(|field| {
field.rust_name == "deleted_at"
&& field.nullable
&& matches!(field.ty, FieldTypeIr::Datetime)
})
{
diagnostics.push(Diagnostic::error(
"AS2041",
"soft_delete requires a nullable datetime field named `deleted_at`",
entity.span.clone(),
));
}
let indexes = build_indexes(&entity, &entity_id, &fields, diagnostics);
let display_field = lower_display_field(&entity, &fields, diagnostics);
let charts = build_charts(&entity, &fields, diagnostics);
seeds.extend(build_seeds(&entity, &entity_id, &fields, diagnostics));
let workflow = lower_workflow(&entity, &fields, known_values, auth, diagnostics);
relations.append(&mut entity_relations);
if let Some(access) = access {
entities.push(EntityIr {
id: entity_id,
rust_name: entity.name.value.clone(),
api_name: entity.name.value.clone(),
label: entity
.label
.map_or_else(|| entity.name.value.clone(), |label| label.value),
table_name,
fields,
indexes,
access,
views: EntityViewsIr {
aggregates: entity.aggregates,
charts,
display_field,
soft_delete: entity.soft_delete,
},
hooks: HooksIr::default(),
concurrency: ConcurrencyIr { enabled: true },
tenant_scoped: entity.tenant_scoped,
audit_enabled: entity.audit_enabled,
workflow,
});
}
}
seeds.sort_by(|left, right| left.id.cmp(&right.id));
(entities, relations, seeds)
}
fn lower_display_field(
entity: &SurfaceEntity,
fields: &[appstruct_ir::FieldIr],
diagnostics: &mut Vec<Diagnostic>,
) -> Option<appstruct_ir::FieldId> {
let name = entity.display_field.as_ref()?;
match fields.iter().find(|field| field.api_name == name.value) {
Some(field)
if matches!(
field.ty,
FieldTypeIr::String
| FieldTypeIr::Text
| FieldTypeIr::Enum { .. }
| FieldTypeIr::Uuid
| FieldTypeIr::Integer
| FieldTypeIr::Bigint
) =>
{
Some(field.id.clone())
}
_ => {
diagnostics.push(Diagnostic::error(
"AS2042",
"display_field must reference a text, enum, UUID or integer field",
name.span.clone(),
));
None
}
}
}