[Fix #863] Adding WorkflowContext and TaskContext as additional params (#864)

User can now specify java filter functions that accepts WorkflowContext
and TaskContext in their signature.

Signed-off-by: fjtirado <ftirados@redhat.com>

Author: fjtirado

experimental/lambda/src/main/java/io/serverlessworkflow/impl/expressions/func/JavaExpressionFactory.java

@@ -18,8 +18,12 @@
 import io.cloudevents.CloudEventData;
 import io.serverlessworkflow.api.types.TaskBase;
 import io.serverlessworkflow.api.types.TaskMetadata;
+import io.serverlessworkflow.api.types.func.JavaContextFunction;
+import io.serverlessworkflow.api.types.func.JavaFilterFunction;
 import io.serverlessworkflow.api.types.func.TaskMetadataKeys;
 import io.serverlessworkflow.api.types.func.TypedFunction;
+import io.serverlessworkflow.api.types.func.TypedJavaContextFunction;
+import io.serverlessworkflow.api.types.func.TypedJavaFilterFunction;
 import io.serverlessworkflow.api.types.func.TypedPredicate;
 import io.serverlessworkflow.impl.WorkflowModelFactory;
 import io.serverlessworkflow.impl.WorkflowPredicate;
@@ -44,6 +48,14 @@ public ObjectExpression buildExpression(ExpressionDescriptor descriptor) {
       return (w, t, n) -> func.apply(n.asJavaObject());
     } else if (value instanceof TypedFunction func) {
       return (w, t, n) -> func.function().apply(n.as(func.argClass()).orElseThrow());
+    } else if (value instanceof JavaFilterFunction func) {
+      return (w, t, n) -> func.apply(n.asJavaObject(), w, t);
+    } else if (value instanceof TypedJavaFilterFunction func) {
+      return (w, t, n) -> func.function().apply(n.as(func.argClass()).orElseThrow(), w, t);
+    } else if (value instanceof JavaContextFunction func) {
+      return (w, t, n) -> func.apply(n.asJavaObject(), w);
+    } else if (value instanceof TypedJavaContextFunction func) {
+      return (w, t, n) -> func.function().apply(n.as(func.argClass()).orElseThrow(), w);
     } else {
       return (w, t, n) -> value;
     }

experimental/lambda/src/test/java/io/serverless/workflow/impl/JavaFunctions.java

@@ -15,6 +15,8 @@
  */
 package io.serverless.workflow.impl;
 
+import io.serverlessworkflow.impl.TaskContextData;
+import io.serverlessworkflow.impl.WorkflowContextData;
 import java.util.Map;
 
 public class JavaFunctions {
@@ -27,6 +29,15 @@ static String getName(Person person) {
     return person.name() + " Javierito";
   }
 
+  static String getFilterName(
+      Person person, WorkflowContextData workflowContext, TaskContextData taskContext) {
+    return person.name() + "_" + workflowContext.instanceData().id() + "_" + taskContext.taskName();
+  }
+
+  static String getContextName(Person person, WorkflowContextData workflowContext) {
+    return person.name() + "_" + workflowContext.instanceData().id();
+  }
+
   static Map<String, Object> addJavierito(Map<String, Object> map) {
     return Map.of("name", map.get("name") + " Javierito");
   }

experimental/lambda/src/test/java/io/serverless/workflow/impl/ModelTest.java

@@ -30,6 +30,7 @@
 import io.serverlessworkflow.api.types.Workflow;
 import io.serverlessworkflow.api.types.func.OutputAsFunction;
 import io.serverlessworkflow.impl.WorkflowApplication;
+import io.serverlessworkflow.impl.WorkflowInstance;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
@@ -173,4 +174,62 @@ void testPOJOStringExpression() throws InterruptedException, ExecutionException
           .isEqualTo("Francisco Javierito");
     }
   }
+
+  @Test
+  void testPOJOStringExpressionWithContext() throws InterruptedException, ExecutionException {
+    try (WorkflowApplication app = WorkflowApplication.builder().build()) {
+      Workflow workflow =
+          new Workflow()
+              .withDocument(
+                  new Document().withNamespace("test").withName("testPojo").withVersion("1.0"))
+              .withDo(
+                  List.of(
+                      new TaskItem(
+                          "doNothing",
+                          new Task()
+                              .withWaitTask(
+                                  new WaitTask()
+                                      .withWait(
+                                          new TimeoutAfter()
+                                              .withDurationInline(
+                                                  new DurationInline().withMilliseconds(10)))))))
+              .withOutput(
+                  new Output()
+                      .withAs(new OutputAsFunction().withFunction(JavaFunctions::getContextName)));
+      WorkflowInstance instance =
+          app.workflowDefinition(workflow).instance(new Person("Francisco", 33));
+      assertThat(instance.start().get().asText().orElseThrow())
+          .isEqualTo("Francisco_" + instance.id());
+    }
+  }
+
+  @Test
+  void testPOJOStringExpressionWithFilter() throws InterruptedException, ExecutionException {
+    try (WorkflowApplication app = WorkflowApplication.builder().build()) {
+      Workflow workflow =
+          new Workflow()
+              .withDocument(
+                  new Document().withNamespace("test").withName("testPojo").withVersion("1.0"))
+              .withDo(
+                  List.of(
+                      new TaskItem(
+                          "doNothing",
+                          new Task()
+                              .withWaitTask(
+                                  new WaitTask()
+                                      .withOutput(
+                                          new Output()
+                                              .withAs(
+                                                  new OutputAsFunction()
+                                                      .withFunction(JavaFunctions::getFilterName)))
+                                      .withWait(
+                                          new TimeoutAfter()
+                                              .withDurationInline(
+                                                  new DurationInline().withMilliseconds(10)))))));
+      WorkflowInstance instance =
+          app.workflowDefinition(workflow).instance(new Person("Francisco", 33));
+      assertThat(instance.start().get().asText().orElseThrow())
+          .isEqualTo("Francisco_" + instance.id() + "_doNothing");
+    }
+  }
 }

