localstack-core 4.4.1.dev62__tar.gz → 4.4.1.dev65__tar.gz

{localstack_core-4.4.1.dev62/localstack-core/localstack_core.egg-info → localstack_core-4.4.1.dev65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-core
-Version: 4.4.1.dev62
+Version: 4.4.1.dev65
 Summary: The core library and runtime of LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License-Expression: Apache-2.0

{localstack_core-4.4.1.dev62 → localstack_core-4.4.1.dev65}/localstack-core/localstack/services/cloudformation/engine/v2/change_set_model.py

@@ -23,6 +23,9 @@ class NothingType:
             cls._singleton = super().__new__(cls)
         return cls._singleton
 
+    def __eq__(self, other):
+        return is_nothing(other)
+
     def __str__(self):
         return repr(self)
 
@@ -35,11 +38,46 @@ class NothingType:
     def __iter__(self):
         return iter(())
 
+    def __contains__(self, item):
+        return False
+
 
 Maybe = Union[T, NothingType]
 Nothing = NothingType()
 
 
+def is_nothing(value: Any) -> bool:
+    return isinstance(value, NothingType)
+
+
+def is_created(before: Maybe[Any], after: Maybe[Any]) -> bool:
+    return is_nothing(before) and not is_nothing(after)
+
+
+def is_removed(before: Maybe[Any], after: Maybe[Any]) -> bool:
+    return not is_nothing(before) and is_nothing(after)
+
+
+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
+    first_type = change_types[0]
+    if all(ct == first_type for ct in change_types):
+        return first_type
+    return ChangeType.MODIFIED
+
+
+def change_type_of(before: Maybe[Any], after: Maybe[Any], children: list[Maybe[ChangeSetEntity]]):
+    if is_created(before, after):
+        change_type = ChangeType.CREATED
+    elif is_removed(before, after):
+        change_type = ChangeType.REMOVED
+    else:
+        change_type = parent_change_type_of(children)
+    return change_type
+
+
 class Scope(str):
     _ROOT_SCOPE: Final[str] = str()
     _SEPARATOR: Final[str] = "/"
@@ -66,14 +104,6 @@ class ChangeType(enum.Enum):
     def __str__(self):
         return self.value
 
-    def for_child(self, child_change_type: ChangeType) -> ChangeType:
-        if child_change_type == self:
-            return self
-        elif self == ChangeType.UNCHANGED:
-            return child_change_type
-        else:
-            return ChangeType.MODIFIED
-
 
 class ChangeSetEntity(abc.ABC):
     scope: Final[Scope]
@@ -122,13 +152,13 @@ class NodeTemplate(ChangeSetNode):
     def __init__(
         self,
         scope: Scope,
-        change_type: ChangeType,
         mappings: NodeMappings,
         parameters: NodeParameters,
         conditions: NodeConditions,
         resources: NodeResources,
         outputs: NodeOutputs,
     ):
+        change_type = parent_change_type_of([resources, outputs])
         super().__init__(scope=scope, change_type=change_type)
         self.mappings = mappings
         self.parameters = parameters
@@ -151,17 +181,17 @@ class NodeParameter(ChangeSetNode):
     name: Final[str]
     type_: Final[ChangeSetEntity]
     dynamic_value: Final[ChangeSetEntity]
-    default_value: Final[Optional[ChangeSetEntity]]
+    default_value: Final[Maybe[ChangeSetEntity]]
 
     def __init__(
         self,
         scope: Scope,
-        change_type: ChangeType,
         name: str,
         type_: ChangeSetEntity,
         dynamic_value: ChangeSetEntity,
-        default_value: Optional[ChangeSetEntity],
+        default_value: Maybe[ChangeSetEntity],
     ):
+        change_type = parent_change_type_of([type_, default_value, dynamic_value])
         super().__init__(scope=scope, change_type=change_type)
         self.name = name
         self.type_ = type_
@@ -172,7 +202,8 @@ class NodeParameter(ChangeSetNode):
 class NodeParameters(ChangeSetNode):
     parameters: Final[list[NodeParameter]]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, parameters: list[NodeParameter]):
