feat: Add metadata fields to core entities (API)

api/conftest.py

@@ -481,23 +481,23 @@ def task_processor_synchronously(settings):
 
 
 @pytest.fixture()
-def a_metadata_field(organisation):
+def a_metadata_field(organisation: Organisation) -> MetadataField:
     return MetadataField.objects.create(name="a", type="int", organisation=organisation)
 
 
 @pytest.fixture()
-def b_metadata_field(organisation):
+def b_metadata_field(organisation: Organisation) -> MetadataField:
     return MetadataField.objects.create(name="b", type="str", organisation=organisation)
 
 
 @pytest.fixture()
 def required_a_environment_metadata_field(
-    organisation,
-    a_metadata_field,
-    environment,
-    project,
-    project_content_type,
-):
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    environment: Environment,
+    project: Project,
+    project_content_type: ContentType,
+) -> MetadataModelField:
     environment_type = ContentType.objects.get_for_model(environment)
     model_field = MetadataModelField.objects.create(
         field=a_metadata_field,
@@ -511,7 +511,75 @@ def required_a_environment_metadata_field(
 
 
 @pytest.fixture()
-def optional_b_environment_metadata_field(organisation, b_metadata_field, environment):
+def required_a_feature_metadata_field(
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    feature_content_type: ContentType,
+    project: Project,
+    project_content_type: ContentType,
+) -> MetadataModelField:
+    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: Organisation,
+    a_metadata_field: MetadataField,
+    segment_content_type: ContentType,
+    project: Project,
+    project_content_type: ContentType,
+) -> MetadataModelField:
+    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_feature_metadata_field(
+    organisation: Organisation, b_metadata_field: MetadataField, feature: Feature
+) -> MetadataModelField:
+    feature_type = ContentType.objects.get_for_model(feature)
+
+    return MetadataModelField.objects.create(
+        field=b_metadata_field,
+        content_type=feature_type,
+    )
+
+
+@pytest.fixture()
+def optional_b_segment_metadata_field(
+    organisation: Organisation, b_metadata_field: MetadataField, segment: Segment
+) -> MetadataModelField:
+    segment_type = ContentType.objects.get_for_model(segment)
+
+    return MetadataModelField.objects.create(
+        field=b_metadata_field,
+        content_type=segment_type,
+    )
+
+
+@pytest.fixture()
+def optional_b_environment_metadata_field(
+    organisation: Organisation,
+    b_metadata_field: MetadataField,
+    environment: Environment,
+) -> MetadataModelField:
     environment_type = ContentType.objects.get_for_model(environment)
 
     return MetadataModelField.objects.create(
@@ -521,7 +589,10 @@ def optional_b_environment_metadata_field(organisation, b_metadata_field, enviro
 
 
 @pytest.fixture()
-def environment_metadata_a(environment, required_a_environment_metadata_field):
+def environment_metadata_a(
+    environment: Environment,
+    required_a_environment_metadata_field: MetadataModelFieldRequirement,
+) -> Metadata:
     environment_type = ContentType.objects.get_for_model(environment)
     return Metadata.objects.create(
         object_id=environment.id,
@@ -532,7 +603,10 @@ def environment_metadata_a(environment, required_a_environment_metadata_field):
 
 
 @pytest.fixture()
-def environment_metadata_b(environment, optional_b_environment_metadata_field):
+def environment_metadata_b(
+    environment: Environment,
+    optional_b_environment_metadata_field: MetadataModelFieldRequirement,
+) -> Metadata:
     environment_type = ContentType.objects.get_for_model(environment)
     return Metadata.objects.create(
         object_id=environment.id,
@@ -543,12 +617,22 @@ def environment_metadata_b(environment, optional_b_environment_metadata_field):
 
 
 @pytest.fixture()
-def environment_content_type():
+def environment_content_type() -> ContentType:
     return ContentType.objects.get_for_model(Environment)
 
 
 @pytest.fixture()
-def project_content_type():
+def feature_content_type() -> ContentType:
+    return ContentType.objects.get_for_model(Feature)
+
+
+@pytest.fixture()
+def segment_content_type() -> ContentType:
+    return ContentType.objects.get_for_model(Segment)
+
+
+@pytest.fixture()
+def project_content_type() -> ContentType:
     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
 
@@ -126,6 +128,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

@@ -11,6 +11,7 @@
 from environments.sdk.serializers_mixins import (
     HideSensitiveFieldsSerializerMixin,
 )
+from metadata.serializers import MetadataSerializer, SerializerWithMetadata
 from projects.models import Project
 from users.serializers import (
     UserIdsSerializer,
@@ -270,11 +271,33 @@ def get_last_modified_in_current_environment(
         return getattr(instance, "last_modified_in_current_environment", 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 := view.kwargs.get("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 UpdateFeatureSerializerWithMetadata(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,
@@ -66,7 +67,7 @@
     ProjectFeatureSerializer,
     SDKFeatureStateSerializer,
     SDKFeatureStatesQuerySerializer,
-    UpdateFeatureSerializer,
+    UpdateFeatureSerializerWithMetadata,
     WritableNestedFeatureStateSerializer,
 )
 from .tasks import trigger_feature_state_change_webhooks
@@ -103,11 +104,11 @@ class FeatureViewSet(viewsets.ModelViewSet):
 
     def get_serializer_class(self):
         return {
-            "list": ListCreateFeatureSerializer,
-            "retrieve": ListCreateFeatureSerializer,
-            "create": ListCreateFeatureSerializer,
-            "update": UpdateFeatureSerializer,
-            "partial_update": UpdateFeatureSerializer,
+            "list": FeatureSerializerWithMetadata,
+            "retrieve": FeatureSerializerWithMetadata,
+            "create": FeatureSerializerWithMetadata,
+            "update": UpdateFeatureSerializerWithMetadata,
+            "partial_update": UpdateFeatureSerializerWithMetadata,
         }.get(self.action, ProjectFeatureSerializer)
 
     def get_queryset(self):

api/metadata/models.py

@@ -12,7 +12,7 @@
 
 FIELD_VALUE_MAX_LENGTH = 2000
 
-METADATA_SUPPORTED_MODELS = ["environment"]
+METADATA_SUPPORTED_MODELS = ["environment", "feature", "project", "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

@@ -8,13 +8,15 @@
     abstract_base_auditable_model_factory,
 )
 from django.conf import settings
+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__)
@@ -40,6 +42,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,12 +1,15 @@
 import typing
 
 from django.conf import settings
+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
 
@@ -42,6 +45,7 @@ class Meta:
 
 class SegmentSerializer(serializers.ModelSerializer):
     rules = RuleSerializer(many=True)
+    metadata = MetadataSerializer(required=False, many=True)
 
     class Meta:
         model = Segment
@@ -59,13 +63,15 @@ def create(self, validated_data):
         self.validate_project_segment_limit(project)
 
         rules_data = validated_data.pop("rules", [])
+        metadata_data = validated_data.pop("metadata", [])
         self.validate_segment_rules_conditions_limit(rules_data)
 
         # 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 update(self, instance, validated_data):
@@ -156,6 +162,24 @@ def _update_or_create_segment_rules(
                 child_rules, rule=child_rule, is_create=is_create
             )
 
+    def _update_or_create_metadata(
+        self, metadata_data: typing.Dict, segment: typing.Optional[Segment] = None
+    ) -> 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