Architectural question about (de)serialization

[dominiwe]

I am quite new to mlua and lua. I have an idea for the architecture of my project when it comes to mlua. I arrived at something working, but I'd love it if someone more experienced could reassure me that I am on the right path.

I would like users to be able to write a config file in lua. However they should also be able to specify some run time behavior there. Essentially, there will be a "config evaluation run time" and then the "actual run time" of the program. I am taking inspiration from wezterm for the config structure.

Here is how a wezterm config file could look like:

local wezterm = require("wezterm")
local config = wezterm.config_builder()

config.somekey = "exampleval"
config.some.sub = {
  someother = 2,
}

-- here one can define some kind of "event handlers" in wezterm.
wezterm.on("someevent", function () print("someevent happened") end)

return config -- what gets returned is purely data that is (de)serializable

The returned config is then turned into a rust Config struct, I think the event handlers are stored in some kind of function registry.

However, I want to allow the user to define regular lua functions as values for some config keys because I think that is more ergonomic. Here is an example:

local mymod = require("mymod")
local config = mymod.config_builder()
config.servers = {
    {
        listen_on = { "127.0.0.1:3000" },
        routes = {
            {
                path = "/",
                handler = function(req)
                    print(req)
                    return "hey"
                end,
            },
            {
                path = "/simple",
                handler = "hello world",
            },
        },
    },
}
return config

The config is then also deserialized into a Config struct that the program uses. Now, I really want to use the serde feature and keep rust types as a sort of source of truth. Mainly because I think this will make it easier later to generate LuaLS type definitions from them.

I know that trying to serialize functions is a bad idea. So, here is the workaround/poc I have arrived at:

use mlua::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Config {
    key1: i32,
    key2: String,
    key3: Inner,
}

#[derive(Debug, Serialize, Deserialize)]
struct Inner {
    #[serde(skip)]
    func: Option<LuaFunction>,
    #[serde(skip)]
    func2: Option<LuaFunction>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lua = Lua::new();
    let chunk = lua.load(
        r#"
local config = {
    key1 = 42,
    key2 = "hello world",
    key3 = {
        func = function(arg)
            print('hello from function: ' .. arg)
        end,
    }
}

config.key3.func2 = config.key3.func

return config
    "#,
    );
    let res = chunk.eval::<LuaValue>()?;
    if let Some(table) = res.as_table() {
        let inner = table.get::<LuaTable>("key3")?;
        let func = inner.get::<LuaFunction>("func")?;
        let func2 = inner.get::<LuaFunction>("func2")?;
        inner.raw_remove("func")?;
        inner.raw_remove("func2")?;
        let mut config: Config = lua.from_value(res)?;
        inner.set("func", &func)?;
        inner.set("func2", &func2)?;
        config.key3.func = Some(func);
        config.key3.func2 = Some(func2);
        println!("\n{config:#?}");
        // Now we try calling the function!
        if let Some(f) = config.key3.func {
            f.call::<()>("okay...")?;
        }
        if let Some(f) = config.key3.func2 {
            f.call::<()>("well...")?;
        }
    }

    Ok(())
}

This seems to work and here is the output:

 Config {
     key1: 42,
     key2: "hello world",
     key3: Inner {
         func: Some(
             Function(                                                                                                                                 
                 Ref(0x555866e85f00),                                                                                                                  
             ),                                                                                                                                        
         ),                                                                                                                                            
         func2: Some(                                                                                                                                  
             Function(                                                                                                                                 
                 Ref(0x555866e85f00),                                                                                                                  
             ),                                                                                                                                        
         ),                                                                                                                                            
     },                                                                                                                                                
 }                                                                                                                                                     
 hello from function: okay...                                                                                                                          
 hello from function: well...

But.. is this a good, even decent idea? I suppose I would have to walk the config "tree"/nested table multiple times for this which doesn't seem right. Does this perhaps have some implications I didn't consider? It seems weird because I'm almost fighting serde at that point. Really any advice is welcome.