+    def __init__(self, scope: Scope, parameters: list[NodeParameter]):
+        change_type = parent_change_type_of(parameters)
         super().__init__(scope=scope, change_type=change_type)
         self.parameters = parameters
 
@@ -181,8 +212,8 @@ class NodeMapping(ChangeSetNode):
     name: Final[str]
     bindings: Final[NodeObject]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, name: str, bindings: NodeObject):
-        super().__init__(scope=scope, change_type=change_type)
+    def __init__(self, scope: Scope, name: str, bindings: NodeObject):
+        super().__init__(scope=scope, change_type=bindings.change_type)
         self.name = name
         self.bindings = bindings
 
@@ -190,7 +221,8 @@ class NodeMapping(ChangeSetNode):
 class NodeMappings(ChangeSetNode):
     mappings: Final[list[NodeMapping]]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, mappings: list[NodeMapping]):
+    def __init__(self, scope: Scope, mappings: list[NodeMapping]):
+        change_type = parent_change_type_of(mappings)
         super().__init__(scope=scope, change_type=change_type)
         self.mappings = mappings
 
@@ -198,18 +230,18 @@ class NodeMappings(ChangeSetNode):
 class NodeOutput(ChangeSetNode):
     name: Final[str]
     value: Final[ChangeSetEntity]
-    export: Final[Optional[ChangeSetEntity]]
-    condition_reference: Final[Optional[TerminalValue]]
+    export: Final[Maybe[ChangeSetEntity]]
+    condition_reference: Final[Maybe[TerminalValue]]
 
     def __init__(
         self,
         scope: Scope,
-        change_type: ChangeType,
         name: str,
         value: ChangeSetEntity,
-        export: Optional[ChangeSetEntity],
-        conditional_reference: Optional[TerminalValue],
+        export: Maybe[ChangeSetEntity],
+        conditional_reference: Maybe[TerminalValue],
     ):
+        change_type = parent_change_type_of([value, export, conditional_reference])
         super().__init__(scope=scope, change_type=change_type)
         self.name = name
         self.value = value
@@ -220,7 +252,8 @@ class NodeOutput(ChangeSetNode):
 class NodeOutputs(ChangeSetNode):
     outputs: Final[list[NodeOutput]]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, outputs: list[NodeOutput]):
+    def __init__(self, scope: Scope, outputs: list[NodeOutput]):
+        change_type = parent_change_type_of(outputs)
         super().__init__(scope=scope, change_type=change_type)
         self.outputs = outputs
 
@@ -229,8 +262,8 @@ class NodeCondition(ChangeSetNode):
     name: Final[str]
     body: Final[ChangeSetEntity]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, name: str, body: ChangeSetEntity):
-        super().__init__(scope=scope, change_type=change_type)
+    def __init__(self, scope: Scope, name: str, body: ChangeSetEntity):
+        super().__init__(scope=scope, change_type=body.change_type)
         self.name = name
         self.body = body
 
@@ -238,7 +271,8 @@ class NodeCondition(ChangeSetNode):
 class NodeConditions(ChangeSetNode):
     conditions: Final[list[NodeCondition]]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, conditions: list[NodeCondition]):
+    def __init__(self, scope: Scope, conditions: list[NodeCondition]):
+        change_type = parent_change_type_of(conditions)
         super().__init__(scope=scope, change_type=change_type)
         self.conditions = conditions
 
@@ -246,7 +280,8 @@ class NodeConditions(ChangeSetNode):
 class NodeResources(ChangeSetNode):
     resources: Final[list[NodeResource]]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, resources: list[NodeResource]):
+    def __init__(self, scope: Scope, resources: list[NodeResource]):
+        change_type = parent_change_type_of(resources)
         super().__init__(scope=scope, change_type=change_type)
         self.resources = resources
 
@@ -254,9 +289,9 @@ class NodeResources(ChangeSetNode):
 class NodeResource(ChangeSetNode):
     name: Final[str]
     type_: Final[ChangeSetTerminal]
-    condition_reference: Final[Optional[TerminalValue]]
     properties: Final[NodeProperties]
