You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@streampipes.apache.org by ri...@apache.org on 2026/05/27 09:30:40 UTC

(streampipes) branch dev updated: fix: Properly convert arrays in JS script transformer (#4507)

This is an automated email from the ASF dual-hosted git repository.

dominikriemer pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/streampipes.git


The following commit(s) were added to refs/heads/dev by this push:
     new d3cc9c56fe fix: Properly convert arrays in JS script transformer (#4507)
d3cc9c56fe is described below

commit d3cc9c56feefa9d4d526db2f8a6761422a030812
Author: Dominik Riemer <do...@gmail.com>
AuthorDate: Wed May 27 11:30:34 2026 +0200

    fix: Properly convert arrays in JS script transformer (#4507)
---
 .../transformer/js/PolyglotTypeConverter.java      |  21 ++++
 .../transformer/js/GraalJsScriptEngineTest.java    | 110 +++++++++++++++++++++
 2 files changed, 131 insertions(+)

diff --git a/streampipes-connect-transformer-js/src/main/java/org/apache/streampipes/connect/transformer/js/PolyglotTypeConverter.java b/streampipes-connect-transformer-js/src/main/java/org/apache/streampipes/connect/transformer/js/PolyglotTypeConverter.java
index c062e7a9b3..d083bf6ce1 100644
--- a/streampipes-connect-transformer-js/src/main/java/org/apache/streampipes/connect/transformer/js/PolyglotTypeConverter.java
+++ b/streampipes-connect-transformer-js/src/main/java/org/apache/streampipes/connect/transformer/js/PolyglotTypeConverter.java
@@ -22,7 +22,9 @@ import org.apache.streampipes.connect.transformer.api.exception.ScriptExecutionE
 import org.apache.streampipes.connect.transformer.api.utils.TransformationEngineConversionUtils;
 
 import org.graalvm.polyglot.Value;
+import org.jspecify.annotations.NonNull;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -86,6 +88,9 @@ public final class PolyglotTypeConverter {
       }
       return result;
     }
+    if (input.getClass().isArray()) {
+      return getArrayValue(input);
+    }
     try {
       Value value = Value.asValue(input);
       if (!value.isHostObject() || value.hasHashEntries() || value.hasArrayElements() || value.hasMembers()) {
@@ -97,10 +102,26 @@ public final class PolyglotTypeConverter {
     return input;
   }
 
+  @NonNull
+  private static Object getArrayValue(Object input) {
+    int length = Array.getLength(input);
+    List<Object> result = new ArrayList<>(length);
+    for (int i = 0; i < length; i++) {
+      result.add(toJavaValue(Array.get(input, i)));
+    }
+    return result;
+  }
+
   private static Object fromValue(Value value) {
     if (value.isNull()) {
       return null;
     }
+    if (value.isHostObject()) {
+      Object hostObject = value.asHostObject();
+      if (hostObject != null && hostObject.getClass().isArray()) {
+        return getArrayValue(hostObject);
+      }
+    }
     if (value.hasHashEntries()) {
       Map<String, Object> result = new LinkedHashMap<>();
       Value iterator = value.getHashEntriesIterator();
diff --git a/streampipes-connect-transformer-js/src/test/java/org/apache/streampipes/connect/transformer/js/GraalJsScriptEngineTest.java b/streampipes-connect-transformer-js/src/test/java/org/apache/streampipes/connect/transformer/js/GraalJsScriptEngineTest.java
index f81977195a..0cc0954779 100644
--- a/streampipes-connect-transformer-js/src/test/java/org/apache/streampipes/connect/transformer/js/GraalJsScriptEngineTest.java
+++ b/streampipes-connect-transformer-js/src/test/java/org/apache/streampipes/connect/transformer/js/GraalJsScriptEngineTest.java
@@ -24,6 +24,8 @@ import org.apache.streampipes.connect.transformer.api.Context;
 import org.apache.streampipes.connect.transformer.api.exception.ScriptCompilationException;
 import org.apache.streampipes.connect.transformer.api.exception.ScriptExecutionException;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.graalvm.polyglot.proxy.ProxyArray;
 import org.graalvm.polyglot.proxy.ProxyExecutable;
 import org.graalvm.polyglot.proxy.ProxyObject;
 import org.junit.jupiter.api.Test;
@@ -41,6 +43,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class GraalJsScriptEngineTest {
 
+  private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
   private final GraalJsScriptEngine engine = new GraalJsScriptEngine();
 
   @Test
@@ -113,6 +116,91 @@ public class GraalJsScriptEngineTest {
     assertEquals(List.of(41, 42), output.get(0).get("history"));
   }
 
+  @Test
+  void serializePrimitiveArraysInCollectedOutput() throws Exception {
+    var transformer = engine.compile("""
+        function transform(event, out, ctx) {
+          var values = [1, 2, 3];
+          var names = ["a", "b"];
+          out.collect({
+          values: values,
+          names: names,
+          intInput: event.intInput,
+          stringInput: event.stringInput
+          });
+        }
+        """);
+
+    var output = new ArrayList<Map<String, Object>>();
+    Integer[] intInput = {1, 2, 3};
+    String[] stringInput = {"a", "b"};
+    transformer.transform(new LinkedHashMap<>(
+        Map.of(
+            "value", 1,
+            "intInput", intInput,
+            "stringInput", stringInput)), output::add, null);
+
+    assertEquals(1, output.size());
+    assertEquals(List.of(1, 2, 3), output.get(0).get("values"));
+    assertEquals(List.of("a", "b"), output.get(0).get("names"));
+    assertEquals(List.of(1, 2, 3), output.get(0).get("intInput"));
+    assertEquals(List.of("a", "b"), output.get(0).get("stringInput"));
+    var serialized = OBJECT_MAPPER.writeValueAsString(output.get(0));
+    assertTrue(serialized.contains("\"values\":[1,2,3]"));
+    assertTrue(serialized.contains("\"names\":[\"a\",\"b\"]"));
+    assertTrue(serialized.contains("\"intInput\":[1,2,3]"));
+    assertTrue(serialized.contains("\"stringInput\":[\"a\",\"b\"]"));
+  }
+
+  @Test
+  void serializePrimitiveArraysNestedInHostMapOutput() throws Exception {
+    var transformer = engine.compile("""
+        function transform(event, out, ctx) {
+          const payload = ctx.client().wrapArray([1, 2, 3], ["a", "b"]);
+          out.collect(payload);
+        }
+        """);
+
+    var output = new ArrayList<Map<String, Object>>();
+    transformer.transform(
+        Map.of("value", 1),
+        output::add,
+        scriptContext(scriptClientWithHostMapWrapper())
+    );
+
+    assertEquals(1, output.size());
+    assertEquals(List.of(1, 2, 3), output.get(0).get("values"));
+    assertEquals(List.of("a", "b"), output.get(0).get("names"));
+
+    var serialized = OBJECT_MAPPER.writeValueAsString(output.get(0));
+    assertTrue(serialized.contains("\"values\":[1,2,3]"));
+    assertTrue(serialized.contains("\"names\":[\"a\",\"b\"]"));
+  }
+
+  @Test
+  void serializeProxyArraysNestedInHostMapOutput() throws Exception {
+    var transformer = engine.compile("""
+        function transform(event, out, ctx) {
+          out.collect(ctx.client().proxyArrayMap());
+        }
+        """);
+
+    var output = new ArrayList<Map<String, Object>>();
+    transformer.transform(
+        Map.of("value", 1),
+        output::add,
+        scriptContext(scriptClientWithProxyArrayMap())
+    );
+
+    assertEquals(1, output.size());
+    assertEquals(List.of(1, 2, 3), output.get(0).get("values"));
+    assertEquals(List.of("a", "b"), output.get(0).get("names"));
+
+    var serialized = OBJECT_MAPPER.writeValueAsString(output.get(0));
+    assertTrue(serialized.contains("\"values\":[1,2,3]"));
+    assertTrue(serialized.contains("\"names\":[\"a\",\"b\"]"));
+  }
+
   @Test
   void compileFailsWhenNoExecutableTransformExists() {
     var exception = assertThrows(
@@ -331,6 +419,28 @@ public class GraalJsScriptEngineTest {
     ));
   }
 
+  private static Object scriptClientWithHostMapWrapper() {
+    return ProxyObject.fromMap(Map.of(
+        "wrapArray", (ProxyExecutable) args -> {
+          Map<String, Object> result = new LinkedHashMap<>();
+          result.put("values", args[0]);
+          result.put("names", args[1]);
+          return result;
+        }
+    ));
+  }
+
+  private static Object scriptClientWithProxyArrayMap() {
+    return ProxyObject.fromMap(Map.of(
+        "proxyArrayMap", (ProxyExecutable) args -> {
+          Map<String, Object> result = new LinkedHashMap<>();
+          result.put("values", ProxyArray.fromList(List.of(1, 2, 3)));
+          result.put("names", ProxyArray.fromList(List.of("a", "b")));
+          return result;
+        }
+    ));
+  }
+
   private static CredentialsProvider emptyCredentials() {
     return List::of;
   }