og_image: Use Typst's --input instead of minijinja to pass in data

This makes the crate more secure while maintaining the same functionality, and it simplifies the implementation by removing the intermediate template rendering step.

Author: Turbo87

Cargo.lock

@@ -12,9 +12,9 @@ workspace = true
 anyhow = "=1.0.98"
 bytes = "=1.10.1"
 crates_io_env_vars = { path = "../crates_io_env_vars" }
-minijinja = { version = "=2.10.2", features = ["builtins"] }
 reqwest = "=0.12.20"
 serde = { version = "=1.0.219", features = ["derive"] }
+serde_json = "=1.0.140"
 tempfile = "=3.20.0"
 thiserror = "=2.0.12"
 tokio = { version = "=1.45.1", features = ["process", "fs"] }

crates/crates_io_og_image/Cargo.toml

@@ -30,9 +30,9 @@ pub enum OgImageError {
         source: std::io::Error,
     },
 
-    /// Template rendering error.
-    #[error("Template rendering error: {0}")]
-    TemplateError(#[from] minijinja::Error),
+    /// JSON serialization error.
+    #[error("JSON serialization error: {0}")]
+    JsonSerializationError(#[source] serde_json::Error),
 
     /// Typst compilation failed.
     #[error("Typst compilation failed: {stderr}")]

crates/crates_io_og_image/src/error.rs

@@ -3,6 +3,8 @@
 //! This module contains utility functions for formatting numbers in various ways,
 //! such as human-readable byte sizes.
 
+use serde::Serializer;
+
 /// Formats a byte size value into a human-readable string.
 ///
 /// The function follows these rules:
@@ -50,6 +52,10 @@ pub fn format_bytes(bytes: u32) -> String {
     }
 }
 
+pub fn serialize_bytes<S: Serializer>(bytes: &u32, serializer: S) -> Result<S::Ok, S::Error> {
+    serializer.serialize_str(&format_bytes(*bytes))
+}
+
 /// Formats a number with "k" and "M" suffixes for thousands and millions.
 ///
 /// The function follows these rules:
@@ -95,6 +101,20 @@ pub fn format_number(number: u32) -> String {
     }
 }
 
+pub fn serialize_number<S: Serializer>(number: &u32, serializer: S) -> Result<S::Ok, S::Error> {
+    serializer.serialize_str(&format_number(*number))
+}
+
+pub fn serialize_optional_number<S: Serializer>(
+    opt_number: &Option<u32>,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    match opt_number {
+        Some(number) => serializer.serialize_str(&format_number(*number)),
+        None => serializer.serialize_none(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/crates_io_og_image/src/formatting.rs

@@ -5,40 +5,17 @@ mod formatting;
 
 pub use error::OgImageError;
 
-use crate::formatting::{format_bytes, format_number};
+use crate::formatting::{serialize_bytes, serialize_number, serialize_optional_number};
 use bytes::Bytes;
 use crates_io_env_vars::var;
-use minijinja::{Environment, context};
 use serde::Serialize;
+use serde_json;
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::sync::LazyLock;
 use tempfile::NamedTempFile;
 use tokio::fs;
 use tokio::process::Command;
 
-static TEMPLATE_ENV: LazyLock<Environment<'_>> = LazyLock::new(|| {
-    let mut env = Environment::new();
-
-    // Add custom filter for escaping Typst special characters
-    env.add_filter("typst_escape", |value: String| -> String {
-        value
-            .replace('\\', "\\\\") // Escape backslashes first
-            .replace('"', "\\\"") // Escape double quotes
-        // Note: No need to escape # characters when inside double-quoted strings
-    });
-
-    // Add custom filter for formatting byte sizes
-    env.add_filter("format_bytes", format_bytes);
-
-    // Add custom filter for formatting numbers with k/M suffixes
-    env.add_filter("format_number", format_number);
-
-    let template_str = include_str!("../templates/og-image.typ.j2");
-    env.add_template("og-image.typ", template_str).unwrap();
-    env
-});
-
 /// Data structure containing information needed to generate an OpenGraph image
 /// for a crates.io crate.
 #[derive(Debug, Clone, Serialize)]
@@ -56,10 +33,13 @@ pub struct OgImageData<'a> {
     /// Author information
     pub authors: &'a [OgImageAuthorData<'a>],
     /// Source lines of code count (optional)
+    #[serde(serialize_with = "serialize_optional_number")]
     pub lines_of_code: Option<u32>,
     /// Package size in bytes
+    #[serde(serialize_with = "serialize_bytes")]
     pub crate_size: u32,
     /// Total number of releases
+    #[serde(serialize_with = "serialize_number")]
     pub releases: u32,
 }
 
@@ -187,20 +167,6 @@ impl OgImageGenerator {
         Ok(avatar_map)
     }
 
-    /// Generates the Typst template content from the provided data.
-    ///
-    /// This private method renders the Jinja2 template with the provided data
-    /// and returns the resulting Typst markup as a string.
-    fn generate_template(
-        &self,
-        data: &OgImageData<'_>,
-        avatar_map: &HashMap<&str, String>,
-    ) -> Result<String, OgImageError> {
-        let template = TEMPLATE_ENV.get_template("og-image.typ")?;
-        let rendered = template.render(context! { data, avatar_map })?;
-        Ok(rendered)
-    }
-
     /// Generates an OpenGraph image using the provided data.
     ///
     /// This method creates a temporary directory with all the necessary files
@@ -258,19 +224,30 @@ impl OgImageGenerator {
         // Process avatars - download URLs and copy assets
         let avatar_map = self.process_avatars(&data, &assets_dir).await?;
 
-        // Create og-image.typ file using minijinja template
-        let rendered = self.generate_template(&data, &avatar_map)?;
+        // Copy the static Typst template file
+        let template_content = include_str!("../templates/og-image.typ");
         let typ_file_path = temp_dir.path().join("og-image.typ");
-        fs::write(&typ_file_path, rendered).await?;
+        fs::write(&typ_file_path, template_content).await?;
 
         // Create a named temp file for the output PNG
         let output_file = NamedTempFile::new().map_err(OgImageError::TempFileError)?;
 
-        // Run typst compile command
+        // Serialize data and avatar_map to JSON
+        let json_data = serde_json::to_string(&data);
+        let json_data = json_data.map_err(OgImageError::JsonSerializationError)?;
+
+        let json_avatar_map = serde_json::to_string(&avatar_map);
+        let json_avatar_map = json_avatar_map.map_err(OgImageError::JsonSerializationError)?;
+
+        // Run typst compile command with input data
         let output = Command::new(&self.typst_binary_path)
             .arg("compile")
             .arg("--format")
             .arg("png")
+            .arg("--input")
+            .arg(format!("data={}", json_data))
+            .arg("--input")
+            .arg(format!("avatar_map={}", json_avatar_map))
             .arg(&typ_file_path)
             .arg(output_file.path())
             .output()
@@ -313,22 +290,6 @@ mod tests {
         OgImageAuthorData::new(name, Some("test-avatar"))
     }
 
-    fn create_standard_test_data() -> OgImageData<'static> {
-        static AUTHORS: &[OgImageAuthorData<'_>] = &[author_with_avatar("alice"), author("bob")];
-
-        OgImageData {
-            name: "example-crate",
-            version: "v2.1.0",
-            description: "A comprehensive example crate showcasing various OpenGraph features",
-            license: "MIT OR Apache-2.0",
-            tags: &["web", "api", "async", "json", "http"],
-            authors: AUTHORS,
-            lines_of_code: Some(5500),
-            crate_size: 128000,
-            releases: 15,
-        }
-    }
-
     fn create_minimal_test_data() -> OgImageData<'static> {
         static AUTHORS: &[OgImageAuthorData<'_>] = &[author("author")];
 
@@ -428,12 +389,6 @@ mod tests {
             .is_err()
     }
 
-    fn generate_template(data: OgImageData<'_>, avatar_map: HashMap<&str, String>) -> String {
-        OgImageGenerator::default()
-            .generate_template(&data, &avatar_map)
-            .expect("Failed to generate template")
-    }
-
     async fn generate_image(data: OgImageData<'_>) -> Option<Vec<u8>> {
         if skip_if_typst_unavailable() {
             return None;
@@ -449,33 +404,6 @@ mod tests {
         Some(std::fs::read(temp_file.path()).expect("Failed to read generated image"))
     }
 
-    #[test]
-    fn test_generate_template_snapshot() {
-        let data = create_standard_test_data();
-        let avatar_map = HashMap::from([("test-avatar", "avatar_0.png".to_string())]);
-
-        let template_content = generate_template(data, avatar_map);
-        insta::assert_snapshot!("generated_template.typ", template_content);
-    }
-
-    #[test]
-    fn test_generate_template_minimal_snapshot() {
-        let data = create_minimal_test_data();
-        let avatar_map = HashMap::new();
-
-        let template_content = generate_template(data, avatar_map);
-        insta::assert_snapshot!("generated_template_minimal.typ", template_content);
-    }
-
-    #[test]
-    fn test_generate_template_escaping_snapshot() {
-        let data = create_escaping_test_data();
-        let avatar_map = HashMap::from([("test-avatar", "avatar_0.png".to_string())]);
-
-        let template_content = generate_template(data, avatar_map);
-        insta::assert_snapshot!("generated_template_escaping.typ", template_content);
-    }
-
     #[tokio::test]
     async fn test_generate_og_image_snapshot() {
         let data = create_simple_test_data();