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}