Merge pull request #685 from fjtirado/refactor_expressions

Refactoring expression building

Author: fjtirado

experimental/agentic/src/main/java/io/serverlessworkflow/impl/expressions/agentic/AgenticModel.java

@@ -32,6 +32,11 @@ class AgenticModel extends JavaModel {
     this.cognisphere = cognisphere;
   }
 
+  @Override
+  public void setObject(Object obj) {
+    super.setObject(obj);
+  }
+
   @Override
   public Collection<WorkflowModel> asCollection() {
     return object instanceof Collection value

experimental/agentic/src/main/java/io/serverlessworkflow/impl/expressions/agentic/AgenticModelFactory.java

@@ -26,12 +26,23 @@
 import java.util.Map;
 
 class AgenticModelFactory implements WorkflowModelFactory {
-  private final Cognisphere cognisphere = CognisphereRegistry.createEphemeralCognisphere();
+
+  private Cognisphere cognisphere = CognisphereRegistry.createEphemeralCognisphere();
 
   private final AgenticModel TrueModel = new AgenticModel(Boolean.TRUE, cognisphere);
   private final AgenticModel FalseModel = new AgenticModel(Boolean.FALSE, cognisphere);
   private final AgenticModel NullModel = new AgenticModel(null, cognisphere);
 
+  public void setCognishere(Cognisphere cognisphere) {
+    this.cognisphere = cognisphere;
+  }
+
+  @Override
+  public WorkflowModel fromAny(WorkflowModel prev, Object obj) {
+    ((AgenticModel) prev).setObject(obj);
+    return prev;
+  }
+
   @Override
   public WorkflowModel combine(Map<String, WorkflowModel> workflowVariables) {
     return new AgenticModel(workflowVariables, cognisphere);

experimental/lambda/src/main/java/io/serverlessworkflow/impl/executors/func/JavaForExecutorBuilder.java

@@ -23,12 +23,14 @@
 import io.serverlessworkflow.api.types.func.ForTaskFunction;
 import io.serverlessworkflow.api.types.func.TypedFunction;
 import io.serverlessworkflow.impl.WorkflowApplication;
-import io.serverlessworkflow.impl.WorkflowFilter;
 import io.serverlessworkflow.impl.WorkflowPosition;
-import io.serverlessworkflow.impl.WorkflowUtils;
+import io.serverlessworkflow.impl.WorkflowPredicate;
+import io.serverlessworkflow.impl.WorkflowValueResolver;
 import io.serverlessworkflow.impl.executors.ForExecutor.ForExecutorBuilder;
+import io.serverlessworkflow.impl.expressions.ExpressionDescriptor;
 import io.serverlessworkflow.impl.expressions.LoopPredicateIndex;
 import io.serverlessworkflow.impl.resources.ResourceLoader;
+import java.util.Collection;
 import java.util.Optional;
 
 public class JavaForExecutorBuilder extends ForExecutorBuilder {
@@ -42,7 +44,8 @@ protected JavaForExecutorBuilder(
     super(position, task, workflow, application, resourceLoader);
   }
 
-  protected Optional<WorkflowFilter> buildWhileFilter() {
+  @Override
+  protected Optional<WorkflowPredicate> buildWhileFilter() {
     if (task instanceof ForTaskFunction taskFunctions) {
       final LoopPredicateIndex whilePred = taskFunctions.getWhilePredicate();
       Optional<Class<?>> whileClass = taskFunctions.getWhileClass();
@@ -52,23 +55,21 @@ protected Optional<WorkflowFilter> buildWhileFilter() {
         return Optional.of(
             (w, t, n) -> {
               Object item = safeObject(t.variables().get(varName));
-              return application
-                  .modelFactory()
-                  .from(
-                      whilePred.test(
-                          JavaFuncUtils.convert(n, whileClass),
-                          item,
-                          (Integer) safeObject(t.variables().get(indexName))));
+              return whilePred.test(
+                  JavaFuncUtils.convert(n, whileClass),
+                  item,
+                  (Integer) safeObject(t.variables().get(indexName)));
             });
       }
     }
     return super.buildWhileFilter();
   }
 
-  protected WorkflowFilter buildCollectionFilter() {
+  protected WorkflowValueResolver<Collection<?>> buildCollectionFilter() {
     return task instanceof ForTaskFunction taskFunctions
-        ? WorkflowUtils.buildWorkflowFilter(
-            application, null, collectionFilterObject(taskFunctions))
+        ? application
+            .expressionFactory()
+            .resolveCollection(ExpressionDescriptor.object(collectionFilterObject(taskFunctions)))
         : super.buildCollectionFilter();
   }
 

experimental/lambda/src/main/java/io/serverlessworkflow/impl/executors/func/JavaSwitchExecutorBuilder.java

@@ -22,10 +22,10 @@
 import io.serverlessworkflow.api.types.func.SwitchCaseFunction;
 import io.serverlessworkflow.api.types.func.TypedPredicate;
 import io.serverlessworkflow.impl.WorkflowApplication;
-import io.serverlessworkflow.impl.WorkflowFilter;
 import io.serverlessworkflow.impl.WorkflowPosition;
-import io.serverlessworkflow.impl.WorkflowUtils;
+import io.serverlessworkflow.impl.WorkflowPredicate;
 import io.serverlessworkflow.impl.executors.SwitchExecutor.SwitchExecutorBuilder;
+import io.serverlessworkflow.impl.expressions.ExpressionDescriptor;
 import io.serverlessworkflow.impl.resources.ResourceLoader;
 import java.util.Optional;
 import java.util.function.Predicate;
@@ -42,11 +42,14 @@ protected JavaSwitchExecutorBuilder(
   }
 
   @Override
-  protected Optional<WorkflowFilter> buildFilter(SwitchCase switchCase) {
+  protected Optional<WorkflowPredicate> buildFilter(SwitchCase switchCase) {
     return switchCase instanceof SwitchCaseFunction function
         ? Optional.of(
-            WorkflowUtils.buildWorkflowFilter(
-                application, null, predObject(function.predicate(), function.predicateClass())))
+            application
+                .expressionFactory()
+                .buildPredicate(
+                    ExpressionDescriptor.object(
+                        predObject(function.predicate(), function.predicateClass()))))
         : super.buildFilter(switchCase);
   }
 

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

@@ -15,75 +15,52 @@
  */
 package io.serverlessworkflow.impl.expressions.func;
 
+import io.cloudevents.CloudEventData;
 import io.serverlessworkflow.api.types.TaskBase;
 import io.serverlessworkflow.api.types.TaskMetadata;
 import io.serverlessworkflow.api.types.func.TypedFunction;
 import io.serverlessworkflow.api.types.func.TypedPredicate;
-import io.serverlessworkflow.impl.TaskContext;
-import io.serverlessworkflow.impl.WorkflowContext;
-import io.serverlessworkflow.impl.WorkflowFilter;
-import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowModelFactory;
-import io.serverlessworkflow.impl.expressions.Expression;
-import io.serverlessworkflow.impl.expressions.ExpressionFactory;
+import io.serverlessworkflow.impl.WorkflowPredicate;
+import io.serverlessworkflow.impl.expressions.AbstractExpressionFactory;
+import io.serverlessworkflow.impl.expressions.ExpressionDescriptor;
+import io.serverlessworkflow.impl.expressions.ObjectExpression;
 import io.serverlessworkflow.impl.expressions.TaskMetadataKeys;
+import java.time.OffsetDateTime;
+import java.util.Collection;
+import java.util.Map;
 import java.util.Optional;
-import java.util.function.BiFunction;
-import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
-public class JavaExpressionFactory implements ExpressionFactory {
+public class JavaExpressionFactory extends AbstractExpressionFactory {
 
   private final WorkflowModelFactory modelFactory = new JavaModelFactory();
-  private final Expression dummyExpression =
-      new Expression() {
-        @Override
-        public WorkflowModel eval(
-            WorkflowContext workflowContext, TaskContext context, WorkflowModel model) {
-          return model;
-        }
-      };
 
   @Override
-  public Expression buildExpression(String expression) {
-    return dummyExpression;
-  }
-
-  @Override
-  public WorkflowFilter buildFilter(String expr, Object value) {
+  public ObjectExpression buildExpression(ExpressionDescriptor descriptor) {
+    Object value = descriptor.asObject();
     if (value instanceof Function func) {
-      return (w, t, n) -> modelFactory.fromAny(func.apply(n.asJavaObject()));
+      return (w, t, n) -> func.apply(n.asJavaObject());
     } else if (value instanceof TypedFunction func) {
-      return (w, t, n) ->
-          modelFactory.fromAny(func.function().apply(n.as(func.argClass()).orElseThrow()));
-    } else if (value instanceof Predicate pred) {
-      return fromPredicate(pred);
-    } else if (value instanceof TypedPredicate pred) {
-      return fromPredicate(pred);
-    } else if (value instanceof BiPredicate pred) {
-      return (w, t, n) -> modelFactory.from(pred.test(w, t));
-    } else if (value instanceof BiFunction func) {
-      return (w, t, n) -> modelFactory.fromAny(func.apply(w, t));
-    } else if (value instanceof WorkflowFilter filter) {
-      return filter;
+      return (w, t, n) -> func.function().apply(n.as(func.argClass()).orElseThrow());
     } else {
       return (w, t, n) -> modelFactory.fromAny(value);
     }
   }
 
   @SuppressWarnings({"rawtypes", "unchecked"})
-  private WorkflowFilter fromPredicate(Predicate pred) {
-    return (w, t, n) -> modelFactory.from(pred.test(n.asJavaObject()));
+  private WorkflowPredicate fromPredicate(Predicate pred) {
+    return (w, t, n) -> pred.test(n.asJavaObject());
   }
 
   @SuppressWarnings({"rawtypes", "unchecked"})
-  private WorkflowFilter fromPredicate(TypedPredicate pred) {
-    return (w, t, n) -> modelFactory.from(pred.pred().test(n.as(pred.argClass()).orElseThrow()));
+  private WorkflowPredicate fromPredicate(TypedPredicate pred) {
+    return (w, t, n) -> pred.pred().test(n.as(pred.argClass()).orElseThrow());
   }
 
   @Override
-  public Optional<WorkflowFilter> buildIfFilter(TaskBase task) {
+  public Optional<WorkflowPredicate> buildIfFilter(TaskBase task) {
     TaskMetadata metadata = task.getMetadata();
     if (metadata != null) {
       Object obj = metadata.getAdditionalProperties().get(TaskMetadataKeys.IF_PREDICATE);
@@ -93,11 +70,54 @@ public Optional<WorkflowFilter> buildIfFilter(TaskBase task) {
         return Optional.of(fromPredicate(pred));
       }
     }
-    return ExpressionFactory.super.buildIfFilter(task);
+    return super.buildIfFilter(task);
   }
 
   @Override
   public WorkflowModelFactory modelFactory() {
     return modelFactory;
   }
+
+  @Override
+  public WorkflowPredicate buildPredicate(ExpressionDescriptor desc) {
+    Object value = desc.asObject();
+    if (value instanceof Predicate pred) {
+      return fromPredicate(pred);
+    } else if (value instanceof TypedPredicate pred) {
+      return fromPredicate(pred);
+    } else if (value instanceof Boolean bool) {
+      return (w, f, n) -> bool;
+    } else {
+      throw new IllegalArgumentException("value should be a predicate or a boolean");
+    }
+  }
+
+  @Override
+  protected String toString(Object eval) {
+    return asClass(eval, String.class);
+  }
+
+  @Override
+  protected CloudEventData toCloudEventData(Object eval) {
+    return asClass(eval, CloudEventData.class);
+  }
+
+  @Override
+  protected OffsetDateTime toDate(Object eval) {
+    return asClass(eval, OffsetDateTime.class);
+  }
+
+  @Override
+  protected Map<String, Object> toMap(Object eval) {
+    return asClass(eval, Map.class);
+  }
+
+  @Override
+  protected Collection<?> toCollection(Object obj) {
+    return asClass(obj, Collection.class);
+  }
+
+  private <T> T asClass(Object obj, Class<T> clazz) {
+    return clazz.cast(obj);
+  }
 }

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

@@ -15,7 +15,6 @@
  */
 package io.serverlessworkflow.impl.expressions.func;
 
-import io.cloudevents.CloudEventData;
 import io.serverlessworkflow.impl.WorkflowModel;
 import java.time.OffsetDateTime;
 import java.util.Collection;
@@ -28,12 +27,16 @@
 
 public class JavaModel implements WorkflowModel {
 
-  protected final Object object;
+  protected Object object;
 
   protected JavaModel(Object object) {
     this.object = asJavaObject(object);
   }
 
+  protected void setObject(Object object) {
+    this.object = object;
+  }
+
   @Override
   public void forEach(BiConsumer<String, WorkflowModel> consumer) {
     asMap()
@@ -72,11 +75,6 @@ public Optional<Number> asNumber() {
     return object instanceof Number value ? Optional.of(value) : Optional.empty();
   }
 
-  @Override
-  public Optional<CloudEventData> asCloudEventData() {
-    return object instanceof CloudEventData value ? Optional.of(value) : Optional.empty();
-  }
-
   @Override
   public Optional<Map<String, Object>> asMap() {
     return object instanceof Map ? Optional.of((Map<String, Object>) object) : Optional.empty();

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

@@ -79,7 +79,7 @@ public WorkflowModel fromNull() {
   }
 
   @Override
-  public WorkflowModel fromAny(Object obj) {
+  public WorkflowModel fromOther(Object obj) {
     return new JavaModel(obj);
   }
 }

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

@@ -17,5 +17,5 @@
 
 @FunctionalInterface
 public interface WorkflowFilter {
-  WorkflowModel apply(WorkflowContext workflow, TaskContext task, WorkflowModel node);
+  WorkflowModel apply(WorkflowContext workflow, TaskContext task, WorkflowModel model);
 }

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

@@ -15,7 +15,6 @@
  */
 package io.serverlessworkflow.impl;
 
-import io.cloudevents.CloudEventData;
 import java.time.OffsetDateTime;
 import java.util.Collection;
 import java.util.Map;
@@ -36,8 +35,6 @@ public interface WorkflowModel {
 
   Optional<Number> asNumber();
 
-  Optional<CloudEventData> asCloudEventData();
-
   Optional<Map<String, Object>> asMap();
 
   Object asJavaObject();

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

@@ -47,6 +47,10 @@ default WorkflowModel fromOther(Object obj) {
         "Unsupported conversion for object " + obj + " of type" + obj.getClass());
   }
 
+  default WorkflowModel fromAny(WorkflowModel prev, Object obj) {
+    return fromAny(obj);
+  }
+
   default WorkflowModel fromAny(Object obj) {
     if (obj == null) {
       return fromNull();
@@ -66,6 +70,10 @@ default WorkflowModel fromAny(Object obj) {
       return from((Map<String, Object>) obj);
     } else if (obj instanceof WorkflowModel model) {
       return model;
+    } else if (obj instanceof CloudEventData ce) {
+      return from(ce);
+    } else if (obj instanceof CloudEvent ce) {
+      return from(ce);
     } else {
       return fromOther(obj);
     }