[WIP] more refactor

Signed-off-by: Matheus Cruz <matheuscruz.dev@gmail.com>

Author: mcruzdev

impl/core/src/main/java/io/serverlessworkflow/impl/executors/RunScriptExecutor.java

@@ -23,22 +23,47 @@
 import io.serverlessworkflow.impl.WorkflowApplication;
 import io.serverlessworkflow.impl.WorkflowContext;
 import io.serverlessworkflow.impl.WorkflowDefinition;
+import io.serverlessworkflow.impl.WorkflowError;
+import io.serverlessworkflow.impl.WorkflowException;
 import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowModelFactory;
 import io.serverlessworkflow.impl.WorkflowUtils;
 import io.serverlessworkflow.impl.expressions.ExpressionUtils;
 import java.io.ByteArrayOutputStream;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.PolyglotException;
 import org.graalvm.polyglot.Value;
 
 public class RunScriptExecutor implements RunnableTask<RunScript> {
 
-  private static final Set<String> SUPPORTED_LANGUAGES = Set.of("js", "python");
+  enum ScriptLanguage {
+    JS("js"),
+    PYTHON("python");
+
+    private final String lang;
+
+    ScriptLanguage(String lang) {
+      this.lang = lang;
+    }
+
+    public String getLang() {
+      return lang;
+    }
+
+    public static boolean isSupported(String lang) {
+      for (ScriptLanguage l : ScriptLanguage.values()) {
+        if (l.getLang().equalsIgnoreCase(lang)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
 
   @FunctionalInterface
   private interface FnExecutor {
@@ -55,19 +80,21 @@ public void init(RunScript taskConfiguration, WorkflowDefinition definition) {
     boolean isAwait = taskConfiguration.isAwait();
 
     WorkflowApplication application = definition.application();
-    if (language == null || !SUPPORTED_LANGUAGES.contains(language.toLowerCase())) {
+    if (language == null || ScriptLanguage.isSupported(language)) {
       throw new IllegalArgumentException(
           "Unsupported script language: "
               + language
               + ". Supported languages are: "
-              + SUPPORTED_LANGUAGES);
+              + Arrays.toString(ScriptLanguage.values()));
     }
 
     fnExecutor =
         (workflowContext, taskContext) -> {
           ByteArrayOutputStream stderr = new ByteArrayOutputStream();
           ByteArrayOutputStream stdout = new ByteArrayOutputStream();
 
+          String lowerLang = language.toLowerCase();
+
           Map<String, String> envs = new HashMap<>();
           if (script.getEnvironment() != null) {
             for (Map.Entry<String, Object> entry :
@@ -101,7 +128,7 @@ public void init(RunScript taskConfiguration, WorkflowDefinition definition) {
           }
 
           try (Context context =
-              Context.newBuilder(language.toLowerCase())
+              Context.newBuilder(lowerLang)
                   .err(stderr)
                   .out(stdout)
                   .environment(envs)
@@ -114,11 +141,11 @@ public void init(RunScript taskConfiguration, WorkflowDefinition definition) {
 
             args.forEach(
                 (arg, val) -> {
-                  context.getBindings(language.toLowerCase()).putMember(arg, val);
+                  context.getBindings(lowerLang).putMember(arg, val);
                 });
 
-            // configure process.env for js
-            if (language.equalsIgnoreCase("js")) {
+            // configure process.env for js environment variables
+            if (language.equalsIgnoreCase(ScriptLanguage.JS.lang)) {
               configureProcessEnv(context, envs);
             }
 
@@ -135,23 +162,38 @@ public void init(RunScript taskConfiguration, WorkflowDefinition definition) {
             context.eval(
                 scriptUnion.getInlineScript().getLanguage(),
                 scriptUnion.getInlineScript().getCode());
+
             WorkflowModelFactory modelFactory = application.modelFactory();
 
+            int statusCode =
+                0; // GraalVM does not provide exit code, assuming 0 for successful execution
+
             return switch (taskConfiguration.getReturn()) {
               case ALL ->
-                  modelFactory.fromAny(new ProcessResult(0, stdout.toString(), stderr.toString()));
+                  modelFactory.fromAny(
+                      new ProcessResult(statusCode, stdout.toString(), stderr.toString()));
               case NONE -> modelFactory.fromNull();
-              case CODE -> modelFactory.from(0);
+              case CODE -> modelFactory.from(statusCode);
               case STDOUT -> modelFactory.from(stdout.toString().trim());
               case STDERR -> modelFactory.from(stderr.toString().trim());
             };
+          } catch (PolyglotException e) {
+            throw new WorkflowException(WorkflowError.runtime(taskContext, e).build());
           }
         };
   }
 
-  private void configureProcessEnv(Context jsCtx, Map<String, String> envs) {
-    Value bindings = jsCtx.getBindings("js");
-    Value process = jsCtx.eval("js", "({ env: {} })");
+  /**
+   * Configures the process.env object in the JavaScript context with the provided environment
+   * variables.
+   *
+   * @param context the GraalVM context
+   * @param envs the environment variables to set
+   */
+  private void configureProcessEnv(Context context, Map<String, String> envs) {
+    String js = ScriptLanguage.JS.lang;
+    Value bindings = context.getBindings(js);
+    Value process = context.eval(js, "({ env: {} })");
 
     for (var entry : envs.entrySet()) {
       process.getMember("env").putMember(entry.getKey(), entry.getValue());