1use std::collections::BTreeMap;
2use std::future::Future;
3use std::sync::{Arc, Mutex};
4use educe::Educe;
5use maplit::btreemap;
6use teo_parser::ast::handler::HandlerInputFormat;
7use teo_parser::ast::middleware::MiddlewareType;
8use teo_parser::r#type::Type;
9use teo_result::{Error, Result};
10use crate::interface::Interface;
11use crate::{handler, interface, middleware, model, pipeline, r#enum, request, Value};
12use crate::app::data::AppData;
13use crate::arguments::Arguments;
14use crate::config::admin::Admin;
15use crate::config::client::Client;
16use crate::config::connector::Connector;
17use crate::config::debug::Debug;
18use crate::config::entity::Entity;
19use crate::config::server::Server;
20use crate::connection::connection::Connection;
21use crate::database::database::Database;
22use crate::handler::ctx_argument::HandlerCtxArgument;
23use crate::handler::Handler;
24use hyper::Method;
25use crate::middleware::middleware_imp::{empty_middleware, MiddlewareImp};
26use crate::middleware::Middleware;
27use crate::middleware::next::Next;
28use crate::model::{Model, Relation};
29use crate::namespace::Namespace;
30use crate::pipeline::item::Call;
31use crate::pipeline::item::item_impl::ItemImpl;
32use crate::pipeline::item::templates::callback::{Callback, CallbackResult};
33use crate::pipeline::item::templates::compare::Compare;
34use crate::pipeline::item::templates::transformer::{TransformerResult, Transformer};
35use crate::pipeline::item::templates::validator::{Validator, ValidatorResult};
36use crate::r#enum::Enum;
37use crate::r#struct::Struct;
38use crate::stdlib::load::load;
39use crate::utils::next_path;
40
41#[derive(Clone, Debug)]
42pub struct Builder {
43 inner: Arc<Inner>
44}
45
46#[derive(Educe)]
47#[educe(Debug)]
48struct Inner {
49 pub path: Vec<String>,
50 pub namespaces: Arc<Mutex<BTreeMap<String, Builder>>>,
51 pub structs: Arc<Mutex<BTreeMap<String, Struct>>>,
52 pub models: Arc<Mutex<BTreeMap<String, Model>>>,
53 pub enums: Arc<Mutex<BTreeMap<String, Enum>>>,
54 pub interfaces: Arc<Mutex<BTreeMap<String, Interface>>>,
55 pub model_decorators: Arc<Mutex<BTreeMap<String, model::Decorator>>>,
56 pub model_field_decorators: Arc<Mutex<BTreeMap<String, model::field::Decorator>>>,
57 pub model_relation_decorators: Arc<Mutex<BTreeMap<String, model::relation::Decorator>>>,
58 pub model_property_decorators: Arc<Mutex<BTreeMap<String, model::property::Decorator>>>,
59 pub enum_decorators: Arc<Mutex<BTreeMap<String, r#enum::Decorator>>>,
60 pub enum_member_decorators: Arc<Mutex<BTreeMap<String, r#enum::member::Decorator>>>,
61 pub interface_decorators: Arc<Mutex<BTreeMap<String, interface::Decorator>>>,
62 pub interface_field_decorators: Arc<Mutex<BTreeMap<String, interface::field::Decorator>>>,
63 pub handler_decorators: Arc<Mutex<BTreeMap<String, handler::Decorator>>>,
64 pub pipeline_items: Arc<Mutex<BTreeMap<String, pipeline::Item>>>,
65 pub request_middlewares: Arc<Mutex<BTreeMap<String, middleware::Definition>>>,
66 pub handler_middlewares: Arc<Mutex<BTreeMap<String, middleware::Definition>>>,
67 pub handlers: Arc<Mutex<BTreeMap<String, Handler>>>,
68 pub handler_templates: Arc<Mutex<BTreeMap<String, Handler>>>,
69 pub model_handler_groups: Arc<Mutex<BTreeMap<String, handler::group::Builder>>>,
70 pub handler_groups: Arc<Mutex<BTreeMap<String, handler::group::Builder>>>,
71 pub server: Arc<Mutex<Option<Server>>>,
72 pub connector: Arc<Mutex<Option<Connector>>>,
73 pub clients: Arc<Mutex<BTreeMap<String, Client>>>,
74 pub entities: Arc<Mutex<BTreeMap<String, Entity>>>,
75 pub debug: Arc<Mutex<Option<Debug>>>,
76 pub admin: Arc<Mutex<Option<Admin>>>,
77 pub request_middlewares_block: Arc<Mutex<Option<middleware::Block>>>,
78 pub handler_middlewares_block: Arc<Mutex<Option<middleware::Block>>>,
79 pub database: Arc<Mutex<Option<Database>>>,
80 pub connector_reference: Arc<Mutex<Option<Vec<String>>>>,
81 pub connection: Arc<Mutex<Option<Arc<dyn Connection>>>>,
82 pub model_opposite_relations_map: Arc<Mutex<BTreeMap<Vec<String>, Vec<(Vec<String>, String)>>>>,
83 pub handler_map: Arc<Mutex<handler::Map>>,
84 #[educe(Debug(ignore))]
85 pub handler_middleware_stack: Arc<Mutex<Middleware>>,
86 #[educe(Debug(ignore))]
87 pub request_middleware_stack: Arc<Mutex<Middleware>>,
88 pub app_data: AppData,
89}
90
91impl Builder {
92
93 fn new(path: Vec<String>, app_data: AppData) -> Self {
94 Self {
95 inner: Arc::new(Inner {
96 path,
97 namespaces: Arc::new(Mutex::new(Default::default())),
98 structs: Arc::new(Mutex::new(Default::default())),
99 models: Arc::new(Mutex::new(Default::default())),
100 enums: Arc::new(Mutex::new(Default::default())),
101 interfaces: Arc::new(Mutex::new(Default::default())),
102 model_decorators: Arc::new(Mutex::new(Default::default())),
103 model_field_decorators: Arc::new(Mutex::new(Default::default())),
104 model_relation_decorators: Arc::new(Mutex::new(Default::default())),
105 model_property_decorators: Arc::new(Mutex::new(Default::default())),
106 enum_decorators: Arc::new(Mutex::new(Default::default())),
107 enum_member_decorators: Arc::new(Mutex::new(Default::default())),
108 interface_decorators: Arc::new(Mutex::new(Default::default())),
109 interface_field_decorators: Arc::new(Mutex::new(Default::default())),
110 handler_decorators: Arc::new(Mutex::new(Default::default())),
111 pipeline_items: Arc::new(Mutex::new(Default::default())),
112 handler_middlewares: Arc::new(Mutex::new(Default::default())),
113 request_middlewares: Arc::new(Mutex::new(Default::default())),
114 handlers: Arc::new(Mutex::new(Default::default())),
115 handler_templates: Arc::new(Mutex::new(Default::default())),
116 model_handler_groups: Arc::new(Mutex::new(Default::default())),
117 handler_groups: Arc::new(Mutex::new(Default::default())),
118 server: Arc::new(Mutex::new(None)),
119 connector: Arc::new(Mutex::new(None)),
120 clients: Arc::new(Mutex::new(Default::default())),
121 entities: Arc::new(Mutex::new(Default::default())),
122 debug: Arc::new(Mutex::new(None)),
123 admin: Arc::new(Mutex::new(None)),
124 request_middlewares_block: Arc::new(Mutex::new(None)),
125 handler_middlewares_block: Arc::new(Mutex::new(None)),
126 database: Arc::new(Mutex::new(None)),
127 connector_reference: Arc::new(Mutex::new(None)),
128 connection: Arc::new(Mutex::new(None)),
129 model_opposite_relations_map: Arc::new(Mutex::new(Default::default())),
130 handler_map: Arc::new(Mutex::new(handler::Map::new())),
131 handler_middleware_stack: Arc::new(Mutex::new(empty_middleware())),
132 request_middleware_stack: Arc::new(Mutex::new(empty_middleware())),
133 app_data
134 })
135 }
136 }
137
138 pub fn main(app_data: AppData) -> Self {
139 Self::new(vec![], app_data)
140 }
141
142 pub fn load_standard_library(&self) -> Result<()> {
143 if self.inner.path.is_empty() {
144 Err(Error::new("Standard library can only be loaded on main namespace"))?
145 }
146 load(self);
147 Ok(())
148 }
149
150 pub fn path(&self) -> &Vec<String> {
151 &self.inner.path
152 }
153
154 pub fn is_main(&self) -> bool {
155 self.path().is_empty()
156 }
157
158 pub fn is_std(&self) -> bool {
159 self.path().len() == 0 && self.path().first().unwrap().as_str() == "std"
160 }
161
162 pub fn set_server(&self, server: Option<Server>) {
163 *self.inner.server.lock().unwrap() = server;
164 }
165
166 pub fn set_connector(&self, connector: Option<Connector>) {
167 *self.inner.connector.lock().unwrap() = connector;
168 }
169
170 pub fn connector(&self) -> Option<Connector> {
171 self.inner.connector.lock().unwrap().clone()
172 }
173
174 pub fn set_debug(&self, debug: Option<Debug>) {
175 *self.inner.debug.lock().unwrap() = debug;
176 }
177
178 pub fn insert_entity(&self, name: String, entity: Entity) {
179 let mut entities = self.inner.entities.lock().unwrap();
180 entities.insert(name, entity);
181 }
182
183 pub fn insert_client(&self, name: String, client: Client) {
184 let mut clients = self.inner.clients.lock().unwrap();
185 clients.insert(name, client);
186 }
187
188 pub fn set_admin(&self, admin: Option<Admin>) {
189 *self.inner.admin.lock().unwrap() = admin;
190 }
191
192 pub fn set_database(&self, database: Option<Database>) {
193 *self.inner.database.lock().unwrap() = database;
194 }
195
196 pub fn database(&self) -> Option<Database> {
197 *self.inner.database.lock().unwrap()
198 }
199
200 pub fn set_connector_reference(&self, connector_reference: Option<Vec<String>>) {
201 *self.inner.connector_reference.lock().unwrap() = connector_reference;
202 }
203
204 pub fn connector_reference(&self) -> Option<Vec<String>> {
205 self.inner.connector_reference.lock().unwrap().clone()
206 }
207
208 pub fn request_middlewares_block(&self) -> Option<middleware::Block> {
209 self.inner.request_middlewares_block.lock().unwrap().clone()
210 }
211
212 pub fn handler_middlewares_block(&self) -> Option<middleware::Block> {
213 self.inner.handler_middlewares_block.lock().unwrap().clone()
214 }
215
216 pub fn insert_enum(&self, name: String, r#enum: Enum) {
217 let mut enums = self.inner.enums.lock().unwrap();
218 enums.insert(name, r#enum);
219 }
220
221 pub fn insert_model(&self, name: String, model: Model) {
222 let mut models = self.inner.models.lock().unwrap();
223 models.insert(name, model);
224 }
225
226 pub fn insert_interface(&self, name: String, interface: Interface) {
227 let mut interfaces = self.inner.interfaces.lock().unwrap();
228 interfaces.insert(name, interface);
229 }
230
231 pub fn namespaces(&self) -> BTreeMap<String, Builder> {
232 self.inner.namespaces.lock().unwrap().clone()
233 }
234
235 pub fn child_namespace(&self, name: &str) -> Option<Builder> {
236 let namespaces = self.inner.namespaces.lock().unwrap();
237 if let Some(namespace) = namespaces.get(name) {
238 Some(namespace.clone())
239 } else {
240 None
241 }
242 }
243
244 pub fn child_namespace_or_create(&self, name: &str) -> Builder {
245 let mut namespaces = self.inner.namespaces.lock().unwrap();
246 if !namespaces.contains_key(name) {
247 namespaces.insert(name.to_owned(), Builder::new(next_path(self.path(), name), self.app_data().clone()));
248 }
249 namespaces.get(name).unwrap().clone()
250 }
251
252 pub fn descendant_namespace_at_path(&self, path: &Vec<String>) -> Option<Builder> {
253 let mut current = Some(self.clone());
254 for item in path {
255 if current.is_none() {
256 return None;
257 }
258 current = current.unwrap().child_namespace(item);
259 }
260 current
261 }
262
263 pub fn descendant_namespace_or_create_at_path(&self, path: &Vec<String>) -> Builder {
264 let mut current = self.clone();
265 for item in path {
266 current = current.child_namespace_or_create(item)
267 }
268 current
269 }
270
271 pub fn define_model_decorator<F>(&self, name: &str, call: F) where F: Fn(Arguments, &model::Builder) -> Result<()> + 'static + Send + Sync {
272 let mut model_decorators = self.inner.model_decorators.lock().unwrap();
273 model_decorators.insert(name.to_owned(), model::Decorator::new(next_path(self.path(), name), call));
274 }
275
276 pub fn define_model_field_decorator(&self, name: &str, call: impl Fn(Arguments, &model::field::Builder) -> Result<()> + 'static + Send + Sync) {
277 let mut model_field_decorators = self.inner.model_field_decorators.lock().unwrap();
278 model_field_decorators.insert(name.to_owned(), model::field::Decorator::new(next_path(self.path(), name), call));
279 }
280
281 pub fn define_model_relation_decorator(&self, name: &str, call: impl Fn(Arguments, &model::relation::Builder) -> Result<()> + 'static + Send + Sync) {
282 let mut model_relation_decorators = self.inner.model_relation_decorators.lock().unwrap();
283 model_relation_decorators.insert(name.to_owned(), model::relation::Decorator::new(next_path(self.path(), name), call));
284 }
285
286 pub fn define_model_property_decorator(&self, name: &str, call: impl Fn(Arguments, &model::property::Builder) -> Result<()> + 'static + Send + Sync) {
287 let mut model_property_decorators = self.inner.model_property_decorators.lock().unwrap();
288 model_property_decorators.insert(name.to_owned(), model::property::Decorator::new(next_path(self.path(), name), call));
289 }
290
291 pub fn define_enum_decorator(&self, name: &str, call: impl Fn(Arguments, &r#enum::Builder) -> Result<()> + 'static + Send + Sync) {
292 let mut enum_decorators = self.inner.enum_decorators.lock().unwrap();
293 enum_decorators.insert(name.to_owned(), r#enum::Decorator::new(next_path(self.path(), name), call));
294 }
295
296 pub fn define_enum_member_decorator(&self, name: &str, call: impl Fn(Arguments, &r#enum::member::Builder) -> Result<()> + 'static + Send + Sync) {
297 let mut enum_member_decorators = self.inner.enum_member_decorators.lock().unwrap();
298 enum_member_decorators.insert(name.to_owned(), r#enum::member::Decorator::new(next_path(self.path(), name), call));
299 }
300
301 pub fn define_interface_decorator<F>(&self, name: &str, call: F) where F: Fn(Arguments, &interface::Builder) -> Result<()> + 'static + Send + Sync {
302 let mut interface_decorators = self.inner.interface_decorators.lock().unwrap();
303 interface_decorators.insert(name.to_owned(), interface::Decorator::new(next_path(self.path(), name), call));
304 }
305
306 pub fn define_handler_decorator(&self, name: &str, call: impl Fn(Arguments, &handler::Builder) -> Result<()> + 'static + Send + Sync) {
307 let mut handler_decorators = self.inner.handler_decorators.lock().unwrap();
308 handler_decorators.insert(name.to_owned(), handler::Decorator::new(next_path(self.path(), name), call));
309 }
310
311 pub fn define_pipeline_item<C, F>(&self, name: &str, creator: C) where
312 C: Fn(Arguments) -> Result<F> + 'static,
313 F: Call + 'static {
314 let mut pipeline_items = self.inner.pipeline_items.lock().unwrap();
315 pipeline_items.insert(name.to_owned(), pipeline::Item::new(next_path(self.path(), name), Arc::new(move |args| {
316 let f = creator(args)?;
317 Ok(ItemImpl::new(f))
318 }), self.app_data().clone()));
319 }
320
321 pub fn define_transform_pipeline_item<C, A, O, F, R>(&self, name: &str, creator: C) where
322 C: Fn(Arguments) -> Result<F> + 'static,
323 A: Send + Sync + 'static,
324 O: Into<Value> + Send + Sync + 'static,
325 R: Into<TransformerResult<O>> + Send + Sync + 'static,
326 F: Transformer<A, O, R> + 'static {
327 let mut pipeline_items = self.inner.pipeline_items.lock().unwrap();
328 pipeline_items.insert(name.to_owned(), pipeline::Item::new(next_path(self.path(), name), Arc::new(move |args: Arguments| {
329 let transformer = creator(args)?;
330 Ok(ItemImpl::new(move |ctx: pipeline::Ctx| {
331 let transformer = transformer.clone();
332 async move {
333 let transform_result: TransformerResult<O> = transformer.call(ctx).await.into();
334 match transform_result {
335 TransformerResult::Object(t) => Ok(t.into()),
336 TransformerResult::Result(r) => match r {
337 Ok(t) => Ok(t.into()),
338 Err(e) => Err(e.into()),
339 }
340 }
341 }
342 }))
343 }), self.app_data().clone()));
344 }
345
346 pub fn define_validator_pipeline_item<C, T, F, O>(&self, name: &str, creator: C) where
347 C: Fn(Arguments) -> Result<F> + 'static,
348 T: Send + Sync + 'static,
349 F: Validator<T, O> + 'static,
350 O: Into<ValidatorResult> + Send + Sync + 'static {
351 let mut pipeline_items = self.inner.pipeline_items.lock().unwrap();
352 pipeline_items.insert(name.to_owned(), pipeline::Item::new(next_path(self.path(), name), Arc::new(move |args: Arguments| {
353 let validator = creator(args)?;
354 Ok(ItemImpl::new(move |ctx: pipeline::Ctx| {
355 let validator = validator.clone();
356 async move {
357 let ctx_value = ctx.value().clone();
358 let validate_result: ValidatorResult = validator.call(ctx).await.into();
359 match validate_result {
360 ValidatorResult::Validity(validity) => if validity.is_valid() {
361 Ok(ctx_value)
362 } else if let Some(reason) = validity.invalid_reason() {
363 Err(Error::new_with_code(reason, 400))
364 } else {
365 Err(Error::new_with_code("value is invalid", 400))
366 },
367 ValidatorResult::Result(result) => match result {
368 Ok(validity) => if validity.is_valid() {
369 Ok(ctx_value)
370 } else if let Some(reason) = validity.invalid_reason() {
371 Err(Error::new_with_code(reason, 400))
372 } else {
373 Err(Error::new_with_code("value is invalid", 400))
374 },
375 Err(err) => Err(err),
376 }
377 }
378 }
379 }))
380 }), self.app_data().clone()));
381 }
382
383 pub fn define_callback_pipeline_item<C, T, F, O>(&self, name: &str, creator: C) where
384 C: Fn(Arguments) -> Result<F> + 'static,
385 T: Send + Sync + 'static,
386 F: Callback<T, O> + 'static,
387 O: Into<CallbackResult> + Send + Sync + 'static {
388 let mut pipeline_items = self.inner.pipeline_items.lock().unwrap();
389 pipeline_items.insert(name.to_owned(), pipeline::Item::new(next_path(self.path(), name), Arc::new(move |args: Arguments| {
390 let callback = creator(args)?;
391 Ok(ItemImpl::new(move |ctx: pipeline::Ctx| {
392 let callback = callback.clone();
393 async move {
394 let ctx_value = ctx.value().clone();
395 let callback_result: CallbackResult = callback.call(ctx).await.into();
396 match callback_result {
397 CallbackResult::Result(t) => match t {
398 Ok(_) => Ok(ctx_value),
399 Err(err) => Err(err),
400 },
401 }
402 }
403 }))
404 }), self.app_data().clone()));
405 }
406
407 pub fn define_compare_pipeline_item<C, T, O, F, E>(&self, name: &str, creator: C) where
408 C: Fn(Arguments) -> Result<F> + 'static,
409 T: Send + Sync + 'static,
410 O: Into<ValidatorResult> + Send + Sync + 'static,
411 E: Into<Error> + std::error::Error,
412 F: Compare<T, O, E> + 'static {
413 let mut pipeline_items = self.inner.pipeline_items.lock().unwrap();
414 pipeline_items.insert(name.to_owned(), pipeline::Item::new(next_path(self.path(), name), Arc::new(move |args: Arguments| {
415 let compare = creator(args)?;
416 Ok(ItemImpl::new(move |ctx: pipeline::Ctx| {
417 let compare = compare.clone();
418 async move {
419 if ctx.object().is_new() {
420 return Ok(ctx.value().clone());
421 }
422 let key = ctx.path()[ctx.path().len() - 1].as_key().unwrap();
423 let previous_value = ctx.object().get_previous_value(key)?;
424 let current_value = ctx.value();
425 if &previous_value == current_value {
426 return Ok(ctx.value().clone());
427 }
428 let validate_result: ValidatorResult = compare.call(previous_value, current_value.clone(), ctx.clone()).await.into();
429 match validate_result {
430 ValidatorResult::Validity(validity) => if validity.is_valid() {
431 Ok(current_value.clone())
432 } else if let Some(reason) = validity.invalid_reason() {
433 Err(Error::new(reason))
434 } else {
435 Err(Error::new("value is invalid"))
436 },
437 ValidatorResult::Result(result) => match result {
438 Ok(validity) => if validity.is_valid() {
439 Ok(current_value.clone())
440 } else if let Some(reason) = validity.invalid_reason() {
441 Err(Error::new(reason))
442 } else {
443 Err(Error::new("value is invalid"))
444 },
445 Err(err) => Err(err),
446 }
447 }
448 }
449 }))
450 }), self.app_data().clone()));
451 }
452
453 pub fn define_handler_middleware_impl<T>(&self, name: &str, call: T) where T: middleware::creator::Creator + 'static {
454 let mut middlewares = self.inner.handler_middlewares.lock().unwrap();
455 middlewares.insert(name.to_owned(), middleware::Definition::new(next_path(self.path(), name), Arc::new(call), self.app_data().clone()));
456 }
457
458 pub fn define_request_middleware_impl<T>(&self, name: &str, call: T) where T: middleware::creator::Creator + 'static {
459 let mut middlewares = self.inner.request_middlewares.lock().unwrap();
460 middlewares.insert(name.to_owned(), middleware::Definition::new(next_path(self.path(), name), Arc::new(call), self.app_data().clone()));
461 }
462
463 pub fn define_handler_middleware<C, F>(&self, name: &str, creator: C) where
464 C: Fn(Arguments) -> Result<F> + 'static,
465 F: MiddlewareImp + 'static {
466 let mut middlewares = self.inner.handler_middlewares.lock().unwrap();
467 middlewares.insert(name.to_owned(), middleware::Definition::new(next_path(self.path(), name), Arc::new(move |args| {
468 Ok(Middleware::new(creator(args)?))
469 }), self.app_data().clone()));
470 }
471
472 pub fn define_request_middleware<C, F>(&self, name: &str, creator: C) where
473 C: Fn(Arguments) -> Result<F> + 'static,
474 F: MiddlewareImp + 'static {
475 let mut middlewares = self.inner.request_middlewares.lock().unwrap();
476 middlewares.insert(name.to_owned(), middleware::Definition::new(next_path(self.path(), name), Arc::new(move |args| {
477 Ok(Middleware::new(creator(args)?))
478 }), self.app_data().clone()));
479 }
480
481 pub fn define_model_handler_group<T>(&self, name: &str, builder: T) -> Result<()> where T: Fn(&handler::group::Builder) -> Result<()> {
482 let handler_group_builder = handler::group::Builder::new(next_path(self.path(), name), self.app_data().clone());
483 builder(&handler_group_builder)?;
484 let mut model_handler_groups = self.inner.model_handler_groups.lock().unwrap();
485 model_handler_groups.insert(name.to_owned(), handler_group_builder);
486 Ok(())
487 }
488
489 pub fn insert_handler(&self, name: &str, handler: Handler) {
490 let mut handlers = self.inner.handlers.lock().unwrap();
491 handlers.insert(name.to_owned(), handler);
492 }
493
494 pub fn insert_handler_template(&self, name: &str, handler_template: Handler) {
495 let mut handler_templates = self.inner.handler_templates.lock().unwrap();
496 handler_templates.insert(name.to_owned(), handler_template);
497 }
498
499 pub fn define_handler<T, F>(&self, name: &str, body: F) where T: 'static, F: 'static + HandlerCtxArgument<T> {
500 let body = Arc::new(body);
501 let builder = handler::Builder::new(
502 next_path(self.path(), name),
503 self.inner.path.clone(),
504 Type::Undetermined,
505 Type::Undetermined,
506 false,
507 HandlerInputFormat::Json,
508 Next::new(move |request: request::Request| {
509 let body = body.clone();
510 async move {
511 body.call(request).await
512 }
513 }),
514 self.app_data().clone()
515 );
516 builder.set_method(Method::POST);
517 builder.set_interface(None);
518 builder.set_url(None);
519 let handler = builder.build();
520 let mut handlers = self.inner.handlers.lock().unwrap();
521 handlers.insert(name.to_owned(), handler);
522 }
523
524 pub fn define_handler_template<T, F>(&self, name: &str, body: F) where T: 'static, F: 'static + HandlerCtxArgument<T> {
525 let body = Arc::new(body);
526 let builder = handler::Builder::new(
527 next_path(self.path(), name),
528 self.inner.path.clone(),
529 Type::Undetermined,
530 Type::Undetermined,
531 false,
532 HandlerInputFormat::Json,
533 Next::new(move |request: request::Request| {
534 let body = body.clone();
535 async move {
536 body.call(request).await
537 }
538 }),
539 self.app_data().clone()
540 );
541 builder.set_method(Method::POST);
542 builder.set_interface(None);
543 builder.set_url(None);
544 let handler = builder.build();
545 let mut handler_templates = self.inner.handler_templates.lock().unwrap();
546 handler_templates.insert(name.to_owned(), handler);
547 }
548
549 pub fn define_handler_group<T>(&self, name: &str, builder: T) -> Result<()> where T: Fn(&handler::group::Builder) -> Result<()> {
550 let handler_group_builder = handler::group::Builder::new(next_path(self.path(), name), self.app_data().clone());
551 builder(&handler_group_builder)?;
552 let mut handler_groups = self.inner.handler_groups.lock().unwrap();
553 handler_groups.insert(name.to_owned(), handler_group_builder);
554 Ok(())
555 }
556
557 pub fn define_struct<T>(&self, name: &str, builder: T) where T: Fn(Vec<String>, &mut Struct) {
558 let path = next_path(self.path(), name);
559 let mut r#struct = Struct {
560 path: path.clone(),
561 functions: btreemap! {},
562 static_functions: btreemap! {}
563 };
564 builder(path, &mut r#struct);
565 let mut structs = self.inner.structs.lock().unwrap();
566 structs.insert(name.to_owned(), r#struct);
567 }
568
569 pub fn model_decorator(&self, name: &str) -> Option<model::Decorator> {
570 let model_decorators = self.inner.model_decorators.lock().unwrap();
571 model_decorators.get(name).cloned()
572 }
573
574 pub fn model_decorator_at_path(&self, path: &Vec<&str>) -> Option<model::Decorator> {
575 let decorator_name = *path.last().unwrap();
576 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
577 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
578 ns.model_decorator(decorator_name)
579 } else {
580 None
581 }
582 }
583
584 pub fn model_field_decorator(&self, name: &str) -> Option<model::field::Decorator> {
585 let model_field_decorators = self.inner.model_field_decorators.lock().unwrap();
586 model_field_decorators.get(name).cloned()
587 }
588
589 pub fn model_field_decorator_at_path(&self, path: &Vec<&str>) -> Option<model::field::Decorator> {
590 let decorator_name = *path.last().unwrap();
591 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
592 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
593 ns.model_field_decorator(decorator_name)
594 } else {
595 None
596 }
597 }
598
599 pub fn model_relation_decorator(&self, name: &str) -> Option<model::relation::Decorator> {
600 let model_relation_decorators = self.inner.model_relation_decorators.lock().unwrap();
601 model_relation_decorators.get(name).cloned()
602 }
603
604 pub fn model_relation_decorator_at_path(&self, path: &Vec<&str>) -> Option<model::relation::Decorator> {
605 let decorator_name = *path.last().unwrap();
606 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
607 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
608 ns.model_relation_decorator(decorator_name)
609 } else {
610 None
611 }
612 }
613
614 pub fn model_property_decorator(&self, name: &str) -> Option<model::property::Decorator> {
615 let model_property_decorators = self.inner.model_property_decorators.lock().unwrap();
616 model_property_decorators.get(name).cloned()
617 }
618
619 pub fn model_property_decorator_at_path(&self, path: &Vec<&str>) -> Option<model::property::Decorator> {
620 let decorator_name = *path.last().unwrap();
621 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
622 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
623 ns.model_property_decorator(decorator_name)
624 } else {
625 None
626 }
627 }
628
629 pub fn enum_decorator(&self, name: &str) -> Option<r#enum::Decorator> {
630 let enum_decorators = self.inner.enum_decorators.lock().unwrap();
631 enum_decorators.get(name).cloned()
632 }
633
634 pub fn enum_decorator_at_path(&self, path: &Vec<&str>) -> Option<r#enum::Decorator> {
635 let decorator_name = *path.last().unwrap();
636 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
637 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
638 ns.enum_decorator(decorator_name)
639 } else {
640 None
641 }
642 }
643
644 pub fn enum_member_decorator(&self, name: &str) -> Option<r#enum::member::Decorator> {
645 let enum_member_decorators = self.inner.enum_member_decorators.lock().unwrap();
646 enum_member_decorators.get(name).cloned()
647 }
648
649 pub fn enum_member_decorator_at_path(&self, path: &Vec<&str>) -> Option<r#enum::member::Decorator> {
650 let decorator_name = *path.last().unwrap();
651 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
652 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
653 ns.enum_member_decorator(decorator_name)
654 } else {
655 None
656 }
657 }
658
659 pub fn interface_decorator(&self, name: &str) -> Option<interface::Decorator> {
660 let interface_decorators = self.inner.interface_decorators.lock().unwrap();
661 interface_decorators.get(name).cloned()
662 }
663
664 pub fn interface_decorator_at_path(&self, path: &Vec<&str>) -> Option<interface::Decorator> {
665 let decorator_name = *path.last().unwrap();
666 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
667 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
668 ns.interface_decorator(decorator_name)
669 } else {
670 None
671 }
672 }
673
674 pub fn interface_field_decorator(&self, name: &str) -> Option<interface::field::Decorator> {
675 let interface_field_decorators = self.inner.interface_field_decorators.lock().unwrap();
676 interface_field_decorators.get(name).cloned()
677 }
678
679 pub fn interface_field_decorator_at_path(&self, path: &Vec<&str>) -> Option<interface::field::Decorator> {
680 let decorator_name = *path.last().unwrap();
681 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
682 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
683 ns.interface_field_decorator(decorator_name)
684 } else {
685 None
686 }
687 }
688
689 pub fn handler_decorator(&self, name: &str) -> Option<handler::Decorator> {
690 let handler_decorators = self.inner.handler_decorators.lock().unwrap();
691 handler_decorators.get(name).cloned()
692 }
693
694 pub fn handler_decorator_at_path(&self, path: &Vec<&str>) -> Option<handler::Decorator> {
695 let decorator_name = *path.last().unwrap();
696 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
697 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
698 ns.handler_decorator(decorator_name)
699 } else {
700 None
701 }
702 }
703
704 pub fn pipeline_item(&self, name: &str) -> Option<pipeline::Item> {
705 let pipeline_items = self.inner.pipeline_items.lock().unwrap();
706 pipeline_items.get(name).cloned()
707 }
708
709 pub fn pipeline_item_at_path(&self, path: &Vec<&str>) -> Option<pipeline::Item> {
710 let pipeline_item_name = *path.last().unwrap();
711 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
712 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
713 ns.pipeline_item(pipeline_item_name)
714 } else {
715 None
716 }
717 }
718
719 pub fn r#struct(&self, name: &str) -> Option<Struct> {
720 let structs = self.inner.structs.lock().unwrap();
721 structs.get(name).cloned()
722 }
723
724 pub fn struct_at_path(&self, path: &Vec<&str>) -> Option<Struct> {
725 let struct_name = *path.last().unwrap();
726 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
727 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
728 ns.r#struct(struct_name)
729 } else {
730 None
731 }
732 }
733
734 pub fn r#enum(&self, name: &str) -> Option<Enum> {
735 let enums = self.inner.enums.lock().unwrap();
736 enums.get(name).cloned()
737 }
738
739 pub fn enum_at_path(&self, path: &Vec<&str>) -> Option<Enum> {
740 let enum_name = *path.last().unwrap();
741 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
742 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
743 ns.r#enum(enum_name)
744 } else {
745 None
746 }
747 }
748
749 pub fn models(&self) -> BTreeMap<String, Model> {
750 self.inner.models.lock().unwrap().clone()
751 }
752
753 pub fn model(&self, name: &str) -> Option<Model> {
754 let models = self.inner.models.lock().unwrap();
755 models.get(name).cloned()
756 }
757
758 pub fn model_at_path(&self, path: &Vec<String>) -> Option<Model> {
759 let model_name = path.last().unwrap();
760 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
761 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
762 ns.model(model_name)
763 } else {
764 None
765 }
766 }
767
768 pub fn interface(&self, name: &str) -> Option<Interface> {
769 let interfaces = self.inner.interfaces.lock().unwrap();
770 interfaces.get(name).cloned()
771 }
772
773 pub fn interface_at_path(&self, path: &Vec<&str>) -> Option<Interface> {
774 let interface_name = *path.last().unwrap();
775 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
776 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
777 ns.interface(interface_name)
778 } else {
779 None
780 }
781 }
782
783 pub fn handler_middleware(&self, name: &str) -> Option<middleware::Definition> {
784 let middlewares = self.inner.handler_middlewares.lock().unwrap();
785 middlewares.get(name).cloned()
786 }
787
788 pub fn request_middleware(&self, name: &str) -> Option<middleware::Definition> {
789 let middlewares = self.inner.request_middlewares.lock().unwrap();
790 middlewares.get(name).cloned()
791 }
792
793 pub fn middleware_at_path_with_type(&self, path: &Vec<&str>, middleware_type: MiddlewareType) -> Option<middleware::Definition> {
794 match middleware_type {
795 MiddlewareType::HandlerMiddleware => self.handler_middleware_at_path(path),
796 MiddlewareType::RequestMiddleware => self.request_middleware_at_path(path),
797 }
798 }
799
800 pub fn handler_middleware_at_path(&self, path: &Vec<&str>) -> Option<middleware::Definition> {
801 let middleware_name = *path.last().unwrap();
802 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
803 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
804 ns.handler_middleware(middleware_name)
805 } else {
806 None
807 }
808 }
809
810 pub fn request_middleware_at_path(&self, path: &Vec<&str>) -> Option<middleware::Definition> {
811 let middleware_name = *path.last().unwrap();
812 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
813 if let Some(ns) = self.descendant_namespace_at_path(&namespace_path) {
814 ns.request_middleware(middleware_name)
815 } else {
816 None
817 }
818 }
819
820 pub fn handler_template(&self, name: &str) -> Option<Handler> {
821 let handler_templates = self.inner.handler_templates.lock().unwrap();
822 handler_templates.get(name).cloned()
823 }
824
825 pub fn handler_template_at_path(&self, path: &Vec<String>) -> Option<Handler> {
826 let handler_name = path.last().unwrap();
827 if path.len() == 1 {
828 self.handler_template(handler_name)
829 } else {
830 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
832 if let Some(dest_namespace) = self.descendant_namespace_at_path(&namespace_path) {
833 dest_namespace.handler_template(handler_name)
834 } else {
835 None
836 }
837 }
838 }
839
840 pub fn handler(&self, name: &str) -> Option<Handler> {
841 let handlers = self.inner.handlers.lock().unwrap();
842 handlers.get(name).cloned()
843 }
844
845 pub fn handler_group(&self, name: &str) -> Option<handler::group::Builder> {
846 let handler_groups = self.inner.handler_groups.lock().unwrap();
847 handler_groups.get(name).cloned()
848 }
849
850 pub fn handler_group_or_create(&self, name: &str) -> handler::group::Builder {
851 if let Some(handler_group) = self.handler_group(name) {
852 handler_group
853 } else {
854 let mut handler_groups = self.inner.handler_groups.lock().unwrap();
855 handler_groups.insert(name.to_owned(), handler::group::Builder::new(next_path(self.path(), name), self.app_data().clone()));
856 handler_groups.get(name).unwrap().clone()
857 }
858 }
859
860 pub fn model_handler_group(&self, name: &str) -> Option<handler::group::Builder> {
861 let model_handler_groups = self.inner.model_handler_groups.lock().unwrap();
862 model_handler_groups.get(name).cloned()
863 }
864
865 pub fn model_handler_group_or_create(&self, name: &str) -> handler::group::Builder {
866 if let Some(model_handler_group) = self.model_handler_group(name) {
867 model_handler_group
868 } else {
869 let mut model_handler_groups = self.inner.model_handler_groups.lock().unwrap();
870 model_handler_groups.insert(name.to_owned(), handler::group::Builder::new(next_path(self.path(), name), self.app_data().clone()));
871 model_handler_groups.get(name).unwrap().clone()
872 }
873 }
874
875 pub fn handler_at_path(&self, path: &Vec<&str>) -> Option<Handler> {
876 let handler_name = *path.last().unwrap();
877 if path.len() == 1 {
878 self.handler(handler_name)
879 } else {
880 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
882 if let Some(dest_namespace) = self.descendant_namespace_at_path(&namespace_path) {
883 dest_namespace.handler(handler_name)
884 } else {
885 let handler_name = *path.last().unwrap();
887 let group_name = *path.get(path.len() - 2).unwrap();
888 let namespace_path: Vec<String> = path.into_iter().rev().skip(2).rev().map(|i| i.to_string()).collect();
889 if let Some(dest_namespace) = self.descendant_namespace_at_path(&namespace_path) {
890 if let Some(group) = dest_namespace.handler_group(group_name) {
891 group.handler(handler_name)
892 } else if let Some(group) = dest_namespace.model_handler_group(group_name) {
893 group.handler(handler_name)
894 } else {
895 None
896 }
897 } else {
898 None
899 }
900 }
901 }
902 }
903
904 pub fn replace_handler_template_at_path(&self, path: &Vec<&str>, handler: Handler) {
905 let handler_name = *path.last().unwrap();
906 let namespace_path: Vec<String> = path.into_iter().rev().skip(1).rev().map(|i| i.to_string()).collect();
907 let dest_namespace = self.descendant_namespace_or_create_at_path(&namespace_path);
908 dest_namespace.insert_handler_template(handler_name, handler);
909 }
910
911 pub fn replace_handler_at_path(&self, path: &Vec<&str>, handler: Handler, inside_group: bool) -> Result<()> {
912 let handler_name = *path.last().unwrap();
913 let group_name = if inside_group {
914 Some(*path.get(path.len() - 2).unwrap())
915 } else {
916 None
917 };
918 let namespace_path: Vec<String> = path.into_iter().rev().skip(if inside_group { 2 } else { 1 }).rev().map(|i| i.to_string()).collect();
919 let dest_namespace = self.descendant_namespace_or_create_at_path(&namespace_path);
920 if let Some(group_name) = group_name {
921 if let Some(group) = dest_namespace.handler_group(group_name) {
922 group.insert_handler(handler_name, handler);
923 } else if let Some(group) = dest_namespace.model_handler_group(group_name) {
924 group.insert_handler(handler_name, handler);
925 } else {
926 dest_namespace.define_model_handler_group(group_name, |f| { Ok(()) })?;
927 if let Some(group) = dest_namespace.model_handler_group(group_name) {
928 group.insert_handler(handler_name, handler);
929 }
930 }
931 } else {
932 dest_namespace.insert_handler(handler_name, handler);
933 }
934 Ok(())
935 }
936
937 pub fn handler_map(&self) -> Arc<Mutex<handler::Map>> {
938 self.inner.handler_map.clone()
939 }
940
941 pub fn opposite_relation(&self, relation: &Relation) -> (Model, Option<Relation>) {
952 let opposite_model = self.model_at_path(&relation.model_path()).unwrap();
953 let opposite_relation = opposite_model.relations().values().find(|r| r.fields() == relation.references() && r.references() == relation.fields());
954 (opposite_model.clone(), opposite_relation.cloned())
955 }
956
957 pub fn through_relation(&self, relation: &Relation) -> (Model, Relation) {
969 let through_model = self.model_at_path(relation.through_path().unwrap()).unwrap();
970 let through_local_relation = through_model.relation(relation.local().unwrap()).unwrap();
971 (through_model.clone(), through_local_relation.clone())
972 }
973
974 pub fn through_opposite_relation(&self, relation: &Relation) -> (Model, Relation) {
986 let through_model = self.model_at_path(relation.through_path().unwrap()).unwrap();
987 let through_foreign_relation = through_model.relation(relation.foreign().unwrap()).unwrap();
988 (through_model.clone(), through_foreign_relation.clone())
989 }
990
991 pub fn model_opposite_relations(&self, model: &Model) -> Vec<(Model, Relation)> {
993 let model_opposite_relations_map = self.inner.model_opposite_relations_map.lock().unwrap();
994 let result = model_opposite_relations_map.get(model.path()).unwrap();
995 result.iter().map(|result| {
996 let model = self.model_at_path(&result.0).unwrap();
997 let relation = model.relation(result.1.as_str()).unwrap();
998 (model.clone(), relation.clone())
999 }).collect()
1000 }
1001
1002 pub fn set_model_opposite_relations_map(&self, map: BTreeMap<Vec<String>, Vec<(Vec<String>, String)>>) {
1003 *self.inner.model_opposite_relations_map.lock().unwrap() = map;
1004 }
1005
1006 pub fn set_handler_middlewares_block(&self, block: Option<middleware::Block>) {
1007 *self.inner.handler_middlewares_block.lock().unwrap() = block;
1008 }
1009
1010 pub fn set_request_middlewares_block(&self, block: Option<middleware::Block>) {
1011 *self.inner.request_middlewares_block.lock().unwrap() = block;
1012 }
1013
1014 pub fn handler_middleware_stack(&self) -> Middleware {
1015 self.inner.handler_middleware_stack.lock().unwrap().clone()
1016 }
1017
1018 pub fn set_handler_middleware_stack(&self, stack: Middleware) {
1019 *self.inner.handler_middleware_stack.lock().unwrap() = stack;
1020 }
1021
1022 pub fn request_middleware_stack(&self) -> Middleware {
1023 self.inner.request_middleware_stack.lock().unwrap().clone()
1024 }
1025
1026 pub fn set_request_middleware_stack(&self, stack: Middleware) {
1027 *self.inner.request_middleware_stack.lock().unwrap() = stack;
1028 }
1029
1030 pub fn app_data(&self) -> &AppData {
1031 &self.inner.app_data
1032 }
1033
1034 pub fn build(&self) -> Namespace {
1035 Namespace {
1036 inner: Arc::new(super::namespace::Inner {
1037 path: self.inner.path.clone(),
1038 namespaces: self.namespaces().into_iter().map(|(k, n)| (k.to_string(), n.build())).collect(),
1039 structs: self.inner.structs.lock().unwrap().clone(),
1040 models: self.inner.models.lock().unwrap().clone(),
1041 enums: self.inner.enums.lock().unwrap().clone(),
1042 interfaces: self.inner.interfaces.lock().unwrap().clone(),
1043 model_decorators: self.inner.model_decorators.lock().unwrap().clone(),
1044 model_field_decorators: self.inner.model_field_decorators.lock().unwrap().clone(),
1045 model_relation_decorators: self.inner.model_relation_decorators.lock().unwrap().clone(),
1046 model_property_decorators: self.inner.model_property_decorators.lock().unwrap().clone(),
1047 enum_decorators: self.inner.enum_decorators.lock().unwrap().clone(),
1048 enum_member_decorators: self.inner.enum_member_decorators.lock().unwrap().clone(),
1049 interface_decorators: self.inner.interface_decorators.lock().unwrap().clone(),
1050 interface_field_decorators: self.inner.interface_field_decorators.lock().unwrap().clone(),
1051 handler_decorators: self.inner.handler_decorators.lock().unwrap().clone(),
1052 pipeline_items: self.inner.pipeline_items.lock().unwrap().clone(),
1053 handler_middlewares: self.inner.handler_middlewares.lock().unwrap().clone(),
1054 request_middlewares: self.inner.request_middlewares.lock().unwrap().clone(),
1055 handlers: self.inner.handlers.lock().unwrap().clone(),
1056 handler_templates: self.inner.handler_templates.lock().unwrap().clone(),
1057 model_handler_groups: self.inner.model_handler_groups.lock().unwrap().clone().into_iter().map(|(k, v)| (k.to_string(), v.build())).collect(),
1058 handler_groups: self.inner.handler_groups.lock().unwrap().clone().into_iter().map(|(k, v)| (k.to_string(), v.build())).collect(),
1059 server: self.inner.server.lock().unwrap().clone(),
1060 connector: self.inner.connector.lock().unwrap().clone(),
1061 clients: self.inner.clients.lock().unwrap().clone(),
1062 entities: self.inner.entities.lock().unwrap().clone(),
1063 debug: self.inner.debug.lock().unwrap().clone(),
1064 admin: self.inner.admin.lock().unwrap().clone(),
1065 handler_middlewares_block: self.inner.handler_middlewares_block.lock().unwrap().clone(),
1066 request_middlewares_block: self.inner.request_middlewares_block.lock().unwrap().clone(),
1067 database: self.inner.database.lock().unwrap().clone(),
1068 connector_reference: self.inner.connector_reference.lock().unwrap().clone(),
1069 connection: self.inner.connection.clone(),
1070 handler_middleware_stack: self.inner.handler_middleware_stack.lock().unwrap().clone(),
1071 request_middleware_stack: self.inner.request_middleware_stack.lock().unwrap().clone(),
1072 handler_map: self.inner.handler_map.lock().unwrap().clone(),
1073 model_opposite_relations_map: self.inner.model_opposite_relations_map.lock().unwrap().clone(),
1074 app_data: self.app_data().clone(),
1075 })
1076 }
1077 }
1078}
1079
1080unsafe impl Send for Builder { }
1081unsafe impl Sync for Builder { }