feat: release build bundles templates in bin

crates/common/Cargo.toml

@@ -31,3 +31,7 @@ tempfile = "3.12.0"
 url = { version = "2.5.2", features = ["serde"] }
 uuid = { version = "1.10.0", features = ["v4", "serde"] }
 
+minijinja = { version = "2.5.0", features = ["loader", "multi_template"] }
+minijinja-autoreload = "2.5.0"
+minijinja-embed = { version = "2.8.0" }
+minijinja-contrib = { version = "2.6.0", features = ["datetime", "timezone"] }

crates/common/src/utils/mailer.rs

@@ -1 +0,0 @@
-

crates/common/src/utils/mod.rs

@@ -1,3 +1,3 @@
 pub mod config;
 pub mod embedding;
-pub mod mailer;
+pub mod template_engine;

crates/common/src/utils/template_engine.rs

@@ -0,0 +1,92 @@
+pub use minijinja::{path_loader, Environment, Value};
+pub use minijinja_autoreload::AutoReloader;
+pub use minijinja_contrib;
+pub use minijinja_embed;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub enum TemplateEngine {
+    // Use AutoReload for debug builds (debug_assertions is true)
+    #[cfg(debug_assertions)]
+    AutoReload(Arc<AutoReloader>),
+    // Use Embedded for release builds (debug_assertions is false)
+    #[cfg(not(debug_assertions))]
+    Embedded(Arc<Environment<'static>>),
+}
+
+#[macro_export]
+macro_rules! create_template_engine {
+    // Macro takes the relative path to the templates dir as input
+    ($relative_path:expr) => {{
+        // Code for debug builds (AutoReload)
+        #[cfg(debug_assertions)]
+        {
+            // These lines execute in the CALLING crate's context
+            let crate_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            let template_path = crate_dir.join($relative_path);
+            let reloader = $crate::utils::template_engine::AutoReloader::new(move |notifier| {
+                let mut env = $crate::utils::template_engine::Environment::new();
+                env.set_loader($crate::utils::template_engine::path_loader(&template_path));
+                notifier.set_fast_reload(true);
+                notifier.watch_path(&template_path, true);
+                // Add contrib filters/functions
+                $crate::utils::template_engine::minijinja_contrib::add_to_environment(&mut env);
+                Ok(env)
+            });
+            $crate::utils::template_engine::TemplateEngine::AutoReload(std::sync::Arc::new(
+                reloader,
+            ))
+        }
+        // Code for release builds (Embedded)
+        #[cfg(not(debug_assertions))]
+        {
+            // These lines also execute in the CALLING crate's context
+            let mut env = $crate::utils::template_engine::Environment::new();
+            $crate::utils::template_engine::minijinja_embed::load_templates!(&mut env);
+            // Add contrib filters/functions
+            $crate::utils::template_engine::minijinja_contrib::add_to_environment(&mut env);
+            $crate::utils::template_engine::TemplateEngine::Embedded(std::sync::Arc::new(env))
+        }
+    }};
+}
+
+impl TemplateEngine {
+    pub fn render(&self, name: &str, ctx: &Value) -> Result<String, minijinja::Error> {
+        match self {
+            // Only compile this arm for debug builds
+            #[cfg(debug_assertions)]
+            TemplateEngine::AutoReload(reloader) => {
+                let env = reloader.acquire_env()?;
+                env.get_template(name)?.render(ctx)
+            }
+            // Only compile this arm for release builds
+            #[cfg(not(debug_assertions))]
+            TemplateEngine::Embedded(env) => env.get_template(name)?.render(ctx),
+        }
+    }
+
+    pub fn render_block(
+        &self,
+        template_name: &str,
+        block_name: &str,
+        context: &Value,
+    ) -> Result<String, minijinja::Error> {
+        match self {
+            // Only compile this arm for debug builds
+            #[cfg(debug_assertions)]
+            TemplateEngine::AutoReload(reloader) => {
+                let env = reloader.acquire_env()?;
+                let template = env.get_template(template_name)?;
+                let mut state = template.eval_to_state(context)?;
+                state.render_block(block_name)
+            }
+            // Only compile this arm for release builds
+            #[cfg(not(debug_assertions))]
+            TemplateEngine::Embedded(env) => {
+                let template = env.get_template(template_name)?;
+                let mut state = template.eval_to_state(context)?;
+                state.render_block(block_name)
+            }
+        }
+    }
+}