Light, fluffy, and always free - The AWS Local Emulator alternative
feat(stepfunctions): resolve payload-template .$ inside arrays and $$ context in intrinsic args (#1691)
Alex Banna54b378ed6cde
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 82d2c10b8a..0ba721a7aa 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@@ -1716,9 +1716,12 @@ public class AslExecutor {} else if ("$$".equals(path)) {resolved.set(realKey, context);} else {- resolved.set(realKey, resolvePath(path, input));+ // Pass the Context Object through so a $$. reference nested inside an+ // intrinsic (e.g. States.Format(..., $$.Map.Item.Value.x)) can resolve it;+ // for a plain $. or States.* input reference, context is simply ignored.+ resolved.set(realKey, resolvePath(path, input, context));}- } else if (val.isObject()) {+ } else if (val.isObject() || val.isArray()) {resolved.set(key, resolveParameters(val, input, context));} else {resolved.set(key, val);@@ -1726,27 +1729,53 @@ public class AslExecutor {}return resolved;}+ if (parameters.isArray()) {+ // Payload templates resolve .$ references at any depth, including inside arrays+ // (e.g. an ECS Overrides.ContainerOverrides[].Environment[].Value.$).+ ArrayNode resolvedArray = objectMapper.createArrayNode();+ for (JsonNode element : parameters) {+ resolvedArray.add(resolveParameters(element, input, context));+ }+ return resolvedArray;+ }return parameters;}JsonNode resolvePath(String path, JsonNode root) {- JsonNode node = resolvePathNode(path, root);- // Most callers do not distinguish an absent path from an explicit null; collapse both to null.+ return resolvePath(path, root, null);+ }++ /**+ * Resolve a JSONPath reference or {@code States.*} intrinsic. When {@code context} is+ * non-null it is the Context Object ({@code $$}), letting intrinsic arguments reference it+ * (e.g. a {@code $$.Map.Item.Value.x} argument nested inside {@code States.Format(...)}).+ * It is null for ordinary input-only resolution, which preserves existing behavior.+ *+ * <p>Most callers do not distinguish an absent path from an explicit null, so both collapse+ * to null; callers that care about presence (e.g. {@code IsPresent}) use {@link #resolvePathNode}.+ */+ JsonNode resolvePath(String path, JsonNode root, JsonNode context) {+ JsonNode node = resolvePathNode(path, root, context);return node.isMissingNode() ? NullNode.getInstance() : node;}+ JsonNode resolvePathNode(String path, JsonNode root) {+ return resolvePathNode(path, root, null);+ }+/*** Resolves a reference path while preserving the distinction between an explicit null value* (returns a {@link NullNode}) and a missing/absent path (returns a {@link MissingNode}).* {@link #resolvePath} collapses both to null; only callers that care about presence- * (e.g. {@code IsPresent}) should use this variant.+ * (e.g. {@code IsPresent}) should use this variant. When {@code context} is non-null it is the+ * Context Object ({@code $$}) available to {@code States.*} intrinsic arguments.*/- JsonNode resolvePathNode(String path, JsonNode root) {+ JsonNode resolvePathNode(String path, JsonNode root, JsonNode context) {if (path == null || "$".equals(path)) {return root;}if (path.startsWith("States.")) {- return evaluateIntrinsic(path, root);+ return evaluateIntrinsic(path, root, context);}// Support dotted ($.a.b) and root-bracket ($[*], $[0]) forms; anything else is unsupported.if (!path.startsWith("$.") && !path.startsWith("$[")) {@@ -1842,7 +1871,7 @@ public class AslExecutor {* States.Array, States.ArrayLength, States.ArrayContains, States.MathAdd, States.UUID.* Throws FailStateException("States.Runtime") for unrecognized functions.*/- private JsonNode evaluateIntrinsic(String expr, JsonNode root) {+ private JsonNode evaluateIntrinsic(String expr, JsonNode root, JsonNode context) {int parenOpen = expr.indexOf('(');int parenClose = expr.lastIndexOf(')');if (parenOpen < 0 || parenClose < 0) {@@ -1853,7 +1882,7 @@ public class AslExecutor {return switch (fnName) {case "States.StringToJson" -> {- JsonNode arg = resolveIntrinsicArg(argsStr, root);+ JsonNode arg = resolveIntrinsicArg(argsStr, root, context);try {yield objectMapper.readTree(arg.asText());} catch (Exception e) {@@ -1862,7 +1891,7 @@ public class AslExecutor {}}case "States.JsonToString" -> {- JsonNode arg = resolveIntrinsicArg(argsStr, root);+ JsonNode arg = resolveIntrinsicArg(argsStr, root, context);try {yield objectMapper.getNodeFactory().textNode(objectMapper.writeValueAsString(arg));} catch (Exception e) {@@ -1882,7 +1911,7 @@ public class AslExecutor {if (argIdx >= parts.size()) {throw new FailStateException("States.Runtime", "States.Format: not enough arguments");}- JsonNode argVal = resolveIntrinsicArg(parts.get(argIdx++).trim(), root);+ JsonNode argVal = resolveIntrinsicArg(parts.get(argIdx++).trim(), root, context);sb.append(argVal.isTextual() ? argVal.asText() : argVal.toString());i++; // skip '}'} else {@@ -1895,12 +1924,12 @@ public class AslExecutor {List<String> parts = splitIntrinsicArgs(argsStr);ArrayNode arr = objectMapper.createArrayNode();for (String part : parts) {- arr.add(resolveIntrinsicArg(part.trim(), root));+ arr.add(resolveIntrinsicArg(part.trim(), root, context));}yield arr;}case "States.ArrayLength" -> {- JsonNode arg = resolveIntrinsicArg(argsStr, root);+ JsonNode arg = resolveIntrinsicArg(argsStr, root, context);if (!arg.isArray()) {throw new FailStateException("States.Runtime", "States.ArrayLength requires an array");}@@ -1911,8 +1940,8 @@ public class AslExecutor {if (parts.size() != 2) {throw new FailStateException("States.Runtime", "States.MathAdd requires exactly 2 arguments");}- JsonNode a = resolveIntrinsicArg(parts.get(0).trim(), root);- JsonNode b = resolveIntrinsicArg(parts.get(1).trim(), root);+ JsonNode a = resolveIntrinsicArg(parts.get(0).trim(), root, context);+ JsonNode b = resolveIntrinsicArg(parts.get(1).trim(), root, context);yield objectMapper.getNodeFactory().numberNode(a.asLong() + b.asLong());}case "States.ArrayContains" -> {@@ -1921,8 +1950,8 @@ public class AslExecutor {throw new FailStateException("States.Runtime","States.ArrayContains requires exactly 2 arguments");}- JsonNode array = resolveIntrinsicArg(parts.get(0).trim(), root);- JsonNode value = resolveIntrinsicArg(parts.get(1).trim(), root);+ JsonNode array = resolveIntrinsicArg(parts.get(0).trim(), root, context);+ JsonNode value = resolveIntrinsicArg(parts.get(1).trim(), root, context);if (!array.isArray()) {// AWS throws rather than silently returning false, matching States.ArrayLength.throw new FailStateException("States.Runtime",@@ -1949,10 +1978,23 @@ public class AslExecutor {* Resolve a single intrinsic argument: either a $.path reference, a quoted string literal,* or a numeric literal.*/- private JsonNode resolveIntrinsicArg(String arg, JsonNode root) {+ private JsonNode resolveIntrinsicArg(String arg, JsonNode root, JsonNode context) {arg = arg.trim();+ // A $$.-prefixed argument references the Context Object; resolve it against context+ // (as a $. path) so intrinsics can read e.g. $$.Map.Item.Value.x or $$.Execution.Id.+ // When context is null these fall through to the bare-path branch and a $$. arg formats+ // as the literal string "null". This is Floci-internal transitional behavior, not AWS+ // semantics: on real AWS the Context Object always exists. Every payload-template call+ // site already threads context; this fallback (and the noContext_* test pinning it) only+ // exists until context is also threaded into the remaining resolvePath callers.+ if (context != null && arg.startsWith("$$.")) {+ return resolvePath("$." + arg.substring(3), context);+ }+ if (context != null && "$$".equals(arg)) {+ return context;+ }if (arg.startsWith("$.") || "$".equals(arg)) {- return resolvePath(arg, root);+ return resolvePath(arg, root, context);}if (arg.startsWith("'") && arg.endsWith("'")) {return objectMapper.getNodeFactory().textNode(arg.substring(1, arg.length() - 1));@@ -1966,8 +2008,8 @@ public class AslExecutor {try {return objectMapper.getNodeFactory().numberNode(Double.parseDouble(arg));} catch (NumberFormatException e2) {- // fall through: treat as bare path- return resolvePath(arg, root);+ // fall through: treat as bare path (may itself be a nested States.* intrinsic)+ return resolvePath(arg, root, context);}}}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorArrayParamsTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorArrayParamsTest.javanew file mode 100644index 0000000000..ab5f2d940f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorArrayParamsTest.java@@ -0,0 +1,56 @@+package io.github.hectorvent.floci.services.stepfunctions;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * A Parameters / ItemSelector payload template must resolve {@code .$} references at ANY nesting+ * depth, including inside arrays — e.g. the {@code Environment} array of an ECS+ * {@code Overrides.ContainerOverrides[]}. Without array recursion those {@code Value.$} entries pass+ * through verbatim and the launched container receives empty environment variables.+ */+class AslExecutorArrayParamsTest {++ private final ObjectMapper mapper = new ObjectMapper();++ private AslExecutor newExecutor() {+ return new AslExecutor(null, null, null, null, null, null, null, null,+ null, null, mapper, null, null);+ }++ @Test+ void resolvesDotDollarReferencesInsideArrays() throws Exception {+ JsonNode parameters = mapper.readTree("""+ {+ "Overrides": {+ "ContainerOverrides": [+ {+ "Name": "runner",+ "Environment": [+ {"Name": "ACTION_TYPE", "Value.$": "$.solution.operation"},+ {"Name": "PROVISION_TYPE", "Value.$": "$.solution.primaryProvisionType"},+ {"Name": "STATIC", "Value": "CREATE_UPDATE"}+ ]+ }+ ]+ }+ }+ """);+ JsonNode input = mapper.readTree("""+ { "solution": { "operation": "create", "primaryProvisionType": "awscdk" } }+ """);++ JsonNode resolved = newExecutor().resolveParameters(parameters, input, mapper.createObjectNode());++ JsonNode env = resolved.path("Overrides").path("ContainerOverrides").path(0).path("Environment");+ assertEquals("create", env.path(0).path("Value").asText());+ assertEquals("awscdk", env.path(1).path("Value").asText());+ assertEquals("CREATE_UPDATE", env.path(2).path("Value").asText());+ // The unresolved ".$" key must be gone.+ assertTrue(env.path(0).path("Value.$").isMissingNode(), "Value.$ should have been resolved away");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicContextTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicContextTest.javanew file mode 100644index 0000000000..d1579fb8da--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorIntrinsicContextTest.java@@ -0,0 +1,107 @@+package io.github.hectorvent.floci.services.stepfunctions;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * Unit tests for Context Object ($$) resolution inside JSONPath-mode intrinsic functions.+ *+ * <p>A whole-value {@code "x.$": "$$.Map.Item.Value"} Parameters field already resolved against+ * the Context Object, but a {@code $$.} reference nested inside an intrinsic argument — e.g.+ * {@code States.Format('.../{}', $$.Map.Item.Value.solutionId)} — used to fall through to an+ * input-only lookup and resolve to null, because the context was never threaded from+ * {@code resolveParameters} into {@code evaluateIntrinsic}/{@code resolveIntrinsicArg}. These+ * tests pin the fix and guard the no-context (input-only) path against regression.+ */+class AslExecutorIntrinsicContextTest {++ private final ObjectMapper mapper = new ObjectMapper();++ /** Only ObjectMapper is exercised by the path/intrinsic resolution methods under test. */+ private AslExecutor newExecutor() {+ return new AslExecutor(null, null, null, null, null, null, null, null,+ null, null, mapper, null, null);+ }++ @Test+ void statesFormat_resolvesContextArgInsideParameters() throws Exception {+ AslExecutor executor = newExecutor();+ // Shaped like a Map ItemSelector: $. args come from the Map state's effective input,+ // $$.Map.Item.Value.* comes from the per-iteration Context Object.+ JsonNode parameters = mapper.readTree("""+ {+ "provisionerFolder.$": "States.Format('/mnt/efs/{}/{}/{}/provisioner', $.systemId, $.systemConfigVersion, $$.Map.Item.Value.solutionId)"+ }+ """);+ JsonNode input = mapper.readTree("""+ { "systemId": "SYS1", "systemConfigVersion": "v3" }+ """);+ JsonNode context = mapper.readTree("""+ { "Map": { "Item": { "Index": 0, "Value": { "solutionId": "SOLUTION_A" } } } }+ """);++ JsonNode resolved = executor.resolveParameters(parameters, input, context);++ assertEquals("/mnt/efs/SYS1/v3/SOLUTION_A/provisioner",+ resolved.path("provisionerFolder").asText());+ }++ @Test+ void statesFormat_resolvesContextArgViaResolvePath() {+ AslExecutor executor = newExecutor();+ JsonNode input = mapper.createObjectNode();+ JsonNode context = mapper.createObjectNode();+ ((com.fasterxml.jackson.databind.node.ObjectNode) context).putObject("Map")+ .putObject("Item").putObject("Value").put("solutionId", "SOLUTION_B");++ JsonNode result = executor.resolvePath(+ "States.Format('id={}', $$.Map.Item.Value.solutionId)", input, context);++ assertEquals("id=SOLUTION_B", result.asText());+ }++ @Test+ void wholeContext_resolvesInsideIntrinsic() {+ AslExecutor executor = newExecutor();+ JsonNode input = mapper.createObjectNode();+ JsonNode context = mapper.createObjectNode();+ ((com.fasterxml.jackson.databind.node.ObjectNode) context).put("token", "abc");++ // States.JsonToString($$) serializes the whole Context Object.+ JsonNode result = executor.resolvePath("States.JsonToString($$)", input, context);++ assertEquals("{\"token\":\"abc\"}", result.asText());+ }++ @Test+ void inputArgsStillResolveWithContextPresent() {+ AslExecutor executor = newExecutor();+ JsonNode input = mapper.createObjectNode();+ ((com.fasterxml.jackson.databind.node.ObjectNode) input).put("a", "X").put("b", "Y");+ JsonNode context = mapper.createObjectNode();++ JsonNode result = executor.resolvePath("States.Format('{}-{}', $.a, $.b)", input, context);++ assertEquals("X-Y", result.asText());+ }++ @Test+ void noContext_intrinsicResolutionUnchanged() {+ AslExecutor executor = newExecutor();+ JsonNode input = mapper.createObjectNode();+ ((com.fasterxml.jackson.databind.node.ObjectNode) input).put("name", "widget");++ // The 2-arg form (context == null) must behave exactly as before: $. args resolve,+ // and a stray $$. arg — which has no context to resolve against — yields "null".+ // The "null" here pins Floci-internal transitional behavior, NOT AWS semantics (on real+ // AWS the Context Object always exists); see resolveIntrinsicArg. It only holds until+ // context is threaded into the remaining resolvePath callers, at which point this+ // assertion should be updated rather than treated as a contract.+ assertEquals("widget", executor.resolvePath("States.Format('{}', $.name)", input).asText());+ assertEquals("null", executor.resolvePath(+ "States.Format('{}', $$.Map.Item.Value.solutionId)", input).asText());+ }+}