feat: Add metadata fields to core entities (FE)

api/conftest.py

@@ -505,6 +505,46 @@ def required_a_environment_metadata_field(
     return model_field
 
 
+@pytest.fixture()
+def required_a_feature_metadata_field(
+    organisation,
+    a_metadata_field,
+    feature_content_type,
+    project,
+    project_content_type,
+):
+    model_field = MetadataModelField.objects.create(
+        field=a_metadata_field,
+        content_type=feature_content_type,
+    )
+
+    MetadataModelFieldRequirement.objects.create(
+        content_type=project_content_type, object_id=project.id, model_field=model_field
+    )
+
+    return model_field
+
+
+@pytest.fixture()
+def required_a_segment_metadata_field(
+    organisation,
+    a_metadata_field,
+    segment_content_type,
+    project,
+    project_content_type,
+):
+    model_field = MetadataModelField.objects.create(
+        field=a_metadata_field,
+        content_type=segment_content_type,
+    )
+
+    MetadataModelFieldRequirement.objects.create(
+        content_type=project_content_type, object_id=project.id, model_field=model_field
+    )
+
+    return model_field
+
+
 @pytest.fixture()
 def optional_b_environment_metadata_field(organisation, b_metadata_field, environment):
     environment_type = ContentType.objects.get_for_model(environment)
@@ -542,6 +582,16 @@ def environment_content_type():
     return ContentType.objects.get_for_model(Environment)
 
 
+@pytest.fixture()
+def feature_content_type():
+    return ContentType.objects.get_for_model(Feature)
+
+
+@pytest.fixture()
+def segment_content_type():
+    return ContentType.objects.get_for_model(Segment)
+
+
 @pytest.fixture()
 def project_content_type():
     return ContentType.objects.get_for_model(Project)

api/features/models.py

@@ -11,6 +11,7 @@
     SoftDeleteExportableModel,
     abstract_base_auditable_model_factory,
 )
+from django.contrib.contenttypes.fields import GenericRelation
 from django.core.exceptions import (
     NON_FIELD_ERRORS,
     ObjectDoesNotExist,
@@ -72,6 +73,7 @@
     STRING,
 )
 from features.versioning.models import EnvironmentFeatureVersion
+from metadata.models import Metadata
 from projects.models import Project
 from projects.tags.models import Tag
 
