alternative "template reload" experience

examples/demo/src/initializers/view_engine.rs

@@ -18,13 +18,22 @@ impl Initializer for ViewEngineInitializer {
     }
 
     async fn after_routes(&self, router: AxumRouter, _ctx: &AppContext) -> Result<AxumRouter> {
+        #[allow(unused_mut)]
         let mut tera_engine = engines::TeraView::build()?;
         if std::path::Path::new(I18N_DIR).exists() {
             let arc = ArcLoader::builder(&I18N_DIR, unic_langid::langid!("en-US"))
                 .shared_resources(Some(&[I18N_SHARED.into()]))
                 .customize(|bundle| bundle.set_use_isolating(false))
                 .build()
                 .map_err(|e| Error::string(&e.to_string()))?;
+            #[cfg(debug_assertions)]
+            tera_engine
+                .tera
+                .lock()
+                .expect("lock")
+                .register_function("t", FluentLoader::new(arc));
+
+            #[cfg(not(debug_assertions))]
             tera_engine
                 .tera
                 .register_function("t", FluentLoader::new(arc));

src/controller/middleware/cors.rs

@@ -45,7 +45,7 @@ impl Default for Cors {
 }
 
 fn default_allow_origins() -> Vec<String> {
-    vec!["*".to_string()]
+    vec!["any".to_string()]
 }
 
 fn default_allow_headers() -> Vec<String> {

src/controller/views/engines.rs

@@ -8,7 +8,15 @@ const VIEWS_DIR: &str = "assets/views";
 
 #[derive(Clone, Debug)]
 pub struct TeraView {
+    #[cfg(debug_assertions)]
+    pub tera: std::sync::Arc<std::sync::Mutex<tera::Tera>>,
+
+    #[cfg(not(debug_assertions))]
     pub tera: tera::Tera,
+
+    #[cfg(debug_assertions)]
+    pub view_dir: String,
+
     pub default_context: tera::Context,
 }
 
@@ -44,38 +52,35 @@ impl TeraView {
         )?;
         let ctx = tera::Context::default();
         Ok(Self {
-            tera,
+            #[cfg(debug_assertions)]
+            view_dir: path.as_ref().to_string_lossy().to_string(),
+            #[cfg(debug_assertions)]
+            tera: std::sync::Arc::new(std::sync::Mutex::new(tera)),
+            #[cfg(not(debug_assertions))]
+            tera: tera,
             default_context: ctx,
         })
     }
 }
 
 impl ViewRenderer for TeraView {
     fn render<S: Serialize>(&self, key: &str, data: S) -> Result<String> {
+        #[cfg(debug_assertions)]
+        use std::borrow::BorrowMut;
+
         let context = tera::Context::from_serialize(data)?;
 
-        // NOTE: this supports full reload of template for every render request.
-        // it means that you will see refreshed content without rebuild and rerun
-        // of the app.
-        // the code here is required, since Tera has no "build every time your render"
-        // mode, which would have been better.
-        // we minimize risk by flagging this in debug (development) builds only
-        // for now we leave this commented out, we propose people use `cargo-watch`
-        // we want to delay using un__safe as much as possible.
-        /*
         #[cfg(debug_assertions)]
-        {
-            let ptr = std::ptr::addr_of!(self.tera);
-            let mut_ptr = ptr.cast_mut();
-            // fix this keyword
-            un__safe {
-                let tera = &mut *mut_ptr;
-                tera.full_reload()?;
-            }
-        }
-        */
+        tracing::debug!(key = key, "Tera rendering in non-optimized debug mode");
+        #[cfg(debug_assertions)]
+        return Ok(self.tera.lock().expect("lock").borrow_mut().render_str(
+            &std::fs::read_to_string(Path::new(&self.view_dir).join(key))
+                .map_err(|_e| tera::Error::template_not_found(key))?,
+            &context,
+        )?);
 
-        Ok(self.tera.render(key, &context)?)
+        #[cfg(not(debug_assertions))]
+        return Ok(self.tera.render(key, &context)?);
     }
 }