fix(cfn-lang-ext): derive Mapping-prefix list and artifact-property set from canonical dict

Two consumers of PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES were left out of
sync when this PR began emitting Mappings for newly-supported resource
types (Application, Glue, EB, AppSync, CFN Module/ResourceVersion) and for
dotted-leaf entries (Code.ImageUri):

- samcli/lib/cfn_language_extensions/utils.py — _SAM_GENERATED_MAPPING_PREFIXES
  was a hand-maintained tuple covering only the pre-PR set, so
  is_sam_generated_mapping returned False for SAMLocation*, SAMScriptLocation*,
  SAMSourceBundle*, SAMModulePackage*, SAMSchemaHandlerPackage*. That made
  _update_sam_mappings_relative_paths skip these mappings on template move
  (paths weren't adjusted) and prevented _create_deploy_error from wrapping
  CFN "key not found" errors as MissingMappingKeyError.

- samcli/commands/_utils/template.py — _ARTIFACT_PATH_PROPERTIES was built
  from the dotted form ("Command.ScriptLocation") but the SAM-generated
  Mapping value-dicts use the leaf ("ScriptLocation") as the key. So the
  inner property check rejected leaf names and Glue script paths never got
  their relative paths adjusted on template move.

Both lists now derive from PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES at
module import (mirroring the single-source-of-truth approach used for the
dict itself in models.py). Adds two sync tests so future drift fails loudly.

Addresses second review comment on PR #9009.

Author: bnusunny

samcli/commands/_utils/template.py

@@ -33,8 +33,17 @@
 # Artifact path property names derived from PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES
 # so the two lists cannot drift. Used by _update_sam_mappings_relative_paths to
 # identify which SAM-generated Mapping values are local paths needing adjustment.
+#
+# Includes both the dotted form (e.g. "Command.ScriptLocation") and its leaf
+# (e.g. "ScriptLocation"), because SAM-generated Mapping value-dicts are keyed
+# by the leaf segment so the third argument of Fn::FindInMap stays alphanumeric
+# (see _compute_mapping_name and _generate_artifact_mappings in
+# samcli/lib/package/language_extensions_packaging.py).
 _ARTIFACT_PATH_PROPERTIES = frozenset(
-    prop for props in PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES.values() for prop in props
+    name
+    for props in PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES.values()
+    for prop in props
+    for name in (prop, prop.rsplit(".", 1)[-1])
 )
 
 

samcli/lib/cfn_language_extensions/utils.py

@@ -94,25 +94,34 @@ def is_unresolved_param_or_pseudo_ref(value: Any, context: "TemplateProcessingCo
 
 
 # Mapping-name prefixes that SAM CLI emits for dynamic Fn::ForEach handling:
-#   - SAM + <packageable artifact property> + <nesting path> + [resource suffix]
+#   - SAM + <leaf of packageable artifact property> + <nesting path> + [resource suffix]
 #     (see language_extensions_packaging._compute_mapping_name)
 #   - SAMLayers + <nesting path>  (see build_context — auto dependency layer refs)
-# Customer-authored mappings should never start with one of these exact
-# PascalCase prefixes, so exact-prefix matching avoids the false positives
-# a regex like r"^SAM[A-Z]..." would hit on names like SAMPLE / SAMSUNG.
-_SAM_GENERATED_MAPPING_PREFIXES: Tuple[str, ...] = (
-    "SAMCodeUri",
-    "SAMImageUri",
-    "SAMContentUri",
-    "SAMDefinitionUri",
-    "SAMSchemaUri",
-    "SAMBodyS3Location",
-    "SAMDefinitionS3Location",
-    "SAMTemplateURL",
-    "SAMCode",
-    "SAMContent",
-    "SAMLayers",
-)
+# Derived from PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES so the set automatically
+# tracks the canonical packageable-resource list. Customer-authored mappings
+# should never start with one of these exact PascalCase prefixes; exact-prefix
+# matching avoids the false positives a regex like r"^SAM[A-Z]..." would hit on
+# names like SAMPLE / SAMSUNG.
+def _build_sam_generated_mapping_prefixes() -> Tuple[str, ...]:
+    from samcli.lib.cfn_language_extensions.models import PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES
+
+    seen: set = set()
+    prefixes: list = []
+    for props in PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES.values():
+        for prop in props:
+            leaf = prop.rsplit(".", 1)[-1]
+            prefix = f"SAM{leaf}"
+            if prefix not in seen:
+                seen.add(prefix)
+                prefixes.append(prefix)
+    # SAMLayers is emitted by sam build for auto dependency layer references and
+    # has no corresponding artifact property; add it explicitly.
+    if "SAMLayers" not in seen:
+        prefixes.append("SAMLayers")
+    return tuple(prefixes)
+
+
+_SAM_GENERATED_MAPPING_PREFIXES: Tuple[str, ...] = _build_sam_generated_mapping_prefixes()
 
 
 def is_sam_generated_mapping(mapping_name: str) -> bool:

tests/unit/commands/_utils/test_template.py

@@ -688,6 +688,53 @@ def test_move_template_preserves_docker_imageuri_in_sam_mappings(self):
                 "emulation-python3.9-beta:latest",
             )
 
+    def test_updates_glue_script_location_mapping(self):
+        """Mappings emitted for AWS::Glue::Job (key 'ScriptLocation' from leaf of 'Command.ScriptLocation')
+        must be recognized as SAM-generated and have their relative paths adjusted on template move.
+        """
+        mappings = {
+            "SAMScriptLocationJobs": {
+                "Etl1": {"ScriptLocation": os.path.join(".aws-sam", "build", "Etl1Job", "job.py")},
+                "Etl2": {"ScriptLocation": os.path.join(".aws-sam", "build", "Etl2Job", "job.py")},
+            }
+        }
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            original_root = tmpdir
+            new_root = os.path.join(tmpdir, ".aws-sam", "build")
+            os.makedirs(new_root, exist_ok=True)
+
+            _update_sam_mappings_relative_paths(mappings, original_root, new_root)
+
+            self.assertEqual(
+                mappings["SAMScriptLocationJobs"]["Etl1"]["ScriptLocation"],
+                os.path.join("Etl1Job", "job.py"),
+            )
+            self.assertEqual(
+                mappings["SAMScriptLocationJobs"]["Etl2"]["ScriptLocation"],
+                os.path.join("Etl2Job", "job.py"),
+            )
+
+    def test_updates_serverless_application_location_mapping(self):
+        """Mappings emitted for AWS::Serverless::Application (key 'Location') must be recognized."""
+        mappings = {
+            "SAMLocationApps": {
+                "Pub": {"Location": os.path.join(".aws-sam", "build", "PubApi", "template.yaml")},
+            }
+        }
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            original_root = tmpdir
+            new_root = os.path.join(tmpdir, ".aws-sam", "build")
+            os.makedirs(new_root, exist_ok=True)
+
+            _update_sam_mappings_relative_paths(mappings, original_root, new_root)
+
+            self.assertEqual(
+                mappings["SAMLocationApps"]["Pub"]["Location"],
+                os.path.join("PubApi", "template.yaml"),
+            )
+
 
 class Test_resolve_relative_to(TestCase):
     def setUp(self):

tests/unit/lib/cfn_language_extensions/test_utils.py

@@ -76,6 +76,48 @@ def test_layers_prefix_matches(self):
     def test_layers_digit_matches(self):
         self.assertTrue(is_sam_generated_mapping("SAMLayers1stBatch"))
 
+    # Mappings with leaf names derived from dotted artifact paths
+    def test_glue_script_location_mapping_matches(self):
+        # AWS::Glue::Job.Command.ScriptLocation -> leaf "ScriptLocation"
+        self.assertTrue(is_sam_generated_mapping("SAMScriptLocationJobs"))
+
+    def test_lambda_image_uri_mapping_matches(self):
+        # AWS::Lambda::Function.Code.ImageUri -> leaf "ImageUri" (already covered by SAMImageUri)
+        self.assertTrue(is_sam_generated_mapping("SAMImageUriFuncs"))
+
+    # Mappings produced by leaf names from non-dotted artifact paths added by #9005
+    def test_serverless_application_location_mapping_matches(self):
+        self.assertTrue(is_sam_generated_mapping("SAMLocationApps"))
+
+    def test_eb_source_bundle_mapping_matches(self):
+        self.assertTrue(is_sam_generated_mapping("SAMSourceBundleVersions"))
+
+    def test_cfn_module_package_mapping_matches(self):
+        self.assertTrue(is_sam_generated_mapping("SAMModulePackageMods"))
+
+    def test_cfn_resource_version_mapping_matches(self):
+        self.assertTrue(is_sam_generated_mapping("SAMSchemaHandlerPackageRes"))
+
+    # Sync test mirroring test_dict_is_in_sync_with_canonical_lists in test_models.py
+    def test_prefixes_in_sync_with_packageable_artifact_properties(self):
+        """Every leaf in PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES must be classifiable
+        as a SAM-generated Mapping prefix. Future additions to the canonical list
+        propagate automatically, so missing one fails this test loudly.
+        """
+        from samcli.lib.cfn_language_extensions.models import PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES
+
+        for resource_type, props in PACKAGEABLE_RESOURCE_ARTIFACT_PROPERTIES.items():
+            for prop in props:
+                leaf = prop.rsplit(".", 1)[-1]
+                # A Mapping name is SAM<leaf><LoopName>; using "X" as a stand-in loop name.
+                mapping_name = f"SAM{leaf}X"
+                self.assertTrue(
+                    is_sam_generated_mapping(mapping_name),
+                    f"Mapping name {mapping_name!r} (from {resource_type}.{prop}) "
+                    f"is not recognized as SAM-generated; "
+                    f"_SAM_GENERATED_MAPPING_PREFIXES is out of sync.",
+                )
+
 
 class TestIsUnresolvedParamOrPseudoRef(TestCase):
     def _ctx(self, parameters=None) -> TemplateProcessingContext: