Add taskInput taskOutput and workflowInput

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

Author: mcruzdev

experimental/fluent/func/src/main/java/io/serverlessworkflow/fluent/func/dsl/EnrichWithModelBiFunction.java

@@ -32,8 +32,6 @@
 import io.serverlessworkflow.fluent.spec.configurers.AuthenticationConfigurer;
 import io.serverlessworkflow.impl.TaskContextData;
 import io.serverlessworkflow.impl.WorkflowContextData;
-import io.serverlessworkflow.impl.WorkflowModel;
-import io.serverlessworkflow.impl.jackson.JsonUtils;
 import java.net.URI;
 import java.util.Collection;
 import java.util.List;
@@ -281,123 +279,6 @@ public static FuncPredicateEventConfigurer event(String type) {
     return OPS.event(type);
   }
 
-  /**
-   * Create an input transformation that enriches the typed last state with the root workflow input
-   * as WorkflowModel.
-   *
-   * <p>This is useful when you want to combine the last task output (with its actual type) with the
-   * original workflow input as WorkflowModel.
-   *
-   * <p>Example usage:
-   *
-   * <pre>{@code
-   * function("processData", (Long input) -> input + 5, Long.class),
-   * function("combineData", (Long enrichedValue) -> enrichedValue, Long.class)
-   *     .inputFrom(
-   *         FuncDSL.enrichInput((Long lastState, WorkflowModel rootInputModel) -> {
-   *             Long rootInput = rootInputModel.as(Long.class).orElse(0L);
-   *             return lastState + rootInput;
-   *         }),
-   *         Long.class)
-   * }</pre>
-   *
-   * @param fn the enrichment function that receives typed lastState and WorkflowModel rootInput
-   * @param <T> the type of the last state
-   * @param <R> the type of the enriched result
-   * @return a JavaContextFunction that can be used with inputFrom
-   */
-  public static <T, R> JavaContextFunction<T, R> enrichInput(EnrichWithModelBiFunction<T, R> fn) {
-    return (lastState, workflowContext) -> {
-      final WorkflowModel rootInput = workflowContext.instanceData().input();
-      return fn.apply(lastState, rootInput);
-    };
-  }
-
-  /**
-   * Create an input transformation that uses only the root workflow input as WorkflowModel.
-   *
-   * <p>This is useful when you want to transform the task input based solely on the original
-   * workflow input, ignoring the last state.
-   *
-   * <p>Example usage:
-   *
-   * <pre>{@code
-   * function("processData", (Long input) -> input * 2, Long.class)
-   *     .inputFrom(enrichInput(rootInput -> rootInput.asNumber().orElseThrow()))
-   * }</pre>
-   *
-   * @param fn the function that receives the root workflow input and returns the enriched result
-   * @param <R> the type of the enriched result
-   * @return a JavaContextFunction that can be used with inputFrom
-   */
-  public static <R> JavaContextFunction<Object, R> enrichInput(Function<WorkflowModel, R> fn) {
-    return (lastState, workflowContext) -> {
-      final WorkflowModel rootInput = workflowContext.instanceData().input();
-      return fn.apply(rootInput);
-    };
-  }
-
-  /**
-   * Create an output transformation that enriches the typed task output with the root workflow
-   * input as WorkflowModel.
-   *
-   * <p>This is useful when you want to combine the task output (converted to a specific type) with
-   * the original workflow input as WorkflowModel. The task output will be converted to the
-   * specified type using Jackson conversion before being passed to the enrichment function.
-   *
-   * <p>Example usage:
-   *
-   * <pre>{@code
-   * // Task returns Long, but we want to work with it as Integer in the enrichment function
-   * function("processData", (Long input) -> input + 5, Long.class)
-   *     .outputAs(FuncDSL.enrichOutput((taskOutput, rootInputModel) -> {
-   *         // taskOutput is converted from Long to Integer
-   *         Long rootInput = rootInputModel.as(Long.class).orElse(0L);
-   *         return taskOutput + rootInput.intValue();
-   *     }, Integer.class))
-   * }</pre>
-   *
-   * @param fn the enrichment function that receives typed taskOutput and WorkflowModel rootInput
-   * @param taskOutputClass the target type to convert the task output to before passing it to the
-   *     enrichment function
-   * @param <T> the target type for the task output conversion
-   * @param <R> the type of the enriched result
-   * @return a JavaContextFunction that can be used with outputAs
-   */
-  public static <T, R> JavaContextFunction<T, R> enrichOutput(
-      EnrichWithModelBiFunction<T, R> fn, Class<T> taskOutputClass) {
-    return (taskOutput, workflowContext) -> {
-      Objects.requireNonNull(taskOutputClass, "taskOutputClass must not be null");
-      final WorkflowModel rootInput = workflowContext.instanceData().input();
-      final T typedTaskOutput = JsonUtils.convertValue(taskOutput, taskOutputClass);
-      return fn.apply(typedTaskOutput, rootInput);
-    };
-  }
-
-  /**
-   * Create an output transformation that uses only the root workflow input as WorkflowModel.
-   *
-   * <p>This is useful when you want to transform the task output based solely on the original
-   * workflow input, ignoring the actual task output.
-   *
-   * <p>Example usage:
-   *
-   * <pre>{@code
-   * function("processData", (Long input) -> input * 2, Long.class)
-   *     .outputAs(FuncDSL.enrichOutput(rootInput -> rootInput.asNumber().orElseThrow()))
-   * }</pre>
-   *
-   * @param fn the function that receives the root workflow input and returns the enriched result
-   * @param <R> the type of the enriched result
-   * @return a JavaContextFunction that can be used with outputAs
-   */
-  public static <R> JavaContextFunction<Object, R> enrichOutput(Function<WorkflowModel, R> fn) {
-    return (ignore, workflowContext) -> {
-      final WorkflowModel rootInput = workflowContext.instanceData().input();
-      return fn.apply(rootInput);
-    };
-  }
-
   /**
    * Create a {@link FuncCallStep} that calls a simple Java {@link Function} with explicit input
    * type.
@@ -1441,4 +1322,85 @@ public static FuncCallHttpStep post(
 
     return http(name).POST().endpoint(endpoint, auth).body(body);
   }
+
+  /**
+   * Extracts and deserializes the workflow input data into the specified type from a workflow
+   * context.
+   *
+   * <p>This utility method provides type-safe access to the workflow's initial input.
+   *
+   * <p>Use this method when you have access to the {@link WorkflowContextData} and need to retrieve
+   * the original input that was provided when the workflow instance was started.
+   *
+   * <p><b>Usage Example:</b>
+   *
+   * <pre>{@code
+   * inputFrom((object, WorkflowContextData workflowContext) -> {
+   *   OrderRequest order = workflowInput(workflowContext, OrderRequest.class);
+   *   return new Input(order);
+   * }
+   * }</pre>
+   *
+   * @param <T> the type to deserialize the input into
+   * @param context the workflow context containing instance data and input
+   * @param inputClass the class object representing the target type for deserialization
+   * @return the deserialized workflow input object of type T
+   */
+  public static <T> T taskInput(WorkflowContextData context, Class<T> inputClass) {
+    return context.instanceData().input().as(inputClass).orElseThrow();
+  }
+
+  /**
+   * Extracts and deserializes the workflow input data into the specified type from a task context.
+   *
+   * <p>This utility method provides type-safe access to the workflow's initial input.
+   *
+   * <p>Use this method when you only have access to the {@link TaskContextData} but need to
+   * retrieve the original workflow input (not the task's input). This is useful when a task needs
+   * to reference the initial workflow input data.
+   *
+   * <p><b>Usage Example:</b>
+   *
+   * <pre>{@code
+   * inputFrom((Object obj, TaskContextData taskContextData) -> {
+   *   OrderRequest order = taskInput(taskContextData, OrderRequest.class);
+   *   return new Input(order);
+   * }
+   * }</pre>
+   *
+   * @param <T> the type to deserialize the input into
+   * @param taskContextData the task context from which to retrieve the workflow input
+   * @param inputClass the class object representing the target type for deserialization
+   * @return the deserialized workflow input object of type T
+   */
+  public static <T> T taskInput(TaskContextData taskContextData, Class<T> inputClass) {
+    return taskContextData.input().as(inputClass).orElseThrow();
+  }
+
+  /**
+   * Extracts and deserializes the output data from a task into the specified type.
+   *
+   * <p>This utility method provides type-safe access to a task's output.
+   *
+   * <p>Use this method when you need to access the result/output produced by a task execution. This
+   * is particularly useful in subsequent tasks that need to process or transform the output of a
+   * previous task in the workflow.
+   *
+   * <p><b>Usage Example:</b>
+   *
+   * <pre>{@code
+   * .exportAs((object, workflowContext, taskContextData) -> {
+   *     Long input = taskOutput(taskContextData, Long.class);
+   *     return input * 2;
+   *  }))
+   * }</pre>
+   *
+   * @param <T> the type to deserialize the task output into
+   * @param taskContextData the task context containing the output data
+   * @param inputClass the class object representing the target type for deserialization
+   * @return the deserialized task output object of type T
+   */
+  public static <T> T taskOutput(TaskContextData taskContextData, Class<T> inputClass) {
+    return taskContextData.output().as(inputClass).orElseThrow();
+  }
 }