Replace JSONata4Java with dashjoin/jsonata-java for full JSONata compatibility (#69)

JSONata4Java is not a complete implementation of the JSONata spec, causing
expressions that work on try.jsonata.org to fail in Kestra (e.g. nested array
path expressions). Switch to dashjoin/jsonata-java which is a 1:1 port of the
JavaScript reference implementation with 100% feature parity.

Fixes #40

Co-authored-by: François Delbrayelle <fdelbrayelle@kestra.io>

Author: fdelbrayelle

plugin-transform-json/build.gradle

@@ -13,5 +13,5 @@ jar {
 }
 
 dependencies {
-    implementation 'com.ibm.jsonata4java:JSONata4Java:2.6.2'
+    implementation 'com.dashjoin:jsonata:0.9.9'
 }

plugin-transform-json/src/main/java/io/kestra/plugin/transform/jsonata/Transform.java

@@ -1,21 +1,24 @@
 package io.kestra.plugin.transform.jsonata;
 
-import com.api.jsonata4java.expressions.EvaluateException;
-import com.api.jsonata4java.expressions.Expressions;
-import com.api.jsonata4java.expressions.ParseException;
+import static com.dashjoin.jsonata.Jsonata.jsonata;
+
+import com.dashjoin.jsonata.JException;
+import com.dashjoin.jsonata.Jsonata;
 import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.NullNode;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.Output;
 import io.kestra.core.models.tasks.RunnableTask;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.runners.RunContext;
+import io.kestra.core.serializers.JacksonMapper;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
 
-import java.io.IOException;
 import java.time.Duration;
 
 import io.kestra.core.models.enums.MonacoLanguages;
@@ -28,36 +31,44 @@
 @NoArgsConstructor
 public abstract class Transform<T extends Output> extends Task implements JSONataInterface, RunnableTask<T> {
 
+    private static final ObjectMapper MAPPER = JacksonMapper.ofJson();
+
     @PluginProperty(language = MonacoLanguages.JAVASCRIPT)
     private Property<String> expression;
 
     @Builder.Default
     private Property<Integer> maxDepth = Property.ofValue(1000);
 
     @Getter(AccessLevel.PRIVATE)
-    private Expressions expressions;
+    private Jsonata parsedExpression;
 
     public void init(RunContext runContext) throws Exception {
-        this.expressions = parseExpression(runContext);
+        var exprString = runContext.render(this.expression).as(String.class).orElseThrow();
+        try {
+            this.parsedExpression = jsonata(exprString);
+        } catch (JException e) {
+            throw new IllegalArgumentException("Invalid JSONata expression. Error: " + e.getMessage(), e);
+        }
     }
 
     protected JsonNode evaluateExpression(RunContext runContext, JsonNode jsonNode) {
         try {
-            long timeoutInMilli = runContext.render(getTimeout()).as(Duration.class)
+            var timeoutInMilli = runContext.render(getTimeout()).as(Duration.class)
                 .map(Duration::toMillis)
                 .orElse(Long.MAX_VALUE);
+            var rMaxDepth = runContext.render(getMaxDepth()).as(Integer.class).orElseThrow();
 
-            return this.expressions.evaluate(jsonNode, timeoutInMilli, runContext.render(getMaxDepth()).as(Integer.class).orElseThrow());
-        } catch (EvaluateException | IllegalVariableEvaluationException e) {
-            throw new RuntimeException("Failed to evaluate expression", e);
-        }
-    }
+            var data = MAPPER.convertValue(jsonNode, Object.class);
+            var frame = this.parsedExpression.createFrame();
+            frame.setRuntimeBounds(timeoutInMilli, rMaxDepth);
 
-    private Expressions parseExpression(RunContext runContext) throws IllegalVariableEvaluationException {
-        try {
-            return Expressions.parse(runContext.render(this.expression).as(String.class).orElseThrow());
-        } catch (ParseException | IOException e) {
-            throw new IllegalArgumentException("Invalid JSONata expression. Error: " + e.getMessage(), e);
+            var result = this.parsedExpression.evaluate(data, frame);
+            if (result == null) {
+                return NullNode.getInstance();
+            }
+            return MAPPER.valueToTree(result);
+        } catch (JException | IllegalVariableEvaluationException e) {
+            throw new RuntimeException("Failed to evaluate expression", e);
         }
     }
 }

plugin-transform-json/src/test/java/io/kestra/plugin/transform/jsonata/TransformValueTest.java

@@ -1,5 +1,7 @@
 package io.kestra.plugin.transform.jsonata;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.runners.RunContext;
@@ -8,6 +10,8 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 @KestraTest
 class TransformValueTest {
 
@@ -79,4 +83,54 @@ void shouldGetOutputForValidExprReturningObjectForFromJSON() throws Exception {
         Assertions.assertNotNull(output);
         Assertions.assertEquals("{\"order_id\":\"ABC123\",\"customer_name\":\"John Doe\",\"total_price\":4.2}", output.getValue().toString());
     }
+
+    @Test
+    void shouldHandleNestedArrayExpressionFromIssue40() throws Exception {
+        String input = """
+            {
+              "filterTuples": [
+                {
+                  "filter": [
+                    {"parent": {"parent": {"hybrisId": "8796977876513"}, "hybrisId": "8796995440161"}, "hybrisId": "8796998946337"},
+                    {"parent": {"parent": {"hybrisId": "8796977876513"}, "hybrisId": "8796995472929"}, "hybrisId": "8797002583585"},
+                    {"parent": {"parent": {"hybrisId": "8796977843745"}, "hybrisId": "8796995341857"}, "hybrisId": "8796999798305"}
+                  ]
+                },
+                {
+                  "filter": [
+                    {"parent": {"parent": {"hybrisId": "8796977876513"}, "hybrisId": "8796995440161"}, "hybrisId": "8796998946337"},
+                    {"parent": {"parent": {"hybrisId": "8796977876513"}, "hybrisId": "8796995472929"}, "hybrisId": "8797002583585"},
+                    {"parent": {"parent": {"hybrisId": "8796977843745"}, "hybrisId": "8796995341857"}, "hybrisId": "8796999765537"}
+                  ]
+                }
+              ]
+            }
+            """;
+        var expression = "[filterTuples.[filter.(parent.parent.hybrisId & \"/\" & parent.hybrisId & \"/\" & hybrisId)]]";
+
+        var task = TransformValue.builder()
+            .id("test")
+            .type(TransformValue.class.getName())
+            .from(Property.of(input))
+            .expression(Property.of(expression))
+            .build();
+
+        var runContext = runContextFactory.of();
+        var output = task.run(runContext);
+
+        // Verify it's a nested array (not flattened)
+        assertThat(output.getValue()).isNotNull();
+        // The result should be a JSON array of arrays
+        var mapper = new ObjectMapper();
+        JsonNode result = mapper.valueToTree(output.getValue());
+        assertThat(result.isArray()).isTrue();
+        assertThat(result.size()).isEqualTo(2);
+        assertThat(result.get(0).isArray()).isTrue();
+        assertThat(result.get(0).size()).isEqualTo(3);
+        assertThat(result.get(0).get(0).asText()).isEqualTo("8796977876513/8796995440161/8796998946337");
+        assertThat(result.get(0).get(1).asText()).isEqualTo("8796977876513/8796995472929/8797002583585");
+        assertThat(result.get(0).get(2).asText()).isEqualTo("8796977843745/8796995341857/8796999798305");
+        assertThat(result.get(1).isArray()).isTrue();
+        assertThat(result.get(1).get(2).asText()).isEqualTo("8796977843745/8796995341857/8796999765537");
+    }
 }