experimental/types/pom.xml

@@ -12,5 +12,9 @@
         <groupId>io.serverlessworkflow</groupId>
         <artifactId>serverlessworkflow-types</artifactId>
     </dependency>
+     <dependency>
+        <groupId>io.serverlessworkflow</groupId>
+        <artifactId>serverlessworkflow-impl-core</artifactId>
+    </dependency>
   </dependencies>
 </project>

experimental/types/src/main/java/io/serverlessworkflow/api/types/func/ExportAsFunction.java

@@ -31,4 +31,24 @@ public <T, V> ExportAs withFunction(Function<T, V> value, Class<T> argClass) {
     setObject(new TypedFunction<>(value, argClass));
     return this;
   }
+
+  public <T, V> ExportAs withFunction(JavaFilterFunction<T, V> value) {
+    setObject(value);
+    return this;
+  }
+
+  public <T, V> ExportAs withFunction(JavaFilterFunction<T, V> value, Class<T> argClass) {
+    setObject(new TypedJavaFilterFunction<>(value, argClass));
+    return this;
+  }
+
+  public <T, V> ExportAs withFunction(JavaContextFunction<T, V> value) {
+    setObject(value);
+    return this;
+  }
+
+  public <T, V> ExportAs withFunction(JavaContextFunction<T, V> value, Class<T> argClass) {
+    setObject(new TypedJavaContextFunction<>(value, argClass));
+    return this;
+  }
 }

experimental/types/src/main/java/io/serverlessworkflow/api/types/func/InputFromFunction.java

@@ -31,4 +31,24 @@ public <T, V> InputFrom withFunction(Function<T, V> value, Class<T> argClass) {
     setObject(new TypedFunction<>(value, argClass));
     return this;
   }
+
+  public <T, V> InputFrom withFunction(JavaFilterFunction<T, V> value) {
+    setObject(value);
+    return this;
+  }
+
+  public <T, V> InputFrom withFunction(JavaFilterFunction<T, V> value, Class<T> argClass) {
+    setObject(new TypedJavaFilterFunction<>(value, argClass));
+    return this;
+  }
+
+  public <T, V> InputFrom withFunction(JavaContextFunction<T, V> value) {
+    setObject(value);
+    return this;
+  }
+
+  public <T, V> InputFrom withFunction(JavaContextFunction<T, V> value, Class<T> argClass) {
+    setObject(new TypedJavaContextFunction<>(value, argClass));
+    return this;
+  }
 }

experimental/types/src/main/java/io/serverlessworkflow/api/types/func/JavaContextFunction.java

@@ -0,0 +1,23 @@
+/*
+ * 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.api.types.func;
+
+import io.serverlessworkflow.impl.WorkflowContextData;
+
+@FunctionalInterface
+public interface JavaContextFunction<T, R> {
+  R apply(T object, WorkflowContextData workflowContext);
+}

experimental/types/src/main/java/io/serverlessworkflow/api/types/func/JavaFilterFunction.java

@@ -0,0 +1,24 @@
+/*
+ * 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.api.types.func;
+
+import io.serverlessworkflow.impl.TaskContextData;
+import io.serverlessworkflow.impl.WorkflowContextData;
+
+@FunctionalInterface
+public interface JavaFilterFunction<T, R> {
+  R apply(T object, WorkflowContextData workflowContext, TaskContextData taskContext);
+}

experimental/types/src/main/java/io/serverlessworkflow/api/types/func/OutputAsFunction.java

@@ -31,4 +31,24 @@ public <T, V> OutputAs withFunction(Function<T, V> value, Class<T> argClass) {
     setObject(new TypedFunction<>(value, argClass));
     return this;
   }
+
+  public <T, V> OutputAs withFunction(JavaFilterFunction<T, V> value) {
+    setObject(value);
+    return this;
+  }
+
+  public <T, V> OutputAs withFunction(JavaFilterFunction<T, V> value, Class<T> argClass) {
+    setObject(new TypedJavaFilterFunction<>(value, argClass));
+    return this;
+  }
+
+  public <T, V> OutputAs withFunction(JavaContextFunction<T, V> value) {
+    setObject(value);
+    return this;
+  }
+
+  public <T, V> OutputAs withFunction(JavaContextFunction<T, V> value, Class<T> argClass) {
+    setObject(new TypedJavaContextFunction<>(value, argClass));
+    return this;
+  }
 }

experimental/types/src/main/java/io/serverlessworkflow/api/types/func/TypedJavaContextFunction.java

@@ -0,0 +1,19 @@
+/*
+ * 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.api.types.func;
+
+public record TypedJavaContextFunction<T, V>(
+    JavaContextFunction<T, V> function, Class<T> argClass) {}