Varargs signature validation error

[alturkovic]

Hi!

I am trying to implement an adapter to use with jsonata for the following interface:

interface JsonExtension {
    fun call(node: JsonNode, arguments: List<JsonNode>): JsonNode
}

I implemented the following class to bridge the gap between the two interfaces:

class ExtensionFunction(
    val extension: JsonExtension
) : Jsonata.JFunctionCallable {
    override fun call(input: Any?, args: MutableList<Any?>?): JsonNode {
        val mapper = jacksonObjectMapper()
        val node: JsonNode = mapper.valueToTree(input)
        val arguments: List<JsonNode> = args?.let { mapper.convertValue(it) } ?: emptyList()
        return extension.call(node, arguments)
    }
}

I am trying to register it with jsonata like this:

val extension = object : JsonExtension {
    override fun call(node: JsonNode, arguments: List<JsonNode>): JsonNode {
        println("Input: '$node' and args: $arguments")
        return node
    }
}

registerFunction("myExtension", Jsonata.JFunction(ExtensionFunction(extension), "???"))

But I cannot figure out how to write a varargs signature. I want this function to accept any number of any type of json arguments and return any type of result, something like the following in Java:

Object call(Object... args);

[alturkovic]

I have no experience with jsonata and I should have checked their docs before opening a ticket. There seems to be no support for such signature in jsonata. I opened a ticket there and will wait for their support.

Sorry for the noise!

[aeberhart]

No problem. You raise a good point. You'll probably have to use an array. Consider this count example:

$count(1,2,3)
Argument 2 of function "count" does not match function signature

$count([1,2,3])
3

[alturkovic]

Yes, but it seems kinda awkward to use if an extension expects a single argument.

I thought that at least <j+> would parse the arguments as [1, 2, 3] but it parses them as [1, 1, 1]? Weird :D I hoped that something like <j+?> or <j*> is supported since that sounds like what I am looking for (0 or more json types).

[aeberhart]

Reopened because varargs are not parsed correctly

[alturkovic]

Just to make it clear, the <j+> behaviour seems to be the same as jsonata itself.

[alturkovic]

After further testing, you are right. I implemented it like this:

private class ExtensionFunction(
    val extension: JsonExtension
) : JFunctionCallable {
    override fun call(input: Any?, args: MutableList<Any?>?): JsonNode {
        val node: JsonNode = mapper.valueToTree(input)
        val arguments: List<JsonNode> = args?.let { mapper.convertValue(it.first()) } ?: emptyList()
        return extension.call(node, arguments)
    }
}

And used the following signature: <a?:j>. It works with all of the following:

$myExtension()
$myExtension([1, {"a": "b"}, 2])
$myExtension({"a": 1, "b": 2})
$myExtension([1, 2, 3])

It just doesn't work if there is a null in the list, such as:

$myExtension([1, null, 2])

That results in the following exception:

No serializer found for class com.dashjoin.jsonata.Jsonata$2 and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: java.util.ArrayList[0]->com.dashjoin.jsonata.Utils$JList[1])

The issue is that Jackson does not know that it should deserialize com.dashjoin.jsonata.Jsonata#NULL_VALUE static object as null.

I should be able to fix this with Jackson, thanks for your help!

[alturkovic]

I found that you already added support for it 😄

private class ExtensionFunction(
    val extension: JsonExtension
) : JFunctionCallable {
    override fun call(input: Any?, args: MutableList<Any?>?): JsonNode {
        val node: JsonNode = mapper.valueToTree(input)
        val arguments: List<JsonNode> = args?.let { mapper.convertValue(Utils.convertNulls(it.first())) } ?: emptyList()
        return extension.call(node, arguments)
    }
}

Supports all the usecases I need. Thanks for this amazing library ❤️