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.xmlindex 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.javaindex 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 {@Injectpublic 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 soonerif (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.javanew file mode 100644index 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.javaindex 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.javaindex 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");@Injectpublic 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.javaindex 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.javanew file mode 100644index 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.javanew file mode 100644index 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.javanew file mode 100644index 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")+ + "\"";+ }+}