yang_base/definition/builder/
app.rs1use crate::action::{ActionContext, ApiResponse, Request};
4use crate::definition::{AddonSpec, BuildError};
5use crate::error::BaseError;
6use crate::table::TableDefinition;
7use crate::tools::Tools;
8use std::fmt;
9use std::sync::Arc;
10
11use super::catalog::DefinitionCatalog;
12use super::compile::{
13 build_registry, compile_runtime_modules, compile_runtime_table_views,
14 compile_table_definitions, compile_views,
15};
16use super::handle::ActionHandle;
17use super::registry::Registry;
18use super::validate::{
19 collect_actions, collect_fields, collect_views, resolve_param_fields, sort_definitions,
20 validate_dependencies, validate_middleware_order, validate_module_contents,
21 validate_module_ownership, validate_references, validate_routes, validate_unique_addons,
22 validate_unique_modules,
23};
24
25#[derive(Clone)]
27pub struct BuiltApp {
28 catalog: DefinitionCatalog,
29 registry: Arc<Registry>,
30 tools: Arc<Tools>,
31 table_definitions: Vec<TableDefinition>,
32 compiled_views: Vec<crate::definition::CompiledTableView>,
33}
34
35impl fmt::Debug for BuiltApp {
36 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
37 formatter
38 .debug_struct("BuiltApp")
39 .field("catalog", &self.catalog)
40 .field("registry", &self.registry)
41 .field("tools", &self.tools)
42 .field("table_definition_count", &self.table_definitions.len())
43 .field("compiled_view_count", &self.compiled_views.len())
44 .finish()
45 }
46}
47
48impl BuiltApp {
49 pub fn catalog(&self) -> &DefinitionCatalog {
51 &self.catalog
52 }
53
54 pub fn registry(&self) -> &Registry {
56 &self.registry
57 }
58
59 pub fn tools(&self) -> &Tools {
61 &self.tools
62 }
63
64 pub fn table_definitions(&self) -> &[TableDefinition] {
66 &self.table_definitions
67 }
68
69 pub fn compiled_views(&self) -> &[crate::definition::CompiledTableView] {
71 &self.compiled_views
72 }
73
74 pub fn ui_catalog(
80 &self,
81 context: &ActionContext,
82 ) -> Result<crate::definition::UiCatalog, BaseError> {
83 self.registry.ui_catalog(context)
84 }
85
86 pub fn context(&self, request: Request) -> ActionContext {
88 ActionContext::new(request, Arc::clone(&self.tools))
89 .with_registry(Arc::clone(&self.registry))
90 }
91
92 pub async fn dispatch(
94 &self,
95 handle: ActionHandle,
96 request: Request,
97 ) -> Result<ApiResponse, BaseError> {
98 self.registry.dispatch(handle, self.context(request)).await
99 }
100
101 pub async fn dispatch_context(
103 &self,
104 handle: ActionHandle,
105 context: ActionContext,
106 ) -> Result<ApiResponse, BaseError> {
107 self.registry.dispatch(handle, context).await
108 }
109}
110
111#[derive(Debug, Clone, Default)]
113#[must_use = "AppBuilder 必须调用 build() 才会执行交叉校验并冻结定义"]
114pub struct AppBuilder {
115 addons: Vec<AddonSpec>,
116}
117
118impl AppBuilder {
119 pub fn new() -> Self {
121 Self::default()
122 }
123
124 pub fn addon(mut self, addon: impl Into<AddonSpec>) -> Self {
126 self.addons.push(addon.into());
127 self
128 }
129
130 pub fn build(mut self, tools: impl Into<Arc<Tools>>) -> Result<BuiltApp, BuildError> {
132 validate_unique_addons(&self.addons)?;
133 validate_dependencies(&self.addons)?;
134 validate_module_ownership(&self.addons)?;
135 validate_unique_modules(&self.addons)?;
136 validate_module_contents(&self.addons)?;
137 validate_middleware_order(&self.addons)?;
138 resolve_param_fields(&mut self.addons)?;
139
140 let fields = collect_fields(&self.addons)?;
141 let actions = collect_actions(&self.addons)?;
142 let views = collect_views(&self.addons)?;
143 validate_references(&self.addons, &fields, &actions, &views)?;
144 validate_routes(&self.addons)?;
145
146 sort_definitions(&mut self.addons);
147 let mut registry = build_registry(&self.addons)?;
148 let compiled_views = compile_views(&self.addons, ®istry)?;
149 registry.table_views = compile_runtime_table_views(&self.addons, ®istry)?;
150 registry.modules = compile_runtime_modules(&self.addons, ®istry)?;
151 for runtime in ®istry.handlers {
152 runtime.handler.bind_registry(®istry).map_err(|error| {
153 BuildError::InvalidReference {
154 kind: "ActionLink",
155 reference: error.to_string(),
156 }
157 })?;
158 }
159 let registry = Arc::new(registry);
160 let table_definitions = compile_table_definitions(&self.addons)?;
161 for module in self.addons.iter_mut().flat_map(|addon| &mut addon.modules) {
162 module.clear_handlers();
163 }
164 Ok(BuiltApp {
165 catalog: DefinitionCatalog {
166 addons: self.addons,
167 },
168 registry,
169 tools: tools.into(),
170 table_definitions,
171 compiled_views,
172 })
173 }
174}