how to enable require to load modules in async ways

[mrxsisyphus]

I am trying to enable require to load modules in async ways. My current approach is to register a sync searcher in the searchers table and have it return an async loader.

Here is a simplified example of my code:

#[tokio::test]
async fn test_async_loader() -> anyhow::Result<()> {
    let lua = Lua::new();

    async fn loader(
        lua: Lua,
        (module_name, args): (String, Option<String>),
    ) -> mlua::Result<LuaTable> {
        println!(
            "call loader with module_name: {module_name} args:{:?}",
            args
        );
        tokio::time::sleep(Duration::from_secs(10)).await;
        Ok(lua.create_table()?)
    }

    let searcher = lua.create_function(move |lua, module_name: String| {
        if module_name == "async_mod" {
            Ok((Some(lua.create_async_function(loader)?), Some("args")))
        } else {
            Ok((None, None))
        }
    })?;
    
    let package: mlua::Table = lua.globals().get("package")?;
    let searchers: mlua::Table = package.get("searchers")?;
    searchers.raw_set(searchers.raw_len() + 1, searcher)?;
    
    lua.load(
        r#"
        local async_mod = require("async_mod")
        "#,
    )
    .exec_async()
    .await?;

    Ok(())
}

the answer is:

call loader with module_name: async_mod args:Some("args")
Error: runtime error: attempt to yield across a C-call boundary
stack traceback:
	[C]: in function 'coroutine.yield'
	[string "?"]:16: in main chunk
	[C]: in function 'require'
	[string "src/cases/load_libs.rs:233:13"]:2: in main chunk

Is there a viable way to enable require to load modules in async ways as described?
Would it be possible to achieve this by directly rewriting the require method?

After some exploration, I found that directly waiting for async logic in sync code (for example, using futures::executor::block_on) is feasible. However, I am not sure if this is considered a good practice.

[khvzak]

You need to rewrite require function to make it async as well.
See Lune example how they did it

After some exploration, I found that directly waiting for async logic in sync code (for example, using futures::executor::block_on) is feasible. However, I am not sure if this is considered a good practice.

It depends on your app logic, e.g. it's ok to block the thread if don't use async Lua glue.