feat(flags): Set up initial backend for feature management

posthog/api/__init__.py

@@ -31,6 +31,7 @@
     error_tracking,
     event_definition,
     exports,
+    feature,
     feature_flag,
     hog_function,
     hog_function_template,
@@ -159,6 +160,12 @@ def register_grandfathered_environment_nested_viewset(
     "project_activity_log",
     ["project_id"],
 )
+projects_router.register(
+    r"features",
+    feature.FeatureViewSet,
+    "project_feature_management",
+    ["project_id"],
+)
 project_feature_flags_router = projects_router.register(
     r"feature_flags",
     feature_flag.FeatureFlagViewSet,

posthog/api/early_access_feature.py

@@ -30,14 +30,7 @@ class MinimalEarlyAccessFeatureSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = EarlyAccessFeature
-        fields = [
-            "id",
-            "name",
-            "description",
-            "stage",
-            "documentationUrl",
-            "flagKey",
-        ]
+        fields = ["id", "name", "description", "stage", "documentationUrl", "flagKey"]
         read_only_fields = fields
 
 

posthog/api/feature.py

@@ -0,0 +1,111 @@
+from rest_framework import viewsets, serializers
+from rest_framework.response import Response
+from rest_framework.decorators import action
+from django.db.models import QuerySet
+from posthog.models import Feature
+from posthog.api.routing import TeamAndOrgViewSetMixin
+from posthog.api.forbid_destroy_model import ForbidDestroyModel
+from posthog.rbac.access_control_api_mixin import AccessControlViewSetMixin
+
+
+class FeatureSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Feature
+        fields = [
+            "id",
+            "name",
+            "description",
+            "documentation_url",
+            "issue_url",
+            "status",
+            "primary_feature_flag_id",
+            "created_at",
+            "updated_at",
+            "archived",
+            "deleted",
+        ]
+
+    def create(self, validated_data):
+        validated_data["team_id"] = self.context["team_id"]
+        return super().create(validated_data)
+
+    def get_primary_feature_flag(self, feature: Feature):
+        from posthog.api.feature_flag import FeatureFlagSerializer
+
+        return FeatureFlagSerializer(feature.primary_feature_flag, context=self.context).data
+
+    def get_early_access_features(self, feature: Feature):
+        from posthog.api.early_access_feature import EarlyAccessFeatureSerializer
+
+        return EarlyAccessFeatureSerializer(feature.earlyaccessfeature_set, many=True).data
+
+    def get_experiments(self, feature: Feature):
+        from posthog.api.web_experiment import WebExperimentsAPISerializer
+
+        return WebExperimentsAPISerializer(feature.experiment_set, many=True).data
+
+    def get_feature_flags(self, feature: Feature):
+        from posthog.api.feature_flag import FeatureFlagSerializer
+
+        return FeatureFlagSerializer(feature.featureflag_set, context=self.context, many=True).data
+
+
+class FeatureViewSet(TeamAndOrgViewSetMixin, AccessControlViewSetMixin, ForbidDestroyModel, viewsets.ModelViewSet):
+    scope_object = "feature"
+    queryset = Feature.objects.all()
+    serializer_class = FeatureSerializer
+
+    def safely_get_queryset(self, queryset) -> QuerySet:
+        # Base queryset with team filtering
+        queryset = Feature.objects.filter(team_id=self.team_id)
+
+        if self.action == "primary_feature_flag":
+            queryset = queryset.select_related("primary_feature_flag")
+        elif self.action == "experiments":
+            queryset = queryset.prefetch_related("experiment_set")
+        elif self.action == "early_access_features":
+            queryset = queryset.prefetch_related("earlyaccessfeature_set")
+        elif self.action == "feature_flags":
+            queryset = queryset.prefetch_related("featureflag_set")
+
+        return queryset
+
+    @action(detail=True, methods=["get"])
+    def primary_feature_flag(self, request, pk=None, **kwargs):
+        """
+        Get primary feature flag associated with a specific feature.
+        """
+        feature = self.get_object()
+        serializer = self.get_serializer(feature)
+        primary_feature_flag = serializer.get_primary_feature_flag(feature)
+        return Response(primary_feature_flag)
+
+    @action(detail=True, methods=["get"])
+    def feature_flags(self, request, pk=None, **kwargs):
+        """
+        Get all feature flags associated with a specific feature.
+        """
+        feature = self.get_object()
+        serializer = self.get_serializer(feature)
+        flags = serializer.get_feature_flags(feature)
+        return Response(flags)
+
+    @action(detail=True, methods=["get"])
+    def experiments(self, request, pk=None, **kwargs):
+        """
+        Get experiments associated with a specific feature.
+        """
+        feature = self.get_object()
+        serializer = self.get_serializer(feature)
+        experiments = serializer.get_experiments(feature)
+        return Response(experiments)
+
+    @action(detail=True, methods=["get"])
+    def early_access_features(self, request, pk=None, **kwargs):
+        """
+        Get early access features associated with a specific feature.
+        """
+        feature = self.get_object()
+        serializer = self.get_serializer(feature)
+        early_access_features = serializer.get_early_access_features(feature)
+        return Response(early_access_features)

posthog/api/test/test_feature.py

@@ -0,0 +1,204 @@
+from rest_framework import status
+
+from posthog.models import Feature, FeatureFlag, Experiment, EarlyAccessFeature, Team
+from posthog.test.base import APIBaseTest
+
+
+class TestFeatureAPI(APIBaseTest):
+    def setUp(self):
+        super().setUp()
+        self.feature = Feature.objects.create(
+            team=self.team,
+            name="Test Feature",
+            description="Test Description",
+            documentation_url="http://example.com",
+            issue_url="http://github.com/example",
+            status="beta",
+        )
+
+    def test_list_features(self):
+        # Create a feature flag and experiment for the feature, ensure they are not returned in the response
+        Experiment.objects.create(
+            team=self.team,
+            name="Test Experiment",
+            feature=self.feature,
+            feature_flag=FeatureFlag.objects.create(
+                team=self.team,
+                name="Test Flag for Experiment",
+                key="test-flag-for-experiment-list",
+                feature=self.feature,
+            ),
+        )
+        EarlyAccessFeature.objects.create(
+            team=self.team,
+            name="Test EAF",
+            description="Test Description",
+            feature=self.feature,
+        )
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.json()["results"]), 1)
+        self.assertEqual(response.json()["results"][0]["name"], "Test Feature")
+
+        # Ensure we are not returning joined data
+        with self.assertRaises(KeyError):
+            response.json()["results"][0]["experiments"]
+        with self.assertRaises(KeyError):
+            response.json()["results"][0]["feature_flags"]
+        with self.assertRaises(KeyError):
+            response.json()["results"][0]["early_access_features"]
+
+    def test_retrieve_feature(self):
+        Experiment.objects.create(
+            team=self.team,
+            name="Test Experiment",
+            feature=self.feature,
+            feature_flag=FeatureFlag.objects.create(
+                team=self.team,
+                name="Test Flag for Experiment",
+                key="test-flag-for-experiment-retrieve",
+                feature=self.feature,
+            ),
+        )
+        EarlyAccessFeature.objects.create(
+            team=self.team,
+            name="Test EAF",
+            description="Test Description",
+            feature=self.feature,
+        )
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/{self.feature.id}/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json()["name"], "Test Feature")
+        self.assertEqual(response.json()["description"], "Test Description")
+
+        # Ensure we are not returning joined data
+        with self.assertRaises(KeyError):
+            response.json()["experiments"]
+        with self.assertRaises(KeyError):
+            response.json()["feature_flags"]
+        with self.assertRaises(KeyError):
+            response.json()["early_access_features"]
+
+    def test_create_feature(self):
+        response = self.client.post(
+            f"/api/projects/{self.team.id}/features/",
+            {
+                "name": "New Feature",
+                "team_id": self.team.id,
+                "description": "New Description",
+                "documentation_url": "http://example.com/new",
+                "issue_url": "http://github.com/example/new",
+                "status": "alpha",
+            },
+        )
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertEqual(response.json()["name"], "New Feature")
+        self.assertEqual(Feature.objects.count(), 2)
+
+    def test_update_feature(self):
+        response = self.client.patch(
+            f"/api/projects/{self.team.id}/features/{self.feature.id}/",
+            {
+                "name": "Updated Feature",
+                "status": "beta",
+            },
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json()["name"], "Updated Feature")
+        self.assertEqual(response.json()["status"], "beta")
+
+    def test_delete_not_allowed(self):
+        response = self.client.delete(f"/api/projects/{self.team.id}/features/{self.feature.id}/")
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+
+    def test_get_primary_feature_flag(self):
+        flag = FeatureFlag.objects.create(
+            team=self.team,
+            name="Test Flag",
+            key="test-flag",
+            feature=self.feature,
+        )
+        self.feature.primary_feature_flag = flag
+        self.feature.save()
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/{self.feature.id}/primary_feature_flag/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json()["key"], "test-flag")
+
+    def test_get_experiments(self):
+        Experiment.objects.create(
+            team=self.team,
+            name="Test Experiment",
+            feature_flag=FeatureFlag.objects.create(
+                team=self.team,
+                name="Test Flag",
+                key="test-flag",
+            ),
+            feature=self.feature,
+            description="Test Description",
+        )
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/{self.feature.id}/experiments/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.json()), 1)
+        self.assertEqual(response.json()[0]["name"], "Test Experiment")
+
+    def test_get_early_access_features(self):
+        EarlyAccessFeature.objects.create(
+            team=self.team,
+            name="Test EAF",
+            description="Test Description",
+            feature=self.feature,
+        )
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/{self.feature.id}/early_access_features/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.json()), 1)
+        self.assertEqual(response.json()[0]["name"], "Test EAF")
+
+    def test_get_feature_flags(self):
+        FeatureFlag.objects.create(
+            team=self.team,
+            name="Test Flag",
+            key="test-flag",
+            feature=self.feature,
+        )
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/{self.feature.id}/feature_flags/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.json()), 1)
+        self.assertEqual(response.json()[0]["key"], "test-flag")
+
+    def test_cannot_create_feature_without_name(self):
+        response = self.client.post(
+            f"/api/projects/{self.team.id}/features/",
+            {
+                "team": self.team.id,
+                "description": "New Description",
+            },
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("name", response.json()["attr"])
+
+    def test_cannot_access_feature_from_another_team(self):
+        other_team = Team.objects.create(
+            organization=self.organization,
+            api_token=self.CONFIG_API_TOKEN + "2",
+            test_account_filters=[
+                {
+                    "key": "email",
+                    "value": "@posthog.com",
+                    "operator": "not_icontains",
+                    "type": "person",
+                }
+            ],
+        )
+        other_feature = Feature.objects.create(
+            team=other_team,
+            name="Other Feature",
+        )
+
+        response = self.client.get(f"/api/projects/{self.team.id}/features/{other_feature.id}/")
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)