Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat: add JSONata query language support for Step Functions (#84)

thegagnef82b370ab2e3
diff --git a/pom.xml b/pom.xml
index c7289355a1..abc258d1cb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -95,6 +95,13 @@
<version>1.83</version>
</dependency>
+ <!-- JSONata expression engine (Step Functions) -->
+ <dependency>
+ <groupId>com.dashjoin</groupId>
+ <artifactId>jsonata</artifactId>
+ <version>0.9.9</version>
+ </dependency>
+
<!-- Testing -->
<dependency>
<groupId>io.quarkus</groupId>
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
index c739afc3e3..f780790058 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
@@ -34,9 +34,12 @@ public class AslExecutor {
private static final Logger LOG = Logger.getLogger(AslExecutor.class);
private static final int MAX_WAIT_SECONDS = 30;
+ private static final String QUERY_LANGUAGE_JSONATA = "JSONata";
+
private final LambdaExecutorService lambdaExecutor;
private final LambdaFunctionStore functionStore;
private final ObjectMapper objectMapper;
+ private final JsonataEvaluator jsonataEvaluator;
private final ExecutorService executor = Executors.newCachedThreadPool(r -> {
Thread t = new Thread(r, "sfn-executor");
t.setDaemon(true);
@@ -45,10 +48,11 @@ public class AslExecutor {
@Inject
public AslExecutor(LambdaExecutorService lambdaExecutor, LambdaFunctionStore functionStore,
- ObjectMapper objectMapper) {
+ ObjectMapper objectMapper, JsonataEvaluator jsonataEvaluator) {
this.lambdaExecutor = lambdaExecutor;
this.functionStore = functionStore;
this.objectMapper = objectMapper;
+ this.jsonataEvaluator = jsonataEvaluator;
}
/**
@@ -62,7 +66,9 @@ public class AslExecutor {
JsonNode definition = objectMapper.readTree(sm.getDefinition());
JsonNode states = definition.path("States");
String startAt = definition.path("StartAt").asText();
+ String topLevelQueryLanguage = definition.path("QueryLanguage").asText("JSONPath");
JsonNode currentInput = parseInput(exec.getInput());
+ JsonNode execContext = buildContext(exec, sm);
String currentStateName = startAt;
while (currentStateName != null) {
@@ -75,8 +81,13 @@ public class AslExecutor {
addEvent(history, eventId, stateEnteredEventType(type), null,
Map.of("name", currentStateName, "input", currentInput.toString()));
+ // Update per-state context fields
+ updateStateContext(execContext, currentStateName);
+
try {
- StateResult stateResult = executeState(currentStateName, type, stateDef, currentInput, history, eventId, sm);
+ boolean jsonata = isJsonata(stateDef, topLevelQueryLanguage);
+ StateResult stateResult = executeState(currentStateName, type, stateDef, currentInput,
+ history, eventId, sm, jsonata, topLevelQueryLanguage, execContext);
addEvent(history, eventId, stateExitedEventType(type), eventId.get() - 1,
Map.of("name", currentStateName, "output", stateResult.output().toString()));
@@ -89,16 +100,23 @@ public class AslExecutor {
} catch (FailStateException e) {
exec.setStatus("FAILED");
exec.setStopDate(System.currentTimeMillis() / 1000L);
+ String failError = e.error != null ? e.error : "States.Runtime";
+ String failCause = e.cause != null ? e.cause : "";
+ exec.setError(failError);
+ exec.setCause(failCause);
addEvent(history, eventId, "ExecutionFailed", null,
- Map.of("error", e.error != null ? e.error : "States.Runtime",
- "cause", e.cause != null ? e.cause : ""));
+ Map.of("error", failError, "cause", failCause));
onUpdate.accept(exec, history);
return;
} catch (Exception e) {
exec.setStatus("FAILED");
exec.setStopDate(System.currentTimeMillis() / 1000L);
+ String runtimeError = "States.Runtime";
+ String runtimeCause = e.getMessage() != null ? e.getMessage() : "Unknown error";
+ exec.setError(runtimeError);
+ exec.setCause(runtimeCause);
addEvent(history, eventId, "ExecutionFailed", null,
- Map.of("error", "States.Runtime", "cause", e.getMessage() != null ? e.getMessage() : "Unknown error"));
+ Map.of("error", runtimeError, "cause", runtimeCause));
onUpdate.accept(exec, history);
return;
}
@@ -121,22 +139,28 @@ public class AslExecutor {
}
private StateResult executeState(String name, String type, JsonNode stateDef, JsonNode input,
- List<HistoryEvent> history, AtomicLong eventId, StateMachine sm) throws Exception {
+ List<HistoryEvent> history, AtomicLong eventId, StateMachine sm,
+ boolean jsonata, String topLevelQueryLanguage, JsonNode context) throws Exception {
return switch (type) {
- case "Pass" -> executePassState(stateDef, input);
- case "Task" -> executeTaskState(name, stateDef, input, history, eventId, sm);
- case "Choice" -> executeChoiceState(stateDef, input);
- case "Wait" -> executeWaitState(stateDef, input);
- case "Succeed" -> new StateResult(applyOutputPath(stateDef, input, input), null);
- case "Fail" -> throw new FailStateException(
- stateDef.path("Error").asText(null), stateDef.path("Cause").asText(null));
- case "Parallel" -> executeParallelState(name, stateDef, input, sm);
- case "Map" -> executeMapState(name, stateDef, input, sm);
+ case "Pass" -> executePassState(stateDef, input, jsonata, context);
+ case "Task" -> executeTaskState(name, stateDef, input, history, eventId, sm, jsonata, context);
+ case "Choice" -> executeChoiceState(stateDef, input, jsonata, context);
+ case "Wait" -> executeWaitState(stateDef, input, jsonata, context);
+ case "Succeed" -> executeSucceedState(stateDef, input, jsonata, context);
+ case "Fail" -> executeFail(stateDef, input, jsonata, context);
+ case "Parallel" -> executeParallelState(name, stateDef, input, sm, jsonata, topLevelQueryLanguage, context);
+ case "Map" -> executeMapState(name, stateDef, input, sm, jsonata, topLevelQueryLanguage, context);
default -> new StateResult(input, stateDef.path("Next").asText(null));
};
}
- private StateResult executePassState(JsonNode stateDef, JsonNode input) throws Exception {
+ private StateResult executePassState(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context) throws Exception {
+ if (jsonata) {
+ JsonNode result = stateDef.has("Result") ? stateDef.get("Result") : input;
+ JsonNode output = applyJsonataOutput(stateDef, input, result, context);
+ return new StateResult(output, stateDef.path("Next").asText(null));
+ }
+
JsonNode effectiveInput = applyInputPath(stateDef, input);
JsonNode result;
@@ -152,7 +176,22 @@ public class AslExecutor {
}
private StateResult executeTaskState(String stateName, JsonNode stateDef, JsonNode input,
- List<HistoryEvent> history, AtomicLong eventId, StateMachine sm) throws Exception {
+ List<HistoryEvent> history, AtomicLong eventId, StateMachine sm,
+ boolean jsonata, JsonNode context) throws Exception {
+ if (jsonata) {
+ JsonNode effectiveInput = input;
+ if (stateDef.has("Arguments")) {
+ JsonNode statesVar = buildStatesVar(input, null, context);
+ effectiveInput = jsonataEvaluator.resolveTemplate(stateDef.get("Arguments"), statesVar);
+ }
+
+ String resource = stateDef.path("Resource").asText();
+ JsonNode taskResult = invokeResource(resource, effectiveInput, stateDef, sm);
+ JsonNode output = applyJsonataOutput(stateDef, input, taskResult, context);
+
+ return new StateResult(output, stateDef.path("Next").asText(null));
+ }
+
JsonNode effectiveInput = applyInputPath(stateDef, input);
if (stateDef.has("Parameters")) {
effectiveInput = resolveParameters(stateDef.get("Parameters"), effectiveInput);
@@ -222,7 +261,26 @@ public class AslExecutor {
return input;
}
- private StateResult executeChoiceState(JsonNode stateDef, JsonNode input) throws Exception {
+ private StateResult executeChoiceState(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context) throws Exception {
+ if (jsonata) {
+ JsonNode statesVar = buildStatesVar(input, null, context);
+ JsonNode choices = stateDef.path("Choices");
+ for (JsonNode choice : choices) {
+ String condition = choice.path("Condition").asText(null);
+ if (condition != null) {
+ JsonNode result = jsonataEvaluator.evaluate(condition, statesVar);
+ if (result.isBoolean() && result.asBoolean()) {
+ return new StateResult(input, choice.path("Next").asText());
+ }
+ }
+ }
+ String defaultState = stateDef.path("Default").asText(null);
+ if (defaultState != null) {
+ return new StateResult(input, defaultState);
+ }
+ throw new FailStateException("States.NoChoiceMatched", "No choice rule matched and no default state");
+ }
+
JsonNode choices = stateDef.path("Choices");
for (JsonNode choice : choices) {
if (evaluateCondition(choice, input)) {
@@ -318,13 +376,26 @@ public class AslExecutor {
return false;
}
- private StateResult executeWaitState(JsonNode stateDef, JsonNode input) throws InterruptedException {
+ private StateResult executeWaitState(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context) throws InterruptedException {
int seconds = 0;
- if (stateDef.has("Seconds")) {
- seconds = Math.min(stateDef.get("Seconds").asInt(), MAX_WAIT_SECONDS);
- } else if (stateDef.has("SecondsPath")) {
- JsonNode val = resolvePath(stateDef.get("SecondsPath").asText(), input);
- seconds = Math.min(val.asInt(), MAX_WAIT_SECONDS);
+ if (jsonata) {
+ if (stateDef.has("Seconds")) {
+ JsonNode secondsNode = stateDef.get("Seconds");
+ if (secondsNode.isTextual() && JsonataEvaluator.isExpression(secondsNode.asText())) {
+ JsonNode statesVar = buildStatesVar(input, null, context);
+ JsonNode result = jsonataEvaluator.evaluate(secondsNode.asText(), statesVar);
+ seconds = Math.min(result.asInt(), MAX_WAIT_SECONDS);
+ } else {
+ seconds = Math.min(secondsNode.asInt(), MAX_WAIT_SECONDS);
+ }
+ }
+ } else {
+ if (stateDef.has("Seconds")) {
+ seconds = Math.min(stateDef.get("Seconds").asInt(), MAX_WAIT_SECONDS);
+ } else if (stateDef.has("SecondsPath")) {
+ JsonNode val = resolvePath(stateDef.get("SecondsPath").asText(), input);
+ seconds = Math.min(val.asInt(), MAX_WAIT_SECONDS);
+ }
}
// Timestamp and TimestampPath: wait until that time or now, whichever is sooner
if (seconds > 0) {
@@ -333,7 +404,31 @@ public class AslExecutor {
return new StateResult(input, stateDef.path("Next").asText(null));
}
- private StateResult executeParallelState(String name, JsonNode stateDef, JsonNode input, StateMachine sm) throws Exception {
+ private StateResult executeSucceedState(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context) {
+ if (jsonata) {
+ JsonNode output = applyJsonataOutput(stateDef, input, input, context);
+ return new StateResult(output, null);
+ }
+ return new StateResult(applyOutputPath(stateDef, input, input), null);
+ }
+
+ private StateResult executeFail(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context) {
+ String error = stateDef.path("Error").asText(null);
+ String cause = stateDef.path("Cause").asText(null);
+ if (jsonata) {
+ JsonNode statesVar = buildStatesVar(input, null, context);
+ if (error != null && JsonataEvaluator.isExpression(error)) {
+ error = jsonataEvaluator.evaluate(error, statesVar).asText();
+ }
+ if (cause != null && JsonataEvaluator.isExpression(cause)) {
+ cause = jsonataEvaluator.evaluate(cause, statesVar).asText();
+ }
+ }
+ throw new FailStateException(error, cause);
+ }
+
+ private StateResult executeParallelState(String name, JsonNode stateDef, JsonNode input, StateMachine sm,
+ boolean jsonata, String topLevelQueryLanguage, JsonNode context) throws Exception {
JsonNode branches = stateDef.path("Branches");
List<Future<JsonNode>> futures = new ArrayList<>();
@@ -342,7 +437,7 @@ public class AslExecutor {
JsonNode branchStates = branch.path("States");
JsonNode capturedInput = input;
- futures.add(executor.submit(() -> executeBranch(startAt, branchStates, capturedInput, sm)));
+ futures.add(executor.submit(() -> executeBranch(startAt, branchStates, capturedInput, sm, topLevelQueryLanguage, context)));
}
ArrayNode results = objectMapper.createArrayNode();
@@ -350,26 +445,49 @@ public class AslExecutor {
results.add(future.get(60, TimeUnit.SECONDS));
}
+ if (jsonata) {
+ JsonNode output = applyJsonataOutput(stateDef, input, results, context);
+ return new StateResult(output, stateDef.path("Next").asText(null));
+ }
+
JsonNode output = mergeResult(stateDef, input, results);
output = applyOutputPath(stateDef, input, output);
return new StateResult(output, stateDef.path("Next").asText(null));
}
- private StateResult executeMapState(String name, JsonNode stateDef, JsonNode input, StateMachine sm) throws Exception {
- JsonNode itemsPath = stateDef.path("ItemsPath");
- JsonNode items = itemsPath.isMissingNode() ? input : resolvePath(itemsPath.asText("$"), input);
+ private StateResult executeMapState(String name, JsonNode stateDef, JsonNode input, StateMachine sm,
+ boolean jsonata, String topLevelQueryLanguage, JsonNode context) throws Exception {
+ JsonNode items;
+ if (jsonata && stateDef.has("Items")) {
+ JsonNode itemsNode = stateDef.get("Items");
+ if (itemsNode.isTextual() && JsonataEvaluator.isExpression(itemsNode.asText())) {
+ JsonNode statesVar = buildStatesVar(input, null, context);
+ items = jsonataEvaluator.evaluate(itemsNode.asText(), statesVar);
+ } else {
+ items = itemsNode;
+ }
+ } else {
+ JsonNode itemsPath = stateDef.path("ItemsPath");
+ items = itemsPath.isMissingNode() ? input : resolvePath(itemsPath.asText("$"), input);
+ }
if (!items.isArray()) {
- throw new FailStateException("States.Runtime", "ItemsPath must reference an array");
+ throw new FailStateException("States.Runtime", "Items must reference an array");
}
- JsonNode iterator = stateDef.path("Iterator");
+ // Support both Iterator (legacy) and ItemProcessor (current AWS naming)
+ JsonNode iterator = stateDef.has("ItemProcessor") ? stateDef.get("ItemProcessor") : stateDef.path("Iterator");
String startAt = iterator.path("StartAt").asText();
JsonNode iteratorStates = iterator.path("States");
ArrayNode results = objectMapper.createArrayNode();
for (JsonNode item : items) {
- results.add(executeBranch(startAt, iteratorStates, item, sm));
+ results.add(executeBranch(startAt, iteratorStates, item, sm, topLevelQueryLanguage, context));
+ }
+
+ if (jsonata) {
+ JsonNode output = applyJsonataOutput(stateDef, input, results, context);
+ return new StateResult(output, stateDef.path("Next").asText(null));
}
JsonNode output = mergeResult(stateDef, input, results);
@@ -377,7 +495,8 @@ public class AslExecutor {
return new StateResult(output, stateDef.path("Next").asText(null));
}
- private JsonNode executeBranch(String startAt, JsonNode states, JsonNode input, StateMachine sm) throws Exception {
+ private JsonNode executeBranch(String startAt, JsonNode states, JsonNode input, StateMachine sm,
+ String topLevelQueryLanguage, JsonNode context) throws Exception {
List<HistoryEvent> ignored = new ArrayList<>();
AtomicLong eventId = new AtomicLong(0);
JsonNode currentInput = input;
@@ -389,7 +508,9 @@ public class AslExecutor {
throw new RuntimeException("State not found: " + currentState);
}
String type = stateDef.path("Type").asText();
- StateResult result = executeState(currentState, type, stateDef, currentInput, ignored, eventId, sm);
+ boolean stateJsonata = isJsonata(stateDef, topLevelQueryLanguage);
+ StateResult result = executeState(currentState, type, stateDef, currentInput, ignored, eventId, sm,
+ stateJsonata, topLevelQueryLanguage, context);
currentInput = result.output();
currentState = result.nextState();
if ("Succeed".equals(type) || stateDef.path("End").asBoolean(false)) {
@@ -399,6 +520,72 @@ public class AslExecutor {
return currentInput;
}
+ // ──────────────────────────── JSONata helpers ────────────────────────────
+
+ private boolean isJsonata(JsonNode stateDef, String topLevelQueryLanguage) {
+ String stateQL = stateDef.path("QueryLanguage").asText(null);
+ return QUERY_LANGUAGE_JSONATA.equals(stateQL != null ? stateQL : topLevelQueryLanguage);
+ }
+
+ private JsonNode buildStatesVar(JsonNode input, JsonNode result) {
+ return buildStatesVar(input, result, null);
+ }
+
+ private JsonNode buildStatesVar(JsonNode input, JsonNode result, JsonNode context) {
+ ObjectNode states = objectMapper.createObjectNode();
+ states.set("input", input);
+ if (result != null) {
+ states.set("result", result);
+ }
+ if (context != null) {
+ states.set("context", context);
+ }
+ return states;
+ }
+
+ /**
+ * Build the $states.context object for an execution.
+ * Contains Execution metadata (Id, Input, Name, RoleArn, StartTime).
+ */
+ private JsonNode buildContext(Execution exec, StateMachine sm) {
+ ObjectNode context = objectMapper.createObjectNode();
+ ObjectNode execution = objectMapper.createObjectNode();
+ execution.put("Id", exec.getExecutionArn());
+ execution.put("Name", exec.getName());
+ execution.put("RoleArn", sm.getRoleArn());
+ execution.put("StartTime", java.time.Instant.ofEpochSecond(exec.getStartDate()).toString());
+ if (exec.getInput() != null) {
+ execution.set("Input", parseInput(exec.getInput()));
+ }
+ context.set("Execution", execution);
+ ObjectNode stateMachine = objectMapper.createObjectNode();
+ stateMachine.put("Id", sm.getStateMachineArn());
+ stateMachine.put("Name", sm.getName());
+ context.set("StateMachine", stateMachine);
+ return context;
+ }
+
+ private void updateStateContext(JsonNode execContext, String stateName) {
+ ObjectNode context = (ObjectNode) execContext;
+ ObjectNode state = objectMapper.createObjectNode();
+ state.put("Name", stateName);
+ state.put("EnteredTime", java.time.Instant.now().toString());
+ state.put("RetryCount", 0);
+ context.set("State", state);
+ }
+
+ /**
+ * Apply JSONata Output field. If Output is present, resolve it as a template with $states bound.
+ * If absent, use the result directly (or input if result is null).
+ */
+ private JsonNode applyJsonataOutput(JsonNode stateDef, JsonNode input, JsonNode result, JsonNode context) {
+ if (!stateDef.has("Output")) {
+ return result != null ? result : input;
+ }
+ JsonNode statesVar = buildStatesVar(input, result, context);
+ return jsonataEvaluator.resolveTemplate(stateDef.get("Output"), statesVar);
+ }
+
// ──────────────────────────── Path resolution ────────────────────────────
private JsonNode applyInputPath(JsonNode stateDef, JsonNode input) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java
new file mode 100644
index 0000000000..9041325392
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java
@@ -0,0 +1,118 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import com.dashjoin.jsonata.Jsonata;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.NullNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import static com.dashjoin.jsonata.Jsonata.jsonata;
+
+/**
+ * Evaluates JSONata expressions for Step Functions.
+ * Handles {% expression %} delimiters, $states variable binding,
+ * and recursive template resolution for Arguments/Output fields.
+ *
+ * Only pure expressions are evaluated: "{% $states.input.name %}" → any type.
+ * Strings that are not a single {% %} expression pass through unchanged
+ * (AWS does not support string interpolation with multiple {% %} blocks).
+ */
+@ApplicationScoped
+public class JsonataEvaluator {
+
+ private final ObjectMapper objectMapper;
+
+ @Inject
+ public JsonataEvaluator(ObjectMapper objectMapper) {
+ this.objectMapper = objectMapper;
+ }
+
+ /**
+ * Check if the string is a JSONata expression (starts with {% and ends with %}).
+ */
+ static boolean isExpression(String value) {
+ return value != null && value.startsWith("{%") && value.endsWith("%}");
+ }
+
+ /**
+ * Strip {% %} delimiters and return the inner expression, trimmed.
+ */
+ static String unwrap(String value) {
+ return value.substring(2, value.length() - 2).trim();
+ }
+
+ /**
+ * Evaluate a single JSONata expression string with $states bound.
+ * The expression may or may not have {% %} delimiters.
+ */
+ JsonNode evaluate(String expression, JsonNode statesVar) {
+ String expr = isExpression(expression) ? unwrap(expression) : expression;
+ try {
+ Jsonata jsonataExpr = jsonata(expr);
+ Jsonata.Frame frame = jsonataExpr.createFrame();
+ frame.bind("states", toObject(statesVar));
+ Object result = jsonataExpr.evaluate(null, frame);
+ return toJsonNode(result);
+ } catch (Exception e) {
+ throw new AslExecutor.FailStateException("States.QueryEvaluationError", e.getMessage());
+ }
+ }
+
+ /**
+ * Walk a JSON template (Arguments or Output), evaluating any {% %} strings found.
+ * Non-expression values pass through unchanged.
+ *
+ * Only pure {% expression %} strings are evaluated (can return any JSON type).
+ * All other strings pass through unchanged.
+ */
+ JsonNode resolveTemplate(JsonNode template, JsonNode statesVar) {
+ if (template == null || template.isNull() || template.isMissingNode()) {
+ return template;
+ }
+ if (template.isTextual()) {
+ String text = template.asText();
+ if (isExpression(text)) {
+ return evaluate(text, statesVar);
+ }
+ return template;
+ }
+ if (template.isObject()) {
+ ObjectNode resolved = objectMapper.createObjectNode();
+ Iterator<Map.Entry<String, JsonNode>> fields = template.fields();
+ while (fields.hasNext()) {
+ Map.Entry<String, JsonNode> entry = fields.next();
+ resolved.set(entry.getKey(), resolveTemplate(entry.getValue(), statesVar));
+ }
+ return resolved;
+ }
+ if (template.isArray()) {
+ ArrayNode resolved = objectMapper.createArrayNode();
+ for (JsonNode element : template) {
+ resolved.add(resolveTemplate(element, statesVar));
+ }
+ return resolved;
+ }
+ // Primitives (number, boolean) pass through
+ return template;
+ }
+
+ private Object toObject(JsonNode node) {
+ if (node == null || node.isNull() || node.isMissingNode()) {
+ return null;
+ }
+ return objectMapper.convertValue(node, Object.class);
+ }
+
+ private JsonNode toJsonNode(Object value) {
+ if (value == null) {
+ return NullNode.getInstance();
+ }
+ return objectMapper.valueToTree(value);
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
index cef548b1f8..f10201e4ae 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
@@ -116,6 +116,8 @@ public class StepFunctionsJsonHandler {
if (exec.getStopDate() != null) response.put("stopDate", exec.getStopDate());
if (exec.getInput() != null) response.put("input", exec.getInput());
if (exec.getOutput() != null) response.put("output", exec.getOutput());
+ if (exec.getError() != null) response.put("error", exec.getError());
+ if (exec.getCause() != null) response.put("cause", exec.getCause());
return Response.ok(response).build();
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
index f320a048cf..be7dca1f42 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
@@ -5,6 +5,8 @@ import io.github.hectorvent.floci.core.common.RegionResolver;
import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.core.storage.StorageFactory;
import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
import io.github.hectorvent.floci.services.stepfunctions.model.Execution;
import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;
import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;
@@ -25,16 +27,21 @@ public class StepFunctionsService {
private final Map<String, List<HistoryEvent>> historyCache = new ConcurrentHashMap<>();
private final RegionResolver regionResolver;
private final AslExecutor aslExecutor;
+ private final ObjectMapper objectMapper;
+
+ private static final Set<String> JSONPATH_ONLY_FIELDS = Set.of(
+ "InputPath", "OutputPath", "ResultPath", "ResultSelector", "Parameters", "Result", "ItemsPath");
@Inject
public StepFunctionsService(StorageFactory storageFactory, RegionResolver regionResolver,
- AslExecutor aslExecutor) {
+ AslExecutor aslExecutor, ObjectMapper objectMapper) {
this.stateMachineStore = storageFactory.create("stepfunctions", "sfn-state-machines.json",
new TypeReference<Map<String, StateMachine>>() {});
this.executionStore = storageFactory.create("stepfunctions", "sfn-executions.json",
new TypeReference<Map<String, Execution>>() {});
this.regionResolver = regionResolver;
this.aslExecutor = aslExecutor;
+ this.objectMapper = objectMapper;
}
// ──────────────────────────── State Machines ────────────────────────────
@@ -45,6 +52,8 @@ public class StepFunctionsService {
throw new AwsException("StateMachineAlreadyExists", "State machine already exists: " + arn, 400);
}
+ validateDefinition(definition);
+
StateMachine sm = new StateMachine();
sm.setStateMachineArn(arn);
sm.setName(name);
@@ -161,4 +170,54 @@ public class StepFunctionsService {
public void sendTaskHeartbeat(String taskToken) {
LOG.debugv("Task heartbeat for token {0}", taskToken);
}
+
+ // ──────────────────────────── Validation ────────────────────────────
+
+ private void validateDefinition(String definition) {
+ JsonNode def;
+ try {
+ def = objectMapper.readTree(definition);
+ } catch (Exception e) {
+ throw new AwsException("InvalidDefinition",
+ "Invalid State Machine Definition: '" + e.getMessage() + "'", 400);
+ }
+
+ String topLevelQL = def.path("QueryLanguage").asText("JSONPath");
+ boolean topLevelJsonata = "JSONata".equals(topLevelQL);
+ JsonNode states = def.path("States");
+
+ if (states.isObject()) {
+ var fields = states.fields();
+ List<String> errors = new ArrayList<>();
+ while (fields.hasNext()) {
+ var entry = fields.next();
+ validateState(entry.getKey(), entry.getValue(), topLevelJsonata, errors);
+ }
+ if (!errors.isEmpty()) {
+ throw new AwsException("InvalidDefinition",
+ "Invalid State Machine Definition: 'SCHEMA_VALIDATION_FAILED: "
+ + String.join(", ", errors) + "'", 400);
+ }
+ }
+ }
+
+ private void validateState(String stateName, JsonNode stateDef, boolean topLevelJsonata, List<String> errors) {
+ String stateQL = stateDef.path("QueryLanguage").asText(null);
+ boolean stateIsJsonata = stateQL != null ? "JSONata".equals(stateQL) : topLevelJsonata;
+
+ // Cannot override to JSONPath when top-level is JSONata
+ if (topLevelJsonata && "JSONPath".equals(stateQL)) {
+ errors.add("'QueryLanguage' can not be 'JSONPath' if set to 'JSONata' for whole state machine at /States/" + stateName);
+ }
+
+ // JSONPath-only fields are not allowed when the state uses JSONata
+ if (stateIsJsonata) {
+ for (String field : JSONPATH_ONLY_FIELDS) {
+ if (stateDef.has(field)) {
+ errors.add("The QueryLanguage is set to 'JSONata', but field '" + field
+ + "' is only supported for the 'JSONPath' QueryLanguage at /States/" + stateName);
+ }
+ }
+ }
+ }
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java
index 425e94553d..067d40b0b2 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java
@@ -14,6 +14,8 @@ public class Execution {
private String output;
private long startDate;
private Long stopDate;
+ private String error;
+ private String cause;
public Execution() {
this.startDate = System.currentTimeMillis() / 1000L;
@@ -42,4 +44,10 @@ public class Execution {
public Long getStopDate() { return stopDate; }
public void setStopDate(Long stopDate) { this.stopDate = stopDate; }
+
+ public String getError() { return error; }
+ public void setError(String error) { this.error = error; }
+
+ public String getCause() { return cause; }
+ public void setCause(String cause) { this.cause = cause; }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEdgeCaseTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEdgeCaseTest.java
new file mode 100644
index 0000000000..8860983535
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEdgeCaseTest.java
@@ -0,0 +1,146 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static com.dashjoin.jsonata.Jsonata.jsonata;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Edge-case tests exercising the dashjoin jsonata-java library directly
+ * (bypassing the project's JsonataEvaluator wrapper).
+ */
+class JsonataEdgeCaseTest {
+
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ // ---------------------------------------------------------------
+ // 1. Object-constructor expression: {"name": $states.input.name}
+ // ---------------------------------------------------------------
+ @Test
+ void objectConstructor_returnsMap() throws Exception {
+ var input = Map.of("input", Map.of("name", "Alice", "age", 30));
+
+ var expr = jsonata("{\"name\": $states.input.name, \"age\": $states.input.age}");
+ var frame = expr.createFrame();
+ frame.bind("states", input);
+
+ Object result = expr.evaluate(null, frame);
+
+
+ assertNotNull(result, "Expected a non-null result from object constructor");
+ assertInstanceOf(Map.class, result, "Object constructor should yield a Map");
+
+ @SuppressWarnings("unchecked")
+ Map<String, Object> map = (Map<String, Object>) result;
+ assertEquals("Alice", map.get("name"));
+ assertEquals(30, ((Number) map.get("age")).intValue());
+ }
+
+ // ---------------------------------------------------------------
+ // 2. Missing field: does it return null, throw, or something else?
+ // ---------------------------------------------------------------
+ @Test
+ void missingField_returnsNullNotThrows() throws Exception {
+ var input = Map.of("input", Map.of("name", "Alice"));
+
+ var expr = jsonata("$states.input.nonexistent");
+ var frame = expr.createFrame();
+ frame.bind("states", input);
+
+ Object result = expr.evaluate(null, frame);
+
+ // System.out.println("[Test 2] missing field result class: " + (result == null ? "null (Java null)" : result.getClass().getName()));
+ // System.out.println("[Test 2] missing field result value: " + result);
+
+ // Key question: is it Java null?
+ assertNull(result, "Accessing a missing field should return Java null");
+ }
+
+ @Test
+ void missingVariable_returnsNull() throws Exception {
+ // No binding at all for $states
+ var expr = jsonata("$states.input.name");
+ var frame = expr.createFrame();
+
+ Object result = expr.evaluate(null, frame);
+
+ // System.out.println("[Test 2b] unbound variable result class: " + (result == null ? "null (Java null)" : result.getClass().getName()));
+ // System.out.println("[Test 2b] unbound variable result value: " + result);
+
+ assertNull(result, "Accessing an unbound variable should return Java null");
+ }
+
+ // ---------------------------------------------------------------
+ // 3. Nested object binding with deep path access
+ // ---------------------------------------------------------------
+ @Test
+ void deepNestedAccess_works() throws Exception {
+ // Build a deeply nested structure
+ Map<String, Object> nested = new LinkedHashMap<>();
+ nested.put("input", Map.of(
+ "user", Map.of(
+ "address", Map.of(
+ "city", "Springfield",
+ "zip", "62704"
+ ),
+ "tags", java.util.List.of("admin", "active")
+ )
+ ));
+
+ // Deep path access
+ var expr1 = jsonata("$states.input.user.address.city");
+ var frame1 = expr1.createFrame();
+ frame1.bind("states", nested);
+ Object city = expr1.evaluate(null, frame1);
+
+ // System.out.println("[Test 3a] deep path city: " + city);
+ assertEquals("Springfield", city);
+
+ // Access into an array element
+ var expr2 = jsonata("$states.input.user.tags[0]");
+ var frame2 = expr2.createFrame();
+ frame2.bind("states", nested);
+ Object firstTag = expr2.evaluate(null, frame2);
+
+ // System.out.println("[Test 3b] deep path tags[0]: " + firstTag);
+ assertEquals("admin", firstTag);
+
+ // Construct an object from deep paths
+ var expr3 = jsonata("{\"city\": $states.input.user.address.city, \"firstTag\": $states.input.user.tags[0]}");
+ var frame3 = expr3.createFrame();
+ frame3.bind("states", nested);
+ Object combined = expr3.evaluate(null, frame3);
+
+ // System.out.println("[Test 3c] combined object: " + combined);
+ assertInstanceOf(Map.class, combined);
+ @SuppressWarnings("unchecked")
+ Map<String, Object> combinedMap = (Map<String, Object>) combined;
+ assertEquals("Springfield", combinedMap.get("city"));
+ assertEquals("admin", combinedMap.get("firstTag"));
+ }
+
+ // ---------------------------------------------------------------
+ // Bonus: what does convertValue look like round-tripping?
+ // ---------------------------------------------------------------
+ @Test
+ void convertValue_jacksonToMapRoundTrip() throws Exception {
+ var jsonNode = mapper.readTree("""
+ {"input": {"name": "Bob", "scores": [10, 20, 30]}}
+ """);
+
+ @SuppressWarnings("unchecked")
+ Map<String, Object> asMap = mapper.convertValue(jsonNode, Map.class);
+
+ var expr = jsonata("$sum($states.input.scores)");
+ var frame = expr.createFrame();
+ frame.bind("states", asMap);
+ Object result = expr.evaluate(null, frame);
+
+ // System.out.println("[Test 4] sum of scores: " + result);
+ assertEquals(60, ((Number) result).intValue());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.java
new file mode 100644
index 0000000000..2305c8ee47
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.java
@@ -0,0 +1,176 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.NullNode;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class JsonataEvaluatorTest {
+
+ private JsonataEvaluator evaluator;
+ private ObjectMapper objectMapper;
+
+ @BeforeEach
+ void setUp() {
+ objectMapper = new ObjectMapper();
+ evaluator = new JsonataEvaluator(objectMapper);
+ }
+
+ @Test
+ void isExpression_valid() {
+ assertTrue(JsonataEvaluator.isExpression("{% $states.input.x %}"));
+ assertTrue(JsonataEvaluator.isExpression("{%$states.input%}"));
+ assertTrue(JsonataEvaluator.isExpression("{% $states.input %}"));
+ }
+
+ @Test
+ void isExpression_invalid() {
+ assertFalse(JsonataEvaluator.isExpression(null));
+ assertFalse(JsonataEvaluator.isExpression("hello"));
+ assertFalse(JsonataEvaluator.isExpression("{% incomplete"));
+ assertFalse(JsonataEvaluator.isExpression("incomplete %}"));
+ // Not a pure expression — AWS does not support string interpolation
+ assertFalse(JsonataEvaluator.isExpression("Hello {% name %} welcome"));
+ }
+
+ @Test
+ void unwrap_stripsDelimitersAndTrims() {
+ assertEquals("$states.input.x", JsonataEvaluator.unwrap("{% $states.input.x %}"));
+ assertEquals("1 + 2", JsonataEvaluator.unwrap("{%1 + 2%}"));
+ }
+
+ @Test
+ void evaluate_simpleArithmetic() {
+ JsonNode statesVar = objectMapper.createObjectNode();
+ JsonNode result = evaluator.evaluate("{% 1 + 2 %}", statesVar);
+ assertEquals(3, result.asInt());
+ }
+
+ @Test
+ void evaluate_stringConcatenation() {
+ JsonNode statesVar = objectMapper.createObjectNode();
+ JsonNode result = evaluator.evaluate("{% 'hello' & ' ' & 'world' %}", statesVar);
+ assertEquals("hello world", result.asText());
+ }
+
+ @Test
+ void evaluate_statesInputAccess() throws Exception {
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"name": "Alice", "age": 30}}
+ """);
+ JsonNode result = evaluator.evaluate("{% $states.input.name %}", statesVar);
+ assertEquals("Alice", result.asText());
+ }
+
+ @Test
+ void evaluate_statesResultAccess() throws Exception {
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"x": 1}, "result": {"value": 42}}
+ """);
+ JsonNode result = evaluator.evaluate("{% $states.result.value %}", statesVar);
+ assertEquals(42, result.asInt());
+ }
+
+ @Test
+ void evaluate_booleanExpression() throws Exception {
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"score": 85}}
+ """);
+ JsonNode result = evaluator.evaluate("{% $states.input.score > 50 %}", statesVar);
+ assertTrue(result.asBoolean());
+ }
+
+ @Test
+ void evaluate_returnsNullForMissingField() throws Exception {
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"name": "Alice"}}
+ """);
+ JsonNode result = evaluator.evaluate("{% $states.input.missing %}", statesVar);
+ assertTrue(result.isNull());
+ }
+
+ @Test
+ void resolveTemplate_nonExpressionStringPassesThrough() throws Exception {
+ JsonNode template = objectMapper.readTree("\"plain text\"");
+ JsonNode statesVar = objectMapper.createObjectNode();
+ JsonNode result = evaluator.resolveTemplate(template, statesVar);
+ assertEquals("plain text", result.asText());
+ }
+
+ @Test
+ void resolveTemplate_evaluatesExpressionInString() throws Exception {
+ JsonNode template = objectMapper.readTree("\"{% 1 + 1 %}\"");
+ JsonNode statesVar = objectMapper.createObjectNode();
+ JsonNode result = evaluator.resolveTemplate(template, statesVar);
+ assertEquals(2, result.asInt());
+ }
+
+ @Test
+ void resolveTemplate_walksObjectAndEvaluatesExpressions() throws Exception {
+ JsonNode template = objectMapper.readTree("""
+ {
+ "greeting": "{% 'Hello ' & $states.input.name %}",
+ "static": "unchanged",
+ "count": 42
+ }
+ """);
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"name": "Bob"}}
+ """);
+ JsonNode result = evaluator.resolveTemplate(template, statesVar);
+ assertTrue(result.isObject());
+ assertEquals("Hello Bob", result.get("greeting").asText());
+ assertEquals("unchanged", result.get("static").asText());
+ assertEquals(42, result.get("count").asInt());
+ }
+
+ @Test
+ void resolveTemplate_walksArrayAndEvaluatesExpressions() throws Exception {
+ JsonNode template = objectMapper.readTree("""
+ ["{% $states.input.a %}", "static", "{% $states.input.b %}"]
+ """);
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"a": 1, "b": 2}}
+ """);
+ JsonNode result = evaluator.resolveTemplate(template, statesVar);
+ assertTrue(result.isArray());
+ assertEquals(1, result.get(0).asInt());
+ assertEquals("static", result.get(1).asText());
+ assertEquals(2, result.get(2).asInt());
+ }
+
+ @Test
+ void resolveTemplate_nonPureExpressionPassesThrough() throws Exception {
+ // AWS does not support string interpolation — non-pure expressions pass through as-is
+ JsonNode template = objectMapper.readTree("\"Hello {% $states.input.name %}, you are {% $states.input.age %} years old\"");
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"name": "Alice", "age": 30}}
+ """);
+ JsonNode result = evaluator.resolveTemplate(template, statesVar);
+ assertTrue(result.isTextual());
+ assertEquals("Hello {% $states.input.name %}, you are {% $states.input.age %} years old", result.asText());
+ }
+
+ @Test
+ void resolveTemplate_pureExpressionReturnsObject() throws Exception {
+ JsonNode template = objectMapper.readTree("\"{% $states.input %}\"");
+ JsonNode statesVar = objectMapper.readTree("""
+ {"input": {"name": "Alice", "age": 30}}
+ """);
+ JsonNode result = evaluator.resolveTemplate(template, statesVar);
+ assertTrue(result.isObject());
+ assertEquals("Alice", result.get("name").asText());
+ }
+
+ @Test
+ void resolveTemplate_primitivesPassThrough() throws Exception {
+ JsonNode statesVar = objectMapper.createObjectNode();
+
+ assertEquals(42, evaluator.resolveTemplate(objectMapper.readTree("42"), statesVar).asInt());
+ assertTrue(evaluator.resolveTemplate(objectMapper.readTree("true"), statesVar).asBoolean());
+ assertTrue(evaluator.resolveTemplate(NullNode.getInstance(), statesVar).isNull());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java
new file mode 100644
index 0000000000..86cb1305b9
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java
@@ -0,0 +1,301 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.RestAssured;
+import io.restassured.config.EncoderConfig;
+import io.restassured.http.ContentType;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+@QuarkusTest
+class StepFunctionsJsonataIntegrationTest {
+
+ private static final String SFN_CONTENT_TYPE = "application/x-amz-json-1.0";
+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/test-role";
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssured.config = RestAssured.config().encoderConfig(
+ EncoderConfig.encoderConfig()
+ .encodeContentTypeAs(SFN_CONTENT_TYPE, ContentType.TEXT));
+ }
+
+ @Test
+ void passStateWithJsonataOutput() throws Exception {
+ // A Pass state that transforms input using JSONata Output field
+ String definition = """
+ {
+ "QueryLanguage": "JSONata",
+ "StartAt": "Transform",
+ "States": {
+ "Transform": {
+ "Type": "Pass",
+ "Output": {
+ "greeting": "{% 'Hello ' & $states.input.name %}",
+ "doubled": "{% $states.input.value * 2 %}"
+ },
+ "End": true
+ }
+ }
+ }
+ """;
+
+ String smArn = createStateMachine("jsonata-pass-test", definition);
+ String execArn = startExecution(smArn, "{\"name\": \"World\", \"value\": 21}");
+ String output = waitForExecution(execArn);
+
+ assertTrue(output.contains("Hello World"));
+ assertTrue(output.contains("42"));
+ }
+
+ @Test
+ void choiceStateWithJsonataCondition() throws Exception {
+ // Choice state using JSONata Condition instead of Variable/StringEquals
+ String definition = """
+ {
+ "QueryLanguage": "JSONata",
+ "StartAt": "CheckType",
+ "States": {
+ "CheckType": {
+ "Type": "Choice",
+ "Choices": [
+ {
+ "Condition": "{% $states.input.type = 'premium' %}",
+ "Next": "PremiumPath"
+ },
+ {
+ "Condition": "{% $states.input.type = 'basic' %}",
+ "Next": "BasicPath"
+ }
+ ],
+ "Default": "DefaultPath"
+ },
+ "PremiumPath": {
+ "Type": "Pass",
+ "Output": {"result": "premium"},
+ "End": true
+ },
+ "BasicPath": {
+ "Type": "Pass",
+ "Output": {"result": "basic"},
+ "End": true
+ },
+ "DefaultPath": {
+ "Type": "Pass",
+ "Output": {"result": "default"},
+ "End": true
+ }
+ }
+ }
+ """;
+
+ String smArn = createStateMachine("jsonata-choice-test", definition);
+
+ // Test premium path
+ String execArn = startExecution(smArn, "{\"type\": \"premium\"}");
+ String output = waitForExecution(execArn);
+ assertTrue(output.contains("premium"));
+
+ // Test basic path
+ execArn = startExecution(smArn, "{\"type\": \"basic\"}");
+ output = waitForExecution(execArn);
+ assertTrue(output.contains("basic"));
+
+ // Test default path
+ execArn = startExecution(smArn, "{\"type\": \"unknown\"}");
+ output = waitForExecution(execArn);
+ assertTrue(output.contains("default"));
+ }
+
+ @Test
+ void mapStateWithJsonataItems() throws Exception {
+ // Map state using JSONata Items field instead of ItemsPath
+ String definition = """
+ {
+ "QueryLanguage": "JSONata",
+ "StartAt": "MapItems",
+ "States": {
+ "MapItems": {
+ "Type": "Map",
+ "Items": "{% $states.input.numbers %}",
+ "ItemProcessor": {
+ "StartAt": "Double",
+ "States": {
+ "Double": {
+ "Type": "Pass",
+ "End": true
+ }
+ }
+ },
+ "End": true
+ }
+ }
+ }
+ """;
+
+ String smArn = createStateMachine("jsonata-map-test", definition);
+ String execArn = startExecution(smArn, "{\"numbers\": [1, 2, 3]}");
+ String output = waitForExecution(execArn);
+ // Map passes each item through, result is array [1, 2, 3]
+ assertTrue(output.contains("[1,2,3]"));
+ }
+
+ @Test
+ void statesInputVariableAccess() throws Exception {
+ // Verify $states.input gives access to the state's input
+ String definition = """
+ {
+ "QueryLanguage": "JSONata",
+ "StartAt": "Extract",
+ "States": {
+ "Extract": {
+ "Type": "Pass",
+ "Output": {
+ "firstName": "{% $states.input.user.first %}",
+ "lastName": "{% $states.input.user.last %}",
+ "fullName": "{% $states.input.user.first & ' ' & $states.input.user.last %}"
+ },
+ "End": true
+ }
+ }
+ }
+ """;
+
+ String smArn = createStateMachine("jsonata-states-input-test", definition);
+ String execArn = startExecution(smArn, "{\"user\": {\"first\": \"Jane\", \"last\": \"Doe\"}}");
+ String output = waitForExecution(execArn);
+ assertTrue(output.contains("Jane"));
+ assertTrue(output.contains("Doe"));
+ assertTrue(output.contains("Jane Doe"));
+ }
+
+ @Test
+ void mixedModeDefaultJsonPathWithPerStateJsonata() throws Exception {
+ // Default JSONPath (no top-level QueryLanguage) with one state overriding to JSONata
+ String definition = """
+ {
+ "StartAt": "JsonPathState",
+ "States": {
+ "JsonPathState": {
+ "Type": "Pass",
+ "Next": "JsonataState"
+ },
+ "JsonataState": {
+ "Type": "Pass",
+ "QueryLanguage": "JSONata",
+ "Output": {
+ "value": "{% $states.input.x + $states.input.y %}"
+ },
+ "End": true
+ }
+ }
+ }
+ """;
+
+ String smArn = createStateMachine("jsonata-mixed-test", definition);
+ String execArn = startExecution(smArn, "{\"x\": 10, \"y\": 20}");
+ String output = waitForExecution(execArn);
+ assertTrue(output.contains("30"));
+ }
+
+ @Test
+ void backwardCompatibility_jsonPathStillWorks() throws Exception {
+ // No QueryLanguage field — default JSONPath behavior must work
+ String definition = """
+ {
+ "StartAt": "PassThrough",
+ "States": {
+ "PassThrough": {
+ "Type": "Pass",
+ "InputPath": "$.data",
+ "ResultPath": "$.result",
+ "End": true
+ }
+ }
+ }
+ """;
+
+ String smArn = createStateMachine("jsonpath-compat-test", definition);
+ String execArn = startExecution(smArn, "{\"data\": {\"key\": \"value\"}}");
+ String output = waitForExecution(execArn);
+ assertTrue(output.contains("key"));
+ assertTrue(output.contains("value"));
+ }
+
+ // ──────────────── Helpers ────────────────
+
+ private String createStateMachine(String name, String definition) {
+ Response resp = given()
+ .header("X-Amz-Target", "AWSStepFunctions.CreateStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body(String.format("""
+ {
+ "name": "%s",
+ "definition": %s,
+ "roleArn": "%s"
+ }
+ """, name, quote(definition), ROLE_ARN))
+ .when()
+ .post("/");
+ resp.then().statusCode(200);
+ return resp.jsonPath().getString("stateMachineArn");
+ }
+
+ private String startExecution(String smArn, String input) {
+ Response resp = given()
+ .header("X-Amz-Target", "AWSStepFunctions.StartExecution")
+ .contentType(SFN_CONTENT_TYPE)
+ .body(String.format("""
+ {
+ "stateMachineArn": "%s",
+ "input": %s
+ }
+ """, smArn, quote(input)))
+ .when()
+ .post("/");
+ resp.then().statusCode(200);
+ return resp.jsonPath().getString("executionArn");
+ }
+
+ private String waitForExecution(String execArn) throws InterruptedException {
+ for (int i = 0; i < 50; i++) {
+ Response resp = given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeExecution")
+ .contentType(SFN_CONTENT_TYPE)
+ .body(String.format("""
+ { "executionArn": "%s" }
+ """, execArn))
+ .when()
+ .post("/");
+ String status = resp.jsonPath().getString("status");
+ if ("SUCCEEDED".equals(status)) {
+ return resp.jsonPath().getString("output");
+ }
+ if ("FAILED".equals(status) || "ABORTED".equals(status)) {
+ fail("Execution " + status + ": " + resp.body().asString());
+ }
+ Thread.sleep(100);
+ }
+ fail("Execution did not complete within timeout");
+ return null;
+ }
+
+ /**
+ * JSON-encode a string value (escape and wrap in quotes) for embedding
+ * inside a JSON body where the field expects a string.
+ */
+ private static String quote(String raw) {
+ return "\"" + raw
+ .replace("\\", "\\\\")
+ .replace("\"", "\\\"")
+ .replace("\n", "\\n")
+ .replace("\r", "\\r")
+ .replace("\t", "\\t")
+ + "\"";
+ }
+}