Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): merge SAM Globals into resource properties (#1427)
Vishal Goyal5aee7b631234
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.javaindex 99f2d3a2f5..9a5dbc13f7 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java@@ -50,6 +50,12 @@ class SamTransformProcessor {ObjectNode expanded = template.deepCopy();expanded.remove("Transform");+ // Globals is a SAM-only top-level section: capture it for merging into resources, then strip+ // it from the emitted CloudFormation template up front so it is removed on every return path+ // (including the early return below when Resources is absent or not an object).+ JsonNode globals = expanded.path("Globals");+ expanded.remove("Globals");+JsonNode resources = expanded.path("Resources");if (!resources.isObject()) {return expanded;@@ -74,11 +80,11 @@ class SamTransformProcessor {switch (type) {case "AWS::Serverless::Function" ->- expandServerlessFunction(logicalId, properties, expandedResources);+ expandServerlessFunction(logicalId, mergeGlobals(globals, "Function", properties), expandedResources);case "AWS::Serverless::SimpleTable" ->- expandServerlessSimpleTable(logicalId, properties, expandedResources);+ expandServerlessSimpleTable(logicalId, mergeGlobals(globals, "SimpleTable", properties), expandedResources);case "AWS::Serverless::Api" ->- expandServerlessApi(logicalId, properties, expandedResources);+ expandServerlessApi(logicalId, mergeGlobals(globals, "Api", properties), expandedResources);default -> LOG.debugv("Unsupported SAM resource type: {0} ({1})", type, logicalId);}}@@ -300,6 +306,46 @@ class SamTransformProcessor {return id;}+ /**+ * Merges the matching {@code Globals.<section>} block into a resource's own {@code Properties},+ * with the resource's own values taking precedence (per the SAM Globals specification). Returns+ * {@code properties} unchanged when there is no matching globals block.+ *+ * <p>Nested objects (e.g. {@code Environment.Variables}, {@code Tags}) are merged key-wise, so a+ * resource only overrides the individual keys it sets and global entries are preserved — matching+ * SAM's map-merge behavior. Scalar and array-valued properties (e.g. {@code Policies},+ * {@code Layers}) are overridden wholesale; SAM's additive list-append for those is not implemented.+ */+ private JsonNode mergeGlobals(JsonNode globals, String section, JsonNode properties) {+ JsonNode sectionGlobals = globals.path(section);+ if (!sectionGlobals.isObject()) {+ return properties;+ }+ if (!properties.isObject()) {+ return sectionGlobals.deepCopy();+ }+ return deepMerge((ObjectNode) sectionGlobals.deepCopy(), (ObjectNode) properties);+ }++ /**+ * Recursively merges {@code override} into {@code base}: when both sides hold an object for the+ * same key, the objects are merged key-wise; otherwise the override value replaces the base value.+ * {@code base} is mutated and returned.+ */+ private ObjectNode deepMerge(ObjectNode base, ObjectNode override) {+ override.fields().forEachRemaining(entry -> {+ String key = entry.getKey();+ JsonNode overrideValue = entry.getValue();+ JsonNode baseValue = base.get(key);+ if (baseValue != null && baseValue.isObject() && overrideValue.isObject()) {+ base.set(key, deepMerge((ObjectNode) baseValue, (ObjectNode) overrideValue));+ } else {+ base.set(key, overrideValue.deepCopy());+ }+ });+ return base;+ }+private void expandServerlessFunction(String logicalId, JsonNode properties, ObjectNode resources) {resources.remove(logicalId);diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.javaindex eaa081cf50..3371ffa9eb 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java@@ -525,4 +525,121 @@ class SamTransformProcessorTest {}assertEquals(0, methods, "a route with a non-literal Path must not be registered");}++ @Test+ void expandSamTemplate_appliesGlobalsFunctionToFunction() throws Exception {+ // Handler/Runtime defined only in Globals.Function (common SAM pattern, e.g. Go provided.al2023)+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {+ "Function": {+ "Handler": "bootstrap",+ "Runtime": "provided.al2023"+ }+ },+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "InlineCode": "bootstrap"+ }+ }+ }+ }+ """);++ JsonNode expanded = processor.expandSamTemplate(template);++ // Globals is a SAM-only section and must be stripped from the emitted CFN template+ assertTrue(expanded.path("Globals").isMissingNode());++ JsonNode lambdaProps = expanded.path("Resources").path("MyFunc").path("Properties");+ assertEquals("AWS::Lambda::Function",+ expanded.path("Resources").path("MyFunc").path("Type").asText());+ // Handler/Runtime from Globals must be propagated onto the generated function+ assertEquals("bootstrap", lambdaProps.path("Handler").asText());+ assertEquals("provided.al2023", lambdaProps.path("Runtime").asText());+ }++ @Test+ void expandSamTemplate_functionPropertiesOverrideGlobals() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {+ "Function": {+ "Handler": "bootstrap",+ "Runtime": "provided.al2023",+ "Timeout": 3+ }+ },+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Runtime": "nodejs20.x",+ "Handler": "index.handler",+ "InlineCode": "exports.handler = async () => ({});"+ }+ }+ }+ }+ """);++ JsonNode lambdaProps = processor.expandSamTemplate(template)+ .path("Resources").path("MyFunc").path("Properties");++ // Function-level values win; Globals-only values still apply+ assertEquals("index.handler", lambdaProps.path("Handler").asText());+ assertEquals("nodejs20.x", lambdaProps.path("Runtime").asText());+ assertEquals(3, lambdaProps.path("Timeout").asInt());+ }++ @Test+ void expandSamTemplate_mergesNestedMapsFromGlobals() throws Exception {+ // Environment.Variables must merge key-wise: globals-only keys preserved, function keys win on clash+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {+ "Function": {+ "Handler": "bootstrap",+ "Runtime": "provided.al2023",+ "Environment": { "Variables": { "GLOBAL_VAR": "g", "SHARED": "from-globals" } }+ }+ },+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "InlineCode": "bootstrap",+ "Environment": { "Variables": { "LOCAL_VAR": "l", "SHARED": "from-function" } }+ }+ }+ }+ }+ """);++ JsonNode vars = processor.expandSamTemplate(template)+ .path("Resources").path("MyFunc").path("Properties")+ .path("Environment").path("Variables");++ assertEquals("g", vars.path("GLOBAL_VAR").asText()); // globals-only key preserved+ assertEquals("l", vars.path("LOCAL_VAR").asText()); // function-only key added+ assertEquals("from-function", vars.path("SHARED").asText()); // clash resolved in favor of function+ }++ @Test+ void expandSamTemplate_stripsGlobalsWhenResourcesAbsent() throws Exception {+ // SAM-only Globals must be stripped even on the early return (no/!object Resources)+ JsonNode template = objectMapper.readTree("""+ {"Transform": "AWS::Serverless-2016-10-31", "Globals": {"Function": {"Runtime": "provided.al2023"}}}+ """);++ JsonNode expanded = processor.expandSamTemplate(template);++ assertTrue(expanded.path("Transform").isMissingNode());+ assertTrue(expanded.path("Globals").isMissingNode());+ }}