Support stringfied json

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

@@ -46,18 +46,14 @@ public Optional<Map<String, Object>> asMap() {
   }
 
   @Override
-  public <T> Optional<T> as(Class<T> clazz) {
-    if (AgenticScope.class.isAssignableFrom(clazz)) {
-      return Optional.of(clazz.cast(this.agenticScope));
-    } else if (Map.class.isAssignableFrom(clazz)) {
-      return asMap().map(clazz::cast);
-    } else {
-      return super.as(clazz);
-    }
+  public Object asJavaObject() {
+    return agenticScope;
   }
 
   @Override
-  public Object asJavaObject() {
-    return agenticScope;
+  protected <T> Optional<T> convert(Class<T> clazz) {
+    return AgenticScope.class.isAssignableFrom(clazz)
+        ? Optional.of(clazz.cast(this.agenticScope))
+        : super.convert(clazz);
   }
 }

experimental/model/src/main/java/io/serverlessworkflow/impl/model/func/JavaModel.java

@@ -15,6 +15,7 @@
  */
 package io.serverlessworkflow.impl.model.func;
 
+import io.serverlessworkflow.impl.AbstractWorkflowModel;
 import io.serverlessworkflow.impl.WorkflowModel;
 import java.time.OffsetDateTime;
 import java.util.Collection;
@@ -24,7 +25,7 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 
-public class JavaModel implements WorkflowModel {
+public class JavaModel extends AbstractWorkflowModel {
 
   protected Object object;
 
@@ -65,7 +66,6 @@ public Optional<Number> asNumber() {
 
   @Override
   public Optional<Map<String, Object>> asMap() {
-
     return object instanceof Map ? Optional.of((Map<String, Object>) object) : Optional.empty();
   }
 
@@ -94,10 +94,7 @@ public Class<?> objectClass() {
   }
 
   @Override
-  public <T> Optional<T> as(Class<T> clazz) {
-    if (WorkflowModel.class.isAssignableFrom(clazz)) {
-      return Optional.of(clazz.cast(this));
-    }
+  protected <T> Optional<T> convert(Class<T> clazz) {
     return object != null && clazz.isAssignableFrom(object.getClass())
         ? Optional.of(clazz.cast(object))
         : Optional.empty();

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

@@ -0,0 +1,48 @@
+/*
+ * 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 java.time.OffsetDateTime;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+
+public abstract class AbstractWorkflowModel implements WorkflowModel {
+
+  protected abstract <T> Optional<T> convert(Class<T> clazz);
+
+  @Override
+  public <T> Optional<T> as(Class<T> clazz) {
+    if (WorkflowModel.class.isAssignableFrom(clazz)) {
+      return (Optional<T>) Optional.of(this);
+    } else if (String.class.isAssignableFrom(clazz)) {
+      return (Optional<T>) asText();
+    } else if (Boolean.class.isAssignableFrom(clazz)) {
+      return (Optional<T>) asBoolean();
+    } else if (OffsetDateTime.class.isAssignableFrom(clazz)) {
+      return (Optional<T>) asDate();
+    } else if (Number.class.isAssignableFrom(clazz)) {
+      return (Optional<T>) asNumber();
+    } else if (Collection.class.isAssignableFrom(clazz)) {
+      Collection<?> collection = asCollection();
+      return collection.isEmpty() ? Optional.empty() : (Optional<T>) Optional.of(collection);
+    } else if (Map.class.isAssignableFrom(clazz)) {
+      return (Optional<T>) asMap();
+    } else {
+      return convert(clazz);
+    }
+  }
+}

impl/model/pom.xml

@@ -16,5 +16,17 @@
         <groupId>io.serverlessworkflow</groupId>
         <artifactId>serverlessworkflow-impl-core</artifactId>
     </dependency>
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter-engine</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>org.assertj</groupId>
+        <artifactId>assertj-core</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>ch.qos.logback</groupId>
+        <artifactId>logback-classic</artifactId>
+    </dependency>
   </dependencies>
 </project>

impl/model/src/main/java/io/serverlessworkflow/impl/model/jackson/JacksonModel.java

@@ -21,6 +21,7 @@
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.BooleanNode;
 import com.fasterxml.jackson.databind.node.NullNode;
+import io.serverlessworkflow.impl.AbstractWorkflowModel;
 import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.jackson.JsonUtils;
 import java.time.OffsetDateTime;
@@ -31,7 +32,7 @@
 
 @JsonSerialize(using = JacksonModelSerializer.class)
 @JsonDeserialize(using = JacksonModelDeserializer.class)
-public class JacksonModel implements WorkflowModel {
+public class JacksonModel extends AbstractWorkflowModel {
 
   protected JsonNode node;
 
@@ -68,13 +69,6 @@ public Optional<Number> asNumber() {
     return node.isNumber() ? Optional.of(node.asLong()) : Optional.empty();
   }
 
-  @Override
-  public <T> Optional<T> as(Class<T> clazz) {
-    return clazz.isAssignableFrom(node.getClass())
-        ? Optional.of(clazz.cast(node))
-        : Optional.of(JsonUtils.convertValue(node, clazz));
-  }
-
   @Override
   public String toString() {
     return node.toPrettyString();
@@ -84,7 +78,7 @@ public String toString() {
   public Optional<Map<String, Object>> asMap() {
     // TODO use generic to avoid warning
     return node.isObject()
-        ? Optional.of(JsonUtils.convertValue(node, Map.class))
+        ? Optional.of(JsonUtils.mapper().convertValue(node, Map.class))
         : Optional.empty();
   }
 
@@ -97,4 +91,11 @@ public Object asJavaObject() {
   public Class<?> objectClass() {
     return node.getClass();
   }
+
+  @Override
+  protected <T> Optional<T> convert(Class<T> clazz) {
+    return clazz.isAssignableFrom(node.getClass())
+        ? Optional.of(clazz.cast(node))
+        : Optional.of(JsonUtils.mapper().convertValue(node, clazz));
+  }
 }

impl/model/src/test/java/io/serverlessworkflow/impl/model/jackson/JacksonModelTest.java

@@ -0,0 +1,95 @@
+/*
+ * 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.model.jackson;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.serverlessworkflow.impl.WorkflowModel;
+import io.serverlessworkflow.impl.WorkflowModelFactory;
+import io.serverlessworkflow.impl.jackson.JsonUtils;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class JacksonModelTest {
+
+  private static WorkflowModelFactory factory;
+
+  @BeforeAll
+  static void init() {
+    factory = new JacksonModelFactory();
+  }
+
+  @Test
+  void testObjectFromNode() {
+    testObjectNode(
+        factory.fromAny(
+            JsonUtils.mapper()
+                .createObjectNode()
+                .put("name", "Javierito")
+                .put("jobs", 3)
+                .put("male", true)));
+  }
+
+  @Test
+  void testObjectFromString() {
+    testObjectNode(factory.fromAny("{\"name\":\"Javierito\",\"jobs\":3,\"male\":true}"));
+  }
+
+  @Test
+  void testObjectFromMap() {
+    Map<String, Object> map = new LinkedHashMap<String, Object>();
+    map.put("name", "Javierito");
+    map.put("jobs", 3);
+    map.put("male", true);
+    testObjectNode(factory.fromAny(map));
+  }
+
+  private void testObjectNode(WorkflowModel model) {
+    assertThat(model.as(JsonNode.class).orElseThrow())
+        .isEqualTo(
+            JsonUtils.mapper()
+                .createObjectNode()
+                .put("name", "Javierito")
+                .put("jobs", 3)
+                .put("male", true));
+    assertThat(model.as(String.class).orElseThrow())
+        .isEqualTo("{\"name\":\"Javierito\",\"jobs\":3,\"male\":true}");
+    assertThat(model.as(String.class)).isEqualTo(model.asText());
+    assertThat(model.as(Map.class)).isEqualTo(model.asMap());
+    assertThat(model.as(Map.class).orElseThrow())
+        .isEqualTo(Map.of("name", "Javierito", "jobs", 3, "male", true));
+  }
+
+  @Test
+  void testCollection() {
+    WorkflowModel model =
+        factory.fromAny(
+            JsonUtils.mapper()
+                .createArrayNode()
+                .add(
+                    JsonUtils.mapper()
+                        .createObjectNode()
+                        .put("name", "Javierito")
+                        .put("jobs", 3)
+                        .put("male", true)));
+    testObjectNode(factory.fromAny(model.asCollection().iterator().next()));
+    testObjectNode(factory.fromAny(model.as(Collection.class).orElseThrow().iterator().next()));
+  }
+}