Add openapi module

impl/core/src/main/java/io/serverlessworkflow/impl/WorkflowUtils.java

@@ -30,6 +30,7 @@
 import io.serverlessworkflow.impl.json.JsonUtils;
 import io.serverlessworkflow.impl.jsonschema.SchemaValidator;
 import io.serverlessworkflow.impl.jsonschema.SchemaValidatorFactory;
+import io.serverlessworkflow.impl.resources.ClasspathResource;
 import io.serverlessworkflow.impl.resources.ResourceLoader;
 import io.serverlessworkflow.impl.resources.StaticResource;
 import java.io.IOException;
@@ -67,6 +68,19 @@ private static Optional<JsonNode> schemaToNode(
     return Optional.empty();
   }
 
+  public static Optional<JsonNode> classpathResourceToNode(String resource) {
+    if (resource != null && !resource.isEmpty()) {
+      ClasspathResource classpathResource = new ClasspathResource(resource);
+      ObjectMapper mapper = WorkflowFormat.fromFileName(resource).mapper();
+      try (InputStream in = classpathResource.open()) {
+        return Optional.of(mapper.readTree(in));
+      } catch (IOException io) {
+        throw new UncheckedIOException(io);
+      }
+    }
+    return Optional.empty();
+  }
+
   public static Optional<WorkflowFilter> buildWorkflowFilter(
       ExpressionFactory exprFactory, InputFrom from) {
     return from != null

impl/openapi/pom.xml

@@ -0,0 +1,43 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>io.serverlessworkflow</groupId>
+    <artifactId>serverlessworkflow-impl</artifactId>
+    <version>7.0.0-SNAPSHOT</version>
+  </parent>
+  <artifactId>serverlessworkflow-impl-openapi</artifactId>
+  <dependencies>
+    <dependency>
+      <groupId>org.glassfish.jersey.core</groupId>
+      <artifactId>jersey-client</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.glassfish.jersey.media</groupId>
+      <artifactId>jersey-media-json-jackson</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.serverlessworkflow</groupId>
+      <artifactId>serverlessworkflow-impl-core</artifactId>
+    </dependency>
+      <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-api</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-engine</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-params</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

impl/openapi/src/main/java/io/serverlessworkflow/impl/executors/OpenAPIExecutor.java

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl.executors;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
+import io.serverlessworkflow.api.types.CallOpenAPI;
+import io.serverlessworkflow.api.types.Endpoint;
+import io.serverlessworkflow.api.types.EndpointUri;
+import io.serverlessworkflow.api.types.OpenAPIArguments;
+import io.serverlessworkflow.api.types.TaskBase;
+import io.serverlessworkflow.api.types.UriTemplate;
+import io.serverlessworkflow.impl.TaskContext;
+import io.serverlessworkflow.impl.WorkflowContext;
+import io.serverlessworkflow.impl.WorkflowDefinition;
+import io.serverlessworkflow.impl.WorkflowError;
+import io.serverlessworkflow.impl.WorkflowException;
+import io.serverlessworkflow.impl.WorkflowUtils;
+import io.serverlessworkflow.impl.expressions.Expression;
+import io.serverlessworkflow.impl.expressions.ExpressionFactory;
+import io.serverlessworkflow.impl.json.JsonUtils;
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.WebTarget;
+import java.util.Map;
+import java.util.Optional;
+
+public class OpenAPIExecutor implements CallableTask<CallOpenAPI> {
+  private static final Client client = ClientBuilder.newClient();
+  private TargetSupplier targetSupplier;
+
+  @FunctionalInterface
+  private interface TargetSupplier {
+    WebTarget apply(WorkflowContext workflow, TaskContext<?> task, JsonNode node);
+  }
+
+  @Override
+  public void init(CallOpenAPI task, WorkflowDefinition definition) {
+    OpenAPIArguments args = task.getWith();
+    this.targetSupplier = getTargetSupplier(args, definition.expressionFactory());
+  }
+
+  @Override
+  public JsonNode apply(
+      WorkflowContext workflowContext, TaskContext<CallOpenAPI> taskContext, JsonNode input) {
+
+    WebTarget target = this.targetSupplier.apply(workflowContext, taskContext, input);
+
+    System.out.println("target: " + target.getUri());
+
+    return input;
+  }
+
+  @Override
+  public boolean accept(Class<? extends TaskBase> clazz) {
+    return clazz.isAssignableFrom(CallOpenAPI.class);
+  }
+
+  private static TargetSupplier getURISupplier(UriTemplate template, String operationId) {
+    if (template.getLiteralUri() != null) {
+
+      Optional<JsonNode> jsonNode =
+          WorkflowUtils.classpathResourceToNode(template.getLiteralUri().toString());
+
+      if (jsonNode.isEmpty()) {
+        throw new IllegalArgumentException(
+            "Invalid OpenAPI specification " + template.getLiteralUri().toString());
+      }
+
+      String host = OpenAPIReader.getHost(jsonNode.get());
+
+      Optional<JsonNode> possibleOperation =
+          OpenAPIReader.readOperation(jsonNode.get(), operationId);
+
+      if (possibleOperation.isEmpty()) {
+        throw new WorkflowException(
+            WorkflowError.error(WorkflowError.RUNTIME_TYPE, 400)
+                .title("Invalid OpenAPI Specification")
+                .details("There is no operation ID " + operationId)
+                .build());
+      }
+
+      return (w, t, n) -> client.target(host);
+    } else if (template.getLiteralUriTemplate() != null) {
+      return (w, t, n) ->
+          client
+              .target(template.getLiteralUriTemplate())
+              .resolveTemplates(
+                  JsonUtils.mapper().convertValue(n, new TypeReference<Map<String, Object>>() {}));
+    }
+    throw new IllegalArgumentException("Invalid uritemplate definition " + template);
+  }
+
+  private static class ExpressionURISupplier implements TargetSupplier {
+    private Expression expr;
+
+    public ExpressionURISupplier(Expression expr) {
+      this.expr = expr;
+    }
+
+    @Override
+    public WebTarget apply(WorkflowContext workflow, TaskContext<?> task, JsonNode node) {
+      return client.target(expr.eval(workflow, task, node).asText());
+    }
+  }
+
+  private static TargetSupplier getTargetSupplier(
+      OpenAPIArguments args, ExpressionFactory expressionFactory) {
+
+    Endpoint endpoint = args.getDocument().getEndpoint();
+    String operationId = args.getOperationId();
+
+    if (endpoint.getEndpointConfiguration() != null) {
+      EndpointUri uri = endpoint.getEndpointConfiguration().getUri();
+      if (uri.getLiteralEndpointURI() != null) {
+        return getURISupplier(uri.getLiteralEndpointURI(), operationId);
+      } else if (uri.getExpressionEndpointURI() != null) {
+        return new ExpressionURISupplier(
+            expressionFactory.getExpression(uri.getExpressionEndpointURI()));
+      }
+    } else if (endpoint.getRuntimeExpression() != null) {
+      return new ExpressionURISupplier(
+          expressionFactory.getExpression(endpoint.getRuntimeExpression()));
+    } else if (endpoint.getUriTemplate() != null) {
+      return getURISupplier(endpoint.getUriTemplate(), operationId);
+    }
+    throw new IllegalArgumentException("Invalid endpoint definition " + endpoint);
+  }
+}

impl/openapi/src/main/java/io/serverlessworkflow/impl/executors/OpenAPIReader.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl.executors;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+public class OpenAPIReader {
+
+  private static final String HTTPS = "https";
+  private static final String HTTP = "http";
+  private static final String DEFAULT_SCHEME = HTTPS;
+  private static final Set<String> ALLOWED_SCHEMES = Set.of(HTTPS, HTTP);
+
+  public static String getHost(JsonNode jsonNode) {
+    JsonNode host = jsonNode.get("host");
+    if (host == null) {
+      return null;
+    }
+    String scheme = getScheme(jsonNode);
+    return scheme + "://" + host.asText();
+  }
+
+  private static String getScheme(JsonNode jsonNode) {
+    ArrayNode array = jsonNode.withArrayProperty("schemes");
+    if (array != null && !array.isEmpty()) {
+      String firstScheme = array.get(0).asText();
+      return ALLOWED_SCHEMES.contains(firstScheme) ? firstScheme : DEFAULT_SCHEME;
+    }
+    return DEFAULT_SCHEME;
+  }
+
+  public static Optional<JsonNode> readOperation(JsonNode jsonNode, String operationId) {
+    JsonNode paths = jsonNode.get("paths");
+    for (Map.Entry<String, JsonNode> entry : paths.properties()) {
+      for (Map.Entry<String, JsonNode> httpMethod : entry.getValue().properties()) {
+        if (httpMethod.getValue().get("operationId").asText().equals(operationId)) {
+          return Optional.ofNullable(httpMethod.getValue());
+        }
+      }
+    }
+    return Optional.empty();
+  }
+}

impl/openapi/src/main/resources/META-INF/services/io.serverlessworkflow.impl.executors.CallableTask

@@ -0,0 +1 @@
+io.serverlessworkflow.impl.executors.OpenAPIExecutor

impl/openapi/src/test/java/io/serverlessworkflow/impl/OpenAPIWorkflowDefinitionTest.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl;
+
+import static io.serverlessworkflow.api.WorkflowReader.readWorkflowFromClasspath;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class OpenAPIWorkflowDefinitionTest {
+
+  private static WorkflowApplication app;
+
+  @BeforeAll
+  static void init() {
+    app = WorkflowApplication.builder().build();
+  }
+
+  @Test
+  void testWorkflowExecution() throws IOException {
+    Object output =
+        app.workflowDefinition(readWorkflowFromClasspath("findPetsByStatus.yaml"))
+            .execute(Map.of("status", "sold"))
+            .outputAsJsonNode();
+    assertThat(output)
+        .isInstanceOf(JsonNode.class)
+        .satisfies(
+            (obj) -> {
+              JsonNode json = (JsonNode) obj;
+              assertThat(json.get("status").asText()).isEqualTo("sold");
+            });
+  }
+}

impl/openapi/src/test/resources/findPetsByStatus.yaml

@@ -0,0 +1,14 @@
+document:
+  dsl: '1.0.0-alpha5'
+  namespace: test
+  name: openapi-example
+  version: '0.1.0'
+do:
+  - findPet:
+      call: openapi
+      with:
+        document:
+          endpoint: pets.json
+        operationId: findPetsByStatus
+        parameters:
+          status: available