use tera::{Tera, Value};
use super::render;
use super::BlockRenderCtx;
thread_local! {
static CURRENT_STREAM_HTML: std::cell::RefCell<Option<std::sync::Arc<std::collections::HashMap<String, String>>>>
= const { std::cell::RefCell::new(None) };
}
#[must_use = "the guard clears the thread-local on drop; bind it to a local"]
pub struct StreamHtmlGuard {
_priv: (),
}
impl Drop for StreamHtmlGuard {
fn drop(&mut self) {
CURRENT_STREAM_HTML.with(|cell| *cell.borrow_mut() = None);
}
}
pub fn install(stream_html: std::collections::HashMap<String, String>) -> StreamHtmlGuard {
CURRENT_STREAM_HTML.with(|cell| *cell.borrow_mut() = Some(std::sync::Arc::new(stream_html)));
StreamHtmlGuard { _priv: () }
}
pub fn register_tera_function(tera: &mut Tera) {
tera.register_function(
"stream_render",
move |args: &std::collections::HashMap<String, Value>| {
let name = args
.get("name")
.and_then(Value::as_str)
.ok_or_else(|| tera::Error::msg("stream_render: `name` is required"))?;
if let Some(html) = CURRENT_STREAM_HTML
.with(|cell| cell.borrow().as_ref().and_then(|m| m.get(name).cloned()))
{
return Ok(Value::String(html));
}
let html = args
.get("_stream_html")
.and_then(Value::as_object)
.and_then(|m| m.get(name))
.and_then(Value::as_str)
.unwrap_or("")
.to_owned();
Ok(Value::String(html))
},
);
}
pub(crate) fn canonical_parsed(raw: Option<&serde_json::Value>) -> serde_json::Value {
match raw {
Some(serde_json::Value::String(s)) => {
serde_json::from_str(s).unwrap_or(serde_json::Value::Array(Vec::new()))
}
Some(other) => other.clone(),
None => serde_json::Value::Array(Vec::new()),
}
}
fn localized_or_canonical(
field: &str,
raw: Option<&serde_json::Value>,
translations: &std::collections::HashMap<String, String>,
) -> serde_json::Value {
match translations
.get(field)
.map(String::as_str)
.filter(|s| !s.trim().is_empty())
{
Some(s) => match serde_json::from_str::<serde_json::Value>(s) {
Ok(v) if v.is_array() => v,
Ok(_) => {
tracing::warn!(
target: "rustango_cms::block",
field = %field,
"stream translation override is not a JSON array; using canonical body",
);
canonical_parsed(raw)
}
Err(e) => {
tracing::warn!(
target: "rustango_cms::block",
field = %field,
error = %e,
"stream translation override is not valid JSON; using canonical body",
);
canonical_parsed(raw)
}
},
None => canonical_parsed(raw),
}
}
pub fn prerender_extension_streams(
widgets: &[crate::widget::Widget],
extension: &serde_json::Value,
tera: &Tera,
translations: &std::collections::HashMap<String, String>,
) -> Result<std::collections::HashMap<String, String>, super::BlockError> {
let mut out = std::collections::HashMap::new();
let ctx = BlockRenderCtx::new(tera);
for w in widgets {
if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
continue;
}
let base = localized_or_canonical(&w.name, extension.get(&w.name), translations);
let parsed = super::translate::apply_translatable_overrides(&w.name, &base, translations);
let html = render::prerender_stream(&parsed, &ctx)?;
out.insert(w.name.clone(), html);
}
Ok(out)
}
pub async fn prerender_extension_streams_async(
widgets: &[crate::widget::Widget],
extension: &serde_json::Value,
tera: &Tera,
pool: &rustango::sql::Pool,
translations: &std::collections::HashMap<String, String>,
form_locale_id: Option<i64>,
) -> Result<std::collections::HashMap<String, String>, super::BlockError> {
prerender_extension_streams_async_with(
widgets,
extension,
tera,
pool,
translations,
form_locale_id,
None,
"",
)
.await
}
#[allow(clippy::too_many_arguments)]
pub async fn prerender_extension_streams_async_with(
widgets: &[crate::widget::Widget],
extension: &serde_json::Value,
tera: &Tera,
pool: &rustango::sql::Pool,
translations: &std::collections::HashMap<String, String>,
form_locale_id: Option<i64>,
page_id: Option<i64>,
tenant: &str,
) -> Result<std::collections::HashMap<String, String>, super::BlockError> {
let mut out = std::collections::HashMap::new();
let ctx = BlockRenderCtx::new(tera);
for w in widgets {
if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
continue;
}
let base = localized_or_canonical(&w.name, extension.get(&w.name), translations);
let mut parsed =
super::translate::apply_translatable_overrides(&w.name, &base, translations);
enrich_chooser_refs_async(&mut parsed, pool, form_locale_id).await;
super::enrich::fire(
&mut parsed,
super::enrich::EnrichCtx {
pool,
tenant,
page_id,
},
)
.await;
let html = render::prerender_stream(&parsed, &ctx)?;
out.insert(w.name.clone(), html);
}
Ok(out)
}
pub async fn enrich_chooser_refs_async(
stream: &mut serde_json::Value,
pool: &rustango::sql::Pool,
form_locale_id: Option<i64>,
) {
let mut refs = ChooserRefs::default();
collect_chooser_refs(stream, &mut refs);
if refs.is_empty() {
return;
}
let rows = ChooserRows::fetch(pool, &refs, form_locale_id).await;
apply_chooser_refs(stream, &rows);
}
#[derive(Default)]
struct ChooserRefs {
pages: std::collections::BTreeSet<i64>,
snippets: std::collections::BTreeSet<i64>,
media: std::collections::BTreeSet<i64>,
forms: std::collections::BTreeSet<String>,
}
impl ChooserRefs {
fn is_empty(&self) -> bool {
self.pages.is_empty() && self.snippets.is_empty() && self.media.is_empty() && self.forms.is_empty()
}
}
struct ChooserRows {
pages: std::collections::HashMap<i64, crate::page::Page>,
snippets: std::collections::HashMap<i64, crate::snippet::Snippet>,
media: std::collections::HashMap<i64, crate::media::Media>,
forms: std::collections::HashMap<String, (Option<i64>, serde_json::Value)>,
}
const REF_CHUNK: usize = 1_000;
impl ChooserRows {
async fn fetch(
pool: &rustango::sql::Pool,
refs: &ChooserRefs,
form_locale_id: Option<i64>,
) -> Self {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let ids = |set: &std::collections::BTreeSet<i64>| set.iter().copied().collect::<Vec<_>>();
let mut pages = std::collections::HashMap::new();
for chunk in ids(&refs.pages).chunks(REF_CHUNK) {
let found = crate::page::Page::objects()
.where_(crate::page::Page::id.is_in(chunk.iter().copied()))
.fetch(pool)
.await
.unwrap_or_default();
pages.extend(found.into_iter().filter_map(|p| p.id.get().copied().map(|id| (id, p))));
}
let mut snippets = std::collections::HashMap::new();
for chunk in ids(&refs.snippets).chunks(REF_CHUNK) {
let found = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.is_in(chunk.iter().copied()))
.fetch(pool)
.await
.unwrap_or_default();
snippets.extend(found.into_iter().filter_map(|s| s.id.get().copied().map(|id| (id, s))));
}
let mut media = std::collections::HashMap::new();
for chunk in ids(&refs.media).chunks(REF_CHUNK) {
let found = crate::media::Media::objects()
.where_(crate::media::Media::id.is_in(chunk.iter().copied()))
.fetch(pool)
.await
.unwrap_or_default();
media.extend(found.into_iter().filter_map(|m| m.id.get().copied().map(|id| (id, m))));
}
let mut forms = std::collections::HashMap::new();
if !refs.forms.is_empty() {
let found = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
.where_(crate::snippet::Snippet::slug.is_in(refs.forms.iter().cloned()))
.fetch(pool)
.await
.unwrap_or_default();
for s in found {
if forms.contains_key(&s.slug) {
continue; }
let entry = localized_form(pool, &s, form_locale_id).await;
forms.insert(s.slug.clone(), entry);
}
let ids: Vec<i64> = refs
.forms
.iter()
.filter(|r| !forms.contains_key(*r))
.filter_map(|r| r.parse::<i64>().ok())
.collect();
if !ids.is_empty() {
let found = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
.where_(crate::snippet::Snippet::id.is_in(ids))
.fetch(pool)
.await
.unwrap_or_default();
for s in found {
let Some(id) = s.id.get().copied() else { continue };
let entry = localized_form(pool, &s, form_locale_id).await;
forms.insert(id.to_string(), entry);
}
}
}
Self { pages, snippets, media, forms }
}
}
async fn localized_form(
pool: &rustango::sql::Pool,
form: &crate::snippet::Snippet,
form_locale_id: Option<i64>,
) -> (Option<i64>, serde_json::Value) {
let sid = form.id.get().copied();
let mut data = form.data.clone();
if let (Some(lid), Some(sid_)) = (form_locale_id, sid) {
if let Ok(over) = crate::snippet_translation::fetch_for(pool, sid_, lid).await {
if !over.is_empty() {
if let Ok(mut sch) = crate::forms::schema::parse(&data) {
crate::forms::schema::apply_translations(&mut sch, &over);
data = crate::forms::schema::to_value(&sch);
}
}
}
}
(sid, data)
}
fn form_ref(value: Option<&serde_json::Value>) -> Option<String> {
match value? {
serde_json::Value::String(s) => Some(s.trim()).filter(|s| !s.is_empty()).map(str::to_owned),
serde_json::Value::Number(n) => n.as_i64().map(|id| id.to_string()),
_ => None,
}
}
fn for_each_block(
stream: &mut serde_json::Value,
f: &mut dyn FnMut(&str, &str, &mut serde_json::Map<String, serde_json::Value>),
) {
let serde_json::Value::Array(items) = stream else {
return;
};
for entry in items.iter_mut() {
let serde_json::Value::Object(envelope) = entry else {
continue;
};
let type_name = envelope.get("type").and_then(|v| v.as_str()).unwrap_or("").to_owned();
let block_id = envelope.get("id").and_then(|v| v.as_str()).unwrap_or("").to_owned();
let Some(serde_json::Value::Object(value_obj)) = envelope.get_mut("value") else {
continue;
};
f(&type_name, &block_id, value_obj);
for v in value_obj.values_mut() {
if matches!(v, serde_json::Value::Array(_)) {
for_each_block(v, f);
}
}
}
}
fn collect_chooser_refs(stream: &mut serde_json::Value, refs: &mut ChooserRefs) {
for_each_block(stream, &mut |type_name, _id, value| match type_name {
"form" => {
if let Some(r) = form_ref(value.get("form")) {
refs.forms.insert(r);
}
}
"page_chooser" => refs.pages.extend(read_id(value.get("page_id"))),
"snippet_chooser" => refs.snippets.extend(read_id(value.get("snippet_id"))),
"document_chooser" => refs.media.extend(read_id(value.get("document_id"))),
"image" => refs.media.extend(read_id(value.get("media_id"))),
_ => {}
});
}
fn apply_chooser_refs(stream: &mut serde_json::Value, rows: &ChooserRows) {
use serde_json::Value;
for_each_block(stream, &mut |type_name, block_id, value| match type_name {
"form" => {
let key = form_ref(value.get("form")).unwrap_or_default();
if let Some((sid, data)) = rows.forms.get(&key) {
value.insert("_schema".into(), data.clone());
if let Some(sid) = sid {
value.insert("_form_id".into(), serde_json::json!(sid));
}
}
value.insert("_embed".into(), Value::String(block_id.to_owned()));
}
"page_chooser" => {
if let Some(p) = read_id(value.get("page_id")).and_then(|id| rows.pages.get(&id)) {
value.insert("_url".into(), Value::String(p.url_path.clone()));
value.insert("_title".into(), Value::String(p.title.clone()));
value.insert("_slug".into(), Value::String(p.slug.clone()));
}
}
"snippet_chooser" => {
if let Some(s) = read_id(value.get("snippet_id")).and_then(|id| rows.snippets.get(&id)) {
value.insert("_title".into(), Value::String(s.title.clone()));
value.insert("_slug".into(), Value::String(s.slug.clone()));
value.insert("_html".into(), Value::String(crate::markdown::render(&s.body_markdown)));
}
}
"document_chooser" => {
if let Some(m) = read_id(value.get("document_id")).and_then(|id| rows.media.get(&id)) {
value.insert("_url".into(), Value::String(m.public_url()));
value.insert("_title".into(), Value::String(m.title.clone()));
value.insert("_filename".into(), Value::String(m.filename.clone()));
value.insert("_mime".into(), Value::String(m.mime.clone()));
value.insert("_size".into(), serde_json::json!(m.size));
}
}
"image" => {
if let Some(m) = read_id(value.get("media_id")).and_then(|id| rows.media.get(&id)) {
value.insert("_url".into(), Value::String(m.public_url()));
value.insert("_title".into(), Value::String(m.title.clone()));
value.insert("_alt_text".into(), Value::String(m.alt_text.clone()));
if let Some(w) = m.width {
value.insert("_width".into(), serde_json::json!(w));
}
if let Some(h) = m.height {
value.insert("_height".into(), serde_json::json!(h));
}
}
}
_ => {}
});
}
fn read_id(v: Option<&serde_json::Value>) -> Option<i64> {
let v = v?;
if let Some(n) = v.as_i64() {
return Some(n);
}
v.as_str().and_then(|s| s.trim().parse::<i64>().ok())
}
#[cfg(test)]
mod tests {
use super::{canonical_parsed, localized_or_canonical};
use std::collections::HashMap;
const CANONICAL: &str = r#"[{"type":"heading","value":{"text":"Hello","level":"2"}}]"#;
fn raw() -> serde_json::Value {
serde_json::Value::String(CANONICAL.to_owned())
}
fn first_text(v: &serde_json::Value) -> &str {
v.as_array().unwrap()[0]["value"]["text"].as_str().unwrap()
}
#[test]
fn canonical_parsed_handles_every_shape() {
assert_eq!(first_text(&canonical_parsed(Some(&raw()))), "Hello");
let arr = serde_json::json!([{"type":"x","value":{}}]);
assert_eq!(canonical_parsed(Some(&arr)), arr);
assert_eq!(canonical_parsed(None), serde_json::Value::Array(vec![]));
let bad = serde_json::Value::String("{not json".to_owned());
assert_eq!(
canonical_parsed(Some(&bad)),
serde_json::Value::Array(vec![])
);
}
#[test]
fn no_override_uses_canonical() {
let out = localized_or_canonical("body", Some(&raw()), &HashMap::new());
assert_eq!(out, canonical_parsed(Some(&raw())));
assert_eq!(first_text(&out), "Hello");
}
#[test]
fn valid_array_override_wins() {
let fr = r#"[{"type":"heading","value":{"text":"Bonjour","level":"2"}}]"#;
let t = HashMap::from([("body".to_owned(), fr.to_owned())]);
assert_eq!(
first_text(&localized_or_canonical("body", Some(&raw()), &t)),
"Bonjour"
);
}
#[test]
fn empty_or_whitespace_override_falls_back() {
for v in ["", " ", "\n\t"] {
let t = HashMap::from([("body".to_owned(), v.to_owned())]);
assert_eq!(
first_text(&localized_or_canonical("body", Some(&raw()), &t)),
"Hello"
);
}
}
#[test]
fn invalid_json_override_falls_back() {
let t = HashMap::from([("body".to_owned(), "{not valid json".to_owned())]);
assert_eq!(
first_text(&localized_or_canonical("body", Some(&raw()), &t)),
"Hello"
);
}
#[test]
fn non_array_override_falls_back() {
let t = HashMap::from([("body".to_owned(), r#"{"text":"oops"}"#.to_owned())]);
assert_eq!(
first_text(&localized_or_canonical("body", Some(&raw()), &t)),
"Hello"
);
}
#[test]
fn override_keyed_to_other_field_is_ignored() {
let t = HashMap::from([(
"some_other_field".to_owned(),
r#"[{"type":"x","value":{}}]"#.to_owned(),
)]);
assert_eq!(
first_text(&localized_or_canonical("body", Some(&raw()), &t)),
"Hello"
);
}
}