use crate::action::{ActionContext, ApiResponse, Request};
use crate::definition::{AddonSpec, BuildError};
use crate::error::BaseError;
use crate::table::TableDefinition;
use crate::tools::Tools;
use std::fmt;
use std::sync::Arc;
use super::catalog::DefinitionCatalog;
use super::compile::{
build_registry, compile_runtime_modules, compile_runtime_table_views,
compile_table_definitions, compile_views,
};
use super::handle::ActionHandle;
use super::registry::Registry;
use super::validate::{
collect_actions, collect_fields, collect_views, resolve_param_fields, sort_definitions,
validate_dependencies, validate_middleware_order, validate_module_contents,
validate_module_ownership, validate_references, validate_routes, validate_unique_addons,
validate_unique_modules,
};
#[derive(Clone)]
pub struct BuiltApp {
catalog: DefinitionCatalog,
registry: Arc<Registry>,
tools: Arc<Tools>,
table_definitions: Vec<TableDefinition>,
compiled_views: Vec<crate::definition::CompiledTableView>,
}
impl fmt::Debug for BuiltApp {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("BuiltApp")
.field("catalog", &self.catalog)
.field("registry", &self.registry)
.field("tools", &self.tools)
.field("table_definition_count", &self.table_definitions.len())
.field("compiled_view_count", &self.compiled_views.len())
.finish()
}
}
impl BuiltApp {
pub fn catalog(&self) -> &DefinitionCatalog {
&self.catalog
}
pub fn registry(&self) -> &Registry {
&self.registry
}
pub fn tools(&self) -> &Tools {
&self.tools
}
pub fn table_definitions(&self) -> &[TableDefinition] {
&self.table_definitions
}
pub fn compiled_views(&self) -> &[crate::definition::CompiledTableView] {
&self.compiled_views
}
pub fn ui_catalog(
&self,
context: &ActionContext,
) -> Result<crate::definition::UiCatalog, BaseError> {
self.registry.ui_catalog(context)
}
pub fn context(&self, request: Request) -> ActionContext {
ActionContext::new(request, Arc::clone(&self.tools))
.with_registry(Arc::clone(&self.registry))
}
pub async fn dispatch(
&self,
handle: ActionHandle,
request: Request,
) -> Result<ApiResponse, BaseError> {
self.registry.dispatch(handle, self.context(request)).await
}
pub async fn dispatch_context(
&self,
handle: ActionHandle,
context: ActionContext,
) -> Result<ApiResponse, BaseError> {
self.registry.dispatch(handle, context).await
}
}
#[derive(Debug, Clone, Default)]
#[must_use = "AppBuilder 必须调用 build() 才会执行交叉校验并冻结定义"]
pub struct AppBuilder {
addons: Vec<AddonSpec>,
}
impl AppBuilder {
pub fn new() -> Self {
Self::default()
}
pub fn addon(mut self, addon: impl Into<AddonSpec>) -> Self {
self.addons.push(addon.into());
self
}
pub fn build(mut self, tools: impl Into<Arc<Tools>>) -> Result<BuiltApp, BuildError> {
let tools: Arc<Tools> = tools.into();
for addon in &mut self.addons {
if let Some(source) = addon.datasource.clone() {
for module in &mut addon.modules {
if module.datasource.is_none() {
module.datasource = Some(source.clone());
}
if let Some(table) = &mut module.table {
if table.datasource.is_none() {
table.datasource = Some(source.clone());
}
}
}
}
}
validate_unique_addons(&self.addons)?;
validate_dependencies(&self.addons)?;
validate_module_ownership(&self.addons)?;
validate_unique_modules(&self.addons)?;
validate_module_contents(&self.addons)?;
validate_middleware_order(&self.addons)?;
resolve_param_fields(&mut self.addons)?;
let fields = collect_fields(&self.addons)?;
let actions = collect_actions(&self.addons)?;
let views = collect_views(&self.addons)?;
validate_references(&self.addons, &fields, &actions, &views)?;
validate_routes(&self.addons)?;
sort_definitions(&mut self.addons);
let mut registry = build_registry(&self.addons)?;
let compiled_views = compile_views(&self.addons, ®istry)?;
registry.table_views = compile_runtime_table_views(&self.addons, ®istry)?;
registry.modules = compile_runtime_modules(&self.addons, ®istry)?;
registry.reindex_views_by_module();
for runtime in ®istry.handlers {
runtime.handler.bind_registry(®istry).map_err(|error| {
BuildError::InvalidReference {
kind: "ActionLink",
reference: error.to_string(),
}
})?;
}
let registry = Arc::new(registry);
let table_definitions = compile_table_definitions(&self.addons)?;
#[cfg(any(feature = "mysql", feature = "postgres"))]
if let Ok(datasources) = tools.datasources() {
for definition in &table_definitions {
datasources
.resolve_id(definition.datasource())
.map_err(|error| BuildError::InvalidReference {
kind: "Datasource",
reference: error.to_string(),
})?;
}
for module in self.addons.iter().flat_map(|addon| &addon.modules) {
if let Some(source) = &module.datasource {
datasources.resolve_id(source).map_err(|error| {
BuildError::InvalidReference {
kind: "Datasource",
reference: error.to_string(),
}
})?;
}
}
}
for module in self.addons.iter_mut().flat_map(|addon| &mut addon.modules) {
module.clear_handlers();
}
Ok(BuiltApp {
catalog: DefinitionCatalog {
addons: self.addons,
},
registry,
tools,
table_definitions,
compiled_views,
})
}
}