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:00:00 UTC

(streampipes) branch fix-js-script-conversion created (now d603022225)

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

dominikriemer pushed a change to branch fix-js-script-conversion
in repository https://gitbox.apache.org/repos/asf/streampipes.git


      at d603022225 fix: Properly convert arrays in JS script transformer

This branch includes the following new commits:

     new d603022225 fix: Properly convert arrays in JS script transformer

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(streampipes) 01/01: fix: Properly convert arrays in JS script transformer

Posted by ri...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

dominikriemer pushed a commit to branch fix-js-script-conversion
in repository https://gitbox.apache.org/repos/asf/streampipes.git

commit d6030222253a8ab413d367bd38de8481d6150450
Author: Dominik Riemer <do...@gmail.com>
AuthorDate: Wed May 27 10:59:41 2026 +0200

    fix: Properly convert arrays in JS script transformer
---
 .../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;
   }