localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/cloudformation/engine/v2/change_set_model.py

@@ -14,6 +14,7 @@ from localstack.services.cloudformation.v2.types import (
     EngineParameter,
     engine_parameter_value,
 )
+from localstack.utils.json import extract_jsonpath
 from localstack.utils.strings import camel_to_snake_case
 
 T = TypeVar("T")
@@ -69,6 +70,9 @@ def parent_change_type_of(children: list[Maybe[ChangeSetEntity]]):
     change_types = [c.change_type for c in children if not is_nothing(c)]
     if not change_types:
         return ChangeType.UNCHANGED
+    # TODO: rework this logic. Currently if any values are different then we consider it
+    #  modified, but e.g. if everything is unchanged or created, the result should probably be
+    #  "created"
     first_type = change_types[0]
     if all(ct == first_type for ct in change_types):
         return first_type
@@ -106,6 +110,30 @@ class Scope(str):
     def unwrap(self) -> list[str]:
         return self.split(self._SEPARATOR)
 
+    @property
+    def parent(self) -> Scope:
+        return Scope(self._SEPARATOR.join(self.split(self._SEPARATOR)[:-1]))
+
+    @property
+    def jsonpath(self) -> str:
+        parts = self.split("/")
+        json_parts = []
+
+        for part in parts:
+            if not part:  # Skip empty strings from leading/trailing slashes
+                continue
+
+            if part == "divergence":
+                continue
+
+            # Wrap keys with special characters (e.g., colon) in quotes
+            if ":" in part:
+                json_parts.append(f'"{part}"')
+            else:
+                json_parts.append(part)
+
+        return f"$.{'.'.join(json_parts)}"
+
 
 class ChangeType(enum.Enum):
     UNCHANGED = "Unchanged"
@@ -127,7 +155,7 @@ class ChangeType(enum.Enum):
 
 class ChangeSetEntity(abc.ABC):
     scope: Final[Scope]
-    change_type: Final[ChangeType]
+    change_type: ChangeType
 
     def __init__(self, scope: Scope, change_type: ChangeType):
         self.scope = scope
@@ -343,11 +371,21 @@ class NodeTransform(ChangeSetNode):
 
 class NodeResources(ChangeSetNode):
     resources: Final[list[NodeResource]]
+    fn_transform: Final[Maybe[NodeIntrinsicFunctionFnTransform]]
+    fn_foreaches: Final[list[NodeForEach]]
 
-    def __init__(self, scope: Scope, resources: list[NodeResource]):
-        change_type = parent_change_type_of(resources)
+    def __init__(
+        self,
+        scope: Scope,
+        resources: list[NodeResource],
+        fn_transform: Maybe[NodeIntrinsicFunctionFnTransform],
+        fn_foreaches: list[NodeForEach],
+    ):
+        change_type = parent_change_type_of(resources + [fn_transform] + fn_foreaches)
         super().__init__(scope=scope, change_type=change_type)
         self.resources = resources
+        self.fn_transform = fn_transform
+        self.fn_foreaches = fn_foreaches
 
 
 class NodeResource(ChangeSetNode):
@@ -359,6 +397,7 @@ class NodeResource(ChangeSetNode):
     requires_replacement: Final[bool]
     deletion_policy: Final[Maybe[ChangeSetTerminal]]
     update_replace_policy: Final[Maybe[ChangeSetTerminal]]
+    fn_transform: Final[Maybe[NodeIntrinsicFunctionFnTransform]]
 
     def __init__(
         self,
@@ -372,6 +411,7 @@ class NodeResource(ChangeSetNode):
         requires_replacement: bool,
         deletion_policy: Maybe[ChangeSetTerminal],
         update_replace_policy: Maybe[ChangeSetTerminal],
+        fn_transform: Maybe[NodeIntrinsicFunctionFnTransform],
     ):
         super().__init__(scope=scope, change_type=change_type)
         self.name = name
@@ -382,15 +422,23 @@ class NodeResource(ChangeSetNode):
         self.requires_replacement = requires_replacement
         self.deletion_policy = deletion_policy
         self.update_replace_policy = update_replace_policy
+        self.fn_transform = fn_transform
 
 
 class NodeProperties(ChangeSetNode):
     properties: Final[list[NodeProperty]]
+    fn_transform: Final[Maybe[NodeIntrinsicFunctionFnTransform]]
 
