How can env.add_function call asynchronous functions

[sunkaifei]

Do you know anything? Because if all templates can call asynchronous data in the form of tags, the controller does not need to call the database, making template development very convenient.

[mitsuhiko]

This example shows how you can invoke async functions in your templates: https://github.com/mitsuhiko/minijinja/blob/main/examples/object-using-async/src/main.rs

What call_method there is doing you can also do in a function added with add_function. You would however need to pass the handle by other means.

[mitsuhiko]

I added a better example here: https://github.com/mitsuhiko/minijinja/blob/main/examples/function-using-async/src/main.rs

[sunkaifei]

Dear author, hello. I was unsuccessful in trying under activx_web because I wanted the template to be able to automatically reload and also have the add_function to call asynchronous functions. As I have just started working with this engine, it is challenging for beginners to write an example that can both automatically reload templates and call asynchronous functions. If you have time, I hope you can provide an example of activx_web to facilitate our learning. Thank you very much for your prompt reply. Thank you

[mitsuhiko]

Can you be more specific about what problems you are running into? Maybe share the code that you wrote and the problems you have.

[sunkaifei]

use std::cell::RefCell;
use std::sync::Arc;

use actix_web::http::header::ContentType;
use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder};
use minijinja::value::{Enumerator, Object, Rest, Value, ValueKind};
use minijinja::{context, path_loader, Environment, Error, ErrorKind, State};
use tokio::runtime::Handle;
use tokio::task::spawn_blocking;
use log::log;

thread_local! {
    static CURRENT_REQUEST: RefCell<Option<HttpRequest>> = RefCell::default()
}

fn with_bound_req<F, R>(req: &HttpRequest, f: F) -> R
where
    F: FnOnce() -> R,
{
    CURRENT_REQUEST.with(|current_req| *current_req.borrow_mut() = Some(req.clone()));
    let rv = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f));
    CURRENT_REQUEST.with(|current_req| current_req.borrow_mut().take());
    match rv {
        Ok(rv) => rv,
        Err(panic) => std::panic::resume_unwind(panic),
    }
}

#[derive(Debug)]
struct ContextWithRuntime {
    rt: Handle,
    ctx: Value,
}

impl Object for ContextWithRuntime {
    fn get_value(self: &Arc<Self>, name: &Value) -> Option<Value> {
        if name.as_str() == Some("$context") {
            return Some(Value::from_dyn_object(self.clone()));
        }
        self.ctx.get_item(name).ok().filter(|x| !x.is_undefined())
    }

    fn enumerate(self: &Arc<Self>) -> Enumerator {
        if self.ctx.kind() == ValueKind::Map {
            if let Ok(keys) = self.ctx.try_iter() {
                return Enumerator::Values(keys.collect());
            }
        }
        Enumerator::Empty
    }
}

fn capture_runtime_handle(ctx: Value) -> Value {
    Value::from_object(ContextWithRuntime {
        ctx,
        rt: Handle::current(),
    })
}

fn get_runtime_handle(state: &State) -> Handle {
    let value = state.lookup("$context").unwrap();
    value
        .downcast_object_ref::<ContextWithRuntime>()
        .unwrap()
        .rt
        .clone()
}

async fn get_config(key: Arc<str>) -> Option<Value> {
    match &key as &str {
        "title" => Some(Value::from("My Title")),
        _ => None,
    }
}

fn get_config_template(state: &State, key: Arc<str>) -> Result<Value, Error> {
    let rt = get_runtime_handle(state);
    Ok(Value::from(rt.block_on(get_config(key))))
}

struct AppState {
    env: minijinja::Environment<'static>,
}

impl AppState {
    pub async fn render_template(
        &self,
        name: &str,
        _req: &HttpRequest,
        mut ctx: Value,
    ) -> HttpResponse {
        let env = self.env.clone();
        let name = name.to_string();
        ctx = capture_runtime_handle(context! {
            title => Value::from("title"),
        });
        let rv = spawn_blocking(move || {
            let t = env.get_template(&name).unwrap();
            t.render(ctx).unwrap()
        })
        .await
        .unwrap();

        HttpResponse::Ok()
            .content_type(ContentType::html())
            .body(rv)
    }
}

