feat: add GitLab integration for project-level repository linking

Add GitLab integration to Flagsmith, allowing users to link GitLab
issues and merge requests to feature flags. Supports both GitLab.com
and self-managed instances via Group/Project Access Tokens.

## Backend
- New Django app `integrations/gitlab/` with models, views, client,
  webhook handling, async tasks, and serialisers
- `GitLabConfiguration` model (per-project) stores instance URL,
  access token, webhook secret, and linked GitLab project
- Webhook receiver at `/api/v1/gitlab-webhook/<project_id>/` handles
  merge request and issue events for automatic feature tagging
- Comment posting to GitLab issues/MRs when feature flags change
- Extend `FeatureExternalResource` with GITLAB_ISSUE and GITLAB_MR
  resource types, with lifecycle hooks dispatching to GitHub or GitLab
- Add `GITLAB` to `TagType` enum for feature tagging

## Frontend
- RTK Query services for GitLab integration and resource browsing
- GitLabSetupPage component with credentials form, repo selection,
  tagging toggle, and webhook URL display with copy-to-clipboard
- GitLabResourcesSelect for linking issues/MRs to feature flags
- Extend IntegrationList, ExternalResourcesLinkTab, and
  ExternalResourcesTable to support GitLab alongside GitHub

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: asaphko

api/api/urls/v1.py

@@ -11,6 +11,7 @@
 from features.feature_health.views import feature_health_webhook
 from features.views import SDKFeatureStates, get_multivariate_options
 from integrations.github.views import github_webhook
