fix(nft): improve TraitAttribute validation

Author: onyb

app/api/nft/models.py

@@ -1,7 +1,14 @@
+import json
 from enum import Enum
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
 from pydantic.alias_generators import to_camel
 
 
@@ -11,6 +18,52 @@ def strip_trailing_slash_validator(v: str | None) -> str | None:
     return v
 
 
+class TraitAttribute(BaseModel):
+    trait_type: str
+    value: str | bool | int | float | None = None
+
+    @model_validator(mode="before")
+    def check_trait_type_omitted(cls, data):
+        if not isinstance(data, dict):
+            raise ValueError("TraitAttribute data must be a dictionary")
+
+        trait_type = data.get("trait_type", "").strip() or data.get("name", "").strip()
+
+        if not trait_type and not data.get("value"):
+            raise ValueError(
+                "Either trait_type or value must be provided for TraitAttribute"
+            )
+
+        data["trait_type"] = trait_type or "Unknown"
+
+        # Handle complex value types (dict, list) by serializing to JSON.
+        # If serialization fails, the TraitAttribute will be invalid and skipped.
+        value = data.get("value")
+        if isinstance(value, (dict, list)):
+            data["value"] = json.dumps(value)
+
+        return data
+
+
+class AttributesValidationMixin:
+    """Mixin to provide shared attribute validation logic for metadata classes."""
+
+    @field_validator("attributes", mode="before")
+    @classmethod
+    def validate_attributes(cls, v):
+        if not isinstance(v, list):
+            return []
+
+        # Filter out invalid attributes, keeping only valid ones
+        def is_valid_attribute(attr_data):
+            try:
+                return TraitAttribute.model_validate(attr_data)
+            except Exception:
+                return False
+
+        return [attr_data for attr_data in v if is_valid_attribute(attr_data)]
+
+
 class AlchemyTokenType(str, Enum):
     ERC721 = "ERC721"
     ERC1155 = "ERC1155"
@@ -42,12 +95,7 @@ def validate_urls(cls, v: str | None) -> str | None:
     model_config = ConfigDict(alias_generator=to_camel)
 
 
-class TraitAttribute(BaseModel):
-    trait_type: str
-    value: str | bool | int | float | None = None
-
-
-class AlchemyRawMetadata(BaseModel):
+class AlchemyRawMetadata(BaseModel, AttributesValidationMixin):
     name: str | None = None
     description: str | None = None
     image: str | None = None
@@ -59,16 +107,6 @@ class AlchemyRawMetadata(BaseModel):
     def validate_urls(cls, v: str | None) -> str | None:
         return strip_trailing_slash_validator(v)
 
-    @field_validator("attributes", mode="before")
-    @classmethod
-    def validate_attributes(cls, v):
-        if isinstance(v, list):
-            # Already in the correct format
-            return v
-        else:
-            # Return empty list for any other type (dict, string, etc.)
-            return []
-
     model_config = ConfigDict(alias_generator=to_camel)
 
 
@@ -198,7 +236,7 @@ def validate_image(cls, v: Any) -> str | None:
     )
 
 
-class SolanaAssetContentMetadata(BaseModel):
+class SolanaAssetContentMetadata(BaseModel, AttributesValidationMixin):
     name: str
     symbol: str | None = None
     description: str | None = None

app/api/nft/test_models.py

@@ -0,0 +1,79 @@
+import pytest
+from pydantic import ValidationError
+
+from app.api.nft.models import TraitAttribute
+
+
+@pytest.mark.parametrize(
+    "input_data,expected_trait_type,expected_value",
+    [
+        ({"trait_type": "Color", "value": "Red"}, "Color", "Red"),
+        ({"name": "Shape", "value": "Round"}, "Shape", "Round"),
+        ({"value": "Some Value"}, "Unknown", "Some Value"),
+        ({"trait_type": "", "value": "Empty String"}, "Unknown", "Empty String"),
+        ({"trait_type": "   ", "value": "Whitespace"}, "Unknown", "Whitespace"),
+        ({"trait_type": "Size"}, "Size", None),
+        ({"trait_type": "Name", "value": "Test"}, "Name", "Test"),
+        ({"trait_type": "Count", "value": 42}, "Count", 42),
+        ({"trait_type": "Price", "value": 1.99}, "Price", 1.99),
+        ({"trait_type": "Rare", "value": True}, "Rare", True),
+        ({"trait_type": "Test", "value": None}, "Test", None),
+        ({"trait_type": "Test", "value": ""}, "Test", ""),
+        (
+            {
+                "trait_type": "parent",
+                "value": {"parent": {"PARENT_CANNOT_SET_TTL": False}},
+            },
+            "parent",
+            '{"parent": {"PARENT_CANNOT_SET_TTL": false}}',
+        ),
+        (
+            {"trait_type": "tags", "value": ["tag1", "tag2", "tag3"]},
+            "tags",
+            '["tag1", "tag2", "tag3"]',
+        ),
+    ],
+)
+def test_trait_attribute_valid_cases(input_data, expected_trait_type, expected_value):
+    attr = TraitAttribute.model_validate(input_data)
+    assert attr.trait_type == expected_trait_type
+    assert attr.value == expected_value
+
+
+@pytest.mark.parametrize(
+    "input_data,expected_error",
+    [
+        ("not a dict", "TraitAttribute data must be a dictionary"),
+        ({}, "Either trait_type or value must be provided"),
+        ({"invalid_field": "value"}, "Either trait_type or value must be provided"),
+        (
+            {"trait_type": "", "value": None},
+            "Either trait_type or value must be provided for TraitAttribute",
+        ),
+        (
+            {"trait_type": "", "value": ""},
+            "Either trait_type or value must be provided for TraitAttribute",
+        ),
+        (
+            {"name": "", "value": None},
+            "Either trait_type or value must be provided for TraitAttribute",
+        ),
+        (
+            {"name": "", "value": ""},
+            "Either trait_type or value must be provided for TraitAttribute",
+        ),
+        (
+            {"value": None},
+            "Either trait_type or value must be provided for TraitAttribute",
+        ),
+        (
+            {"value": ""},
+            "Either trait_type or value must be provided for TraitAttribute",
+        ),
+    ],
+)
+def test_trait_attribute_invalid_cases(input_data, expected_error):
+    with pytest.raises(ValidationError) as exc_info:
+        TraitAttribute.model_validate(input_data)
+
+    assert expected_error in str(exc_info.value)