improve top-level error handling

Author: lovasoa

CHANGELOG.md

@@ -26,6 +26,8 @@
  - When no component is selected, display data with the `debug` component by default.
    This makes any simple `SELECT` statement a valid SQLPage file.
    Before, data returned outside of a component would be ignored.
+ - Improved error handling. SQLPage now displays a nice error page when an error occurs, even if it's at the top of the page.
+   This makes it easier to debug SQLPage websites. Before, errors that occured before SQLPage had started to render the page would be displayed as a raw text error message without any styling.
 
 ## 0.9.5 (2023-08-12)
 

sqlpage/templates/error.handlebars

@@ -6,20 +6,18 @@
         We are sorry, but an error occurred while generating this page.
         You should contact the site's administrator.
     </p>
-    {{#each_row}}
-        <p>
-            {{#if query_number}}
-                Error in query number <strong>{{query_number}}</strong>:
-            {{/if}}
-        </p>
-        <pre><code>{{description}}</code></pre>
-        {{#if backtrace}}
-            <details class="fs-5">
-                <summary>Backtrace</summary>
-                {{~#each backtrace~}}
-                    <pre class="fs-5 mt-1 p-1 my-1"><code>{{this}}</code></pre>
-                {{~/each~}}
-            </details>
+    <p>
+        {{#if query_number}}
+            Error in query number <strong>{{query_number}}</strong>:
         {{/if}}
-    {{/each_row}}
+    </p>
+    <pre><code>{{description}}</code></pre>
+    {{#if backtrace}}
+        <details open class="fs-5">
+            <summary>Backtrace</summary>
+            {{~#each backtrace~}}
+                <pre class="fs-5 mt-1 p-1 my-1"><code>{{this}}</code></pre>
+            {{~/each~}}
+        </details>
+    {{/if}}
 </div>

src/render.rs

@@ -56,6 +56,16 @@ impl<W: std::io::Write> HeaderContext<W> {
         }
     }
 
+    pub async fn handle_error(self, err: anyhow::Error) -> anyhow::Result<PageContext<W>> {
+        log::debug!("Handling header error: {err}");
+        let data = json!({
+            "component": "error",
+            "description": err.to_string(),
+            "backtrace": get_backtrace(&err),
+        });
+        self.start_body(data).await
+    }
+
     fn status_code(mut self, data: &JsonValue) -> anyhow::Result<Self> {
         let status_code = data
             .as_object()
@@ -209,6 +219,16 @@ impl<W: std::io::Write> HeaderContext<W> {
     }
 }
 
+fn get_backtrace(error: &anyhow::Error) -> Vec<String> {
+    let mut backtrace = vec![];
+    let mut source = error.source();
+    while let Some(s) = source {
+        backtrace.push(format!("{s}"));
+        source = s.source();
+    }
+    backtrace
+}
+
 fn get_object_str<'a>(json: &'a JsonValue, key: &str) -> Option<&'a str> {
     json.as_object()
         .and_then(|obj| obj.get(key))
@@ -278,8 +298,9 @@ impl<W: std::io::Write> RenderContext<W> {
 
         if let Some(component) = initial_component {
             log::trace!("The page starts with a component without a shell: {component}");
-            initial_context.open_component(component).await?;
-            initial_context.handle_row(&initial_row).await?;
+            initial_context
+                .open_component_with_data(component, &initial_row)
+                .await?;
         }
 
         Ok(initial_context)
@@ -367,20 +388,13 @@ impl<W: std::io::Write> RenderContext<W> {
     pub async fn handle_error(&mut self, error: &anyhow::Error) -> anyhow::Result<()> {
         log::warn!("SQL error: {:?}", error);
         self.close_component()?;
-        let saved_component = self.open_component("error").await?;
         let description = error.to_string();
-        let mut backtrace = vec![];
-        let mut source = error.source();
-        while let Some(s) = source {
-            backtrace.push(format!("{s}"));
-            source = s.source();
-        }
-        self.render_current_template_with_data(&json!({
+        let data = json!({
             "query_number": self.current_statement,
             "description": description,
-            "backtrace": backtrace
-        }))
-        .await?;
+            "backtrace": get_backtrace(error)
+        });
+        let saved_component = self.open_component_with_data("error", &data).await?;
         self.close_component()?;
         self.current_component = saved_component;
         Ok(())
@@ -416,13 +430,6 @@ impl<W: std::io::Write> RenderContext<W> {
         Ok(())
     }
 
-    async fn open_component(
-        &mut self,
-        component: &str,
-    ) -> anyhow::Result<Option<SplitTemplateRenderer>> {
-        self.open_component_with_data(component, &json!(null)).await
-    }
-
     async fn create_renderer(
         component: &str,
         app_state: Arc<AppState>,
@@ -519,7 +526,13 @@ impl SplitTemplateRenderer {
         writer: W,
         data: JsonValue,
     ) -> Result<(), RenderError> {
-        log::trace!("Starting rendering of a new page with the following page-level data: {data}");
+        log::trace!(
+            "Starting rendering of a template{} with the following top-level parameters: {data}",
+            self.split_template
+                .name()
+                .map(|n| format!(" ('{n}')"))
+                .unwrap_or_default(),
+        );
         let mut render_context = handlebars::RenderContext::new(None);
         *self.ctx.data_mut() = data;
         let mut output = HandlebarWriterOutput(writer);
@@ -569,7 +582,13 @@ impl SplitTemplateRenderer {
     }
 
     fn render_end<W: std::io::Write>(&mut self, writer: W) -> Result<(), RenderError> {
-        log::trace!("Closing the current page");
+        log::trace!(
+            "Closing a template {}",
+            self.split_template
+                .name()
+                .map(|n| format!("('{n}')"))
+                .unwrap_or_default(),
+        );
         if let Some(local_vars) = self.local_vars.take() {
             let mut render_context = handlebars::RenderContext::new(None);
             *render_context

src/templates.rs

@@ -19,6 +19,12 @@ pub struct SplitTemplate {
     pub after_list: Template,
 }
 
+impl SplitTemplate {
+    pub fn name(&self) -> Option<&str> {
+        self.before_list.name.as_deref()
+    }
+}
+
 pub fn split_template(mut original: Template) -> SplitTemplate {
     let mut elements_after = Vec::new();
     let mut mapping_after = Vec::new();
@@ -287,8 +293,14 @@ impl AllTemplates {
         for file in STATIC_TEMPLATES.files() {
             let mut path = PathBuf::from(TEMPLATES_DIR);
             path.push(file.path());
+            let name = file
+                .path()
+                .file_stem()
+                .unwrap()
+                .to_string_lossy()
+                .to_string();
             let source = String::from_utf8_lossy(file.contents());
-            let tpl = Template::compile(&source)?;
+            let tpl = Template::compile_with_name(&source, name)?;
             let split_template = split_template(tpl);
             self.split_templates.add_static(path, split_template);
         }

src/webserver/database/sql.rs

@@ -119,6 +119,7 @@ fn parse_single_statement(parser: &mut Parser<'_>, db_kind: AnyKind) -> Option<P
 
 fn syntax_error(err: ParserError, parser: &mut Parser) -> ParsedStatement {
     let mut err_msg = "SQL syntax error before: ".to_string();
+    parser.prev_token(); // go back to the token that caused the error
     for _ in 0..32 {
         let next_token = parser.next_token();
         if next_token == EOF {

src/webserver/http.rs

@@ -153,29 +153,33 @@ async fn build_response_header_and_stream<S: Stream<Item = DbItem>>(
     let mut head_context = HeaderContext::new(app_state, writer);
     let mut stream = Box::pin(database_entries);
     while let Some(item) = stream.next().await {
-        match item {
-            DbItem::Row(data) => match head_context.handle_row(data).await? {
-                PageContext::Header(h) => {
-                    head_context = h;
-                }
-                PageContext::Body {
-                    mut http_response,
+        let page_context = match item {
+            DbItem::Row(data) => head_context.handle_row(data).await?,
+            DbItem::FinishedQuery => {
+                log::debug!("finished query");
+                continue;
+            }
+            DbItem::Error(source_err) => head_context.handle_error(source_err).await?,
+        };
+        match page_context {
+            PageContext::Header(h) => {
+                head_context = h;
+            }
+            PageContext::Body {
+                mut http_response,
+                renderer,
+            } => {
+                let body_stream = tokio_stream::wrappers::ReceiverStream::new(receiver);
+                let http_response = http_response.streaming(body_stream);
+                return Ok(ResponseWithWriter::RenderStream {
+                    http_response,
                     renderer,
-                } => {
-                    let body_stream = tokio_stream::wrappers::ReceiverStream::new(receiver);
-                    let http_response = http_response.streaming(body_stream);
-                    return Ok(ResponseWithWriter::RenderStream {
-                        http_response,
-                        renderer,
-                        database_entries_stream: stream,
-                    });
-                }
-                PageContext::Close(http_response) => {
-                    return Ok(ResponseWithWriter::FinishedResponse { http_response })
-                }
-            },
-            DbItem::FinishedQuery => log::debug!("finished query"),
-            DbItem::Error(source_err) => return Err(source_err),
+                    database_entries_stream: stream,
+                });
+            }
+            PageContext::Close(http_response) => {
+                return Ok(ResponseWithWriter::FinishedResponse { http_response })
+            }
         }
     }
     log::debug!("No SQL statements left to execute for the body of the response");