+from integrations.gitlab.views import gitlab_webhook
 from organisations.views import chargebee_webhook
 
 schema_view_permission_class = (  # pragma: no cover
@@ -42,6 +43,12 @@
     re_path(r"cb-webhook/", chargebee_webhook, name="chargebee-webhook"),
     # GitHub integration webhook
     re_path(r"github-webhook/", github_webhook, name="github-webhook"),
+    # GitLab integration webhook
+    re_path(
+        r"gitlab-webhook/(?P<project_pk>\d+)/",
+        gitlab_webhook,
+        name="gitlab-webhook",
+    ),
     re_path(r"cb-webhook/", chargebee_webhook, name="chargebee-webhook"),
     # Feature health webhook
     re_path(

api/app/settings/common.py

@@ -154,6 +154,7 @@
     "integrations.flagsmith",
     "integrations.launch_darkly",
     "integrations.github",
+    "integrations.gitlab",
     "integrations.grafana",
     # Rate limiting admin endpoints
     "axes",

api/conftest.py

@@ -51,6 +51,7 @@
 from features.versioning.tasks import enable_v2_versioning
 from features.workflows.core.models import ChangeRequest
 from integrations.github.models import GithubConfiguration, GitHubRepository
+from integrations.gitlab.models import GitLabConfiguration
 from metadata.models import (
     Metadata,
     MetadataField,
@@ -1219,6 +1220,19 @@ def github_repository(
     )
 
 
+@pytest.fixture()
+def gitlab_configuration(project: Project) -> GitLabConfiguration:
+    return GitLabConfiguration.objects.create(
+        project=project,
+        gitlab_instance_url="https://gitlab.example.com",
+        access_token="test-gitlab-token",
+        webhook_secret="test-webhook-secret",
+        gitlab_project_id=1,
+        project_name="testgroup/testrepo",
+        tagging_enabled=True,
+    )
+
+
 @pytest.fixture(params=AdminClientAuthType.__args__)  # type: ignore[attr-defined]
 def admin_client_auth_type(
     request: pytest.FixtureRequest,

api/features/feature_external_resources/models.py

@@ -14,8 +14,7 @@
 from environments.models import Environment
 from features.models import Feature, FeatureState
 from integrations.github.constants import GitHubEventType, GitHubTag
-from integrations.github.github import call_github_task
-from integrations.github.models import GitHubRepository
+from integrations.gitlab.constants import GitLabEventType, GitLabTag
 from organisations.models import Organisation
 from projects.tags.models import Tag, TagType
 
@@ -26,6 +25,9 @@ class ResourceType(models.TextChoices):
     # GitHub external resource types
     GITHUB_ISSUE = "GITHUB_ISSUE", "GitHub Issue"
     GITHUB_PR = "GITHUB_PR", "GitHub PR"
+    # GitLab external resource types
+    GITLAB_ISSUE = "GITLAB_ISSUE", "GitLab Issue"
+    GITLAB_MR = "GITLAB_MR", "GitLab MR"
 
 
 tag_by_type_and_state = {
@@ -39,6 +41,15 @@ class ResourceType(models.TextChoices):
         "merged": GitHubTag.PR_MERGED.value,
         "draft": GitHubTag.PR_DRAFT.value,
     },
+    ResourceType.GITLAB_ISSUE.value: {
+        "opened": GitLabTag.ISSUE_OPEN.value,
+        "closed": GitLabTag.ISSUE_CLOSED.value,
+    },
+    ResourceType.GITLAB_MR.value: {
+        "opened": GitLabTag.MR_OPEN.value,
+        "closed": GitLabTag.MR_CLOSED.value,
+        "merged": GitLabTag.MR_MERGED.value,
+    },
 }
 
 
@@ -67,12 +78,18 @@ class Meta:
 
     @hook(AFTER_SAVE)
     def execute_after_save_actions(self):  # type: ignore[no-untyped-def]
-        # Tag the feature with the external resource type
         metadata = json.loads(self.metadata) if self.metadata else {}
         state = metadata.get("state", "open")
 
-        # Add a comment to GitHub Issue/PR when feature is linked to the GH external resource
-        # and tag the feature with the corresponding tag if tagging is enabled
+        if self.type in (ResourceType.GITHUB_ISSUE, ResourceType.GITHUB_PR):
+            self._handle_github_after_save(state)
+        elif self.type in (ResourceType.GITLAB_ISSUE, ResourceType.GITLAB_MR):
+            self._handle_gitlab_after_save(state)
+
+    def _handle_github_after_save(self, state: str) -> None:
+        from integrations.github.github import call_github_task
+        from integrations.github.models import GitHubRepository
+
         if (
             github_configuration := Organisation.objects.prefetch_related(
                 "github_config"
@@ -130,17 +147,85 @@ def execute_after_save_actions(self):  # type: ignore[no-untyped-def]
                 feature_states=feature_states,
             )
 
+    def _handle_gitlab_after_save(self, state: str) -> None:
+        from integrations.gitlab.gitlab import call_gitlab_task
+        from integrations.gitlab.models import GitLabConfiguration
+
+        try:
+            gitlab_config = GitLabConfiguration.objects.get(
+                project=self.feature.project,
+                deleted_at__isnull=True,
+            )
+        except GitLabConfiguration.DoesNotExist:
+            return
+
+        if gitlab_config.tagging_enabled:
+            gitlab_tag, _ = Tag.objects.get_or_create(
+                label=tag_by_type_and_state[self.type][state],
+                project=self.feature.project,
+                is_system_tag=True,
+                type=TagType.GITLAB.value,
+            )
+            self.feature.tags.add(gitlab_tag)
+            self.feature.save()
+
+        feature_states: list[FeatureState] = []
+        environments = Environment.objects.filter(
+            project_id=self.feature.project_id
+        )
+        for environment in environments:
+            q = Q(
+                feature_id=self.feature_id,
+                identity__isnull=True,
+            )
+            feature_states.extend(
+                FeatureState.objects.get_live_feature_states(
+                    environment=environment, additional_filters=q
+                )
+            )
+
+        call_gitlab_task(
+            project_id=self.feature.project_id,
+            type=GitLabEventType.FEATURE_EXTERNAL_RESOURCE_ADDED.value,
+            feature=self.feature,
+            segment_name=None,
+            url=None,
+            feature_states=feature_states,
+        )
+
     @hook(BEFORE_DELETE)  # type: ignore[misc]
     def execute_before_save_actions(self) -> None:
-        # Add a comment to GitHub Issue/PR when feature is unlinked to the GH external resource
-        if (
-            Organisation.objects.prefetch_related("github_config")
-            .get(id=self.feature.project.organisation_id)
-            .github_config.first()
-        ):
-            call_github_task(
-                organisation_id=self.feature.project.organisation_id,  # type: ignore[arg-type]
-                type=GitHubEventType.FEATURE_EXTERNAL_RESOURCE_REMOVED.value,
+        if self.type in (ResourceType.GITHUB_ISSUE, ResourceType.GITHUB_PR):
+            from integrations.github.github import call_github_task
+
+            if (
+                Organisation.objects.prefetch_related("github_config")
+                .get(id=self.feature.project.organisation_id)
+                .github_config.first()
+            ):
+                call_github_task(
+                    organisation_id=self.feature.project.organisation_id,  # type: ignore[arg-type]
+                    type=GitHubEventType.FEATURE_EXTERNAL_RESOURCE_REMOVED.value,
+                    feature=self.feature,
+                    segment_name=None,
+                    url=self.url,
+                    feature_states=None,
+                )
+        elif self.type in (ResourceType.GITLAB_ISSUE, ResourceType.GITLAB_MR):
+            from integrations.gitlab.gitlab import call_gitlab_task
+            from integrations.gitlab.models import GitLabConfiguration
+
+            try:
+                GitLabConfiguration.objects.get(
+                    project=self.feature.project,
+                    deleted_at__isnull=True,
+                )
+            except GitLabConfiguration.DoesNotExist:
+                return
+
+            call_gitlab_task(
+                project_id=self.feature.project_id,
+                type=GitLabEventType.FEATURE_EXTERNAL_RESOURCE_REMOVED.value,
                 feature=self.feature,
                 segment_name=None,
                 url=self.url,

api/features/feature_external_resources/views.py

@@ -13,6 +13,9 @@
     label_github_issue_pr,
 )
 from integrations.github.models import GitHubRepository
+from integrations.gitlab.client import (
+    label_gitlab_issue_mr,
+)
 from organisations.models import Organisation
 
 from .models import FeatureExternalResource
@@ -58,9 +61,47 @@ def list(self, request, *args, **kwargs) -> Response:  # type: ignore[no-untyped
 
         for resource in data if isinstance(data, list) else []:
             if resource_url := resource.get("url"):
-                resource["metadata"] = get_github_issue_pr_title_and_state(
-                    organisation_id=organisation_id, resource_url=resource_url
-                )
+                resource_type = resource.get("type", "")
+                if resource_type.startswith("GITHUB_"):
+                    resource["metadata"] = get_github_issue_pr_title_and_state(
+                        organisation_id=organisation_id, resource_url=resource_url
+                    )
+                elif resource_type.startswith("GITLAB_"):
+                    try:
+                        from integrations.gitlab.client import (
+                            get_gitlab_issue_mr_title_and_state as get_gitlab_metadata,
+                        )
+                        from integrations.gitlab.models import (
+                            GitLabConfiguration,
+                        )
+                        import re as _re
+
+                        feature_obj = get_object_or_404(
+                            Feature.objects.filter(id=self.kwargs["feature_pk"]),
+                        )
+                        gitlab_config = GitLabConfiguration.objects.filter(
+                            project=feature_obj.project, deleted_at__isnull=True
+                        ).first()
+                        if gitlab_config and gitlab_config.gitlab_project_id:
+                            # Parse resource IID from URL
+                            if resource_type == "GITLAB_MR":
+                                match = _re.search(r"https?://[^/]+/([^/-]+(?:/[^/-]+)*)/-/merge_requests/(\d+)$", resource_url)
+                                api_type = "merge_requests"
+                            else:
+                                match = _re.search(r"https?://[^/]+/([^/-]+(?:/[^/-]+)*)/-/(?:issues|work_items)/(\d+)$", resource_url)
+                                api_type = "issues"
+
+                            if match:
+                                _project_path, iid = match.group(1), int(match.group(2))
+                                resource["metadata"] = get_gitlab_metadata(
+                                    instance_url=gitlab_config.gitlab_instance_url,
+                                    access_token=gitlab_config.access_token,
+                                    gitlab_project_id=gitlab_config.gitlab_project_id,
+                                    resource_type=api_type,
+                                    resource_iid=iid,
+                                )
+                    except Exception:
+                        pass
 
         return Response(data={"results": data})
 
@@ -71,6 +112,53 @@ def create(self, request, *args, **kwargs):  # type: ignore[no-untyped-def]
             ),
         )
 
+        resource_type = request.data.get("type", "")
+
+        # Handle GitLab resources
+        if resource_type in ("GITLAB_MR", "GITLAB_ISSUE"):
+            from integrations.gitlab.models import GitLabConfiguration
+
+            try:
+                gitlab_config = GitLabConfiguration.objects.get(
+                    project=feature.project,
+                    deleted_at__isnull=True,
+                )
+            except GitLabConfiguration.DoesNotExist:
+                return Response(
+                    data={
+                        "detail": "This Project doesn't have a valid GitLab integration configuration"
+                    },
+                    content_type="application/json",
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            url = request.data.get("url")
+            if resource_type == "GITLAB_MR":
+                pattern = r"https?://[^/]+/([^/-]+(?:/[^/-]+)*)/-/merge_requests/(\d+)$"
+            else:
+                pattern = r"https?://[^/]+/([^/-]+(?:/[^/-]+)*)/-/(?:issues|work_items)/(\d+)$"
+
+            url_match = re.search(pattern, url)
+            if url_match:
+                _project_path, resource_iid = url_match.groups()
+                api_resource_type = "merge_requests" if resource_type == "GITLAB_MR" else "issues"
+                if gitlab_config.tagging_enabled and gitlab_config.gitlab_project_id:
+                    label_gitlab_issue_mr(
+                        instance_url=gitlab_config.gitlab_instance_url,
+                        access_token=gitlab_config.access_token,
+                        gitlab_project_id=gitlab_config.gitlab_project_id,
+                        resource_type=api_resource_type,
+                        resource_iid=int(resource_iid),
+                    )
+                return super().create(request, *args, **kwargs)
+            else:
+                return Response(
+                    data={"detail": "Invalid GitLab Issue/MR URL"},
+                    content_type="application/json",
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        # Handle GitHub resources
         github_configuration = (
             Organisation.objects.prefetch_related("github_config")
             .get(id=feature.project.organisation_id)
@@ -88,9 +176,9 @@ def create(self, request, *args, **kwargs):  # type: ignore[no-untyped-def]
 
         # Get repository owner and name, and issue/PR number from the external resource URL
         url = request.data.get("url")
-        if request.data.get("type") == "GITHUB_PR":
+        if resource_type == "GITHUB_PR":
             pattern = r"github.com/([^/]+)/([^/]+)/pull/(\d+)$"
-        elif request.data.get("type") == "GITHUB_ISSUE":
+        elif resource_type == "GITHUB_ISSUE":
             pattern = r"github.com/([^/]+)/([^/]+)/issues/(\d+)$"
         else:
             return Response(

api/features/models.py

@@ -158,6 +158,24 @@ def create_github_comment(self) -> None:
                 feature_states=None,
             )
 
+        # GitLab comment posting
+        from integrations.gitlab.constants import GitLabEventType
+        from integrations.gitlab.gitlab import call_gitlab_task
+
+        if (
+            self.external_resources.exists()
+            and self.project.gitlab_project.exists()
+            and self.deleted_at
+        ):
+            call_gitlab_task(
+                project_id=self.project_id,
+                type=GitLabEventType.FLAG_DELETED.value,
+                feature=self,
+                segment_name=None,
+                url=None,
+                feature_states=None,
+            )
+
     @hook(AFTER_CREATE)
     def create_feature_states(self):  # type: ignore[no-untyped-def]
         FeatureState.create_initial_feature_states_for_feature(feature=self)
@@ -437,6 +455,23 @@ def create_github_comment(self) -> None:
                 None,
             )
 
+        # GitLab comment posting
+        from integrations.gitlab.constants import GitLabEventType
+        from integrations.gitlab.gitlab import call_gitlab_task
+
+        if (
+            self.feature.external_resources.exists()
+            and self.feature.project.gitlab_project.exists()
+        ):
+            call_gitlab_task(
+                self.feature.project_id,
+                GitLabEventType.SEGMENT_OVERRIDE_DELETED.value,
+                self.feature,
+                self.segment.name,
+                None,
+                None,
+            )
+
 
 class FeatureState(
     SoftDeleteExportableModel,