Skip to main content

densky_core/http/
tree.rs

1use std::cmp::Ordering;
2use std::path::Path;
3use std::sync::MutexGuard;
4
5use crate::utils::{import, relative_path, UrlMatcher};
6use crate::walker::{WalkerContainer, WalkerTree};
7
8use super::{HttpLeaf, HttpParseError, REQ_PARAM};
9
10pub struct HttpTree;
11
12impl HttpTree {
13    pub fn resolve_import<P: AsRef<Path>>(this: &MutexGuard<'_, WalkerTree>, path: P) -> String {
14        let path = path.as_ref().display().to_string();
15        match path.chars().nth(0) {
16            Some('/') => {
17                let output_dirname = this.output_path.parent().expect("Output path is root");
18
19                relative_path(path, output_dirname)
20                    .map(|path| path.display().to_string())
21                    .expect("Output path is root")
22            }
23            _ => path,
24        }
25    }
26
27    pub fn generate_file(
28        this: &mut MutexGuard<'_, WalkerTree>,
29        container: &mut WalkerContainer,
30    ) -> Result<String, HttpParseError> {
31        let url_matcher = UrlMatcher::new(this.rel_path.to_owned());
32        let leaf_parts = this
33            .leaf
34            .as_ref()
35            .map(|&leaf| HttpLeaf::get_parts(&container.get_leaf_locked(leaf).unwrap()));
36        let leaf_parts = if let Some(parts) = leaf_parts {
37            match parts {
38                Ok(expr) => Some(expr),
39                Err(e) => return Err(e.clone()),
40            }
41        } else {
42            None
43        };
44
45        let middlewares = if this.is_middleware {
46            vec![]
47        } else {
48            this.get_middlewares(container)
49        };
50
51        let empty_string = String::new();
52        let leaf_imports = leaf_parts.as_ref().map_or(&empty_string, |parts| &parts.0);
53        let leaf_content = leaf_parts.as_ref().map_or(&empty_string, |parts| &parts.2);
54        let leaf_handlers = leaf_parts.as_ref().map_or(&empty_string, |parts| &parts.1);
55        let is_empty_handlers = String::is_empty(&leaf_handlers);
56        let fallback_import = this.fallback.as_ref().map_or_else(
57            || String::new(),
58            |&fallback| {
59                import(
60                    "$__fallback__$",
61                    Self::resolve_import(
62                        this,
63                        &container.get_leaf_locked(fallback).unwrap().output_path,
64                    ),
65                )
66            },
67        );
68        let children_import: Vec<String> = this
69            .children
70            .iter()
71            .enumerate()
72            .map(|(index, &child)| {
73                import(
74                    format!("$__child__${index}"),
75                    Self::resolve_import(
76                        this,
77                        &container.get_tree_locked(child).unwrap().output_path,
78                    ),
79                )
80            })
81            .collect();
82        let children_import = children_import.join("\n");
83        let middlewares_import = if this.is_middleware {
84            String::new()
85        } else {
86            middlewares
87                .iter()
88                .enumerate()
89                .map(|(index, &middleware)| {
90                    import(
91                        format!("$__middleware__${index}"),
92                        Self::resolve_import(
93                            this,
94                            &container.get_leaf_locked(middleware).unwrap().output_path,
95                        ),
96                    )
97                })
98                .collect::<Vec<String>>()
99                .join("\n")
100        };
101        let imports = format!(
102            "import * as $_Densky_Runtime_$ from \"densky/runtime.ts\";\n{}\n{}\n{}{}",
103            fallback_import, children_import, middlewares_import, leaf_imports
104        );
105
106        let middlewares_handlers = if this.is_middleware {
107            String::new()
108        } else {
109            middlewares
110                .iter()
111                .enumerate()
112                .map(|(index, _)| {
113                    format!(
114                        "{{ 
115                          let _ = await $__middleware__${}(__req_param__); 
116                          if (_) return _; 
117                        }};",
118                        index
119                    )
120                })
121                .collect::<Vec<String>>()
122                .join("\n")
123        };
124
125        let fallback_handler = if this.fallback.is_some() {
126            "return $__fallback__$(__req_param__);"
127        } else {
128            ""
129        };
130
131        let top_content = format!(
132            "{imports}\n{serial}\n{content}",
133            content = leaf_content,
134            serial = url_matcher.serial_decl(),
135        );
136
137        let mut children_content: Vec<(usize, String)> = (0..this.children.len())
138            .map(|index| {
139                (
140                    *this.children.get(index).unwrap(),
141                    format!(
142                        "{{ 
143                          const r = await $__child__${0}({1}); 
144                          if (!!r || r === null) return r; 
145                        }};",
146                        index, REQ_PARAM
147                    ),
148                )
149            })
150            .collect();
151        children_content.sort_by(|a, b| {
152            let a_child = container.get_tree_locked(a.0).unwrap();
153            let b_child = container.get_tree_locked(b.0).unwrap();
154
155            let a_is_deep = a_child.rel_path.find('/').is_some();
156            let b_is_deep = b_child.rel_path.find('/').is_some();
157
158            match (a_is_deep, b_is_deep) {
159                (true, true) => (),
160                (false, false) => {
161                    let a_is_var = a_child.rel_path.starts_with('$');
162                    let b_is_var = b_child.rel_path.starts_with('$');
163
164                    match (a_is_var, b_is_var) {
165                        (true, true) | (false, false) => (),
166                        (true, false) => return Ordering::Greater,
167                        (false, true) => return Ordering::Less,
168                    }
169                }
170                (true, false) => return Ordering::Greater,
171                (false, true) => return Ordering::Less,
172            }
173
174            let a_path: Vec<&str> = a_child.rel_path.split('/').collect();
175            let b_path: Vec<&str> = b_child.rel_path.split('/').collect();
176
177            a_path.len().cmp(&b_path.len())
178        });
179        let children_content: Vec<String> =
180            children_content.iter().map(|a| a.1.to_owned()).collect();
181        let children_content = children_content.join("\n");
182
183        let handler_content = if is_empty_handlers {
184            String::new()
185        } else {
186            format!(
187                "if ({exact}) {{ 
188                  {middlewares} 
189                  {handlers} 
190                  ;return new Response(\"Method not handled\", {{ status: 401 }}); 
191                }} ",
192                middlewares = middlewares_handlers,
193                handlers = leaf_handlers,
194                exact = url_matcher.exact_decl(REQ_PARAM, this.children.len() != 0),
195            )
196        };
197
198        let handler_content = format!(
199            "{}\n{}\n{}",
200            handler_content, children_content, fallback_handler
201        );
202
203        let inner_content = if this.is_root || this.children.len() == 0 {
204            handler_content
205        } else if this.is_fallback {
206            leaf_handlers.clone()
207        } else {
208            format!(
209                "if ({start}) {{ 
210                  {update} 
211                  {inner_content} 
212                  return null;
213                }}",
214                inner_content = handler_content,
215                start = url_matcher.start_decl(REQ_PARAM),
216                update = url_matcher.update_decl(REQ_PARAM),
217            )
218        };
219        let (pretty, _) = prettify_js::prettyprint(
220            format!(
221                "// deno-lint-ignore-file 
222                // {0}
223                // File auto-generated by Densky Framework
224                {top_content}
225                (!!Deno.env.has(\"DENSKY_MODULES_LOAD_DEBUG\")) && console.log(\"[Module Load Debug]\", import.meta.url);
226                ;export default async function(__req_param__: $_Densky_Runtime_$.HTTPRequest) {{
227                  {inner_content}
228                }}",
229                &this.rel_path,
230            )
231            .as_str(),
232        );
233
234        return Ok(pretty);
235    }
236}