@@ -124,6 +126,8 @@ class Feature(
 
     objects = FeatureManager()
 
+    metadata = GenericRelation(Metadata)
+
     class Meta:
         # Note: uniqueness index is added in explicit SQL in the migrations (See 0005, 0050)
         # TODO: after upgrade to Django 4.0 use UniqueConstraint()

api/features/serializers.py

@@ -10,6 +10,7 @@
 from environments.sdk.serializers_mixins import (
     HideSensitiveFieldsSerializerMixin,
 )
+from metadata.serializers import MetadataSerializer, SerializerWithMetadata
 from projects.models import Project
 from users.serializers import (
     UserIdsSerializer,
@@ -245,11 +246,34 @@ def get_num_identity_overrides(self, instance) -> typing.Optional[int]:
             return None
 
 
-class UpdateFeatureSerializer(ListCreateFeatureSerializer):
-    """prevent users from changing certain values after creation"""
+class FeatureSerializerWithMetadata(
+    SerializerWithMetadata, ListCreateFeatureSerializer
+):
+    metadata = MetadataSerializer(required=False, many=True)
 
     class Meta(ListCreateFeatureSerializer.Meta):
-        read_only_fields = ListCreateFeatureSerializer.Meta.read_only_fields + (
+        fields = ListCreateFeatureSerializer.Meta.fields + ("metadata",)
+
+    def get_project(self, validated_data: dict = None) -> Project:
+        view = self.context.get("view")
+
+        if view and "project_pk" in view.kwargs:
+            project_pk = view.kwargs["project_pk"]
+            try:
+                return Project.objects.get(pk=project_pk)
+            except Project.DoesNotExist:
+                raise serializers.ValidationError("Project not found.")
+
+        raise serializers.ValidationError(
+            "Unable to retrieve project for metadata validation."
+        )
+
+
+class UpdateFeatureSerializer(FeatureSerializerWithMetadata):
+    """prevent users from changing certain values after creation"""
+
+    class Meta(FeatureSerializerWithMetadata.Meta):
+        read_only_fields = FeatureSerializerWithMetadata.Meta.read_only_fields + (
             "default_enabled",
             "initial_value",
             "name",

api/features/views.py

@@ -55,6 +55,7 @@
     FeatureInfluxDataSerializer,
     FeatureOwnerInputSerializer,
     FeatureQuerySerializer,
+    FeatureSerializerWithMetadata,
     FeatureStateSerializerBasic,
     FeatureStateSerializerCreate,
     FeatureStateSerializerFull,
@@ -103,9 +104,9 @@ class FeatureViewSet(viewsets.ModelViewSet):
 
     def get_serializer_class(self):
         return {
-            "list": ListCreateFeatureSerializer,
-            "retrieve": ListCreateFeatureSerializer,
-            "create": ListCreateFeatureSerializer,
+            "list": FeatureSerializerWithMetadata,
+            "retrieve": FeatureSerializerWithMetadata,
+            "create": FeatureSerializerWithMetadata,
             "update": UpdateFeatureSerializer,
             "partial_update": UpdateFeatureSerializer,
         }.get(self.action, ProjectFeatureSerializer)

api/metadata/models.py

@@ -12,7 +12,7 @@
 
 FIELD_VALUE_MAX_LENGTH = 2000
 
-METADATA_SUPPORTED_MODELS = ["environment"]
+METADATA_SUPPORTED_MODELS = ["environment", "feature", "segment"]
 
 # A map of model name to a function that takes the object id and returns the organisation_id
 SUPPORTED_REQUIREMENTS_MAPPING = {
@@ -21,7 +21,19 @@
         "project": lambda project_id: Project.objects.get(
             id=project_id
         ).organisation_id,
-    }
+    },
+    "feature": {
+        "organisation": lambda org_id: org_id,
+        "project": lambda project_id: Project.objects.get(
+            id=project_id
+        ).organisation_id,
+    },
+    "segment": {
+        "organisation": lambda org_id: org_id,
+        "project": lambda project_id: Project.objects.get(
+            id=project_id
+        ).organisation_id,
+    },
 }
 
 

api/segments/models.py

@@ -7,13 +7,15 @@
     SoftDeleteExportableModel,
     abstract_base_auditable_model_factory,
 )
+from django.contrib.contenttypes.fields import GenericRelation
 from django.core.exceptions import ValidationError
 from django.db import models
 from flag_engine.segments import constants
 
 from audit.constants import SEGMENT_CREATED_MESSAGE, SEGMENT_UPDATED_MESSAGE
 from audit.related_object_type import RelatedObjectType
 from features.models import Feature
+from metadata.models import Metadata
 from projects.models import Project
 
 logger = logging.getLogger(__name__)
@@ -35,6 +37,8 @@ class Segment(
         Feature, on_delete=models.CASCADE, related_name="segments", null=True
     )
 
+    metadata = GenericRelation(Metadata)
+
     class Meta:
         ordering = ("id",)  # explicit ordering to prevent pagination warnings
 

api/segments/serializers.py

@@ -1,11 +1,14 @@
 import typing
 
+from django.contrib.contenttypes.models import ContentType
 from flag_engine.segments.constants import PERCENTAGE_SPLIT
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 from rest_framework.serializers import ListSerializer
 from rest_framework_recursive.fields import RecursiveField
 
+from metadata.models import Metadata
+from metadata.serializers import MetadataSerializer
 from projects.models import Project
 from segments.models import Condition, Segment, SegmentRule
 
@@ -41,6 +44,7 @@ class Meta:
 
 class SegmentSerializer(serializers.ModelSerializer):
     rules = RuleSerializer(many=True)
+    metadata = MetadataSerializer(required=False, many=True)
 
     class Meta:
         model = Segment
@@ -58,12 +62,14 @@ def create(self, validated_data):
         self.validate_project_segment_limit(project)
 
         rules_data = validated_data.pop("rules", [])
+        metadata_data = validated_data.pop("metadata", [])
 
         # create segment with nested rules and conditions
         segment = Segment.objects.create(**validated_data)
         self._update_or_create_segment_rules(
             rules_data, segment=segment, is_create=True
         )
+        self._update_or_create_metadata(metadata_data, segment=segment)
         return segment
 
     def validate_project_segment_limit(self, project: Project) -> None:
@@ -120,6 +126,22 @@ def _update_or_create_segment_rules(
                 child_rules, rule=child_rule, is_create=is_create
             )
 
+    def _update_or_create_metadata(self, metadata_data, segment=None):
+        for metadata_item in metadata_data:
+            metadata_id = metadata_item.pop("id", None)
+            if metadata_item.get("delete"):
+                Metadata.objects.filter(id=metadata_id).delete()
+                continue
+
+            Metadata.objects.update_or_create(
+                id=metadata_id,
+                defaults={
+                    **metadata_item,
+                    "content_type": ContentType.objects.get_for_model(Segment),
+                    "object_id": segment.id,
+                },
+            )
+
     @staticmethod
     def _update_or_create_segment_rule(
         rule_data: dict, segment: Segment = None, rule: SegmentRule = None

api/tests/unit/features/test_unit_features_views.py

@@ -2219,6 +2219,42 @@ def test_cannot_update_feature_of_a_feature_state(
     )
 
 
+@pytest.mark.parametrize(
+    "client",
+    [lazy_fixture("admin_master_api_key_client"), lazy_fixture("admin_client")],
+)
+def test_create_feature_with_required_metadata_returns_201(
+    project,
+    client,
+    required_a_feature_metadata_field,
+):
+    # Given
+    url = reverse("api-v1:projects:project-features-list", args=[project.id])
+    description = "This is the description"
+    field_value = 10
+    data = {
+        "name": "Test feature",
+        "description": description,
+        "metadata": [
+            {
+                "model_field": required_a_feature_metadata_field.id,
+                "field_value": field_value,
+            },
+        ],
+    }
+
+    # When
+    response = client.post(url, data=json.dumps(data), content_type="application/json")
+
+    # Then
+    assert response.status_code == status.HTTP_201_CREATED
+    assert (
+        response.json()["metadata"][0]["model_field"]
+        == required_a_feature_metadata_field.field.id
+    )
+    assert response.json()["metadata"][0]["field_value"] == str(field_value)
+
+
 def test_create_segment_override__using_simple_feature_state_viewset__allows_manage_segment_overrides(
     staff_client: APIClient,
     with_environment_permissions: Callable[
@@ -2399,7 +2435,7 @@ def test_list_features_n_plus_1(
         v1_feature_state.clone(env=environment, version=i, live_from=timezone.now())
 
     # When
-    with django_assert_num_queries(14):
+    with django_assert_num_queries(15):
         response = staff_client.get(url)
 
     # Then