refactor(package): replace METADATA_EXPORT_LIST and GLOBAL_EXPORT_DICT with typed registries

Migrate two flat package exporter registries to typed dataclass form:

- METADATA_EXPORT_LIST (list of Resource subclasses) -> METADATA_EXPORTS
  (List[MetadataExportSpec]). Each spec captures both the metadata_type
  ('AWS::ServerlessRepo::Application') and the per-property exporter
  classes that handle LicenseUrl/ReadmeUrl. Template._export_metadata
  now dispatches via a metadata_type lookup instead of a per-class
  RESOURCE_TYPE filter.

- GLOBAL_EXPORT_DICT (dict keyed by Fn::Transform) -> GLOBAL_TRANSFORM_EXPORTS
  (List[GlobalTransformExportSpec]). Each spec carries a discriminator
  callable (e.g. _is_aws_include for matching AWS::Include) plus the
  handler. _export_global_artifacts now dispatches through the
  discriminator so future Fn::Transform variants can register without
  touching the walker.

The typed shape is the contract a follow-up commit will read from to
process AWS::Include before language-extension expansion.

Author: bnusunny

samcli/lib/package/artifact_exporter.py

@@ -17,7 +17,7 @@
 import copy
 import logging
 import os
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Sequence
 
 from botocore.utils import set_value_from_jmespath
 
@@ -28,10 +28,11 @@
 from samcli.lib.package.code_signer import CodeSigner
 from samcli.lib.package.local_files_utils import get_uploaded_s3_object_name, mktempfile
 from samcli.lib.package.packageable_resources import (
-    GLOBAL_EXPORT_DICT,
-    METADATA_EXPORT_LIST,
+    GLOBAL_TRANSFORM_EXPORTS,
+    METADATA_EXPORTS,
     RESOURCES_EXPORT_LIST,
     ECRResource,
+    MetadataExportSpec,
     ResourceZip,
 )
 from samcli.lib.package.uploaders import Destination, Uploaders
@@ -336,7 +337,7 @@ class Template:
     template_dict: Dict
     template_dir: str
     resources_to_export: frozenset
-    metadata_to_export: frozenset
+    metadata_to_export: Sequence[MetadataExportSpec]
     uploaders: Uploaders
     code_signer: CodeSigner
 
@@ -350,7 +351,7 @@ def __init__(
             RESOURCES_EXPORT_LIST
             + [CloudFormationStackResource, CloudFormationStackSetResource, ServerlessApplicationResource]
         ),
-        metadata_to_export=frozenset(METADATA_EXPORT_LIST),
+        metadata_to_export=tuple(METADATA_EXPORTS),
         template_str: Optional[str] = None,
         normalize_template: bool = False,
         normalize_parameters: bool = False,
@@ -405,14 +406,21 @@ def _export_global_artifacts(self, template_dict: Dict) -> Dict:
         """
         Template params such as AWS::Include transforms are not specific to
         any resource type but contain artifacts that should be exported,
-        here we iterate through the template dict and export params with a
-        handler defined in GLOBAL_EXPORT_DICT
+        here we iterate through the template dict and dispatch to handlers
+        declared in GLOBAL_TRANSFORM_EXPORTS.
         """
+        specs_by_key: Dict[str, list] = {}
+        for spec in GLOBAL_TRANSFORM_EXPORTS:
+            specs_by_key.setdefault(spec.template_key, []).append(spec)
+
         for key, val in template_dict.items():
-            if key in GLOBAL_EXPORT_DICT:
-                template_dict[key] = GLOBAL_EXPORT_DICT[key](
-                    val, self.uploaders.get(ResourceZip.EXPORT_DESTINATION), self.template_dir
-                )
+            if key in specs_by_key:
+                for spec in specs_by_key[key]:
+                    if spec.discriminator(val):
+                        template_dict[key] = spec.handler(
+                            val, self.uploaders.get(ResourceZip.EXPORT_DESTINATION), self.template_dir
+                        )
+                        val = template_dict[key]  # subsequent specs see the rewrite
             elif isinstance(val, dict):
                 self._export_global_artifacts(val)
             elif isinstance(val, list):
@@ -429,11 +437,13 @@ def _export_metadata(self):
         if "Metadata" not in self.template_dict:
             return
 
