How to load js files with multiple functions (of the same name per file) in java/graalvm and invoke functions by file name

Question

I have a server application that loads several script files (for processing specific dataset-fields) at startup. the scripts should be parsed and the "expression"-data of the script should be stored in a map (by column name) so that they can be accessed and executed from there later.

There are two types of scripts. The "simple" ones just contain a process function, the complex ones currently have a structure similar to the example below (might have more private functions/fields):

// public
function process(input) {
    return _doSomething(input);
}
function selfTest() {
    if (process("123") !== "123") throw "failed";
    // ...
}

// private
var _allowedSymbols = ['H', 'L', 'M'];      
function _doSomething(input) {
    // _allowedSymbols is used here
}

process and selfTest are the "public" functions that will be used by the server-app. selfTest will be executed once after the file is loaded/evaluated and process will be executed for incoming data when needed.

I've started with the old JSR 223 way:

ScriptEngine engine = new ScriptEngineManager().getEngineByName("graal.js");
engine.eval("function process(input) { return input.toUpperCase(); }");
// engine.eval("function process(input) { return input + '123'; }");
Invocable inv = (Invocable) engine;
Object result = inv.invokeFunction("process", "peter");

This approach has the problem that the function-data is stored in the javascript engine instance and therefore i can't have multiple "process" methods in my map.
I Could continue that way and dynamically generate name-prefixes for functions and global variables based on the column name... but thats... "ugly"...

I've tried the graalvm-context-way (with help from SO and Oleg, How to store function handles from ScriptManager for later usage?):

var ctx = Context.newBuilder("js").allowAllAccess(false).build();
var src = Source.newBuilder("js", "(function u(input) { return input.toUpperCase(); })", "test.js").build();
var script = ctx.eval(src);
var result = script.execute("peter");

That works for "simple" functions. But for complex scripts the function-expression way from above doesnt work.

EDIT (Solution):

Modified the answer from Oleg slightly and this seems to do the job...

var jsCode = """
(function() {
    function process(input) { return input; }
    function selfTest() { if (process("123") !== "123") throw "failed"; return true; }
    return { process, selfTest }; 
})();
             """;
var ctx2 = Context.newBuilder("js").allowAllAccess(false).build();
Source source = Source.newBuilder("js", jsCode, "test.js").build();
var script = ctx2.eval(source);
var fnProcess = script.getMember("process");
var result = fnProcess.execute("123");
var fnSelfTest = script.getMember("selfTest");
var result2 = fnSelfTest.execute();

If you need to be able to evaluate those functions later and allow for any function name (i.e. include duplicates) I'd say a clean way is to maintain some sort of context. If the approach you posted at the bottom doesn't work then maybe you can build your own "context" which internally has its own `ScriptEngine`. As for the GraalVM Context way: did you try the [various options to load sources](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/Source.html) already? — Thomas, Jun 07 '21 at 11:14
Interesting link, sadly doesnt solve the problem :( but the language detection is nice :) When I evaluate a file/string that contains a function definition and not a function expression the evaluation result of the graalvm context is undefined and I cant access the functions. Always thought that `ScriptEngine` instances are really heavy and therefore never thought of having one instance per file when expecting hundred and more script files... I'll give that one a try :) @Thomas — Michael, Jun 08 '21 at 07:12

Oleg Šelajev · Accepted Answer · 2021-06-10T12:32:33.017

It's either functions are declared in the top level namespace, and then name collisions are a problem, or they are in their custom scopes and then you have to have some way to access and call them.

When you're evaluating a source like that:

(function u(input) { return input.toUpperCase(); })

The result of that evaluation is the last expression in the script. You can think of the line:

var result = ctx.eval("js", "(function u(input) { return input.toUpperCase(); })");

Approximately as if it'd be in JS like:

result = (function u(input) { return input.toUpperCase(); })

And consequently, you can run it with:

result("HelloWorld");

That means you can return multiple functions using helper objects:

// public
function process(input) {
    return _doSomething(input);
}
function selfTest() {
    if (process("123") !== "123") throw "failed";
    // ...
}

// private
var _allowedSymbols = ['H', 'L', 'M'];      
function _doSomething(input) {
    // _allowedSymbols is used here
}

returnMe = {process, selfTest};

Which is exactly what you'd do in JavaScript (I think).

Then you can either get the process function with

var returnedObject = ctx.eval(src);
var processFunction = returnedObject.getMember("process");
var result = processFunction.execute("peter");

And similarly access the selfTest function. It might not be ideal that you need to modify the JS sources for that, but I think that's necessary.

Thanks for your answer :) I've modified your code slightly to get it working and added it to my question as a solution. Can you confirm that this is the way it should be done? If I reuse that evaluated object (which is cached in a map) everytime the process-method is needed the javascript object with the exported functions needs to be constructed...? — Michael, Jun 10 '21 at 10:51
It's the same thing like in the "simple" case, you don't even have to store that whole object. You can get the returned value, check if there's a member "selfTest" if there's run it, and store the only the "var processFunction = returnedObject.getMember("process"); " function, so you don't need to do that getMember all the time — Oleg Šelajev, Jun 10 '21 at 12:30

How to load js files with multiple functions (of the same name per file) in java/graalvm and invoke functions by file name

1 Answers1