-    depends_on: Final[Optional[NodeDependsOn]]
+    condition_reference: Final[Maybe[TerminalValue]]
+    depends_on: Final[Maybe[NodeDependsOn]]
 
     def __init__(
         self,
@@ -265,8 +300,8 @@ class NodeResource(ChangeSetNode):
         name: str,
         type_: ChangeSetTerminal,
         properties: NodeProperties,
-        condition_reference: Optional[TerminalValue],
-        depends_on: Optional[NodeDependsOn],
+        condition_reference: Maybe[TerminalValue],
+        depends_on: Maybe[NodeDependsOn],
     ):
         super().__init__(scope=scope, change_type=change_type)
         self.name = name
@@ -279,7 +314,8 @@ class NodeResource(ChangeSetNode):
 class NodeProperties(ChangeSetNode):
     properties: Final[list[NodeProperty]]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, properties: list[NodeProperty]):
+    def __init__(self, scope: Scope, properties: list[NodeProperty]):
+        change_type = parent_change_type_of(properties)
         super().__init__(scope=scope, change_type=change_type)
         self.properties = properties
 
@@ -287,8 +323,8 @@ class NodeProperties(ChangeSetNode):
 class NodeDependsOn(ChangeSetNode):
     depends_on: Final[NodeArray]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, depends_on: NodeArray):
-        super().__init__(scope=scope, change_type=change_type)
+    def __init__(self, scope: Scope, depends_on: NodeArray):
+        super().__init__(scope=scope, change_type=depends_on.change_type)
         self.depends_on = depends_on
 
 
@@ -296,8 +332,8 @@ class NodeProperty(ChangeSetNode):
     name: Final[str]
     value: Final[ChangeSetEntity]
 
-    def __init__(self, scope: Scope, change_type: ChangeType, name: str, value: ChangeSetEntity):
-        super().__init__(scope=scope, change_type=change_type)
+    def __init__(self, scope: Scope, name: str, value: ChangeSetEntity):
+        super().__init__(scope=scope, change_type=value.change_type)
         self.name = name
         self.value = value
 
@@ -387,6 +423,7 @@ FnEqualsKey: Final[str] = "Fn::Equals"
 FnFindInMapKey: Final[str] = "Fn::FindInMap"
 FnSubKey: Final[str] = "Fn::Sub"
 FnTransform: Final[str] = "Fn::Transform"
+FnSelect: Final[str] = "Fn::Select"
 INTRINSIC_FUNCTIONS: Final[set[str]] = {
     RefKey,
     FnIfKey,
@@ -397,6 +434,7 @@ INTRINSIC_FUNCTIONS: Final[set[str]] = {
     FnFindInMapKey,
     FnSubKey,
     FnTransform,
+    FnSelect,
 }
 
 
@@ -442,9 +480,9 @@ class ChangeSetModel:
         terminal_value = self._visited_scopes.get(scope)
         if isinstance(terminal_value, TerminalValue):
             return terminal_value
-        if self._is_created(before=before_value, after=after_value):
+        if is_created(before=before_value, after=after_value):
             terminal_value = TerminalValueCreated(scope=scope, value=after_value)
-        elif self._is_removed(before=before_value, after=after_value):
+        elif is_removed(before=before_value, after=after_value):
             terminal_value = TerminalValueRemoved(scope=scope, value=before_value)
         elif before_value == after_value:
             terminal_value = TerminalValueUnchanged(scope=scope, value=before_value)
@@ -468,9 +506,9 @@ class ChangeSetModel:
         arguments = self._visit_value(
             scope=scope, before_value=before_arguments, after_value=after_arguments
         )
-        if self._is_created(before=before_arguments, after=after_arguments):
+        if is_created(before=before_arguments, after=after_arguments):
             change_type = ChangeType.CREATED
-        elif self._is_removed(before=before_arguments, after=after_arguments):
+        elif is_removed(before=before_arguments, after=after_arguments):
             change_type = ChangeType.REMOVED
         else:
             function_name = intrinsic_function.replace("::", "_")
@@ -588,8 +626,7 @@ class ChangeSetModel:
         )
         if not isinstance(node_condition, NodeCondition):
             raise RuntimeError()
-        change_types = [node_condition.change_type, *arguments.array[1:]]
-        change_type = self._change_type_for_parent_of(change_types=change_types)
+        change_type = parent_change_type_of([node_condition, *arguments[1:]])
         return change_type
 
     def _visit_array(
@@ -604,12 +641,7 @@ class ChangeSetModel:
                 scope=value_scope, before_value=before_value, after_value=after_value
             )
             array.append(value)
-        if self._is_created(before=before_array, after=after_array):
-            change_type = ChangeType.CREATED
-        elif self._is_removed(before=before_array, after=after_array):
-            change_type = ChangeType.REMOVED
-        else:
-            change_type = self._change_type_for_parent_of([value.change_type for value in array])
+        change_type = change_type_of(before_array, after_array, array)
         return NodeArray(scope=scope, change_type=change_type, array=array)
 
     def _visit_object(
@@ -618,12 +650,6 @@ class ChangeSetModel:
         node_object = self._visited_scopes.get(scope)
         if isinstance(node_object, NodeObject):
             return node_object
-        if self._is_created(before=before_object, after=after_object):
-            change_type = ChangeType.CREATED
-        elif self._is_removed(before=before_object, after=after_object):
-            change_type = ChangeType.REMOVED
-        else:
-            change_type = ChangeType.UNCHANGED
         binding_names = self._safe_keys_of(before_object, after_object)
         bindings: dict[str, ChangeSetEntity] = dict()
         for binding_name in binding_names:
@@ -634,7 +660,7 @@ class ChangeSetModel:
                 scope=binding_scope, before_value=before_value, after_value=after_value
             )
             bindings[binding_name] = value
-            change_type = change_type.for_child(value.change_type)
+        change_type = change_type_of(before_object, after_object, list(bindings.values()))
         node_object = NodeObject(scope=scope, change_type=change_type, bindings=bindings)
         self._visited_scopes[scope] = node_object
         return node_object
@@ -662,9 +688,9 @@ class ChangeSetModel:
         unset = object()
         if before_type_name == after_type_name:
             dominant_value = before_value
-        elif self._is_created(before=before_value, after=after_value):
+        elif is_created(before=before_value, after=after_value):
             dominant_value = after_value
-        elif self._is_removed(before=before_value, after=after_value):
+        elif is_removed(before=before_value, after=after_value):
             dominant_value = before_value
         else:
             dominant_value = unset
@@ -715,9 +741,7 @@ class ChangeSetModel:
         value = self._visit_value(
             scope=scope, before_value=before_property, after_value=after_property
         )
-        node_property = NodeProperty(
-            scope=scope, change_type=value.change_type, name=property_name, value=value
-        )
+        node_property = NodeProperty(scope=scope, name=property_name, value=value)
         self._visited_scopes[scope] = node_property
         return node_property
 
@@ -727,10 +751,8 @@ class ChangeSetModel:
         node_properties = self._visited_scopes.get(scope)
         if isinstance(node_properties, NodeProperties):
             return node_properties
-        # TODO: double check we are sure not to have this be a NodeObject
         property_names: list[str] = self._safe_keys_of(before_properties, after_properties)
         properties: list[NodeProperty] = list()
-        change_type = ChangeType.UNCHANGED
         for property_name in property_names:
             property_scope, (before_property, after_property) = self._safe_access_in(
                 scope, property_name, before_properties, after_properties
@@ -742,10 +764,7 @@ class ChangeSetModel:
                 after_property=after_property,
             )
             properties.append(property_)
-            change_type = change_type.for_child(property_.change_type)
-        node_properties = NodeProperties(
-            scope=scope, change_type=change_type, properties=properties
-        )
+        node_properties = NodeProperties(scope=scope, properties=properties)
         self._visited_scopes[scope] = node_properties
         return node_properties
 
@@ -767,13 +786,6 @@ class ChangeSetModel:
         if isinstance(node_resource, NodeResource):
             return node_resource
 
-        if self._is_created(before=before_resource, after=after_resource):
-            change_type = ChangeType.CREATED
-        elif self._is_removed(before=before_resource, after=after_resource):
-            change_type = ChangeType.REMOVED
-        else:
-            change_type = ChangeType.UNCHANGED
-
         scope_type, (before_type, after_type) = self._safe_access_in(
             scope, TypeKey, before_resource, after_resource
         )
