feat(s2dm): simplify vspec metadata annotation with sidecar lookup spec file

Signed-off-by: JD Alvarez <8550265+jdacoello@users.noreply.github.com>

Author: jdacoello

src/vss_tools/exporters/s2dm/graphql_directive_processor.py

@@ -70,8 +70,8 @@ def _process_unit_enum_directives(
         """
         Process unit enum directives.
 
-        Annotates enum type with @vspec(element: QUANTITY_KIND, metadata: [{key: "quantity", value: "..."}])
-        and individual enum values with @vspec(element: UNIT, metadata: [{key: "unit", value: "..."}])
+        Annotates enum type with @vspec(element: QUANTITY_KIND)
+        and individual enum values with @vspec(element: UNIT).
         """
         for quantity, units_data in unit_enums_metadata.items():
             enum_name = f"{convert_name_for_graphql_schema(quantity, GraphQLElementType.TYPE)}UnitEnum"
@@ -80,11 +80,7 @@ def _process_unit_enum_directives(
             for i, line in enumerate(lines):
                 if line.strip().startswith(f"enum {enum_name}"):
                     if "@vspec" not in line:
-                        # Annotate enum type with QUANTITY_KIND
-                        directive = (
-                            f"@vspec(element: QUANTITY_KIND, " f'metadata: [{{key: "quantity", value: "{quantity}"}}])'
-                        )
-                        lines[i] = line.replace(" {", f" {directive} {{")
+                        lines[i] = line.replace(" {", " @vspec(element: QUANTITY_KIND) {")
                     in_target_enum = True
                     continue
                 elif line.strip().startswith("enum ") and in_target_enum:
@@ -105,9 +101,7 @@ def _process_unit_enum_directives(
                         if stripped_line.startswith(enum_value_name) and enum_value_key not in processed_values:
                             if "@vspec" not in line:
                                 indent = line[: len(line) - len(line.lstrip())]
-                                # Annotate enum value with UNIT
-                                directive = f'@vspec(element: UNIT, metadata: [{{key: "unit", value: "{unit_key}"}}])'
-                                lines[i] = f"{indent}{enum_value_name} {directive}"
+                                lines[i] = f"{indent}{enum_value_name} @vspec(element: UNIT)"
 
                             processed_values.add(enum_value_key)
                             break
@@ -119,29 +113,19 @@ def _process_allowed_enum_directives(
         """
         Process allowed value enum directives.
 
-        Annotates the enum type itself with @vspec(element, fqn, metadata),
-        and annotates individual enum values that were modified with @vspec(metadata).
+        Annotates the enum type itself with @vspec(element, fqn).
+        Annotates individual enum values that were sanitized with @vspec(metadata: originalName).
         """
         for enum_name, enum_data in allowed_enums_metadata.items():
             fqn = enum_data.get("fqn", "")
             vss_type = enum_data.get("vss_type", "ATTRIBUTE")
-            allowed_values_dict = enum_data.get("allowed_values", {})
             modified_values = enum_data.get("modified_values", {})
 
-            # Build the allowed values list for metadata
-            # GraphQL requires: value: "['val1', 'val2']" (double quotes outside, single quotes inside)
-            allowed_values_list = list(allowed_values_dict.values())
-            allowed_str = ", ".join([f"'{v}'" for v in allowed_values_list])
-
             in_target_enum = False
             for i, line in enumerate(lines):
                 if line.strip().startswith(f"enum {enum_name}"):
                     if "@vspec" not in line:
-                        # Annotate the enum type
-                        directive = (
-                            f'@vspec(element: {vss_type}, fqn: "{fqn}", '
-                            f'metadata: [{{key: "allowed", value: "[{allowed_str}]"}}])'
-                        )
+                        directive = f'@vspec(element: {vss_type}, fqn: "{fqn}")'
                         lines[i] = line.replace(" {", f" {directive} {{")
                     in_target_enum = True
                     continue
@@ -216,13 +200,12 @@ def _process_instance_dimension_enum_directives(
         return lines
 
     def _process_field_directives(self, lines: list[str], vspec_comments: dict) -> list[str]:
-        """Process consolidated field @vspec directives (element + fqn + optional metadata)."""
-        # Process VSS type information (element + fqn + metadata)
+        """Process consolidated field @vspec directives (element + fqn + optional instantiate metadata)."""
         for field_path, vss_info in vspec_comments.get("field_vss_types", {}).items():
             type_name, field_name = field_path.split(".", 1)  # Use maxsplit=1 to handle field names with dots
             element = vss_info["element"]
             fqn = vss_info["fqn"]
-            instantiate = vss_info.get("instantiate")  # Check if this is a hoisted non-instantiated field
+            instantiate = vss_info.get("instantiate")  # Only False for hoisted non-instantiated fields
 
             in_type = False
             for i, line in enumerate(lines):
@@ -237,26 +220,12 @@ def _process_field_directives(self, lines: list[str], vspec_comments: dict) -> l
                     continue
 
                 if in_type and line.strip().startswith(f"{field_name}") and "@vspec" not in line:
-                    # Build metadata array from extended attributes
-                    metadata_entries = []
-
-                    # Add instantiate metadata if present
                     if instantiate is False:
-                        metadata_entries.append('{key: "instantiate", value: "false"}')
-
-                    # Add extended attributes metadata
-                    for key, value in vss_info.items():
-                        if key not in ["element", "fqn", "instantiate"]:
-                            # Escape quotes in value
-                            escaped_value = str(value).replace('"', '\\\\"')
-                            metadata_entries.append(f'{{key: "{key}", value: "{escaped_value}"}}')
-
-                    # Build directive
-                    if metadata_entries:
-                        metadata_str = ", ".join(metadata_entries)
-                        directive = f'@vspec(element: {element}, fqn: "{fqn}", metadata: [{metadata_str}])'
+                        directive = (
+                            f'@vspec(element: {element}, fqn: "{fqn}", '
+                            + 'metadata: [{key: "instantiate", value: "false"}])'
+                        )
                     else:
-                        # Standard directive without metadata
                         directive = f'@vspec(element: {element}, fqn: "{fqn}")'
 
                     lines[i] = line.rstrip() + f" {directive}"
@@ -376,36 +345,14 @@ def _process_type_directives(self, lines: list[str], vspec_comments: dict) -> li
 
                     # Add @vspec directive
                     if needs_instance_tag and "@vspec" not in line:
-                        # Instance tag types get special metadata with instances
                         element = instance_tag_info["element"]
                         fqn = instance_tag_info["fqn"]
-                        instances = instance_tag_info["instances"]
-                        directive = (
-                            f'@vspec(element: {element}, fqn: "{fqn}", '
-                            f'metadata: [{{key: "instances", value: "{instances}"}}])'
-                        )
-                        new_line += f" {directive}"
+                        new_line += f' @vspec(element: {element}, fqn: "{fqn}")'
                     elif needs_vss_type and "@vspec" not in line:
-                        # Regular types get element + fqn + extended attributes metadata
                         vss_info = vspec_comments["vss_types"][type_name]
                         element = vss_info["element"]
                         fqn = vss_info["fqn"]
-
-                        # Build metadata array from extended attributes
-                        metadata_entries = []
-                        for key, value in vss_info.items():
-                            if key not in ["element", "fqn"]:
-                                # Escape quotes in value
-                                escaped_value = str(value).replace('"', '\\\\"')
-                                metadata_entries.append(f'{{key: "{key}", value: "{escaped_value}"}}')
-
-                        # Build directive
-                        if metadata_entries:
-                            metadata_str = ", ".join(metadata_entries)
-                            directive = f'@vspec(element: {element}, fqn: "{fqn}", metadata: [{metadata_str}])'
-                        else:
-                            directive = f'@vspec(element: {element}, fqn: "{fqn}")'
-                        new_line += f" {directive}"
+                        new_line += f' @vspec(element: {element}, fqn: "{fqn}")'
 
                     new_line += " {"
                     lines[i] = new_line  # No extra indentation

src/vss_tools/exporters/s2dm/predefined_elements/directives.graphql

@@ -35,13 +35,6 @@ enum VspecElement {
 }
 
 
-#enum FuelTypeEnum @vspec(element:"ATTRIBUTE", fqn:"Vehicle.Powertrain.FuelType", metadata:[{key:"allowed", value:"[GASOLINE, DIESEL, ELECTRIC, HYBRID]"}]) {
-#  GASOLINE
-#  DIESEL
-#  ELECTRIC
-#  HYBRID
-#}
-
 directive @range(min: Float, max: Float) on FIELD_DEFINITION
 
 directive @instanceTag on OBJECT

src/vss_tools/exporters/s2dm/type_builders.py

@@ -29,7 +29,6 @@
     GraphQLEnumType,
     GraphQLEnumValue,
     GraphQLField,
-    GraphQLID,
     GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
@@ -46,25 +45,6 @@
 from .graphql_utils import GraphQLElementType, convert_name_for_graphql_schema
 from .metadata_tracker import build_field_path
 
-
-def _extract_extended_attributes(row: pd.Series, extended_attributes: tuple[str, ...]) -> dict[str, Any]:
-    """
-    Extract extended attributes from a DataFrame row.
-
-    Args:
-        row: pandas Series (DataFrame row) containing VSS node data
-        extended_attributes: Tuple of extended attribute names to extract
-
-    Returns:
-        Dictionary containing only the extended attributes that exist and are not NA
-    """
-    extracted = {}
-    for ext_attr in extended_attributes:
-        if ext_attr in row.index and pd.notna(row.get(ext_attr)):
-            extracted[ext_attr] = row[ext_attr]
-    return extracted
-
-
 # Initialize inflect engine for pluralization (singleton)
 _inflect_engine = inflect.engine()
 
@@ -375,10 +355,6 @@ def create_struct_types(
 
             field_path = build_field_path(type_name, field_name)
             field_metadata = {"element": "STRUCT_PROPERTY", "fqn": prop_fqn}
-
-            # Capture extended attributes if present
-            field_metadata.update(_extract_extended_attributes(prop_row, extended_attributes))
-
             vspec_comments["field_vss_types"][field_path] = field_metadata
 
             if pd.notna(prop_row.get("min")) or pd.notna(prop_row.get("max")):
@@ -394,10 +370,7 @@ def create_struct_types(
             name=type_name, fields=fields, description=struct_row.get("description", "")
         )
 
-        # Store type-level metadata including extended attributes
-        type_metadata = {"element": "STRUCT", "fqn": fqn}
-        type_metadata.update(_extract_extended_attributes(struct_row, extended_attributes))
-        vspec_comments["vss_types"][type_name] = type_metadata
+        vspec_comments["vss_types"][type_name] = {"element": "STRUCT", "fqn": fqn}
 
     return struct_types
 
@@ -513,8 +486,6 @@ def get_fields() -> dict[str, GraphQLField]:
         fields = {}
 
         # System fields
-        if type_name == "Vehicle" or branch_row.get("instances"):
-            fields["id"] = GraphQLField(GraphQLNonNull(GraphQLID))
         if instance_tag_type := vspec_comments.get("instance_tag_types", {}).get(type_name):
             if instance_tag_type in types_registry:
                 fields["instanceTag"] = GraphQLField(types_registry[instance_tag_type])
@@ -536,12 +507,7 @@ def get_fields() -> dict[str, GraphQLField]:
             field_path = build_field_path(type_name, field_name)
 
             if leaf_type := _get_vss_type_if_valid(leaf_row):
-                field_metadata = {"element": leaf_type, "fqn": child_fqn}
-
-                # Capture extended attributes if present
-                field_metadata.update(_extract_extended_attributes(leaf_row, extended_attributes))
-
-                vspec_comments["field_vss_types"][field_path] = field_metadata
+                vspec_comments["field_vss_types"][field_path] = {"element": leaf_type, "fqn": child_fqn}
 
             if pd.notna(leaf_row.get("min")) or pd.notna(leaf_row.get("max")):
                 vspec_comments["field_ranges"][field_path] = {
@@ -597,14 +563,15 @@ def get_fields() -> dict[str, GraphQLField]:
                     {"fqn": child_fqn, "plural_field_name": plural_field_name, "path_in_graphql_model": field_path}
                 )
             else:
+                field_path = build_field_path(type_name, field_name)
                 fields[field_name] = GraphQLField(child_type)
 
+            # Annotate field with @vspec directive (shared for both cases)
+            vspec_comments["field_vss_types"][field_path] = {"element": "BRANCH", "fqn": child_fqn}
+
         return fields
 
-    # Store type-level metadata including extended attributes
-    type_metadata = {"element": "BRANCH", "fqn": fqn}
-    type_metadata.update(_extract_extended_attributes(branch_row, extended_attributes))
-    vspec_comments["vss_types"][type_name] = type_metadata
+    vspec_comments["vss_types"][type_name] = {"element": "BRANCH", "fqn": fqn}
 
     return GraphQLObjectType(name=type_name, fields=get_fields, description=branch_row.get("description", ""))
 
@@ -647,17 +614,12 @@ def get_hoisted_fields(
             field_path = build_field_path(parent_type_name, hoisted_field_name)
 
             if leaf_type := _get_vss_type_if_valid(leaf_row):
-                field_metadata = {
+                vspec_comments["field_vss_types"][field_path] = {
                     "element": leaf_type,
                     "fqn": leaf_fqn,
                     "instantiate": False,
                 }
 
-                # Capture extended attributes if present
-                field_metadata.update(_extract_extended_attributes(leaf_row, extended_attributes))
-
-                vspec_comments["field_vss_types"][field_path] = field_metadata
-
             if pd.notna(leaf_row.get("min")) or pd.notna(leaf_row.get("max")):
                 vspec_comments["field_ranges"][field_path] = {
                     "min": leaf_row.get("min") if pd.notna(leaf_row.get("min")) else None,

tests/test_s2dm_exporter.py

@@ -751,8 +751,12 @@ def test_instance_dimension_enum_sanitization(self):
         assert 'REAR_LEFT @vspec(metadata: [{key: "originalName", value: "RearLeft"}])' in schema_str
         assert 'REAR_RIGHT @vspec(metadata: [{key: "originalName", value: "RearRight"}])' in schema_str
 
-    def test_extended_attributes_in_metadata(self):
-        """Test that extended attributes are captured and added to @vspec metadata."""
+    def test_extended_attributes_not_in_schema_metadata(self):
+        """Test that extended attributes are not annotated in @vspec schema metadata.
+
+        Extended attributes are available via the sidecar vspec lookup, so they are
+        intentionally omitted from the schema to keep it minimal.
+        """
         # Load the test vspec with extended attributes
         tree, _ = get_trees(
             vspec=Path("tests/vspec/test_s2dm/test_extended_attributes.vspec"),
@@ -771,24 +775,19 @@ def test_extended_attributes_in_metadata(self):
         )
         schema_str = print_schema_with_vspec_directives(schema, unit_metadata, allowed_metadata, vspec_comments)
 
-        # Check Vehicle.Speed has source and quality in metadata
+        # Fields are still annotated with element + fqn
         assert "speed(unit: RelationUnitEnum = PERCENT): Float" in schema_str
         assert '@vspec(element: SENSOR, fqn: "Vehicle.Speed"' in schema_str
-        assert '{key: "source", value: "ecu0xAA"}' in schema_str
-        assert '{key: "quality", value: "100"}' in schema_str
-
-        # Check Vehicle.Temperature has source, quality, and calibration
-        assert "temperature(unit: AngleUnitEnum = DEGREE): Int16" in schema_str
         assert '@vspec(element: SENSOR, fqn: "Vehicle.Temperature"' in schema_str
-        assert '{key: "source", value: "ecu0xBB"}' in schema_str
-        assert '{key: "quality", value: "95"}' in schema_str
-        assert '{key: "calibration", value: "factory"}' in schema_str
-
-        # Check Vehicle.Info.Model has customMetadata and anotherAttribute
         assert "model: String" in schema_str
         assert '@vspec(element: ATTRIBUTE, fqn: "Vehicle.Info.Model"' in schema_str
-        assert '{key: "customMetadata", value: "test_value"}' in schema_str
-        assert '{key: "anotherAttribute", value: "42"}' in schema_str
+
+        # Extended attributes are NOT annotated in @vspec metadata (available via sidecar instead)
+        assert '{key: "source"' not in schema_str
+        assert '{key: "quality"' not in schema_str
+        assert '{key: "calibration"' not in schema_str
+        assert '{key: "customMetadata"' not in schema_str
+        assert '{key: "anotherAttribute"' not in schema_str
 
     def test_empty_branches_are_skipped(self, caplog):
         """Test that empty branches (branches with no children) are skipped during export."""