-        for metadata_type, metadata_dict in self.template_dict["Metadata"].items():
-            for exporter_class in self.metadata_to_export:
-                if exporter_class.RESOURCE_TYPE != metadata_type:
-                    continue
+        specs_by_type = {spec.metadata_type: spec for spec in self.metadata_to_export}
 
+        for metadata_type, metadata_dict in self.template_dict["Metadata"].items():
+            spec = specs_by_type.get(metadata_type)
+            if spec is None:
+                continue
+            for exporter_class in spec.exporters:
                 exporter = exporter_class(self.uploaders, self.code_signer)
                 exporter.export(metadata_type, metadata_dict, self.template_dir)
 

samcli/lib/package/packageable_resources.py

@@ -5,7 +5,8 @@
 import logging
 import os
 import shutil
-from typing import Dict, Optional, Union, cast
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Type, Union, cast
 
 import jmespath
 from botocore.utils import set_value_from_jmespath
@@ -717,7 +718,29 @@ def export(self, resource_id: str, resource_dict: Optional[Dict], parent_dir: st
     GraphQLApiCodeResource,
 ]
 
-METADATA_EXPORT_LIST = [ServerlessRepoApplicationReadme, ServerlessRepoApplicationLicense]
+
+@dataclass(frozen=True)
+class MetadataExportSpec:
+    """How a top-level Metadata.<type> entry is exported and merged back.
+
+    Used by Template._export_metadata to route entries to their exporter
+    classes, and by merge_language_extensions_s3_uris to copy rewritten
+    property values back into the original (Fn::ForEach-preserving)
+    child-stack template after LE expansion.
+    """
+
+    metadata_type: str
+    property_names: List[str]
+    exporters: List[Type["Resource"]] = field(default_factory=list)
+
+
+METADATA_EXPORTS: List[MetadataExportSpec] = [
+    MetadataExportSpec(
+        metadata_type=AWS_SERVERLESSREPO_APPLICATION,
+        property_names=["LicenseUrl", "ReadmeUrl"],
+        exporters=[ServerlessRepoApplicationLicense, ServerlessRepoApplicationReadme],
+    ),
+]
 
 
 def include_transform_export_handler(template_dict, uploader, parent_dir):
@@ -741,4 +764,29 @@ def include_transform_export_handler(template_dict, uploader, parent_dir):
     return template_dict
 
 
-GLOBAL_EXPORT_DICT = {"Fn::Transform": include_transform_export_handler}
+@dataclass(frozen=True)
+class GlobalTransformExportSpec:
+    """How a global (anywhere-in-the-tree) export hook is invoked.
+
+    The discriminator decides whether a given dict node matches this spec
+    (dispatch on Fn::Transform's "Name" field today; ready for future
+    Fn::Transform variants). The handler receives the matched node and
+    mutates it in place to rewrite local paths to S3 URLs.
+    """
+
+    template_key: str
+    discriminator: Callable[[object], bool]
+    handler: Callable
+
+
+def _is_aws_include(node: object) -> bool:
+    return isinstance(node, dict) and node.get("Name") == "AWS::Include"
+
+
+GLOBAL_TRANSFORM_EXPORTS: List[GlobalTransformExportSpec] = [
+    GlobalTransformExportSpec(
+        template_key="Fn::Transform",
+        discriminator=_is_aws_include,
+        handler=include_transform_export_handler,
+    ),
+]

tests/unit/lib/package/test_artifact_exporter.py

@@ -41,7 +41,8 @@
     LambdaLayerVersionResource,
     copy_to_temp_dir,
     include_transform_export_handler,
-    GLOBAL_EXPORT_DICT,
+    GLOBAL_TRANSFORM_EXPORTS,
+    GlobalTransformExportSpec,
     ServerlessLayerVersionResource,
     ServerlessRepoApplicationLicense,
     ServerlessRepoApplicationReadme,
@@ -1454,6 +1455,8 @@ def test_export_serverless_application_no_upload_path_is_dictionary(self):
 
     @patch("samcli.lib.package.artifact_exporter.yaml_parse")
     def test_template_export_metadata(self, yaml_parse_mock):
+        from samcli.lib.package.packageable_resources import MetadataExportSpec
+
         parent_dir = os.path.sep
         template_dir = os.path.join(parent_dir, "foo", "bar")
         template_path = os.path.join(template_dir, "path")