-    def __init__(self, scope: Scope, properties: list[NodeProperty]):
+    def __init__(
+        self,
+        scope: Scope,
+        properties: list[NodeProperty],
+        fn_transform: Maybe[NodeIntrinsicFunctionFnTransform],
+    ):
         change_type = parent_change_type_of(properties)
         super().__init__(scope=scope, change_type=change_type)
         self.properties = properties
+        self.fn_transform = fn_transform
 
 
 class NodeDependsOn(ChangeSetNode):
@@ -427,6 +475,40 @@ class NodeIntrinsicFunction(ChangeSetNode):
         self.arguments = arguments
 
 
+class NodeIntrinsicFunctionFnTransform(NodeIntrinsicFunction):
+    def __init__(
+        self,
+        scope: Scope,
+        change_type: ChangeType,
+        intrinsic_function: str,
+        arguments: ChangeSetEntity,
+        before_siblings: list[Any],
+        after_siblings: list[Any],
+    ):
+        super().__init__(
+            scope=scope,
+            change_type=change_type,
+            intrinsic_function=intrinsic_function,
+            arguments=arguments,
+        )
+        self.before_siblings = before_siblings
+        self.after_siblings = after_siblings
+
+
+class NodeForEach(ChangeSetNode):
+    def __init__(
+        self,
+        scope: Scope,
+        change_type: Final[ChangeType],
+        arguments: Final[ChangeSetEntity],
+    ):
+        super().__init__(
+            scope=scope,
+            change_type=change_type,
+        )
+        self.arguments = arguments
+
+
 class NodeObject(ChangeSetNode):
     bindings: Final[dict[str, ChangeSetEntity]]
 
@@ -598,6 +680,7 @@ class ChangeSetModel:
         arguments = self._visit_value(
             scope=arguments_scope, before_value=before_arguments, after_value=after_arguments
         )
+
         if is_created(before=before_arguments, after=after_arguments):
             change_type = ChangeType.CREATED
         elif is_removed(before=before_arguments, after=after_arguments):
@@ -611,15 +694,47 @@ class ChangeSetModel:
                 change_type = resolve_function(arguments)
             else:
                 change_type = arguments.change_type
-        node_intrinsic_function = NodeIntrinsicFunction(
-            scope=scope,
-            change_type=change_type,
-            intrinsic_function=intrinsic_function,
-            arguments=arguments,
-        )
+
+        if intrinsic_function == FnTransform:
+            if scope.count(FnTransform) > 1:
+                raise RuntimeError(
+                    "Invalid: Fn::Transforms cannot be nested inside another Fn::Transform"
+                )
+
+            path = scope.parent.jsonpath
+            before_siblings = extract_jsonpath(self._before_template, path)
+            after_siblings = extract_jsonpath(self._after_template, path)
+
+            node_intrinsic_function = NodeIntrinsicFunctionFnTransform(
+                scope=scope,
+                change_type=change_type,
+                arguments=arguments,
+                intrinsic_function=intrinsic_function,
+                before_siblings=before_siblings,
+                after_siblings=after_siblings,
+            )
+        else:
+            node_intrinsic_function = NodeIntrinsicFunction(
+                scope=scope,
+                change_type=change_type,
+                intrinsic_function=intrinsic_function,
+                arguments=arguments,
+            )
         self._visited_scopes[scope] = node_intrinsic_function
         return node_intrinsic_function
 
+    def _visit_foreach(
+        self, scope: Scope, before_arguments: Maybe[list], after_arguments: Maybe[list]
+    ) -> NodeForEach:
+        node_foreach = self._visited_scopes.get(scope)
+        if isinstance(node_foreach, NodeForEach):
+            return node_foreach
+        arguments_scope = scope.open_scope("args")
+        arguments = self._visit_array(
+            arguments_scope, before_array=before_arguments, after_array=after_arguments
+        )
+        return NodeForEach(scope=scope, change_type=arguments.change_type, arguments=arguments)
+
     def _resolve_intrinsic_function_fn_sub(self, arguments: ChangeSetEntity) -> ChangeType:
         # TODO: This routine should instead export the implicit Ref and GetAtt calls within the first
         #       string template parameter and compute the respective change set types. Currently,
@@ -667,6 +782,9 @@ class ChangeSetModel:
 
         logical_id = arguments.value
 
+        if isinstance(logical_id, str) and logical_id.startswith("AWS::"):
+            return arguments.change_type
+
         node_condition = self._retrieve_condition_if_exists(condition_name=logical_id)
         if isinstance(node_condition, NodeCondition):
             return node_condition.change_type
@@ -745,6 +863,7 @@ class ChangeSetModel:
     ) -> bool:
         # a bit hacky but we have to load the resource provider executor _and_ resource provider to get the schema
         # Note: we don't log the attempt to load the resource provider, we need to make sure this is only done once and we already do this in the executor
+
         resource_provider = ResourceProviderExecutor.try_load_resource_provider(resource_type.value)
         if not resource_provider:
             # if we don't support a resource, assume an in-place update for simplicity
@@ -889,10 +1008,18 @@ class ChangeSetModel:
             return node_properties
         property_names: list[str] = self._safe_keys_of(before_properties, after_properties)
         properties: list[NodeProperty] = []
+        fn_transform = Nothing
+
         for property_name in property_names:
             property_scope, (before_property, after_property) = self._safe_access_in(
                 scope, property_name, before_properties, after_properties
             )
+            if property_name == FnTransform:
+                fn_transform = self._visit_intrinsic_function(
+                    property_scope, FnTransform, before_property, after_property
+                )
+                continue
+
             property_ = self._visit_property(
                 scope=property_scope,
                 property_name=property_name,
@@ -900,7 +1027,10 @@ class ChangeSetModel:
                 after_property=after_property,
             )
             properties.append(property_)
-        node_properties = NodeProperties(scope=scope, properties=properties)
+
+        node_properties = NodeProperties(
+            scope=scope, properties=properties, fn_transform=fn_transform
+        )
         self._visited_scopes[scope] = node_properties
         return node_properties
 
@@ -1000,10 +1130,44 @@ class ChangeSetModel:
                 after_update_replace_policy,
             )
 
+        fn_transform = Nothing
+        scope_fn_transform, (before_fn_transform_args, after_fn_transform_args) = (
+            self._safe_access_in(scope, FnTransform, before_resource, after_resource)
+        )
+        if not is_nothing(before_fn_transform_args) or not is_nothing(after_fn_transform_args):
+            if scope_fn_transform.count(FnTransform) > 1:
+                raise RuntimeError(
+                    "Invalid: Fn::Transforms cannot be nested inside another Fn::Transform"
+                )
+            path = "$" + ".".join(scope_fn_transform.split("/")[:-1])
+            before_siblings = extract_jsonpath(self._before_template, path)
+            after_siblings = extract_jsonpath(self._after_template, path)
+            arguments_scope = scope.open_scope("args")
+            arguments = self._visit_value(
+                scope=arguments_scope,
+                before_value=before_fn_transform_args,
+                after_value=after_fn_transform_args,
+            )
+            fn_transform = NodeIntrinsicFunctionFnTransform(
+                scope=scope_fn_transform,
+                change_type=ChangeType.MODIFIED,  # TODO
+                arguments=arguments,  # TODO
+                intrinsic_function=FnTransform,
+                before_siblings=before_siblings,
+                after_siblings=after_siblings,
+            )
+
         change_type = change_type_of(
             before_resource,
             after_resource,
-            [properties, condition_reference, depends_on, deletion_policy, update_replace_policy],
+            [
+                properties,
+                condition_reference,
+                depends_on,
+                deletion_policy,
+                update_replace_policy,
+                fn_transform,
+            ],
         )
         requires_replacement = self._resolve_requires_replacement(
             node_properties=properties, resource_type=terminal_value_type
@@ -1019,6 +1183,7 @@ class ChangeSetModel:
             requires_replacement=requires_replacement,
             deletion_policy=deletion_policy,
             update_replace_policy=update_replace_policy,
+            fn_transform=fn_transform,
         )
         self._visited_scopes[scope] = node_resource
         return node_resource
@@ -1029,10 +1194,28 @@ class ChangeSetModel:
         # TODO: investigate type changes behavior.
         resources: list[NodeResource] = []
         resource_names = self._safe_keys_of(before_resources, after_resources)
+        fn_transform = Nothing
+        fn_foreaches = []
         for resource_name in resource_names:
             resource_scope, (before_resource, after_resource) = self._safe_access_in(
                 scope, resource_name, before_resources, after_resources
             )
+            if resource_name == FnTransform:
+                fn_transform = self._visit_intrinsic_function(
+                    scope=resource_scope,
+                    intrinsic_function=resource_name,
+                    before_arguments=before_resource,
+                    after_arguments=after_resource,
+                )
+                continue
+            elif resource_name.startswith("Fn::ForEach"):
+                fn_for_each = self._visit_foreach(
+                    scope=resource_scope,
+                    before_arguments=before_resource,
+                    after_arguments=after_resource,
+                )
+                fn_foreaches.append(fn_for_each)
+                continue
             resource = self._visit_resource(
                 scope=resource_scope,
                 resource_name=resource_name,
@@ -1040,7 +1223,12 @@ class ChangeSetModel:
                 after_resource=after_resource,
             )
             resources.append(resource)
-        return NodeResources(scope=scope, resources=resources)
+        return NodeResources(
+            scope=scope,
+            resources=resources,
+            fn_transform=fn_transform,
+            fn_foreaches=fn_foreaches,
+        )
 
     def _visit_mapping(
         self, scope: Scope, name: str, before_mapping: Maybe[dict], after_mapping: Maybe[dict]

localstack/services/cloudformation/engine/v2/change_set_model_describer.py

@@ -20,6 +20,7 @@ from localstack.services.cloudformation.engine.v2.change_set_model_preproc impor
     PreprocResource,
 )
 from localstack.services.cloudformation.v2.entities import ChangeSet
+from localstack.utils.numbers import is_number
 
 CHANGESET_KNOWN_AFTER_APPLY: Final[str] = "{{changeSet:KNOWN_AFTER_APPLY}}"
 
@@ -96,11 +97,27 @@ class ChangeSetModelDescriber(ChangeSetModelPreproc):
 
         return value
 
+    def visit_node_intrinsic_function(self, node_intrinsic_function: NodeIntrinsicFunction):
+        """
+        Intrinsic function results are always strings when referring to the describe output
+        """
+        # TODO: what about other places?
+        # TODO: should this be put in the preproc?
+        delta = super().visit_node_intrinsic_function(node_intrinsic_function)
+        if is_number(delta.before):
+            delta.before = str(delta.before)
+        if is_number(delta.after):
+            delta.after = str(delta.after)
+        return delta
+
     def visit_node_intrinsic_function_fn_join(
         self, node_intrinsic_function: NodeIntrinsicFunction
     ) -> PreprocEntityDelta:
-        # TODO: investigate the behaviour and impact of this logic with the user defining
-        #       {{changeSet:KNOWN_AFTER_APPLY}} string literals as delimiters or arguments.
+        delta_args = super().visit(node_intrinsic_function.arguments)
+        if isinstance(delta_args.after, list) and CHANGESET_KNOWN_AFTER_APPLY in delta_args.after:
+            delta_args.after = CHANGESET_KNOWN_AFTER_APPLY
+            return delta_args
+
         delta = super().visit_node_intrinsic_function_fn_join(
             node_intrinsic_function=node_intrinsic_function
         )
@@ -112,6 +129,30 @@ class ChangeSetModelDescriber(ChangeSetModelPreproc):
             delta.after = CHANGESET_KNOWN_AFTER_APPLY
         return delta
 
+    def visit_node_intrinsic_function_fn_select(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ):
+        # TODO: should this not _ALWAYS_ return CHANGESET_KNOWN_AFTER_APPLY?
+        arguments_delta = self.visit(node_intrinsic_function.arguments)
+        delta = PreprocEntityDelta()
+        if not is_nothing(arguments_delta.before):
+            idx = arguments_delta.before[0]
+            arr = arguments_delta.before[1]
+            try:
+                delta.before = arr[int(idx)]
+            except Exception:
+                delta.before = CHANGESET_KNOWN_AFTER_APPLY
+
+        if not is_nothing(arguments_delta.after):
+            idx = arguments_delta.after[0]
+            arr = arguments_delta.after[1]
+            try:
+                delta.after = arr[int(idx)]
+            except Exception:
+                delta.after = CHANGESET_KNOWN_AFTER_APPLY
+
+        return delta
+
     def _register_resource_change(
         self,
         logical_id: str,
@@ -240,6 +281,14 @@ class ChangeSetModelDescriber(ChangeSetModelPreproc):
             export_name = node_intrinsic_function.arguments.value
 
             self._change_set.status_reason = f"[WARN] --include-property-values option can return incomplete ChangeSet data because: ChangeSet creation failed for resource [{resource_name}] because: No export named {export_name}"
-            delta.after = "{{changeSet:KNOWN_AFTER_APPLY}}"
+            delta.after = CHANGESET_KNOWN_AFTER_APPLY
 
         return delta
+
+    def visit_node_intrinsic_function_fn_split(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ) -> PreprocEntityDelta:
+        delta = super().visit_node_intrinsic_function_fn_split(node_intrinsic_function)
+        if isinstance(delta.after, list) and ":".join(delta.after) == CHANGESET_KNOWN_AFTER_APPLY:
+            delta.after = [CHANGESET_KNOWN_AFTER_APPLY]
+        return delta