[Fix #1544] auth Content to be completable future

fjtirado · fjtirado · commit 9a099fb35baf · 2026-07-16T11:37:03.000+02:00
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/AccessTokenProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/AccessTokenProvider.java
@@ -18,7 +18,9 @@
 import io.serverlessworkflow.impl.TaskContext;
 import io.serverlessworkflow.impl.WorkflowContext;
 import io.serverlessworkflow.impl.WorkflowModel;
+import java.util.concurrent.CompletableFuture;
 
 public interface AccessTokenProvider {
-  JWT validateAndGet(WorkflowContext workflow, TaskContext context, WorkflowModel model);
+  CompletableFuture<JWT> validateAndGet(
+      WorkflowContext workflow, TaskContext context, WorkflowModel model);
 }
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/AuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/AuthProvider.java
@@ -19,10 +19,12 @@
 import io.serverlessworkflow.impl.WorkflowContext;
 import io.serverlessworkflow.impl.WorkflowModel;
 import java.net.URI;
+import java.util.concurrent.CompletableFuture;
 
 public interface AuthProvider {
 
   String scheme();
 
-  String content(WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri);
+  CompletableFuture<String> content(
+      WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri);
 }
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/BasicAuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/BasicAuthProvider.java
@@ -30,6 +30,7 @@
 import io.serverlessworkflow.impl.WorkflowValueResolver;
 import java.net.URI;
 import java.util.Base64;
+import java.util.concurrent.CompletableFuture;
 
 class BasicAuthProvider implements AuthProvider {
 
@@ -58,15 +59,17 @@ public BasicAuthProvider(
   }
 
   @Override
-  public String content(WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
-    return new String(
-        Base64.getEncoder()
-            .encode(
-                String.format(
-                        USER_PASSWORD,
-                        userFilter.apply(workflow, task, model),
-                        passwordFilter.apply(workflow, task, model))
-                    .getBytes()));
+  public CompletableFuture<String> content(
+      WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
+    return CompletableFuture.completedFuture(
+        new String(
+            Base64.getEncoder()
+                .encode(
+                    String.format(
+                            USER_PASSWORD,
+                            userFilter.apply(workflow, task, model),
+                            passwordFilter.apply(workflow, task, model))
+                        .getBytes())));
   }
 
   @Override
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/BearerAuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/BearerAuthProvider.java
@@ -29,6 +29,7 @@
 import io.serverlessworkflow.impl.WorkflowUtils;
 import io.serverlessworkflow.impl.WorkflowValueResolver;
 import java.net.URI;
+import java.util.concurrent.CompletableFuture;
 
 class BearerAuthProvider implements AuthProvider {
 
@@ -49,8 +50,9 @@ public BearerAuthProvider(
   }
 
   @Override
-  public String content(WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
-    return tokenFilter.apply(workflow, task, model);
+  public CompletableFuture<String> content(
+      WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
+    return CompletableFuture.completedFuture(tokenFilter.apply(workflow, task, model));
   }
 
   @Override
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/CommonOAuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/CommonOAuthProvider.java
@@ -29,8 +29,9 @@
 import java.net.URI;
 import java.util.Arrays;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 
-abstract class CommonOAuthProvider implements AuthProvider {
+public abstract class CommonOAuthProvider implements AuthProvider {
 
   private final WorkflowValueResolver<AccessTokenProvider> tokenProvider;
 
@@ -47,8 +48,12 @@ protected CommonOAuthProvider(WorkflowValueResolver<AccessTokenProvider> tokenPr
   }
 
   @Override
-  public String content(WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
-    return tokenProvider.apply(workflow, task, model).validateAndGet(workflow, task, model).token();
+  public CompletableFuture<String> content(
+      WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
+    return tokenProvider
+        .apply(workflow, task, model)
+        .validateAndGet(workflow, task, model)
+        .thenApply(JWT::token);
   }
 
   @Override
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/DigestAuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/DigestAuthProvider.java
@@ -31,14 +31,14 @@
 import io.serverlessworkflow.impl.WorkflowValueResolver;
 import io.serverlessworkflow.impl.utils.RandomFactory;
 import java.io.IOException;
-import java.io.UncheckedIOException;
 import java.net.HttpURLConnection;
 import java.net.URI;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Optional;
 import java.util.Random;
 import java.util.StringTokenizer;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -146,7 +146,8 @@ public String scheme() {
   }
 
   @Override
-  public String content(WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
+  public CompletableFuture<String> content(
+      WorkflowContext workflow, TaskContext task, WorkflowModel model, URI uri) {
     try {
       HttpURLConnection connection = (HttpURLConnection) uri.toURL().openConnection();
       connection.setRequestMethod(method);
@@ -186,17 +187,19 @@ public String content(WorkflowContext workflow, TaskContext task, WorkflowModel
                             ha2))
                 .orElseGet(() -> calculateHash(ha1, serverInfo.nonce, ha2));
 
-        return buildResponseInfo(serverInfo, userName, path, clientNonce, nonceCount, response);
+        return CompletableFuture.completedFuture(
+            buildResponseInfo(serverInfo, userName, path, clientNonce, nonceCount, response));
       } else {
-        throw new IllegalStateException(
-            "URI "
-                + uri
-                + " is not digest protected, it returned code "
-                + responseCode
-                + " when invoked without authentication header, but it should have returned 401 as per RFC 2617");
+        return CompletableFuture.failedFuture(
+            new IllegalStateException(
+                "URI "
+                    + uri
+                    + " is not digest protected, it returned code "
+                    + responseCode
+                    + " when invoked without authentication header, but it should have returned 401 as per RFC 2617"));
       }
     } catch (IOException io) {
-      throw new UncheckedIOException(io);
+      return CompletableFuture.failedFuture(io);
     }
   }
 
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/OAuth2AuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/OAuth2AuthProvider.java
@@ -18,7 +18,7 @@
 import io.serverlessworkflow.api.types.Workflow;
 import io.serverlessworkflow.impl.WorkflowApplication;
 
-class OAuth2AuthProvider extends CommonOAuthProvider {
+public class OAuth2AuthProvider extends CommonOAuthProvider {
 
   public OAuth2AuthProvider(
       WorkflowApplication application, Workflow workflow, OAuthPolicyData policyData) {
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/auth/OpenIdAuthProvider.java b/impl/core/src/main/java/io/serverlessworkflow/impl/auth/OpenIdAuthProvider.java
@@ -18,7 +18,7 @@
 import io.serverlessworkflow.api.types.Workflow;
 import io.serverlessworkflow.impl.WorkflowApplication;
 
-class OpenIdAuthProvider extends CommonOAuthProvider {
+public class OpenIdAuthProvider extends CommonOAuthProvider {
 
   public OpenIdAuthProvider(
       WorkflowApplication application, Workflow workflow, OAuthPolicyData policyData) {
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/RunScriptExecutor.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/RunScriptExecutor.java
@@ -56,32 +56,31 @@ public RunScriptExecutor(
   @Override
   public CompletableFuture<WorkflowModel> apply(
       WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel input) {
-    ScriptContext scriptContext =
-        new ScriptContext(
-            argumentExpr.map(m -> m.apply(workflowContext, taskContext, input)).orElse(Map.of()),
-            environmentExpr.map(m -> m.apply(workflowContext, taskContext, input)).orElse(Map.of()),
-            codeSupplier.apply(workflowContext, taskContext, input),
-            returnType);
     if (isAwait) {
       return CompletableFuture.supplyAsync(
-          () -> runScript(scriptContext, workflowContext, taskContext, input),
+          () -> runScript(workflowContext, taskContext, input),
           workflowContext.definition().application().executorService());
     } else {
       workflowContext
           .definition()
           .application()
           .executorService()
-          .submit(() -> runScript(scriptContext, workflowContext, taskContext, input));
+          .submit(() -> runScript(workflowContext, taskContext, input));
       return CompletableFuture.completedFuture(input);
     }
   }
 
   private WorkflowModel runScript(
-      ScriptContext scriptContext,
-      WorkflowContext workflowContext,
-      TaskContext taskContext,
-      WorkflowModel input) {
+      WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel input) {
     try {
+      ScriptContext scriptContext =
+          new ScriptContext(
+              argumentExpr.map(m -> m.apply(workflowContext, taskContext, input)).orElse(Map.of()),
+              environmentExpr
+                  .map(m -> m.apply(workflowContext, taskContext, input))
+                  .orElse(Map.of()),
+              codeSupplier.apply(workflowContext, taskContext, input),
+              returnType);
       return taskRunner.runScript(scriptContext, workflowContext, taskContext, input);
     } catch (Exception ex) {
       throw new WorkflowException(WorkflowError.runtime(taskContext, ex).build());
diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/resources/ResourceLoader.java b/impl/core/src/main/java/io/serverlessworkflow/impl/resources/ResourceLoader.java
@@ -113,7 +113,8 @@ public <T> T load(
             .map(
                 auth ->
                     AuthUtils.authHeaderValue(
-                        auth.scheme(), auth.content(workflowContext, taskContext, model, uri))));
+                        auth.scheme(),
+                        auth.content(workflowContext, taskContext, model, uri).join())));
   }
 
   public <T> T loadURI(URI uri, Function<ExternalResourceHandler, T> function) {
diff --git a/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/AbstractRequestExecutor.java b/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/AbstractRequestExecutor.java
@@ -32,6 +32,8 @@
 import jakarta.ws.rs.core.Response.Status.Family;
 import java.net.URI;
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
 
 abstract class AbstractRequestExecutor implements RequestExecutor {
 
@@ -46,10 +48,30 @@ public AbstractRequestExecutor(String method, boolean redirect, Optional<AuthPro
   }
 
   @Override
-  public WorkflowModel apply(
+  public CompletableFuture<WorkflowModel> apply(
       Builder request, URI uri, WorkflowContext workflow, TaskContext task, WorkflowModel model) {
-    HttpModelConverter converter = HttpConverterResolver.converter(workflow, task);
-    authProvider.ifPresent(auth -> addAuthHeader(auth, uri, request, workflow, task, model));
+    ExecutorService executorService = workflow.definition().application().executorService();
+    CompletableFuture<HttpModelConverter> converterFuture =
+        CompletableFuture.supplyAsync(
+            () -> HttpConverterResolver.converter(workflow, task), executorService);
+    CompletableFuture<HttpModelConverter> authFuture =
+        authProvider
+            .map(
+                auth ->
+                    converterFuture.thenCompose(
+                        converter ->
+                            addAuthHeader(auth, uri, request, workflow, task, model)
+                                .thenApply(v -> converter)))
+            .orElse(converterFuture);
+    return authFuture.thenApply(converter -> doRequest(request, converter, workflow, task, model));
+  }
+
+  private WorkflowModel doRequest(
+      Builder request,
+      HttpModelConverter converter,
+      WorkflowContext workflow,
+      TaskContext task,
+      WorkflowModel model) {
     try (Response response = invokeRequest(request, converter, workflow, task, model)) {
       validateStatus(task, response, converter);
       return workflow
@@ -84,16 +106,20 @@ protected abstract Response invokeRequest(
       TaskContext task,
       WorkflowModel model);
 
-  private void addAuthHeader(
+  private CompletableFuture<?> addAuthHeader(
       AuthProvider auth,
       URI uri,
       Builder request,
       WorkflowContext workflow,
       TaskContext task,
       WorkflowModel model) {
     String scheme = auth.scheme();
-    String parameter = auth.content(workflow, task, model, uri);
-    task.authorization(scheme, parameter);
-    request.header(AuthUtils.AUTH_HEADER_NAME, AuthUtils.authHeaderValue(scheme, parameter));
+    return auth.content(workflow, task, model, uri)
+        .thenAccept(
+            parameter -> {
+              task.authorization(scheme, parameter);
+              request.header(
+                  AuthUtils.AUTH_HEADER_NAME, AuthUtils.authHeaderValue(scheme, parameter));
+            });
   }
 }
diff --git a/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/HttpExecutor.java b/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/HttpExecutor.java
@@ -73,8 +73,6 @@ public CompletableFuture<WorkflowModel> apply(
     Builder request = target.request();
     requestDecorators.forEach(d -> d.decorate(request, workflow, taskContext));
     headersMap.ifPresent(h -> h.apply(workflow, taskContext, input).forEach(request::header));
-    return CompletableFuture.supplyAsync(
-        () -> requestFunction.apply(request, uri, workflow, taskContext, input),
-        workflow.definition().application().executorService());
+    return requestFunction.apply(request, uri, workflow, taskContext, input);
   }
 }
diff --git a/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/RequestExecutor.java b/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/RequestExecutor.java
@@ -20,9 +20,10 @@
 import io.serverlessworkflow.impl.WorkflowModel;
 import jakarta.ws.rs.client.Invocation.Builder;
 import java.net.URI;
+import java.util.concurrent.CompletableFuture;
 
 @FunctionalInterface
 interface RequestExecutor {
-  WorkflowModel apply(
+  CompletableFuture<WorkflowModel> apply(
       Builder request, URI uri, WorkflowContext workflow, TaskContext task, WorkflowModel model);
 }
diff --git a/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/auth/JaxRSAccessTokenProvider.java b/impl/http/src/main/java/io/serverlessworkflow/impl/executors/http/auth/JaxRSAccessTokenProvider.java
@@ -40,6 +40,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 
 class JaxRSAccessTokenProvider implements AccessTokenProvider {
 
@@ -54,7 +55,8 @@ class JaxRSAccessTokenProvider implements AccessTokenProvider {
     this.jwtConverter = converter;
   }
 
-  public JWT validateAndGet(WorkflowContext workflow, TaskContext context, WorkflowModel model) {
+  public CompletableFuture<JWT> validateAndGet(
+      WorkflowContext workflow, TaskContext context, WorkflowModel model) {
     Map<String, Object> token = invoke(workflow, context, model);
     JWT jwt = jwtConverter.fromToken((String) token.get("access_token"));
     if (issuers != null && !issuers.isEmpty()) {
@@ -66,7 +68,7 @@ public JWT validateAndGet(WorkflowContext workflow, TaskContext context, Workflo
                 }
               });
     }
-    return jwt;
+    return CompletableFuture.completedFuture(jwt);
   }
 
   private Map<String, Object> invoke(
diff --git a/impl/openapi/src/main/java/io/serverlessworkflow/impl/executors/openapi/OpenAPIExecutor.java b/impl/openapi/src/main/java/io/serverlessworkflow/impl/executors/openapi/OpenAPIExecutor.java
diff --git a/impl/test/src/test/java/io/serverlessworkflow/impl/test/CustomAuthProviderFactoryOverrideTest.java b/impl/test/src/test/java/io/serverlessworkflow/impl/test/CustomAuthProviderFactoryOverrideTest.java

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,8 @@ public <T> T load(`
`113`	`113`	`.map(`
`114`	`114`	`auth ->`
`115`	`115`	`AuthUtils.authHeaderValue(`
`116`		`- auth.scheme(), auth.content(workflowContext, taskContext, model, uri))));`
	`116`	`+ auth.scheme(),`
	`117`	`+ auth.content(workflowContext, taskContext, model, uri).join())));`
`117`	`118`	`}`
`118`	`119`
`119`	`120`	`public <T> T loadURI(URI uri, Function<ExternalResourceHandler, T> function) {`