@@ -781,7 +793,7 @@ class ChangeSetModel:
             scope=scope_type, before_type=before_type, after_type=after_type
         )
 
-        condition_reference = None
+        condition_reference = Nothing
         scope_condition, (before_condition, after_condition) = self._safe_access_in(
             scope, ConditionKey, before_resource, after_resource
         )
@@ -790,7 +802,7 @@ class ChangeSetModel:
                 scope_condition, before_condition, after_condition
             )
 
-        depends_on = None
+        depends_on = Nothing
         scope_depends_on, (before_depends_on, after_depends_on) = self._safe_access_in(
             scope, DependsOnKey, before_resource, after_resource
         )
@@ -807,10 +819,10 @@ class ChangeSetModel:
             before_properties=before_properties,
             after_properties=after_properties,
         )
-        if properties.properties:
-            # Properties were defined in the before or after template, thus must play a role
-            # in affecting the change type of this resource.
-            change_type = change_type.for_child(properties.change_type)
+
+        change_type = change_type_of(
+            before_resource, after_resource, [properties, condition_reference, depends_on]
+        )
         node_resource = NodeResource(
             scope=scope,
             change_type=change_type,
@@ -827,7 +839,6 @@ class ChangeSetModel:
         self, scope: Scope, before_resources: Maybe[dict], after_resources: Maybe[dict]
     ) -> NodeResources:
         # TODO: investigate type changes behavior.
-        change_type = ChangeType.UNCHANGED
         resources: list[NodeResource] = list()
         resource_names = self._safe_keys_of(before_resources, after_resources)
         for resource_name in resource_names:
@@ -841,8 +852,7 @@ class ChangeSetModel:
                 after_resource=after_resource,
             )
             resources.append(resource)
-            change_type = change_type.for_child(resource.change_type)
-        return NodeResources(scope=scope, change_type=change_type, resources=resources)
+        return NodeResources(scope=scope, resources=resources)
 
     def _visit_mapping(
         self, scope: Scope, name: str, before_mapping: Maybe[dict], after_mapping: Maybe[dict]
@@ -850,14 +860,11 @@ class ChangeSetModel:
         bindings = self._visit_object(
             scope=scope, before_object=before_mapping, after_object=after_mapping
         )
-        return NodeMapping(
-            scope=scope, change_type=bindings.change_type, name=name, bindings=bindings
-        )
+        return NodeMapping(scope=scope, name=name, bindings=bindings)
 
     def _visit_mappings(
         self, scope: Scope, before_mappings: Maybe[dict], after_mappings: Maybe[dict]
     ) -> NodeMappings:
-        change_type = ChangeType.UNCHANGED
         mappings: list[NodeMapping] = list()
         mapping_names = self._safe_keys_of(before_mappings, after_mappings)
         for mapping_name in mapping_names:
@@ -871,8 +878,7 @@ class ChangeSetModel:
                 after_mapping=after_mapping,
             )
             mappings.append(mapping)
-            change_type = change_type.for_child(mapping.change_type)
-        return NodeMappings(scope=scope, change_type=change_type, mappings=mappings)
+        return NodeMappings(scope=scope, mappings=mappings)
 
     def _visit_dynamic_parameter(self, parameter_name: str) -> ChangeSetEntity:
         scope = Scope("Dynamic").open_scope("Parameters")
@@ -907,13 +913,8 @@ class ChangeSetModel:
 
         dynamic_value = self._visit_dynamic_parameter(parameter_name=parameter_name)
 