fn url_for(name: &str, args: Rest<String>) -> Result<Value, Error> {
    CURRENT_REQUEST.with(|current_req| {
        Ok(current_req
            .borrow()
            .as_ref()
            .ok_or_else(|| {
                Error::new(
                    ErrorKind::InvalidOperation,
                    "url_for requires an http request",
                )
            })?
            .url_for(name, &args[..])
            .map_err(|err| {
                Error::new(ErrorKind::InvalidOperation, "failed to generate url").with_source(err)
            })?
            .to_string()
            .into())
    })
}

async fn index(app_state: web::Data<AppState>, req: HttpRequest) -> impl Responder {
    let ctx = context! {
        user_id => 1,
        name => "World"
    };
    app_state.render_template("index.html", &req, ctx).await
}

async fn user(
    app_state: web::Data<AppState>,
    req: HttpRequest,
    path: web::Path<(u64,)>,
) -> impl Responder {
    let ctx = capture_runtime_handle(context! {
        user_id => path.0,
    });
    app_state.render_template("user.html", &req, ctx).await
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let mut env = Environment::new();
    env.set_loader(path_loader("templates"));
    env.add_function("url_for", url_for);
    env.add_function("get_config", get_config_template);
    env.add_template("hello", "title: {{ get_config(key) }}")
        .unwrap();

    let state = web::Data::new(AppState { env });

    HttpServer::new(move || {
        App::new()
            .app_data(state.clone())
            .service(web::resource("/").name("index").route(web::get().to(index)))
            .service(
                web::resource("/user/{user_id}")
                    .name("user")
                    .route(web::get().to(user)),
            )
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

After a preliminary attempt, the above code can now obtain asynchronous functions. The {get_config ('title ')} tag can be called in the template, but synchronous functions are no longer available, such as the {{url_for ('index')} tag.

[mitsuhiko]

That won't work because HttpRequest in actix cannot be sent across threads. In this case you will have to give up on the idea of making url_for work.

[sunkaifei]

What I want is for each module to be able to customize N tags when writing a program. These tags can output tag content according to the page element requirements. Currently, after functional testing of all Rust template engines, Minijinja is still quite good. Terra is actually quite useful, but custom tags do not support reading asynchronous data. The author may not be interested in it anymore and has not updated it for a long time. When I asked him, he clearly replied that there is no addition or improvement to the asynchronous calling function

[mitsuhiko]

The problem here is not minijinja but that actix does not have a Send request. That means you cannot send it to other threads and as such you cannot make url_for work here. This would require a change in actix.

[sunkaifei]

How can we solve this problem? I came from Java and just learned about Rust. For example, the Freemarker template engine in Java may have different modes. It doesn't differentiate between synchronous and asynchronous custom tags, so it's very convenient to use. The content returned by tags can be customized. I found that the template engine in Rust returns a Value type. I am sending the Java code, do you think it can achieve this effect?

package com.flycms.framework.config;

import com.flycms.modules.company.directive.CompanyDirective;
import com.flycms.modules.content.directive.BaikeDirective;
import com.flycms.modules.content.directive.HelpDirective;
import com.flycms.modules.content.directive.PreNextPageDirective;
import com.flycms.modules.site.directive.*;
import com.flycms.modules.elastic.directive.SearchDirective;
import com.flycms.modules.content.directive.LabelDirective;
import com.flycms.modules.content.directive.ArticleDirective;
import com.flycms.modules.system.directive.RegionDirective;
import com.flycms.modules.user.directive.UserDirective;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
@RequiredArgsConstructor
public class FreeMarkerConfig {

    final freemarker.template.Configuration configuration;
    final SearchDirective searchDirective;
    final UserDirective userDirective;
    final LinksDirective linksDirective;
    final TextCutDirective textCutDirective;
    final FenCiDirective fenCiDirective;
    final TimeFormatDirective timeFormatDirective;
    final HtmlFilterDirective htmlFilterDirective;
    final PreNextPageDirective preNextPageDirective;
    final LabelDirective labelDirective;
    final ArticleDirective articleDirective;
    final BaikeDirective baikeDirective;
    final RegionDirective regionDirective;
    final CompanyDirective companyDirective;

    final HelpDirective helpDirective;

    /**
     * 添加自定义标签
     */
    @PostConstruct
    public void setSharedVariable() {

        configuration.setSharedVariable("fly_search", searchDirective);
        configuration.setSharedVariable("fly_user", userDirective);
        configuration.setSharedVariable("fly_links", linksDirective);
        //截取内容字符串标签
        configuration.setSharedVariable("text_cut", textCutDirective);
        //截取内容字符串标签
        configuration.setSharedVariable("fly_fenci", fenCiDirective);
        //格式化时间
        configuration.setSharedVariable("time_format", timeFormatDirective);
        //截取内容字符串标签
        configuration.setSharedVariable("html_filter", htmlFilterDirective);
        //查询上一页下一页标签
        configuration.setSharedVariable("fly_prenext",preNextPageDirective);
        //标签列表
        configuration.setSharedVariable("fly_label",labelDirective);
        //文章标签
        configuration.setSharedVariable("fly_article", articleDirective);
        //文章标签
        configuration.setSharedVariable("fly_baike", baikeDirective);
        //地区标签
        configuration.setSharedVariable("fly_region", regionDirective);
        //企业标签
        configuration.setSharedVariable("fly_company", companyDirective);
        //帮助标签
        configuration.setSharedVariable("fly_help", helpDirective);
    }
}

Here is one of the labels

package com.flycms.modules.elastic.directive;

import com.flycms.framework.web.tag.BaseTag;
import com.flycms.modules.elastic.entity.response.SearchDTO;
import com.flycms.modules.elastic.service.BbossElasticSearchService;
import com.flycms.utils.StrUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Map;

@Component
public class SearchDirective extends BaseTag {

    @Autowired
    private BbossElasticSearchService bbossElasticSearchService;;

    public SearchDirective() {
        super(SearchDirective.class.getName());
    }

    public Object paginate(Map params) throws IOException {
        int pageNum = this.getPageNum(params);
        int pageSize = this.getPageSize(params);
        //地区id查询
        String infoType = getParam(params, "infoType");
        //关键词查询
        String title = getParam(params, "title");
        //地区id查询
        String area = getParam(params, "area");
        //地区id查询
        String trade = getParam(params, "trade");
        //排除内容id
        String notId = getParam(params, "notId");
        //排序
        String sort = getParam(params, "sort");
        SearchDTO condition = new SearchDTO();
        if(StrUtils.isNotEmpty(infoType)){
            condition.setInfoType(infoType);
        }
        if(StrUtils.isNotEmpty(title)){
            condition.setKeyword(title);
        }
        if(StrUtils.isNotEmpty(area)){
            condition.setRegionIds(area);
        }
        if(StrUtils.isNotEmpty(trade)){
            condition.setCategoryId(trade);
        }
        if(StrUtils.isNotEmpty(notId)){
            condition.setNotId(notId);
        }
        if(StrUtils.isNotEmpty(sort)){
            condition.setSort(sort);
        }
        condition.setPageNum(pageNum);
        condition.setPageSize(pageSize);
        return bbossElasticSearchService.searchPagine(condition);
    }
}

Usage in templates

 [@fly_search method="paginate" title='${title!}' area="${region.id!}" pageSize="10" p='${p?string}']
         [#list paginate.rows as list]
                ${list.title!}
        [/#list]
[/@fly_search]

[sunkaifei]

The advantage of this is that I write all the content that reads from the database in the form of tags, so the controller is only responsible for receiving the content received in the URL, and there is no need to write various elements needed to read the page in the controller. This greatly facilitates developers to write various functions or methods that call the database in the controller to complete the elements needed for the page. So the front-end is the same, as long as you know the tag, you can read the desired page elements on any page.
The above was translated by the translation software I used, I'm not sure if you can understand it. Thank you!