@@ -1476,7 +1479,18 @@ def test_template_export_metadata(self, yaml_parse_mock):
         metadata_type2_instance = Mock()
         metadata_type2_class.return_value = metadata_type2_instance
 
-        metadata_to_export = [metadata_type1_class, metadata_type2_class]
+        metadata_to_export = [
+            MetadataExportSpec(
+                metadata_type="metadata_type1",
+                property_names=["property_1"],
+                exporters=[metadata_type1_class],
+            ),
+            MetadataExportSpec(
+                metadata_type="metadata_type2",
+                property_names=["property_2"],
+                exporters=[metadata_type2_class],
+            ),
+        ]
 
         template_dict = {"Metadata": {"metadata_type1": {"property_1": "abc"}, "metadata_type2": {"property_2": "def"}}}
         open_mock = mock.mock_open()
@@ -1852,8 +1866,13 @@ def test_template_global_export(self, yaml_parse_mock):
         }
         yaml_parse_mock.return_value = template_dict
 
+        mock_spec = GlobalTransformExportSpec(
+            template_key="Fn::Transform",
+            discriminator=lambda v: isinstance(v, dict),
+            handler=include_transform_export_handler_mock,
+        )
         with patch("samcli.lib.package.artifact_exporter.open", open_mock(read_data=template_str)) as open_mock:
-            with patch.dict(GLOBAL_EXPORT_DICT, {"Fn::Transform": include_transform_export_handler_mock}):
+            with patch("samcli.lib.package.artifact_exporter.GLOBAL_TRANSFORM_EXPORTS", [mock_spec]):
                 template_exporter = Template(template_path, parent_dir, self.uploaders_mock, resources_to_export)
                 exported_template = template_exporter._export_global_artifacts(template_exporter.template_dict)
 
@@ -1970,6 +1989,7 @@ def test_include_transform_export_handler_non_include_transform(self, is_local_f
         self.s3_uploader_mock.upload_with_dedup.assert_not_called()
         self.assertEqual(handler_output, {"Name": "AWS::OtherTransform", "Parameters": {"Location": "foo.yaml"}})
 
+
     def test_template_export_path_be_folder(self):
         template_path = "/path/foo"
         # Set parent_dir to be a non-existent folder
@@ -2571,6 +2591,38 @@ def test_export_cloudformation_stack_unexpected_exception_falls_back(self, Templ
         finally:
             os.remove(template_path)
 
+    def test_metadata_exports_registry_shape(self):
+        from samcli.lib.package.packageable_resources import (
+            METADATA_EXPORTS,
+            MetadataExportSpec,
+            ServerlessRepoApplicationLicense,
+            ServerlessRepoApplicationReadme,
+        )
+
+        self.assertTrue(all(isinstance(s, MetadataExportSpec) for s in METADATA_EXPORTS))
+
+        by_type = {s.metadata_type: s for s in METADATA_EXPORTS}
+        spec = by_type["AWS::ServerlessRepo::Application"]
+
+        self.assertEqual(sorted(spec.property_names), ["LicenseUrl", "ReadmeUrl"])
+        self.assertIn(ServerlessRepoApplicationLicense, spec.exporters)
+        self.assertIn(ServerlessRepoApplicationReadme, spec.exporters)
+
+    def test_global_transform_exports_registry_shape(self):
+        self.assertTrue(all(isinstance(s, GlobalTransformExportSpec) for s in GLOBAL_TRANSFORM_EXPORTS))
+
+        aws_include = next(
+            s for s in GLOBAL_TRANSFORM_EXPORTS if s.discriminator({"Name": "AWS::Include", "Parameters": {}})
+        )
+
+        self.assertEqual(aws_include.template_key, "Fn::Transform")
+        self.assertIs(aws_include.handler, include_transform_export_handler)
+
+        # Discriminator must reject non-AWS::Include transforms and non-dict inputs
+        self.assertFalse(aws_include.discriminator({"Name": "AWS::OtherTransform"}))
+        self.assertFalse(aws_include.discriminator(None))
+        self.assertFalse(aws_include.discriminator("not-a-dict"))
+
 
 class TestResolveNestedStackParameters(unittest.TestCase):
     """Unit tests for _resolve_nested_stack_parameters helper.