-        change_type = self._change_type_for_parent_of(
-            change_types=[type_.change_type, default_value.change_type, dynamic_value.change_type]
-        )
-
         node_parameter = NodeParameter(
             scope=scope,
-            change_type=change_type,
             name=parameter_name,
             type_=type_,
             default_value=default_value,
@@ -930,7 +931,6 @@ class ChangeSetModel:
             return node_parameters
         parameter_names: list[str] = self._safe_keys_of(before_parameters, after_parameters)
         parameters: list[NodeParameter] = list()
-        change_type = ChangeType.UNCHANGED
         for parameter_name in parameter_names:
             parameter_scope, (before_parameter, after_parameter) = self._safe_access_in(
                 scope, parameter_name, before_parameters, after_parameters
@@ -942,10 +942,7 @@ class ChangeSetModel:
                 after_parameter=after_parameter,
             )
             parameters.append(parameter)
-            change_type = change_type.for_child(parameter.change_type)
-        node_parameters = NodeParameters(
-            scope=scope, change_type=change_type, parameters=parameters
-        )
+        node_parameters = NodeParameters(scope=scope, parameters=parameters)
         self._visited_scopes[scope] = node_parameters
         return node_parameters
 
@@ -976,9 +973,7 @@ class ChangeSetModel:
         node_array = self._visit_array(
             scope=scope, before_array=before_depends_on, after_array=after_depends_on
         )
-        node_depends_on = NodeDependsOn(
-            scope=scope, change_type=node_array.change_type, depends_on=node_array
-        )
+        node_depends_on = NodeDependsOn(scope=scope, depends_on=node_array)
         return node_depends_on
 
     def _visit_condition(
@@ -994,9 +989,7 @@ class ChangeSetModel:
         body = self._visit_value(
             scope=scope, before_value=before_condition, after_value=after_condition
         )
-        node_condition = NodeCondition(
-            scope=scope, change_type=body.change_type, name=condition_name, body=body
-        )
+        node_condition = NodeCondition(scope=scope, name=condition_name, body=body)
         self._visited_scopes[scope] = node_condition
         return node_condition
 
@@ -1008,7 +1001,6 @@ class ChangeSetModel:
             return node_conditions
         condition_names: list[str] = self._safe_keys_of(before_conditions, after_conditions)
         conditions: list[NodeCondition] = list()
-        change_type = ChangeType.UNCHANGED
         for condition_name in condition_names:
             condition_scope, (before_condition, after_condition) = self._safe_access_in(
                 scope, condition_name, before_conditions, after_conditions
@@ -1020,33 +1012,27 @@ class ChangeSetModel:
                 after_condition=after_condition,
             )
             conditions.append(condition)
-            change_type = change_type.for_child(child_change_type=condition.change_type)
-        node_conditions = NodeConditions(
-            scope=scope, change_type=change_type, conditions=conditions
-        )
+        node_conditions = NodeConditions(scope=scope, conditions=conditions)
         self._visited_scopes[scope] = node_conditions
         return node_conditions
 
     def _visit_output(
         self, scope: Scope, name: str, before_output: Maybe[dict], after_output: Maybe[dict]
     ) -> NodeOutput:
-        change_type = ChangeType.UNCHANGED
         scope_value, (before_value, after_value) = self._safe_access_in(
             scope, ValueKey, before_output, after_output
         )
         value = self._visit_value(scope_value, before_value, after_value)
-        change_type = change_type.for_child(value.change_type)
 
-        export: Optional[ChangeSetEntity] = None
+        export: Maybe[ChangeSetEntity] = Nothing
         scope_export, (before_export, after_export) = self._safe_access_in(
             scope, ExportKey, before_output, after_output
         )
         if before_export or after_export:
             export = self._visit_value(scope_export, before_export, after_export)
-            change_type = change_type.for_child(export.change_type)
 
         # TODO: condition references should be resolved for the condition's change_type?
-        condition_reference: Optional[TerminalValue] = None
+        condition_reference: Maybe[TerminalValue] = Nothing
         scope_condition, (before_condition, after_condition) = self._safe_access_in(
             scope, ConditionKey, before_output, after_output
         )
@@ -1054,11 +1040,9 @@ class ChangeSetModel:
             condition_reference = self._visit_terminal_value(
                 scope_condition, before_condition, after_condition
             )
-            change_type = change_type.for_child(condition_reference.change_type)
 
         return NodeOutput(
             scope=scope,
-            change_type=change_type,
             name=name,
             value=value,
             export=export,
@@ -1068,7 +1052,6 @@ class ChangeSetModel:
     def _visit_outputs(
         self, scope: Scope, before_outputs: Maybe[dict], after_outputs: Maybe[dict]
     ) -> NodeOutputs:
-        change_type = ChangeType.UNCHANGED
         outputs: list[NodeOutput] = list()
         output_names: list[str] = self._safe_keys_of(before_outputs, after_outputs)
         for output_name in output_names:
@@ -1082,8 +1065,7 @@ class ChangeSetModel:
                 after_output=after_output,
             )
             outputs.append(output)
-            change_type = change_type.for_child(output.change_type)
-        return NodeOutputs(scope=scope, change_type=change_type, outputs=outputs)
+        return NodeOutputs(scope=scope, outputs=outputs)
 
     def _model(self, before_template: Maybe[dict], after_template: Maybe[dict]) -> NodeTemplate:
         root_scope = Scope()
@@ -1133,7 +1115,6 @@ class ChangeSetModel:
         # TODO: compute the change_type of the template properly.
         return NodeTemplate(
             scope=root_scope,
-            change_type=resources.change_type,
             mappings=mappings,
             parameters=parameters,
             conditions=conditions,
@@ -1141,7 +1122,7 @@ class ChangeSetModel:
             outputs=outputs,
         )
 
-    def _retrieve_condition_if_exists(self, condition_name: str) -> Optional[NodeCondition]:
+    def _retrieve_condition_if_exists(self, condition_name: str) -> Maybe[NodeCondition]:
         conditions_scope, (before_conditions, after_conditions) = self._safe_access_in(
             Scope(), ConditionsKey, self._before_template, self._after_template
         )
@@ -1158,14 +1139,12 @@ class ChangeSetModel:
                 after_condition=after_condition,
             )
             return node_condition
-        return None
+        return Nothing
 
-    def _retrieve_parameter_if_exists(self, parameter_name: str) -> Optional[NodeParameter]:
+    def _retrieve_parameter_if_exists(self, parameter_name: str) -> Maybe[NodeParameter]:
         parameters_scope, (before_parameters, after_parameters) = self._safe_access_in(
             Scope(), ParametersKey, self._before_template, self._after_template
         )
-        before_parameters = before_parameters or dict()
-        after_parameters = after_parameters or dict()
         if parameter_name in before_parameters or parameter_name in after_parameters:
             parameter_scope, (before_parameter, after_parameter) = self._safe_access_in(
                 parameters_scope, parameter_name, before_parameters, after_parameters
@@ -1177,15 +1156,13 @@ class ChangeSetModel:
                 after_parameter=after_parameter,
             )
             return node_parameter
-        return None
+        return Nothing
 
     def _retrieve_mapping(self, mapping_name) -> NodeMapping:
         # TODO: add caching mechanism, and raise appropriate error if missing.
         scope_mappings, (before_mappings, after_mappings) = self._safe_access_in(
             Scope(), MappingsKey, self._before_template, self._after_template
         )
-        before_mappings = before_mappings or dict()
-        after_mappings = after_mappings or dict()
         if mapping_name in before_mappings or mapping_name in after_mappings:
             scope_mapping, (before_mapping, after_mapping) = self._safe_access_in(
                 scope_mappings, mapping_name, before_mappings, after_mappings
@@ -1242,15 +1219,6 @@ class ChangeSetModel:
         keys = sorted(key_set)
         return keys
 
-    @staticmethod
-    def _change_type_for_parent_of(change_types: list[ChangeType]) -> ChangeType:
-        parent_change_type = ChangeType.UNCHANGED
-        for child_change_type in change_types:
-            parent_change_type = parent_change_type.for_child(child_change_type)
-            if parent_change_type == ChangeType.MODIFIED:
-                break
-        return parent_change_type
-
     @staticmethod
     def _name_if_intrinsic_function(value: Maybe[Any]) -> Optional[str]:
         if isinstance(value, dict):
@@ -1279,11 +1247,3 @@ class ChangeSetModel:
     @staticmethod
     def _is_array(value: Any) -> bool:
         return isinstance(value, list)
-
-    @staticmethod
-    def _is_created(before: Maybe[Any], after: Maybe[Any]) -> bool:
-        return isinstance(before, NothingType) and not isinstance(after, NothingType)
-
-    @staticmethod
-    def _is_removed(before: Maybe[Any], after: Maybe[Any]) -> bool:
-        return not isinstance(before, NothingType) and isinstance(after, NothingType)