fix: add error code in project updation

* chore: workspace notifications refactor

* fix: url params

* fix: added null checks to avoid run time errors

* fix: notifications header color fix

.dockerignore

@@ -2,6 +2,7 @@
 *.pyc
 .env
 venv
+.venv
 node_modules/
 **/node_modules/
 npm-debug.log
@@ -14,4 +15,4 @@ build/
 out/
 **/out/
 dist/
-**/dist/
+**/dist/

.github/workflows/build-branch.yml

@@ -290,5 +290,6 @@ jobs:
             ${{ github.workspace }}/deploy/selfhost/setup.sh
             ${{ github.workspace }}/deploy/selfhost/swarm.sh
             ${{ github.workspace }}/deploy/selfhost/restore.sh
+            ${{ github.workspace }}/deploy/selfhost/restore-airgapped.sh
             ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
             ${{ github.workspace }}/deploy/selfhost/variables.env

.gitignore

@@ -53,6 +53,8 @@ mediafiles
 .env
 .DS_Store
 logs/
+htmlcov/
+.coverage
 
 node_modules/
 assets/dist/

CONTRIBUTING.md

@@ -69,14 +69,14 @@ chmod +x setup.sh
 docker compose -f docker-compose-local.yml up
 ```
 
-5. Start web apps:
+4. Start web apps:
 
 ```bash
 yarn dev
 ```
 
-6. Open your browser to http://localhost:3001/god-mode/ and register yourself as instance admin
-7. Open up your browser to http://localhost:3000 then log in using the same credentials from the previous step
+5. Open your browser to http://localhost:3001/god-mode/ and register yourself as instance admin
+6. Open up your browser to http://localhost:3000 then log in using the same credentials from the previous step
 
 That’s it! You’re all set to begin coding. Remember to refresh your browser if changes don’t auto-reload. Happy contributing! 🎉
 

admin/app/ai/form.tsx

@@ -26,16 +26,16 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
     formState: { errors, isSubmitting },
   } = useForm<AIFormValues>({
     defaultValues: {
-      OPENAI_API_KEY: config["OPENAI_API_KEY"],
-      GPT_ENGINE: config["GPT_ENGINE"],
+      LLM_API_KEY: config["LLM_API_KEY"],
+      LLM_MODEL: config["LLM_MODEL"],
     },
   });
 
   const aiFormFields: TControllerInputFormField[] = [
     {
-      key: "GPT_ENGINE",
+      key: "LLM_MODEL",
       type: "text",
-      label: "GPT_ENGINE",
+      label: "LLM Model",
       description: (
         <>
           Choose an OpenAI engine.{" "}
@@ -49,12 +49,12 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
           </a>
         </>
       ),
-      placeholder: "gpt-3.5-turbo",
-      error: Boolean(errors.GPT_ENGINE),
+      placeholder: "gpt-4o-mini",
+      error: Boolean(errors.LLM_MODEL),
       required: false,
     },
     {
-      key: "OPENAI_API_KEY",
+      key: "LLM_API_KEY",
       type: "password",
       label: "API key",
       description: (
@@ -71,7 +71,7 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
         </>
       ),
       placeholder: "sk-asddassdfasdefqsdfasd23das3dasdcasd",
-      error: Boolean(errors.OPENAI_API_KEY),
+      error: Boolean(errors.LLM_API_KEY),
       required: false,
     },
   ];

admin/package.json

@@ -1,7 +1,7 @@
 {
   "name": "admin",
   "description": "Admin UI for Plane",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "license": "AGPL-3.0",
   "private": true,
   "scripts": {
@@ -31,7 +31,7 @@
     "lucide-react": "^0.469.0",
     "mobx": "^6.12.0",
     "mobx-react": "^9.1.1",
-    "next": "^14.2.28",
+    "next": "^14.2.29",
     "next-themes": "^0.2.1",
     "postcss": "^8.4.38",
     "react": "^18.3.1",

apiserver/.coveragerc

@@ -0,0 +1,25 @@
+[run]
+source = plane
+omit =
+    */tests/*
+    */migrations/*
+    */settings/*
+    */wsgi.py
+    */asgi.py
+    */urls.py
+    manage.py
+    */admin.py
+    */apps.py
+
+[report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    if self.debug:
+    raise NotImplementedError
+    if __name__ == .__main__.
+    pass
+    raise ImportError
+
+[html]
+directory = htmlcov 

apiserver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plane-api",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "license": "AGPL-3.0",
   "private": true,
   "description": "API server powering Plane's backend"

apiserver/plane/api/views/issue.py

@@ -58,7 +58,7 @@ from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
 from .base import BaseAPIView
 from plane.utils.host import base_host
 from plane.bgtasks.webhook_task import model_activity
-
+from plane.bgtasks.work_item_link_task import crawl_work_item_link_title
 
 class WorkspaceIssueAPIEndpoint(BaseAPIView):
     """
@@ -692,6 +692,9 @@ class IssueLinkAPIEndpoint(BaseAPIView):
         serializer = IssueLinkSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(project_id=project_id, issue_id=issue_id)
+            crawl_work_item_link_title.delay(
+                serializer.data.get("id"), serializer.data.get("url")
+            )
 
             link = IssueLink.objects.get(pk=serializer.data["id"])
             link.created_by_id = request.data.get("created_by", request.user.id)
@@ -719,6 +722,9 @@ class IssueLinkAPIEndpoint(BaseAPIView):
         serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
         if serializer.is_valid():
             serializer.save()
+            crawl_work_item_link_title.delay(
+                serializer.data.get("id"), serializer.data.get("url")
+            )
             issue_activity.delay(
                 type="link.activity.updated",
                 requested_data=requested_data,

apiserver/plane/app/serializers/project.py

@@ -148,10 +148,13 @@ class ProjectMemberAdminSerializer(BaseSerializer):
         fields = "__all__"
 
 
-class ProjectMemberRoleSerializer(DynamicBaseSerializer):
+class ProjectMemberRoleSerializer(DynamicBaseSerializer): 
+    original_role = serializers.IntegerField(source='role', read_only=True)
+
     class Meta:
         model = ProjectMember
-        fields = ("id", "role", "member", "project")
+        fields = ("id", "role", "member", "project", "original_role", "created_at")
+        read_only_fields = ["original_role", "created_at"]
 
 
 class ProjectMemberInviteSerializer(BaseSerializer):

apiserver/plane/app/serializers/user.py

@@ -3,17 +3,21 @@ from rest_framework import serializers
 
 # Module import
 from plane.db.models import Account, Profile, User, Workspace, WorkspaceMemberInvite
-from plane.utils.url import clean_value
+from plane.utils.url import contains_url
+
 from .base import BaseSerializer
 
 
 class UserSerializer(BaseSerializer):
-
     def validate_first_name(self, value):
-        return clean_value(value)
+        if contains_url(value):
+            raise serializers.ValidationError("First name cannot contain a URL.")
+        return value
 
     def validate_last_name(self, value):
-        return clean_value(value)
+        if contains_url(value):
+            raise serializers.ValidationError("Last name cannot contain a URL.")
+        return value
 
     class Meta:
         model = User
@@ -106,11 +110,16 @@ class UserMeSettingsSerializer(BaseSerializer):
                 workspace_member__member=obj.id,
                 workspace_member__is_active=True,
             ).first()
+            logo_asset_url = workspace.logo_asset.asset_url if workspace.logo_asset is not None else ""
             return {
                 "last_workspace_id": profile.last_workspace_id,
                 "last_workspace_slug": (
                     workspace.slug if workspace is not None else ""
                 ),
+                "last_workspace_name": (
+                    workspace.name if workspace is not None else ""
+                ),
+                "last_workspace_logo": (logo_asset_url),
                 "fallback_workspace_id": profile.last_workspace_id,
                 "fallback_workspace_slug": (
                     workspace.slug if workspace is not None else ""

apiserver/plane/app/serializers/workspace.py

@@ -1,11 +1,7 @@
-# Django imports
-from django.core.validators import URLValidator
-from django.core.exceptions import ValidationError
-from django.template.defaultfilters import slugify
-
-
 # Third party imports
 from rest_framework import serializers
+from rest_framework import status
+from rest_framework.response import Response
 
 # Module imports
 from .base import BaseSerializer, DynamicBaseSerializer
@@ -29,7 +25,12 @@ from plane.db.models import (
     WorkspaceUserPreference,
 )
 from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
-from plane.utils.url import clean_value
+from plane.utils.url import contains_url
+
+# Django imports
+from django.core.validators import URLValidator
+from django.core.exceptions import ValidationError
+import re
 
 
 class WorkSpaceSerializer(DynamicBaseSerializer):
@@ -37,34 +38,22 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
     logo_url = serializers.CharField(read_only=True)
     role = serializers.IntegerField(read_only=True)
 
+    def validate_name(self, value):
+        # Check if the name contains a URL
+        if contains_url(value):
+            raise serializers.ValidationError("Name must not contain URLs")
+        return value
+
     def validate_slug(self, value):
         # Check if the slug is restricted
         if value in RESTRICTED_WORKSPACE_SLUGS:
             raise serializers.ValidationError("Slug is not valid")
-
-        # Clean the slug
-        slug = clean_value(value)
-
-        # If the slug is empty, return an error
-        if not slug:
-            raise serializers.ValidationError("Slug cannot be empty")
-
-        # Slugify the slug
-        slug = slugify(slug)
-
-        # Return the slug
-        return slug
-
-    def validate_name(self, value):
-        # Clean the name
-        name = clean_value(value)
-
-        # If the name is empty, return an error
-        if not name:
-            raise serializers.ValidationError("Name cannot be empty")
-
-        # Return the name
-        return name
+        # Slug should only contain alphanumeric characters, hyphens, and underscores
+        if not re.match(r"^[a-zA-Z0-9_-]+$", value):
+            raise serializers.ValidationError(
+                "Slug can only contain letters, numbers, hyphens (-), and underscores (_)"
+            )
+        return value
 
     class Meta:
         model = Workspace

apiserver/plane/app/urls/analytic.py

@@ -11,6 +11,9 @@ from plane.app.views import (
     AdvanceAnalyticsChartEndpoint,
     DefaultAnalyticsEndpoint,
     ProjectStatsEndpoint,
+    ProjectAdvanceAnalyticsEndpoint,
+    ProjectAdvanceAnalyticsStatsEndpoint,
+    ProjectAdvanceAnalyticsChartEndpoint,
 )
 
 
@@ -67,4 +70,19 @@ urlpatterns = [
         AdvanceAnalyticsChartEndpoint.as_view(),
         name="advance-analytics-chart",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics/",
+        ProjectAdvanceAnalyticsEndpoint.as_view(),
+        name="project-advance-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics-stats/",
+        ProjectAdvanceAnalyticsStatsEndpoint.as_view(),
+        name="project-advance-analytics-stats",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics-charts/",
+        ProjectAdvanceAnalyticsChartEndpoint.as_view(),
+        name="project-advance-analytics-chart",
+    ),
 ]

apiserver/plane/app/urls/asset.py

@@ -12,6 +12,7 @@ from plane.app.views import (
     AssetRestoreEndpoint,
     ProjectAssetEndpoint,
     ProjectBulkAssetEndpoint,
+    AssetCheckEndpoint,
 )
 
 
@@ -81,5 +82,11 @@ urlpatterns = [
     path(
         "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:entity_id>/bulk/",
         ProjectBulkAssetEndpoint.as_view(),
+        name="bulk-asset-update",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/check/<uuid:asset_id>/",
+        AssetCheckEndpoint.as_view(),
+        name="asset-check",
     ),
 ]

apiserver/plane/app/views/__init__.py

@@ -106,6 +106,7 @@ from .asset.v2 import (
     AssetRestoreEndpoint,
     ProjectAssetEndpoint,
     ProjectBulkAssetEndpoint,
+    AssetCheckEndpoint,
 )
 from .issue.base import (
     IssueListEndpoint,
@@ -205,6 +206,12 @@ from .analytic.advance import (
     AdvanceAnalyticsChartEndpoint,
 )
 
+from .analytic.project_analytics import (
+    ProjectAdvanceAnalyticsEndpoint,
+    ProjectAdvanceAnalyticsStatsEndpoint,
+    ProjectAdvanceAnalyticsChartEndpoint,
+)
+
 from .notification.base import (
     NotificationViewSet,
     UnreadNotificationEndpoint,

apiserver/plane/app/views/analytic/advance.py

@@ -5,7 +5,6 @@ from django.db.models import QuerySet, Q, Count
 from django.http import HttpRequest
 from django.db.models.functions import TruncMonth
 from django.utils import timezone
-from datetime import timedelta
 from plane.app.views.base import BaseAPIView
 from plane.app.permissions import ROLE, allow_permission
 from plane.db.models import (
@@ -19,10 +18,8 @@ from plane.db.models import (
     Workspace,
     CycleIssue,
     ModuleIssue,
+    ProjectMember,
 )
-from django.db import models
-from django.db.models import F, Case, When, Value
-from django.db.models.functions import Concat
 from plane.utils.build_chart import build_analytics_chart
 from plane.utils.date_utils import (
     get_analytics_filters,
@@ -75,32 +72,27 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
         }
 
     def get_overview_data(self) -> Dict[str, Dict[str, int]]:
+        members_query = WorkspaceMember.objects.filter(
+            workspace__slug=self._workspace_slug, is_active=True
+        )
+
+        if self.request.GET.get("project_ids", None):
+            project_ids = self.request.GET.get("project_ids", None)
+            project_ids = [str(project_id) for project_id in project_ids.split(",")]
+            members_query = ProjectMember.objects.filter(
+                project_id__in=project_ids, is_active=True
+            )
+
         return {
-            "total_users": self.get_filtered_counts(
-                WorkspaceMember.objects.filter(
-                    workspace__slug=self._workspace_slug, is_active=True
-                )
-            ),
+            "total_users": self.get_filtered_counts(members_query),
             "total_admins": self.get_filtered_counts(
-                WorkspaceMember.objects.filter(
-                    workspace__slug=self._workspace_slug,
-                    role=ROLE.ADMIN.value,
-                    is_active=True,
-                )
+                members_query.filter(role=ROLE.ADMIN.value)
             ),
             "total_members": self.get_filtered_counts(
-                WorkspaceMember.objects.filter(
-                    workspace__slug=self._workspace_slug,
-                    role=ROLE.MEMBER.value,
-                    is_active=True,
-                )
+                members_query.filter(role=ROLE.MEMBER.value)
             ),
             "total_guests": self.get_filtered_counts(
-                WorkspaceMember.objects.filter(
-                    workspace__slug=self._workspace_slug,
-                    role=ROLE.GUEST.value,
-                    is_active=True,
-                )
+                members_query.filter(role=ROLE.GUEST.value)
             ),
             "total_projects": self.get_filtered_counts(
                 Project.objects.filter(**self.filters["project_filters"])
@@ -113,30 +105,13 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
             ),
             "total_intake": self.get_filtered_counts(
                 Issue.objects.filter(**self.filters["base_filters"]).filter(
-                    issue_intake__isnull=False
+                    issue_intake__status__in=["-2", "0"]
                 )
             ),
         }
 
-    def get_work_items_stats(
-        self, cycle_id=None, module_id=None
-    ) -> Dict[str, Dict[str, int]]:
-        """
-        Returns work item stats for the workspace, or filtered by cycle_id or module_id if provided.
-        """
-        base_queryset = None
-        if cycle_id is not None:
-            cycle_issues = CycleIssue.objects.filter(
-                **self.filters["base_filters"], cycle_id=cycle_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
-        elif module_id is not None:
-            module_issues = ModuleIssue.objects.filter(
-                **self.filters["base_filters"], module_id=module_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
-        else:
-            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+    def get_work_items_stats(self) -> Dict[str, Dict[str, int]]:
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
 
         return {
             "total_work_items": self.get_filtered_counts(base_queryset),
@@ -165,11 +140,8 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
                 status=status.HTTP_200_OK,
             )
         elif tab == "work-items":
-            # Optionally accept cycle_id or module_id as query params
-            cycle_id = request.GET.get("cycle_id", None)
-            module_id = request.GET.get("module_id", None)
             return Response(
-                self.get_work_items_stats(cycle_id=cycle_id, module_id=module_id),
+                self.get_work_items_stats(),
                 status=status.HTTP_200_OK,
             )
         return Response({"message": "Invalid tab"}, status=status.HTTP_400_BAD_REQUEST)
@@ -188,7 +160,21 @@ class AdvanceAnalyticsStatsEndpoint(AdvanceAnalyticsBaseView):
             )
 
         return (
-            base_queryset.values("project_id", "project__name")
+            base_queryset.values("project_id", "project__name").annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
+                completed_work_items=Count("id", filter=Q(state__group="completed")),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
+                started_work_items=Count("id", filter=Q(state__group="started")),
+            )
+            .order_by("project_id")
+        )
+
+    def get_work_items_stats(self) -> Dict[str, Dict[str, int]]:
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+        return (
+            base_queryset
+            .values("project_id", "project__name")
             .annotate(
                 cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
                 completed_work_items=Count("id", filter=Q(state__group="completed")),
@@ -199,100 +185,14 @@ class AdvanceAnalyticsStatsEndpoint(AdvanceAnalyticsBaseView):
             .order_by("project_id")
         )
 
-    def get_work_items_stats(
-        self, cycle_id=None, module_id=None, peek_view=False
-    ) -> Dict[str, Dict[str, int]]:
-        base_queryset = None
-        if cycle_id is not None:
-            cycle_issues = CycleIssue.objects.filter(
-                **self.filters["base_filters"], cycle_id=cycle_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
-        elif module_id is not None:
-            module_issues = ModuleIssue.objects.filter(
-                **self.filters["base_filters"], module_id=module_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
-        elif peek_view:
-            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
-        else:
-            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
-            return (
-                base_queryset.values("project_id", "project__name")
-                .annotate(
-                    cancelled_work_items=Count(
-                        "id", filter=Q(state__group="cancelled")
-                    ),
-                    completed_work_items=Count(
-                        "id", filter=Q(state__group="completed")
-                    ),
-                    backlog_work_items=Count("id", filter=Q(state__group="backlog")),
-                    un_started_work_items=Count(
-                        "id", filter=Q(state__group="unstarted")
-                    ),
-                    started_work_items=Count("id", filter=Q(state__group="started")),
-                )
-                .order_by("project_id")
-            )
-
-        return (
-            base_queryset.annotate(display_name=F("assignees__display_name"))
-            .annotate(assignee_id=F("assignees__id"))
-            .annotate(avatar=F("assignees__avatar"))
-            .annotate(
-                avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True, then="assignees__avatar"
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .values("display_name", "assignee_id", "avatar_url")
-            .annotate(
-                cancelled_work_items=Count(
-                    "id", filter=Q(state__group="cancelled"), distinct=True
-                ),
-                completed_work_items=Count(
-                    "id", filter=Q(state__group="completed"), distinct=True
-                ),
-                backlog_work_items=Count(
-                    "id", filter=Q(state__group="backlog"), distinct=True
-                ),
-                un_started_work_items=Count(
-                    "id", filter=Q(state__group="unstarted"), distinct=True
-                ),
-                started_work_items=Count(
-                    "id", filter=Q(state__group="started"), distinct=True
-                ),
-            )
-            .order_by("display_name")
-        )
-
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
     def get(self, request: HttpRequest, slug: str) -> Response:
         self.initialize_workspace(slug, type="chart")
         type = request.GET.get("type", "work-items")
 
         if type == "work-items":
-            # Optionally accept cycle_id or module_id as query params
-            cycle_id = request.GET.get("cycle_id", None)
-            module_id = request.GET.get("module_id", None)
-            peek_view = request.GET.get("peek_view", False)
             return Response(
-                self.get_work_items_stats(
-                    cycle_id=cycle_id, module_id=module_id, peek_view=peek_view
-                ),
+                self.get_work_items_stats(),
                 status=status.HTTP_200_OK,
             )
 
@@ -352,9 +252,7 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             for key, value in data.items()
         ]
 
-    def work_item_completion_chart(
-        self, cycle_id=None, module_id=None, peek_view=False
-    ) -> Dict[str, Any]:
+    def work_item_completion_chart(self) -> Dict[str, Any]:
         # Get the base queryset
         queryset = (
             Issue.issue_objects.filter(**self.filters["base_filters"])
@@ -364,143 +262,62 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             )
         )
 
-        if cycle_id is not None and peek_view:
-            cycle_issues = CycleIssue.objects.filter(
-                **self.filters["base_filters"], cycle_id=cycle_id
-            ).values_list("issue_id", flat=True)
-            cycle = Cycle.objects.filter(id=cycle_id).first()
-            if cycle and cycle.start_date:
-                start_date = cycle.start_date.date()
-                end_date = cycle.end_date.date()
-            else:
-                return {"data": [], "schema": {}}
-            queryset = cycle_issues
-        elif module_id is not None and peek_view:
-            module_issues = ModuleIssue.objects.filter(
-                **self.filters["base_filters"], module_id=module_id
-            ).values_list("issue_id", flat=True)
-            module = Module.objects.filter(id=module_id).first()
-            if module and module.start_date:
-                start_date = module.start_date
-                end_date = module.target_date
-            else:
-                return {"data": [], "schema": {}}
-            queryset = module_issues
-        elif peek_view:
-            project_ids_str = self.request.GET.get("project_ids")
-            if project_ids_str:
-                project_id_list = [
-                    pid.strip() for pid in project_ids_str.split(",") if pid.strip()
-                ]
-            else:
-                project_id_list = []
-                return {"data": [], "schema": {}}
-            project_id = project_id_list[0]
-            project = Project.objects.filter(id=project_id).first()
-            if project.created_at:
-                start_date = project.created_at.date().replace(day=1)
-            else:
-                return {"data": [], "schema": {}}
-        else:
-            workspace = Workspace.objects.get(slug=self._workspace_slug)
-            start_date = workspace.created_at.date().replace(day=1)
+        workspace = Workspace.objects.get(slug=self._workspace_slug)
+        start_date = workspace.created_at.date().replace(day=1)
 
-        if cycle_id or module_id:
-            # Get daily stats with optimized query
-            daily_stats = (
-                queryset.values("created_at__date")
-                .annotate(
-                    created_count=Count("id"),
-                    completed_count=Count(
-                        "id", filter=Q(issue__state__group="completed")
-                    ),
-                )
-                .order_by("created_at__date")
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            queryset = queryset.filter(
+                created_at__date__gte=start_date, created_at__date__lte=end_date
             )
 
-            # Create a dictionary of existing stats with summed counts
-            stats_dict = {
-                stat["created_at__date"].strftime("%Y-%m-%d"): {
-                    "created_count": stat["created_count"],
-                    "completed_count": stat["completed_count"],
-                }
-                for stat in daily_stats
-            }
-
-            # Generate data for all days in the range
-            data = []
-            current_date = start_date
-            while current_date <= end_date:
-                date_str = current_date.strftime("%Y-%m-%d")
-                stats = stats_dict.get(
-                    date_str, {"created_count": 0, "completed_count": 0}
-                )
-                data.append(
-                    {
-                        "key": date_str,
-                        "name": date_str,
-                        "count": stats["created_count"] + stats["completed_count"],
-                        "completed_issues": stats["completed_count"],
-                        "created_issues": stats["created_count"],
-                    }
-                )
-                current_date += timedelta(days=1)
-        else:
-            # Apply date range filter if available
-            if self.filters["chart_period_range"]:
-                start_date, end_date = self.filters["chart_period_range"]
-                queryset = queryset.filter(
-                    created_at__date__gte=start_date, created_at__date__lte=end_date
-                )
-
-            # Annotate by month and count
-            monthly_stats = (
-                queryset.annotate(month=TruncMonth("created_at"))
-                .values("month")
-                .annotate(
-                    created_count=Count("id"),
-                    completed_count=Count("id", filter=Q(state__group="completed")),
-                )
-                .order_by("month")
+        # Annotate by month and count
+        monthly_stats = (
+            queryset.annotate(month=TruncMonth("created_at"))
+            .values("month")
+            .annotate(
+                created_count=Count("id"),
+                completed_count=Count("id", filter=Q(state__group="completed")),
             )
+            .order_by("month")
+        )
 
-            # Create dictionary of month -> counts
-            stats_dict = {
-                stat["month"].strftime("%Y-%m-%d"): {
-                    "created_count": stat["created_count"],
-                    "completed_count": stat["completed_count"],
-                }
-                for stat in monthly_stats
+        # Create dictionary of month -> counts
+        stats_dict = {
+            stat["month"].strftime("%Y-%m-%d"): {
+                "created_count": stat["created_count"],
+                "completed_count": stat["completed_count"],
             }
+            for stat in monthly_stats
+        }
 
-            # Generate monthly data (ensure months with 0 count are included)
-            data = []
-            # include the current date at the end
-            end_date = timezone.now().date()
-            last_month = end_date.replace(day=1)
-            current_month = start_date
+        # Generate monthly data (ensure months with 0 count are included)
+        data = []
+        # include the current date at the end
+        end_date = timezone.now().date()
+        last_month = end_date.replace(day=1)
+        current_month = start_date
 
-            while current_month <= last_month:
-                date_str = current_month.strftime("%Y-%m-%d")
-                stats = stats_dict.get(
-                    date_str, {"created_count": 0, "completed_count": 0}
+        while current_month <= last_month:
+            date_str = current_month.strftime("%Y-%m-%d")
+            stats = stats_dict.get(date_str, {"created_count": 0, "completed_count": 0})
+            data.append(
+                {
+                    "key": date_str,
+                    "name": date_str,
+                    "count": stats["created_count"],
+                    "completed_issues": stats["completed_count"],
+                    "created_issues": stats["created_count"],
+                }
+            )
+            # Move to next month
+            if current_month.month == 12:
+                current_month = current_month.replace(
+                    year=current_month.year + 1, month=1
                 )
-                data.append(
-                    {
-                        "key": date_str,
-                        "name": date_str,
-                        "count": stats["created_count"],
-                        "completed_issues": stats["completed_count"],
-                        "created_issues": stats["created_count"],
-                    }
-                )
-                # Move to next month
-                if current_month.month == 12:
-                    current_month = current_month.replace(
-                        year=current_month.year + 1, month=1
-                    )
-                else:
-                    current_month = current_month.replace(month=current_month.month + 1)
+            else:
+                current_month = current_month.replace(month=current_month.month + 1)
 
         schema = {
             "completed_issues": "completed_issues",
@@ -515,8 +332,6 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
         type = request.GET.get("type", "projects")
         group_by = request.GET.get("group_by", None)
         x_axis = request.GET.get("x_axis", "PRIORITY")
-        cycle_id = request.GET.get("cycle_id", None)
-        module_id = request.GET.get("module_id", None)
 
         if type == "projects":
             return Response(self.project_chart(), status=status.HTTP_200_OK)
@@ -530,19 +345,6 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
                 )
             )
 
-            # Apply cycle/module filters if present
-            if cycle_id is not None:
-                cycle_issues = CycleIssue.objects.filter(
-                    **self.filters["base_filters"], cycle_id=cycle_id
-                ).values_list("issue_id", flat=True)
-                queryset = queryset.filter(id__in=cycle_issues)
-
-            elif module_id is not None:
-                module_issues = ModuleIssue.objects.filter(
-                    **self.filters["base_filters"], module_id=module_id
-                ).values_list("issue_id", flat=True)
-                queryset = queryset.filter(id__in=module_issues)
-
             # Apply date range filter if available
             if self.filters["chart_period_range"]:
                 start_date, end_date = self.filters["chart_period_range"]
@@ -556,14 +358,8 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             )
 
         elif type == "work-items":
-            # Optionally accept cycle_id or module_id as query params
-            cycle_id = request.GET.get("cycle_id", None)
-            module_id = request.GET.get("module_id", None)
-            peek_view = request.GET.get("peek_view", False)
             return Response(
-                self.work_item_completion_chart(
-                    cycle_id=cycle_id, module_id=module_id, peek_view=peek_view
-                ),
+                self.work_item_completion_chart(),
                 status=status.HTTP_200_OK,
             )
 

apiserver/plane/app/views/analytic/project_analytics.py

@@ -0,0 +1,421 @@
+from rest_framework.response import Response
+from rest_framework import status
+from typing import Dict, Any
+from django.db.models import QuerySet, Q, Count
+from django.http import HttpRequest
+from django.db.models.functions import TruncMonth
+from django.utils import timezone
+from datetime import timedelta
+from plane.app.views.base import BaseAPIView
+from plane.app.permissions import ROLE, allow_permission
+from plane.db.models import (
+    Project,
+    Issue,
+    Cycle,
+    Module,
+    CycleIssue,
+    ModuleIssue,
+)
+from django.db import models
+from django.db.models import F, Case, When, Value
+from django.db.models.functions import Concat
+from plane.utils.build_chart import build_analytics_chart
+from plane.utils.date_utils import (
+    get_analytics_filters,
+)
+
+
+class ProjectAdvanceAnalyticsBaseView(BaseAPIView):
+    def initialize_workspace(self, slug: str, type: str) -> None:
+        self._workspace_slug = slug
+        self.filters = get_analytics_filters(
+            slug=slug,
+            type=type,
+            user=self.request.user,
+            date_filter=self.request.GET.get("date_filter", None),
+            project_ids=self.request.GET.get("project_ids", None),
+        )
+
+
+class ProjectAdvanceAnalyticsEndpoint(ProjectAdvanceAnalyticsBaseView):
+    def get_filtered_counts(self, queryset: QuerySet) -> Dict[str, int]:
+        def get_filtered_count() -> int:
+            if self.filters["analytics_date_range"]:
+                return queryset.filter(
+                    created_at__gte=self.filters["analytics_date_range"]["current"][
+                        "gte"
+                    ],
+                    created_at__lte=self.filters["analytics_date_range"]["current"][
+                        "lte"
+                    ],
+                ).count()
+            return queryset.count()
+
+        return {
+            "count": get_filtered_count(),
+        }
+
+    def get_work_items_stats(
+        self, project_id, cycle_id=None, module_id=None
+    ) -> Dict[str, Dict[str, int]]:
+        """
+        Returns work item stats for the workspace, or filtered by cycle_id or module_id if provided.
+        """
+        base_queryset = None
+        if cycle_id is not None:
+            cycle_issues = CycleIssue.objects.filter(
+                **self.filters["base_filters"], cycle_id=cycle_id
+            ).values_list("issue_id", flat=True)
+            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
+        elif module_id is not None:
+            module_issues = ModuleIssue.objects.filter(
+                **self.filters["base_filters"], module_id=module_id
+            ).values_list("issue_id", flat=True)
+            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
+        else:
+            base_queryset = Issue.issue_objects.filter(
+                **self.filters["base_filters"], project_id=project_id
+            )
+
+        return {
+            "total_work_items": self.get_filtered_counts(base_queryset),
+            "started_work_items": self.get_filtered_counts(
+                base_queryset.filter(state__group="started")
+            ),
+            "backlog_work_items": self.get_filtered_counts(
+                base_queryset.filter(state__group="backlog")
+            ),
+            "un_started_work_items": self.get_filtered_counts(
+                base_queryset.filter(state__group="unstarted")
+            ),
+            "completed_work_items": self.get_filtered_counts(
+                base_queryset.filter(state__group="completed")
+            ),
+        }
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
+        self.initialize_workspace(slug, type="analytics")
+
+        # Optionally accept cycle_id or module_id as query params
+        cycle_id = request.GET.get("cycle_id", None)
+        module_id = request.GET.get("module_id", None)
+        return Response(
+            self.get_work_items_stats(
+                cycle_id=cycle_id, module_id=module_id, project_id=project_id
+            ),
+            status=status.HTTP_200_OK,
+        )
+
+
+class ProjectAdvanceAnalyticsStatsEndpoint(ProjectAdvanceAnalyticsBaseView):
+    def get_project_issues_stats(self) -> QuerySet:
+        # Get the base queryset with workspace and project filters
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            base_queryset = base_queryset.filter(
+                created_at__date__gte=start_date, created_at__date__lte=end_date
+            )
+
+        return (
+            base_queryset.values("project_id", "project__name")
+            .annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
+                completed_work_items=Count("id", filter=Q(state__group="completed")),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
+                started_work_items=Count("id", filter=Q(state__group="started")),
+            )
+            .order_by("project_id")
+        )
+
+    def get_work_items_stats(
+        self, project_id, cycle_id=None, module_id=None
+    ) -> Dict[str, Dict[str, int]]:
+        base_queryset = None
+        if cycle_id is not None:
+            cycle_issues = CycleIssue.objects.filter(
+                **self.filters["base_filters"], cycle_id=cycle_id
+            ).values_list("issue_id", flat=True)
+            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
+        elif module_id is not None:
+            module_issues = ModuleIssue.objects.filter(
+                **self.filters["base_filters"], module_id=module_id
+            ).values_list("issue_id", flat=True)
+            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
+        else:
+            base_queryset = Issue.issue_objects.filter(
+                **self.filters["base_filters"], project_id=project_id
+            )
+        return (
+            base_queryset.annotate(display_name=F("assignees__display_name"))
+            .annotate(assignee_id=F("assignees__id"))
+            .annotate(avatar=F("assignees__avatar"))
+            .annotate(
+                avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(
+                        assignees__avatar_asset__isnull=True, then="assignees__avatar"
+                    ),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .values("display_name", "assignee_id", "avatar_url")
+            .annotate(
+                cancelled_work_items=Count(
+                    "id", filter=Q(state__group="cancelled"), distinct=True
+                ),
+                completed_work_items=Count(
+                    "id", filter=Q(state__group="completed"), distinct=True
+                ),
+                backlog_work_items=Count(
+                    "id", filter=Q(state__group="backlog"), distinct=True
+                ),
+                un_started_work_items=Count(
+                    "id", filter=Q(state__group="unstarted"), distinct=True
+                ),
+                started_work_items=Count(
+                    "id", filter=Q(state__group="started"), distinct=True
+                ),
+            )
+            .order_by("display_name")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        type = request.GET.get("type", "work-items")
+
+        if type == "work-items":
+            # Optionally accept cycle_id or module_id as query params
+            cycle_id = request.GET.get("cycle_id", None)
+            module_id = request.GET.get("module_id", None)
+            return Response(
+                self.get_work_items_stats(
+                    project_id=project_id, cycle_id=cycle_id, module_id=module_id
+                ),
+                status=status.HTTP_200_OK,
+            )
+
+        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class ProjectAdvanceAnalyticsChartEndpoint(ProjectAdvanceAnalyticsBaseView):
+    def work_item_completion_chart(
+        self, project_id, cycle_id=None, module_id=None
+    ) -> Dict[str, Any]:
+        # Get the base queryset
+        queryset = (
+            Issue.issue_objects.filter(**self.filters["base_filters"])
+            .filter(project_id=project_id)
+            .select_related("workspace", "state", "parent")
+            .prefetch_related(
+                "assignees", "labels", "issue_module__module", "issue_cycle__cycle"
+            )
+        )
+
+        if cycle_id is not None:
+            cycle_issues = CycleIssue.objects.filter(
+                **self.filters["base_filters"], cycle_id=cycle_id
+            ).values_list("issue_id", flat=True)
+            cycle = Cycle.objects.filter(id=cycle_id).first()
+            if cycle and cycle.start_date:
+                start_date = cycle.start_date.date()
+                end_date = cycle.end_date.date()
+            else:
+                return {"data": [], "schema": {}}
+            queryset = cycle_issues
+
+        elif module_id is not None:
+            module_issues = ModuleIssue.objects.filter(
+                **self.filters["base_filters"], module_id=module_id
+            ).values_list("issue_id", flat=True)
+            module = Module.objects.filter(id=module_id).first()
+            if module and module.start_date:
+                start_date = module.start_date
+                end_date = module.target_date
+            else:
+                return {"data": [], "schema": {}}
+            queryset = module_issues
+
+        else:
+            project = Project.objects.filter(id=project_id).first()
+            if project.created_at:
+                start_date = project.created_at.date().replace(day=1)
+            else:
+                return {"data": [], "schema": {}}
+
+        if cycle_id or module_id:
+            # Get daily stats with optimized query
+            daily_stats = (
+                queryset.values("created_at__date")
+                .annotate(
+                    created_count=Count("id"),
+                    completed_count=Count(
+                        "id", filter=Q(issue__state__group="completed")
+                    ),
+                )
+                .order_by("created_at__date")
+            )
+
+            # Create a dictionary of existing stats with summed counts
+            stats_dict = {
+                stat["created_at__date"].strftime("%Y-%m-%d"): {
+                    "created_count": stat["created_count"],
+                    "completed_count": stat["completed_count"],
+                }
+                for stat in daily_stats
+            }
+
+            # Generate data for all days in the range
+            data = []
+            current_date = start_date
+            while current_date <= end_date:
+                date_str = current_date.strftime("%Y-%m-%d")
+                stats = stats_dict.get(
+                    date_str, {"created_count": 0, "completed_count": 0}
+                )
+                data.append(
+                    {
+                        "key": date_str,
+                        "name": date_str,
+                        "count": stats["created_count"] + stats["completed_count"],
+                        "completed_issues": stats["completed_count"],
+                        "created_issues": stats["created_count"],
+                    }
+                )
+                current_date += timedelta(days=1)
+        else:
+            # Apply date range filter if available
+            if self.filters["chart_period_range"]:
+                start_date, end_date = self.filters["chart_period_range"]
+                queryset = queryset.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
+
+            # Annotate by month and count
+            monthly_stats = (
+                queryset.annotate(month=TruncMonth("created_at"))
+                .values("month")
+                .annotate(
+                    created_count=Count("id"),
+                    completed_count=Count("id", filter=Q(state__group="completed")),
+                )
+                .order_by("month")
+            )
+
+            # Create dictionary of month -> counts
+            stats_dict = {
+                stat["month"].strftime("%Y-%m-%d"): {
+                    "created_count": stat["created_count"],
+                    "completed_count": stat["completed_count"],
+                }
+                for stat in monthly_stats
+            }
+
+            # Generate monthly data (ensure months with 0 count are included)
+            data = []
+            # include the current date at the end
+            end_date = timezone.now().date()
+            last_month = end_date.replace(day=1)
+            current_month = start_date
+
+            while current_month <= last_month:
+                date_str = current_month.strftime("%Y-%m-%d")
+                stats = stats_dict.get(
+                    date_str, {"created_count": 0, "completed_count": 0}
+                )
+                data.append(
+                    {
+                        "key": date_str,
+                        "name": date_str,
+                        "count": stats["created_count"],
+                        "completed_issues": stats["completed_count"],
+                        "created_issues": stats["created_count"],
+                    }
+                )
+                # Move to next month
+                if current_month.month == 12:
+                    current_month = current_month.replace(
+                        year=current_month.year + 1, month=1
+                    )
+                else:
+                    current_month = current_month.replace(month=current_month.month + 1)
+
+        schema = {
+            "completed_issues": "completed_issues",
+            "created_issues": "created_issues",
+        }
+
+        return {"data": data, "schema": schema}
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        type = request.GET.get("type", "projects")
+        group_by = request.GET.get("group_by", None)
+        x_axis = request.GET.get("x_axis", "PRIORITY")
+        cycle_id = request.GET.get("cycle_id", None)
+        module_id = request.GET.get("module_id", None)
+
+        if type == "custom-work-items":
+            queryset = (
+                Issue.issue_objects.filter(**self.filters["base_filters"])
+                .filter(project_id=project_id)
+                .select_related("workspace", "state", "parent")
+                .prefetch_related(
+                    "assignees", "labels", "issue_module__module", "issue_cycle__cycle"
+                )
+            )
+
+            # Apply cycle/module filters if present
+            if cycle_id is not None:
+                cycle_issues = CycleIssue.objects.filter(
+                    **self.filters["base_filters"], cycle_id=cycle_id
+                ).values_list("issue_id", flat=True)
+                queryset = queryset.filter(id__in=cycle_issues)
+
+            elif module_id is not None:
+                module_issues = ModuleIssue.objects.filter(
+                    **self.filters["base_filters"], module_id=module_id
+                ).values_list("issue_id", flat=True)
+                queryset = queryset.filter(id__in=module_issues)
+
+            # Apply date range filter if available
+            if self.filters["chart_period_range"]:
+                start_date, end_date = self.filters["chart_period_range"]
+                queryset = queryset.filter(
+                    created_at__date__gte=start_date, created_at__date__lte=end_date
+                )
+
+            return Response(
+                build_analytics_chart(queryset, x_axis, group_by),
+                status=status.HTTP_200_OK,
+            )
+
+        elif type == "work-items":
+            # Optionally accept cycle_id or module_id as query params
+            cycle_id = request.GET.get("cycle_id", None)
+            module_id = request.GET.get("module_id", None)
+
+            return Response(
+                self.work_item_completion_chart(
+                    project_id=project_id, cycle_id=cycle_id, module_id=module_id
+                ),
+                status=status.HTTP_200_OK,
+            )
+
+        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/views/asset/v2.py

@@ -707,3 +707,14 @@ class ProjectBulkAssetEndpoint(BaseAPIView):
                 pass
 
         return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class AssetCheckEndpoint(BaseAPIView):
+    """Endpoint to check if an asset exists."""
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug, asset_id):
+        asset = FileAsset.all_objects.filter(
+            id=asset_id, workspace__slug=slug, deleted_at__isnull=True
+        ).exists()
+        return Response({"exists": asset}, status=status.HTTP_200_OK)

apiserver/plane/app/views/issue/link.py

@@ -15,6 +15,7 @@ from plane.app.serializers import IssueLinkSerializer
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import IssueLink
 from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.work_item_link_task import crawl_work_item_link_title
 from plane.utils.host import base_host
 
 
@@ -44,6 +45,9 @@ class IssueLinkViewSet(BaseViewSet):
         serializer = IssueLinkSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(project_id=project_id, issue_id=issue_id)
+            crawl_work_item_link_title.delay(
+                serializer.data.get("id"), serializer.data.get("url")
+            )
             issue_activity.delay(
                 type="link.activity.created",
                 requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
@@ -55,6 +59,10 @@ class IssueLinkViewSet(BaseViewSet):
                 notification=True,
                 origin=base_host(request=request, is_app=True),
             )
+
+            issue_link = self.get_queryset().get(id=serializer.data.get("id"))
+            serializer = IssueLinkSerializer(issue_link)
+
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
@@ -66,9 +74,14 @@ class IssueLinkViewSet(BaseViewSet):
         current_instance = json.dumps(
             IssueLinkSerializer(issue_link).data, cls=DjangoJSONEncoder
         )
+
         serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
         if serializer.is_valid():
             serializer.save()
+            crawl_work_item_link_title.delay(
+                serializer.data.get("id"), serializer.data.get("url")
+            )
+
             issue_activity.delay(
                 type="link.activity.updated",
                 requested_data=requested_data,
@@ -80,6 +93,9 @@ class IssueLinkViewSet(BaseViewSet):
                 notification=True,
                 origin=base_host(request=request, is_app=True),
             )
+            issue_link = self.get_queryset().get(id=serializer.data.get("id"))
+            serializer = IssueLinkSerializer(issue_link)
+
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 

apiserver/plane/app/views/project/base.py

@@ -341,7 +341,10 @@ class ProjectViewSet(BaseViewSet):
         except IntegrityError as e:
             if "already exists" in str(e):
                 return Response(
-                    {"name": "The project name is already taken"},
+                    {
+                        "name": "The project name is already taken",
+                        "code": "PROJECT_NAME_ALREADY_EXIST",
+                    },
                     status=status.HTTP_409_CONFLICT,
                 )
         except Workspace.DoesNotExist:
@@ -350,7 +353,10 @@ class ProjectViewSet(BaseViewSet):
             )
         except serializers.ValidationError:
             return Response(
-                {"identifier": "The project identifier is already taken"},
+                {
+                    "identifier": "The project identifier is already taken",
+                    "code": "PROJECT_IDENTIFIER_ALREADY_EXIST",
+                },
                 status=status.HTTP_409_CONFLICT,
             )
 
@@ -419,7 +425,10 @@ class ProjectViewSet(BaseViewSet):
         except IntegrityError as e:
             if "already exists" in str(e):
                 return Response(
-                    {"name": "The project name is already taken"},
+                    {
+                        "name": "The project name is already taken",
+                        "code": "PROJECT_NAME_ALREADY_EXIST",
+                    },
                     status=status.HTTP_409_CONFLICT,
                 )
         except (Project.DoesNotExist, Workspace.DoesNotExist):
@@ -428,7 +437,10 @@ class ProjectViewSet(BaseViewSet):
             )
         except serializers.ValidationError:
             return Response(
-                {"identifier": "The project identifier is already taken"},
+                {
+                    "identifier": "The project identifier is already taken",
+                    "code": "PROJECT_IDENTIFIER_ALREADY_EXIST",
+                },
                 status=status.HTTP_409_CONFLICT,
             )
 
@@ -445,7 +457,7 @@ class ProjectViewSet(BaseViewSet):
                 is_active=True,
             ).exists()
         ):
-            project = Project.objects.get(pk=pk)
+            project = Project.objects.get(pk=pk, workspace__slug=slug)
             project.delete()
             webhook_activity.delay(
                 event="project",

apiserver/plane/app/views/project/member.py

@@ -168,6 +168,8 @@ class ProjectMemberViewSet(BaseViewSet):
             workspace__slug=slug,
             member__is_bot=False,
             is_active=True,
+            member__member_workspace__workspace__slug=slug,
+            member__member_workspace__is_active=True,
         ).select_related("project", "member", "workspace")
 
         serializer = ProjectMemberRoleSerializer(
@@ -313,7 +315,11 @@ class UserProjectRolesEndpoint(BaseAPIView):
 
     def get(self, request, slug):
         project_members = ProjectMember.objects.filter(
-            workspace__slug=slug, member_id=request.user.id, is_active=True
+            workspace__slug=slug,
+            member_id=request.user.id,
+            is_active=True,
+            member__member_workspace__workspace__slug=slug,
+            member__member_workspace__is_active=True,
         ).values("project_id", "role")
 
         project_members = {

apiserver/plane/app/views/workspace/base.py

@@ -3,6 +3,7 @@ import csv
 import io
 import os
 from datetime import date
+import uuid
 
 from dateutil.relativedelta import relativedelta
 from django.db import IntegrityError
@@ -35,6 +36,7 @@ from plane.db.models import (
     Workspace,
     WorkspaceMember,
     WorkspaceTheme,
+    Profile,
 )
 from plane.app.permissions import ROLE, allow_permission
 from django.utils.decorators import method_decorator
@@ -43,6 +45,7 @@ from django.views.decorators.vary import vary_on_cookie
 from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
 from plane.license.utils.instance_value import get_configuration_value
 from plane.bgtasks.workspace_seed_task import workspace_seed
+from plane.utils.url import contains_url
 
 
 class WorkSpaceViewSet(BaseViewSet):
@@ -92,6 +95,8 @@ class WorkSpaceViewSet(BaseViewSet):
                     status=status.HTTP_403_FORBIDDEN,
                 )
 
+            serializer = WorkSpaceSerializer(data=request.data)
+
             slug = request.data.get("slug", False)
             name = request.data.get("name", False)
 
@@ -107,8 +112,11 @@ class WorkSpaceViewSet(BaseViewSet):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            # Validate the serializer
-            serializer = WorkSpaceSerializer(data=request.data)
+            if contains_url(name):
+                return Response(
+                    {"error": "Name cannot contain a URL"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
 
             if serializer.is_valid(raise_exception=True):
                 serializer.save(owner=request.user)
@@ -151,8 +159,18 @@ class WorkSpaceViewSet(BaseViewSet):
     def partial_update(self, request, *args, **kwargs):
         return super().partial_update(request, *args, **kwargs)
 
+    def remove_last_workspace_ids_from_user_settings(self, id: uuid.UUID) -> None:
+        """
+        Remove the last workspace id from the user settings
+        """
+        Profile.objects.filter(last_workspace_id=id).update(last_workspace_id=None)
+        return
+
     @allow_permission([ROLE.ADMIN], level="WORKSPACE")
     def destroy(self, request, *args, **kwargs):
+        # Get the workspace
+        workspace = self.get_object()
+        self.remove_last_workspace_ids_from_user_settings(workspace.id)
         return super().destroy(request, *args, **kwargs)
 
 
@@ -160,8 +178,6 @@ class UserWorkSpacesEndpoint(BaseAPIView):
     search_fields = ["name"]
     filterset_fields = ["owner"]
 
-    @method_decorator(cache_control(private=True, max_age=12))
-    @method_decorator(vary_on_cookie)
     def get(self, request):
         fields = [field for field in request.GET.get("fields", "").split(",") if field]
         member_count = (

apiserver/plane/app/views/workspace/member.py

@@ -1,5 +1,6 @@
 # Django imports
 from django.db.models import Count, Q, OuterRef, Subquery, IntegerField
+from django.utils import timezone
 from django.db.models.functions import Coalesce
 
 # Third party modules
@@ -133,7 +134,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         # Deactivate the users from the projects where the user is part of
         _ = ProjectMember.objects.filter(
             workspace__slug=slug, member_id=workspace_member.member_id, is_active=True
-        ).update(is_active=False)
+        ).update(is_active=False, updated_at=timezone.now())
 
         workspace_member.is_active = False
         workspace_member.save()
@@ -194,7 +195,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         # # Deactivate the users from the projects where the user is part of
         _ = ProjectMember.objects.filter(
             workspace__slug=slug, member_id=workspace_member.member_id, is_active=True
-        ).update(is_active=False)
+        ).update(is_active=False, updated_at=timezone.now())
 
         # # Deactivate the user
         workspace_member.is_active = False

apiserver/plane/authentication/urls.py

@@ -42,11 +42,11 @@ urlpatterns = [
     # credentials
     path("sign-in/", SignInAuthEndpoint.as_view(), name="sign-in"),
     path("sign-up/", SignUpAuthEndpoint.as_view(), name="sign-up"),
-    path("spaces/sign-in/", SignInAuthSpaceEndpoint.as_view(), name="sign-in"),
-    path("spaces/sign-up/", SignUpAuthSpaceEndpoint.as_view(), name="sign-in"),
+    path("spaces/sign-in/", SignInAuthSpaceEndpoint.as_view(), name="space-sign-in"),
+    path("spaces/sign-up/", SignUpAuthSpaceEndpoint.as_view(), name="space-sign-up"),
     # signout
     path("sign-out/", SignOutAuthEndpoint.as_view(), name="sign-out"),
-    path("spaces/sign-out/", SignOutAuthSpaceEndpoint.as_view(), name="sign-out"),
+    path("spaces/sign-out/", SignOutAuthSpaceEndpoint.as_view(), name="space-sign-out"),
     # csrf token
     path("get-csrf-token/", CSRFTokenEndpoint.as_view(), name="get_csrf_token"),
     # Magic sign in
@@ -56,17 +56,17 @@ urlpatterns = [
     path(
         "spaces/magic-generate/",
         MagicGenerateSpaceEndpoint.as_view(),
-        name="magic-generate",
+        name="space-magic-generate",
     ),
     path(
         "spaces/magic-sign-in/",
         MagicSignInSpaceEndpoint.as_view(),
-        name="magic-sign-in",
+        name="space-magic-sign-in",
     ),
     path(
         "spaces/magic-sign-up/",
         MagicSignUpSpaceEndpoint.as_view(),
-        name="magic-sign-up",
+        name="space-magic-sign-up",
     ),
     ## Google Oauth
     path("google/", GoogleOauthInitiateEndpoint.as_view(), name="google-initiate"),
@@ -74,12 +74,12 @@ urlpatterns = [
     path(
         "spaces/google/",
         GoogleOauthInitiateSpaceEndpoint.as_view(),
-        name="google-initiate",
+        name="space-google-initiate",
     ),
     path(
-        "google/callback/",
+        "spaces/google/callback/",
         GoogleCallbackSpaceEndpoint.as_view(),
-        name="google-callback",
+        name="space-google-callback",
     ),
     ## Github Oauth
     path("github/", GitHubOauthInitiateEndpoint.as_view(), name="github-initiate"),
@@ -87,12 +87,12 @@ urlpatterns = [
     path(
         "spaces/github/",
         GitHubOauthInitiateSpaceEndpoint.as_view(),
-        name="github-initiate",
+        name="space-github-initiate",
     ),
     path(
         "spaces/github/callback/",
         GitHubCallbackSpaceEndpoint.as_view(),
-        name="github-callback",
+        name="space-github-callback",
     ),
     ## Gitlab Oauth
     path("gitlab/", GitLabOauthInitiateEndpoint.as_view(), name="gitlab-initiate"),
@@ -100,12 +100,12 @@ urlpatterns = [
     path(
         "spaces/gitlab/",
         GitLabOauthInitiateSpaceEndpoint.as_view(),
-        name="gitlab-initiate",
+        name="space-gitlab-initiate",
     ),
     path(
         "spaces/gitlab/callback/",
         GitLabCallbackSpaceEndpoint.as_view(),
-        name="gitlab-callback",
+        name="space-gitlab-callback",
     ),
     # Email Check
     path("email-check/", EmailCheckEndpoint.as_view(), name="email-check"),
@@ -120,12 +120,12 @@ urlpatterns = [
     path(
         "spaces/forgot-password/",
         ForgotPasswordSpaceEndpoint.as_view(),
-        name="forgot-password",
+        name="space-forgot-password",
     ),
     path(
         "spaces/reset-password/<uidb64>/<token>/",
         ResetPasswordSpaceEndpoint.as_view(),
-        name="forgot-password",
+        name="space-forgot-password",
     ),
     path("change-password/", ChangePasswordEndpoint.as_view(), name="forgot-password"),
     path("set-password/", SetUserPasswordEndpoint.as_view(), name="set-password"),

apiserver/plane/bgtasks/email_notification_task.py

@@ -284,6 +284,7 @@ def send_email_notification(
                 "project": str(issue.project.name),
                 "user_preference": f"{base_api}/profile/preferences/email",
                 "comments": comments,
+                "entity_type": "issue",
             }
             html_content = render_to_string(
                 "emails/notifications/issue-updates.html", context

apiserver/plane/bgtasks/work_item_link_task.py

@@ -0,0 +1,177 @@
+# Python imports
+import logging
+
+
+# Third party imports
+from celery import shared_task
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urlparse, urljoin
+import base64
+import ipaddress
+from typing import Dict, Any
+from typing import Optional
+from plane.db.models import IssueLink
+from plane.utils.exception_logger import log_exception
+
+logger = logging.getLogger("plane.worker")
+
+
+DEFAULT_FAVICON = "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLWxpbmstaWNvbiBsdWNpZGUtbGluayI+PHBhdGggZD0iTTEwIDEzYTUgNSAwIDAgMCA3LjU0LjU0bDMtM2E1IDUgMCAwIDAtNy4wNy03LjA3bC0xLjcyIDEuNzEiLz48cGF0aCBkPSJNMTQgMTFhNSA1IDAgMCAwLTcuNTQtLjU0bC0zIDNhNSA1IDAgMCAwIDcuMDcgNy4wN2wxLjcxLTEuNzEiLz48L3N2Zz4="  # noqa: E501
+
+def crawl_work_item_link_title_and_favicon(url: str) -> Dict[str, Any]:
+    """
+    Crawls a URL to extract the title and favicon.
+
+    Args:
+        url (str): The URL to crawl
+
+    Returns:
+        str: JSON string containing title and base64-encoded favicon
+    """
+    try:
+        # Prevent access to private IP ranges
+        parsed = urlparse(url)
+
+        try:
+            ip = ipaddress.ip_address(parsed.hostname)
+            if ip.is_private or ip.is_loopback or ip.is_reserved:
+                raise ValueError("Access to private/internal networks is not allowed")
+        except ValueError:
+            # Not an IP address, continue with domain validation
+            pass
+
+        # Set up headers to mimic a real browser
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"  # noqa: E501
+        }
+
+        soup = None
+        title = None
+
+        try:
+            response = requests.get(url, headers=headers, timeout=1)
+
+            soup = BeautifulSoup(response.content, "html.parser")
+            title_tag = soup.find("title")
+            title = title_tag.get_text().strip() if title_tag else None
+
+        except requests.RequestException as e:
+            logger.warning(f"Failed to fetch HTML for title: {str(e)}")
+
+        # Fetch and encode favicon
+        favicon_base64 = fetch_and_encode_favicon(headers, soup, url)
+
+        # Prepare result
+        result = {
+            "title": title,
+            "favicon": favicon_base64["favicon_base64"],
+            "url": url,
+            "favicon_url": favicon_base64["favicon_url"],
+        }
+
+        return result
+
+    except Exception as e:
+        log_exception(e)
+        return {
+            "error": f"Unexpected error: {str(e)}",
+            "title": None,
+            "favicon": None,
+            "url": url,
+        }
+
+
+def find_favicon_url(soup: Optional[BeautifulSoup], base_url: str) -> Optional[str]:
+    """
+    Find the favicon URL from HTML soup.
+
+    Args:
+        soup: BeautifulSoup object
+        base_url: Base URL for resolving relative paths
+
+    Returns:
+        str: Absolute URL to favicon or None
+    """
+
+    if soup is not None:
+        # Look for various favicon link tags
+        favicon_selectors = [
+            'link[rel="icon"]',
+            'link[rel="shortcut icon"]',
+            'link[rel="apple-touch-icon"]',
+            'link[rel="apple-touch-icon-precomposed"]',
+        ]
+
+        for selector in favicon_selectors:
+            favicon_tag = soup.select_one(selector)
+            if favicon_tag and favicon_tag.get("href"):
+                return urljoin(base_url, favicon_tag["href"])
+
+    # Fallback to /favicon.ico
+    parsed_url = urlparse(base_url)
+    fallback_url = f"{parsed_url.scheme}://{parsed_url.netloc}/favicon.ico"
+
+    # Check if fallback exists
+    try:
+        response = requests.head(fallback_url, timeout=2)
+        if response.status_code == 200:
+            return fallback_url
+    except requests.RequestException as e:
+        log_exception(e)
+        return None
+
+    return None
+
+
+def fetch_and_encode_favicon(
+    headers: Dict[str, str], soup: Optional[BeautifulSoup], url: str
+) -> Dict[str, Optional[str]]:
+    """
+    Fetch favicon and encode it as base64.
+
+    Args:
+        favicon_url: URL to the favicon
+        headers: Request headers
+
+    Returns:
+        str: Base64 encoded favicon with data URI prefix or None
+    """
+    try:
+        favicon_url = find_favicon_url(soup, url)
+        if favicon_url is None:
+            return {
+                "favicon_url": None,
+                "favicon_base64": f"data:image/svg+xml;base64,{DEFAULT_FAVICON}",
+            }
+
+        response = requests.get(favicon_url, headers=headers, timeout=1)
+
+        # Get content type
+        content_type = response.headers.get("content-type", "image/x-icon")
+
+        # Convert to base64
+        favicon_base64 = base64.b64encode(response.content).decode("utf-8")
+
+        # Return as data URI
+        return {
+            "favicon_url": favicon_url,
+            "favicon_base64": f"data:{content_type};base64,{favicon_base64}",
+        }
+
+    except Exception as e:
+        logger.warning(f"Failed to fetch favicon: {e}")
+        return {
+            "favicon_url": None,
+            "favicon_base64": f"data:image/svg+xml;base64,{DEFAULT_FAVICON}",
+        }
+
+
+@shared_task
+def crawl_work_item_link_title(id: str, url: str) -> None:
+    meta_data = crawl_work_item_link_title_and_favicon(url)
+    issue_link = IssueLink.objects.get(id=id)
+
+    issue_link.metadata = meta_data
+
+    issue_link.save()

apiserver/plane/db/migrations/0096_user_is_email_valid_user_masked_at.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.20 on 2025-05-21 13:43
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("db", "0095_page_external_id_page_external_source"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="user",
+            name="is_email_valid",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="user",
+            name="masked_at",
+            field=models.DateTimeField(null=True),
+        ),
+    ]

apiserver/plane/db/migrations/0097_project_external_id_project_external_source.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.21 on 2025-06-06 12:33
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('db', '0096_user_is_email_valid_user_masked_at'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='project',
+            name='external_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='project',
+            name='external_source',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

apiserver/plane/db/models/project.py

@@ -122,6 +122,9 @@ class Project(BaseModel):
     # timezone
     TIMEZONE_CHOICES = tuple(zip(pytz.all_timezones, pytz.all_timezones))
     timezone = models.CharField(max_length=255, default="UTC", choices=TIMEZONE_CHOICES)
+    # external_id for imports
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     @property
     def cover_image_url(self):

apiserver/plane/db/models/user.py

@@ -106,6 +106,12 @@ class User(AbstractBaseUser, PermissionsMixin):
         max_length=255, default="UTC", choices=USER_TIMEZONE_CHOICES
     )
 
+    # email validation
+    is_email_valid = models.BooleanField(default=False)
+
+    # masking
+    masked_at = models.DateTimeField(null=True)
+
     USERNAME_FIELD = "email"
     REQUIRED_FIELDS = ["username"]
 

apiserver/plane/license/api/views/instance.py

@@ -57,7 +57,7 @@ class InstanceEndpoint(BaseAPIView):
             POSTHOG_API_KEY,
             POSTHOG_HOST,
             UNSPLASH_ACCESS_KEY,
-            OPENAI_API_KEY,
+            LLM_API_KEY,
             IS_INTERCOM_ENABLED,
             INTERCOM_APP_ID,
         ) = get_configuration_value(
@@ -112,8 +112,8 @@ class InstanceEndpoint(BaseAPIView):
                     "default": os.environ.get("UNSPLASH_ACCESS_KEY", ""),
                 },
                 {
-                    "key": "OPENAI_API_KEY",
-                    "default": os.environ.get("OPENAI_API_KEY", ""),
+                    "key": "LLM_API_KEY",
+                    "default": os.environ.get("LLM_API_KEY", ""),
                 },
                 # Intercom settings
                 {
@@ -151,7 +151,7 @@ class InstanceEndpoint(BaseAPIView):
         data["has_unsplash_configured"] = bool(UNSPLASH_ACCESS_KEY)
 
         # Open AI settings
-        data["has_openai_configured"] = bool(OPENAI_API_KEY)
+        data["has_llm_configured"] = bool(LLM_API_KEY)
 
         # File size settings
         data["file_size_limit"] = float(os.environ.get("FILE_SIZE_LIMIT", 5242880))

apiserver/plane/middleware/logger.py

@@ -83,6 +83,32 @@ class APITokenLogMiddleware:
         self.process_request(request, response, request_body)
         return response
 
+    def _safe_decode_body(self, content):
+        """
+        Safely decodes request/response body content, handling binary data.
+        Returns None if content is None, or a string representation of the content.
+        """
+        # If the content is None, return None
+        if content is None:
+            return None
+
+        # If the content is an empty bytes object, return None
+        if content == b"":
+            return None
+
+        # Check if content is binary by looking for common binary file signatures
+        if (
+            content.startswith(b"\x89PNG")
+            or content.startswith(b"\xff\xd8\xff")
+            or content.startswith(b"%PDF")
+        ):
+            return "[Binary Content]"
+
+        try:
+            return content.decode("utf-8")
+        except UnicodeDecodeError:
+            return "[Could not decode content]"
+
     def process_request(self, request, response, request_body):
         api_key_header = "X-Api-Key"
         api_key = request.headers.get(api_key_header)
@@ -95,9 +121,13 @@ class APITokenLogMiddleware:
                     method=request.method,
                     query_params=request.META.get("QUERY_STRING", ""),
                     headers=str(request.headers),
-                    body=(request_body.decode("utf-8") if request_body else None),
+                    body=(
+                        self._safe_decode_body(request_body) if request_body else None
+                    ),
                     response_body=(
-                        response.content.decode("utf-8") if response.content else None
+                        self._safe_decode_body(response.content)
+                        if response.content
+                        else None
                     ),
                     response_code=response.status_code,
                     ip_address=get_client_ip(request=request),

apiserver/plane/space/views/issue.py

@@ -179,7 +179,7 @@ class ProjectIssuesPublicEndpoint(BaseAPIView):
                             Q(issue_intake__status=1)
                             | Q(issue_intake__status=-1)
                             | Q(issue_intake__status=2)
-                            | Q(issue_intake__status=True),
+                            | Q(issue_intake__isnull=True),
                             archived_at__isnull=True,
                             is_draft=False,
                         ),
@@ -205,7 +205,7 @@ class ProjectIssuesPublicEndpoint(BaseAPIView):
                         Q(issue_intake__status=1)
                         | Q(issue_intake__status=-1)
                         | Q(issue_intake__status=2)
-                        | Q(issue_intake__status=True),
+                        | Q(issue_intake__isnull=True),
                         archived_at__isnull=True,
                         is_draft=False,
                     ),

apiserver/plane/tests/README.md

@@ -0,0 +1,143 @@
+# Plane Tests
+
+This directory contains tests for the Plane application. The tests are organized using pytest.
+
+## Test Structure
+
+Tests are organized into the following categories:
+
+- **Unit tests**: Test individual functions or classes in isolation.
+- **Contract tests**: Test interactions between components and verify API contracts are fulfilled.
+  - **API tests**: Test the external API endpoints (under `/api/v1/`).
+  - **App tests**: Test the web application API endpoints (under `/api/`).
+- **Smoke tests**: Basic tests to verify that the application runs correctly.
+
+## API vs App Endpoints
+
+Plane has two types of API endpoints:
+
+1. **External API** (`plane.api`):
+   - Available at `/api/v1/` endpoint
+   - Uses API key authentication (X-Api-Key header)
+   - Designed for external API contracts and third-party access
+   - Tests use the `api_key_client` fixture for authentication
+   - Test files are in `contract/api/`
+
+2. **Web App API** (`plane.app`):
+   - Available at `/api/` endpoint
+   - Uses session-based authentication (CSRF disabled)
+   - Designed for the web application frontend
+   - Tests use the `session_client` fixture for authentication
+   - Test files are in `contract/app/`
+
+## Running Tests
+
+To run all tests:
+
+```bash
+python -m pytest
+```
+
+To run specific test categories:
+
+```bash
+# Run unit tests
+python -m pytest plane/tests/unit/
+
+# Run API contract tests
+python -m pytest plane/tests/contract/api/
+
+# Run App contract tests
+python -m pytest plane/tests/contract/app/
+
+# Run smoke tests
+python -m pytest plane/tests/smoke/
+```
+
+For convenience, we also provide a helper script:
+
+```bash
+# Run all tests
+./run_tests.py
+
+# Run only unit tests
+./run_tests.py -u
+
+# Run contract tests with coverage report
+./run_tests.py -c -o
+
+# Run tests in parallel
+./run_tests.py -p
+```
+
+## Fixtures
+
+The following fixtures are available for testing:
+
+- `api_client`: Unauthenticated API client
+- `create_user`: Creates a test user
+- `api_token`: API token for the test user
+- `api_key_client`: API client with API key authentication (for external API tests)
+- `session_client`: API client with session authentication (for app API tests)
+- `plane_server`: Live Django test server for HTTP-based smoke tests
+
+## Writing Tests
+
+When writing tests, follow these guidelines:
+
+1. Place tests in the appropriate directory based on their type.
+2. Use the correct client fixture based on the API being tested:
+   - For external API (`/api/v1/`), use `api_key_client`
+   - For web app API (`/api/`), use `session_client`
+   - For smoke tests with real HTTP, use `plane_server`
+3. Use the correct URL namespace when reverse-resolving URLs:
+   - For external API, use `reverse("api:endpoint_name")`  
+   - For web app API, use `reverse("endpoint_name")`
+4. Add the `@pytest.mark.django_db` decorator to tests that interact with the database.
+5. Add the appropriate markers (`@pytest.mark.contract`, etc.) to categorize tests.
+
+## Test Fixtures
+
+Common fixtures are defined in:
+
+- `conftest.py`: General fixtures for authentication, database access, etc.
+- `conftest_external.py`: Fixtures for external services (Redis, Elasticsearch, Celery, MongoDB)
+- `factories.py`: Test factories for easy model instance creation
+
+## Best Practices
+
+When writing tests, follow these guidelines:
+
+1. **Use pytest's assert syntax** instead of Django's `self.assert*` methods.
+2. **Add markers to categorize tests**:
+   ```python
+   @pytest.mark.unit
+   @pytest.mark.contract
+   @pytest.mark.smoke
+   ```
+3. **Use fixtures instead of setUp/tearDown methods** for cleaner, more reusable test code.
+4. **Mock external dependencies** with the provided fixtures to avoid external service dependencies.
+5. **Write focused tests** that verify one specific behavior or edge case.
+6. **Keep test files small and organized** by logical components or endpoints.
+7. **Target 90% code coverage** for models, serializers, and business logic.
+
+## External Dependencies
+
+Tests for components that interact with external services should:
+
+1. Use the `mock_redis`, `mock_elasticsearch`, `mock_mongodb`, and `mock_celery` fixtures for unit and most contract tests.
+2. For more comprehensive contract tests, use Docker-based test containers (optional).
+
+## Coverage Reports
+
+Generate a coverage report with:
+
+```bash
+python -m pytest --cov=plane --cov-report=term --cov-report=html
+```
+
+This creates an HTML report in the `htmlcov/` directory.
+
+## Migration from Old Tests
+
+Some tests are still in the old format in the `api/` directory. These need to be migrated to the new contract test structure in the appropriate directories. 

apiserver/plane/tests/TESTING_GUIDE.md

@@ -0,0 +1,151 @@
+# Testing Guide for Plane
+
+This guide explains how to write tests for Plane using our pytest-based testing strategy.
+
+## Test Categories
+
+We divide tests into three categories:
+
+1. **Unit Tests**: Testing individual components in isolation.
+2. **Contract Tests**: Testing API endpoints and verifying contracts between components.
+3. **Smoke Tests**: Basic end-to-end tests for critical flows.
+
+## Writing Unit Tests
+
+Unit tests should be placed in the appropriate directory under `tests/unit/` depending on what you're testing:
+
+- `tests/unit/models/` - For model tests
+- `tests/unit/serializers/` - For serializer tests
+- `tests/unit/utils/` - For utility function tests
+
+### Example Unit Test:
+
+```python
+import pytest
+from plane.api.serializers import MySerializer
+
+@pytest.mark.unit
+class TestMySerializer:
+    def test_serializer_valid_data(self):
+        # Create input data
+        data = {"field1": "value1", "field2": 42}
+        
+        # Initialize the serializer
+        serializer = MySerializer(data=data)
+        
+        # Validate
+        assert serializer.is_valid()
+        
+        # Check validated data
+        assert serializer.validated_data["field1"] == "value1"
+        assert serializer.validated_data["field2"] == 42
+```
+
+## Writing Contract Tests
+
+Contract tests should be placed in `tests/contract/api/` or `tests/contract/app/` directories and should test the API endpoints.
+
+### Example Contract Test:
+
+```python
+import pytest
+from django.urls import reverse
+from rest_framework import status
+
+@pytest.mark.contract
+class TestMyEndpoint:
+    @pytest.mark.django_db
+    def test_my_endpoint_get(self, auth_client):
+        # Get the URL
+        url = reverse("my-endpoint")
+        
+        # Make request
+        response = auth_client.get(url)
+        
+        # Check response
+        assert response.status_code == status.HTTP_200_OK
+        assert "data" in response.data
+```
+
+## Writing Smoke Tests
+
+Smoke tests should be placed in `tests/smoke/` directory and use the `plane_server` fixture to test against a real HTTP server.
+
+### Example Smoke Test:
+
+```python
+import pytest
+import requests
+
+@pytest.mark.smoke
+class TestCriticalFlow:
+    @pytest.mark.django_db
+    def test_login_flow(self, plane_server, create_user, user_data):
+        # Get login URL
+        url = f"{plane_server.url}/api/auth/signin/"
+        
+        # Test login
+        response = requests.post(
+            url, 
+            json={
+                "email": user_data["email"],
+                "password": user_data["password"]
+            }
+        )
+        
+        # Verify
+        assert response.status_code == 200
+        data = response.json()
+        assert "access_token" in data
+```
+
+## Useful Fixtures
+
+Our test setup provides several useful fixtures:
+
+1. `api_client`: An unauthenticated DRF APIClient
+2. `api_key_client`: API client with API key authentication (for external API tests)
+3. `session_client`: API client with session authentication (for web app API tests)
+4. `create_user`: Creates and returns a test user
+5. `mock_redis`: Mocks Redis interactions
+6. `mock_elasticsearch`: Mocks Elasticsearch interactions
+7. `mock_celery`: Mocks Celery task execution
+
+## Using Factory Boy
+
+For more complex test data setup, use the provided factories:
+
+```python
+from plane.tests.factories import UserFactory, WorkspaceFactory
+
+# Create a user
+user = UserFactory()
+
+# Create a workspace with a specific owner
+workspace = WorkspaceFactory(owner=user)
+
+# Create multiple objects
+users = UserFactory.create_batch(5)
+```
+
+## Running Tests
+
+Use pytest to run tests:
+
+```bash
+# Run all tests
+python -m pytest
+
+# Run only unit tests with coverage
+python -m pytest -m unit --cov=plane
+```
+
+## Best Practices
+
+1. **Keep tests small and focused** - Each test should verify one specific behavior.
+2. **Use markers** - Always add appropriate markers (`@pytest.mark.unit`, etc.).
+3. **Mock external dependencies** - Use the provided mock fixtures.
+4. **Use factories** - For complex data setup, use factories.
+5. **Don't test the framework** - Focus on testing your business logic, not Django/DRF itself.
+6. **Write readable assertions** - Use plain `assert` statements with clear messaging.
+7. **Focus on coverage** - Aim for ≥90% code coverage for critical components.

apiserver/plane/tests/__init__.py

@@ -1 +1 @@
-from .api import *
+# Test package initialization

apiserver/plane/tests/api/base.py

@@ -1,34 +0,0 @@
-# Third party imports
-from rest_framework.test import APITestCase, APIClient
-
-# Module imports
-from plane.db.models import User
-from plane.app.views.authentication import get_tokens_for_user
-
-
-class BaseAPITest(APITestCase):
-    def setUp(self):
-        self.client = APIClient(HTTP_USER_AGENT="plane/test", REMOTE_ADDR="10.10.10.10")
-
-
-class AuthenticatedAPITest(BaseAPITest):
-    def setUp(self):
-        super().setUp()
-
-        ## Create Dummy User
-        self.email = "user@plane.so"
-        user = User.objects.create(email=self.email)
-        user.set_password("user@123")
-        user.save()
-
-        # Set user
-        self.user = user
-
-        # Set Up User ID
-        self.user_id = user.id
-
-        access_token, _ = get_tokens_for_user(user)
-        self.access_token = access_token
-
-        # Set Up Authentication Token
-        self.client.credentials(HTTP_AUTHORIZATION="Bearer " + access_token)

apiserver/plane/tests/api/test_asset.py

@@ -1 +0,0 @@
-# TODO: Tests for File Asset Uploads

apiserver/plane/tests/api/test_auth_extended.py

@@ -1 +0,0 @@
-# TODO: Tests for ChangePassword and other Endpoints

apiserver/plane/tests/api/test_authentication.py

@@ -1,183 +0,0 @@
-# Python import
-import json
-
-# Django imports
-from django.urls import reverse
-
-# Third Party imports
-from rest_framework import status
-from .base import BaseAPITest
-
-# Module imports
-from plane.db.models import User
-from plane.settings.redis import redis_instance
-
-
-class SignInEndpointTests(BaseAPITest):
-    def setUp(self):
-        super().setUp()
-        user = User.objects.create(email="user@plane.so")
-        user.set_password("user@123")
-        user.save()
-
-    def test_without_data(self):
-        url = reverse("sign-in")
-        response = self.client.post(url, {}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-    def test_email_validity(self):
-        url = reverse("sign-in")
-        response = self.client.post(
-            url, {"email": "useremail.com", "password": "user@123"}, format="json"
-        )
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(
-            response.data, {"error": "Please provide a valid email address."}
-        )
-
-    def test_password_validity(self):
-        url = reverse("sign-in")
-        response = self.client.post(
-            url, {"email": "user@plane.so", "password": "user123"}, format="json"
-        )
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(
-            response.data,
-            {
-                "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-            },
-        )
-
-    def test_user_exists(self):
-        url = reverse("sign-in")
-        response = self.client.post(
-            url, {"email": "user@email.so", "password": "user123"}, format="json"
-        )
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(
-            response.data,
-            {
-                "error": "Sorry, we could not find a user with the provided credentials. Please try again."
-            },
-        )
-
-    def test_user_login(self):
-        url = reverse("sign-in")
-
-        response = self.client.post(
-            url, {"email": "user@plane.so", "password": "user@123"}, format="json"
-        )
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data.get("user").get("email"), "user@plane.so")
-
-
-class MagicLinkGenerateEndpointTests(BaseAPITest):
-    def setUp(self):
-        super().setUp()
-        user = User.objects.create(email="user@plane.so")
-        user.set_password("user@123")
-        user.save()
-
-    def test_without_data(self):
-        url = reverse("magic-generate")
-        response = self.client.post(url, {}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-    def test_email_validity(self):
-        url = reverse("magic-generate")
-        response = self.client.post(url, {"email": "useremail.com"}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(
-            response.data, {"error": "Please provide a valid email address."}
-        )
-
-    def test_magic_generate(self):
-        url = reverse("magic-generate")
-
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-
-        response = self.client.post(url, {"email": "user@plane.so"}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-
-    def test_max_generate_attempt(self):
-        url = reverse("magic-generate")
-
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-
-        for _ in range(4):
-            response = self.client.post(url, {"email": "user@plane.so"}, format="json")
-
-        response = self.client.post(url, {"email": "user@plane.so"}, format="json")
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(
-            response.data, {"error": "Max attempts exhausted. Please try again later."}
-        )
-
-
-class MagicSignInEndpointTests(BaseAPITest):
-    def setUp(self):
-        super().setUp()
-        user = User.objects.create(email="user@plane.so")
-        user.set_password("user@123")
-        user.save()
-
-    def test_without_data(self):
-        url = reverse("magic-sign-in")
-        response = self.client.post(url, {}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(response.data, {"error": "User token and key are required"})
-
-    def test_expired_invalid_magic_link(self):
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-
-        url = reverse("magic-sign-in")
-        response = self.client.post(
-            url,
-            {"key": "magic_user@plane.so", "token": "xxxx-xxxxx-xxxx"},
-            format="json",
-        )
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(
-            response.data, {"error": "The magic code/link has expired please try again"}
-        )
-
-    def test_invalid_magic_code(self):
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-        ## Create Token
-        url = reverse("magic-generate")
-        self.client.post(url, {"email": "user@plane.so"}, format="json")
-
-        url = reverse("magic-sign-in")
-        response = self.client.post(
-            url,
-            {"key": "magic_user@plane.so", "token": "xxxx-xxxxx-xxxx"},
-            format="json",
-        )
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(
-            response.data, {"error": "Your login code was incorrect. Please try again."}
-        )
-
-    def test_magic_code_sign_in(self):
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-        ## Create Token
-        url = reverse("magic-generate")
-        self.client.post(url, {"email": "user@plane.so"}, format="json")
-
-        # Get the token
-        user_data = json.loads(ri.get("magic_user@plane.so"))
-        token = user_data["token"]
-
-        url = reverse("magic-sign-in")
-        response = self.client.post(
-            url, {"key": "magic_user@plane.so", "token": token}, format="json"
-        )
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data.get("user").get("email"), "user@plane.so")

apiserver/plane/tests/api/test_cycle.py

@@ -1 +0,0 @@
-# TODO: Write Test for Cycle Endpoints

apiserver/plane/tests/api/test_issue.py

@@ -1 +0,0 @@
-# TODO: Write Test for Issue Endpoints

apiserver/plane/tests/api/test_oauth.py

@@ -1 +0,0 @@
-# TODO: Tests for OAuth Authentication Endpoint

apiserver/plane/tests/api/test_people.py

@@ -1 +0,0 @@
-# TODO: Write Test for people Endpoint

apiserver/plane/tests/api/test_project.py

@@ -1 +0,0 @@
-# TODO: Write Tests for project endpoints

apiserver/plane/tests/api/test_shortcut.py

@@ -1 +0,0 @@
-# TODO: Write Test for shortcuts

apiserver/plane/tests/api/test_state.py

@@ -1 +0,0 @@
-# TODO: Wrote test for state endpoints

apiserver/plane/tests/api/test_view.py

@@ -1 +0,0 @@
-# TODO: Write test for view endpoints

apiserver/plane/tests/api/test_workspace.py

@@ -1,44 +0,0 @@
-# Django imports
-from django.urls import reverse
-
-# Third party import
-from rest_framework import status
-
-# Module imports
-from .base import AuthenticatedAPITest
-from plane.db.models import Workspace, WorkspaceMember
-
-
-class WorkSpaceCreateReadUpdateDelete(AuthenticatedAPITest):
-    def setUp(self):
-        super().setUp()
-
-    def test_create_workspace(self):
-        url = reverse("workspace")
-
-        # Test with empty data
-        response = self.client.post(url, {}, format="json")
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-        # Test with valid data
-        response = self.client.post(
-            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
-        )
-        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-        self.assertEqual(Workspace.objects.count(), 1)
-        # Check if the member is created
-        self.assertEqual(WorkspaceMember.objects.count(), 1)
-
-        # Check other values
-        workspace = Workspace.objects.get(pk=response.data["id"])
-        workspace_member = WorkspaceMember.objects.get(
-            workspace=workspace, member_id=self.user_id
-        )
-        self.assertEqual(workspace.owner_id, self.user_id)
-        self.assertEqual(workspace_member.role, 20)
-
-        # Create a already existing workspace
-        response = self.client.post(
-            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
-        )
-        self.assertEqual(response.status_code, status.HTTP_409_CONFLICT)

apiserver/plane/tests/conftest.py

@@ -0,0 +1,78 @@
+import pytest
+from django.conf import settings
+from rest_framework.test import APIClient
+from pytest_django.fixtures import django_db_setup
+from unittest.mock import patch, MagicMock
+
+from plane.db.models import User
+from plane.db.models.api import APIToken
+
+
+@pytest.fixture(scope="session")
+def django_db_setup(django_db_setup):
+    """Set up the Django database for the test session"""
+    pass
+
+
+@pytest.fixture
+def api_client():
+    """Return an unauthenticated API client"""
+    return APIClient()
+
+
+@pytest.fixture
+def user_data():
+    """Return standard user data for tests"""
+    return {
+        "email": "test@plane.so",
+        "password": "test-password",
+        "first_name": "Test",
+        "last_name": "User"
+    }
+
+
+@pytest.fixture
+def create_user(db, user_data):
+    """Create and return a user instance"""
+    user = User.objects.create(
+        email=user_data["email"],
+        first_name=user_data["first_name"],
+        last_name=user_data["last_name"]
+    )
+    user.set_password(user_data["password"])
+    user.save()
+    return user
+
+
+@pytest.fixture
+def api_token(db, create_user):
+    """Create and return an API token for testing the external API"""
+    token = APIToken.objects.create(
+        user=create_user,
+        label="Test API Token",
+        token="test-api-token-12345",
+    )
+    return token
+
+
+@pytest.fixture
+def api_key_client(api_client, api_token):
+    """Return an API key authenticated client for external API testing"""
+    api_client.credentials(HTTP_X_API_KEY=api_token.token)
+    return api_client
+
+
+@pytest.fixture
+def session_client(api_client, create_user):
+    """Return a session authenticated API client for app API testing, which is what plane.app uses"""
+    api_client.force_authenticate(user=create_user)
+    return api_client
+
+
+@pytest.fixture
+def plane_server(live_server):
+    """
+    Renamed version of live_server fixture to avoid name clashes.
+    Returns a live Django server for testing HTTP requests.
+    """
+    return live_server

apiserver/plane/tests/conftest_external.py

@@ -0,0 +1,117 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from django.conf import settings
+
+
+@pytest.fixture
+def mock_redis():
+    """
+    Mock Redis for testing without actual Redis connection.
+
+    This fixture patches the redis_instance function to return a MagicMock
+    that behaves like a Redis client.
+    """
+    mock_redis_client = MagicMock()
+
+    # Configure the mock to handle common Redis operations
+    mock_redis_client.get.return_value = None
+    mock_redis_client.set.return_value = True
+    mock_redis_client.delete.return_value = True
+    mock_redis_client.exists.return_value = 0
+    mock_redis_client.ttl.return_value = -1
+
+    # Start the patch
+    with patch('plane.settings.redis.redis_instance', return_value=mock_redis_client):
+        yield mock_redis_client
+
+
+@pytest.fixture
+def mock_elasticsearch():
+    """
+    Mock Elasticsearch for testing without actual ES connection.
+
+    This fixture patches Elasticsearch to return a MagicMock
+    that behaves like an Elasticsearch client.
+    """
+    mock_es_client = MagicMock()
+
+    # Configure the mock to handle common ES operations
+    mock_es_client.indices.exists.return_value = True
+    mock_es_client.indices.create.return_value = {"acknowledged": True}
+    mock_es_client.search.return_value = {"hits": {"total": {"value": 0}, "hits": []}}
+    mock_es_client.index.return_value = {"_id": "test_id", "result": "created"}
+    mock_es_client.update.return_value = {"_id": "test_id", "result": "updated"}
+    mock_es_client.delete.return_value = {"_id": "test_id", "result": "deleted"}
+
+    # Start the patch
+    with patch('elasticsearch.Elasticsearch', return_value=mock_es_client):
+        yield mock_es_client
+
+
+@pytest.fixture
+def mock_mongodb():
+    """
+    Mock MongoDB for testing without actual MongoDB connection.
+
+    This fixture patches PyMongo to return a MagicMock that behaves like a MongoDB client.
+    """
+    # Create mock MongoDB clients and collections
+    mock_mongo_client = MagicMock()
+    mock_mongo_db = MagicMock()
+    mock_mongo_collection = MagicMock()
+
+    # Set up the chain: client -> database -> collection
+    mock_mongo_client.__getitem__.return_value = mock_mongo_db
+    mock_mongo_client.get_database.return_value = mock_mongo_db
+    mock_mongo_db.__getitem__.return_value = mock_mongo_collection
+
+    # Configure common MongoDB collection operations
+    mock_mongo_collection.find_one.return_value = None
+    mock_mongo_collection.find.return_value = MagicMock(
+        __iter__=lambda x: iter([]),
+        count=lambda: 0
+    )
+    mock_mongo_collection.insert_one.return_value = MagicMock(
+        inserted_id="mock_id_123",
+        acknowledged=True
+    )
+    mock_mongo_collection.insert_many.return_value = MagicMock(
+        inserted_ids=["mock_id_123", "mock_id_456"],
+        acknowledged=True
+    )
+    mock_mongo_collection.update_one.return_value = MagicMock(
+        modified_count=1,
+        matched_count=1,
+        acknowledged=True
+    )
+    mock_mongo_collection.update_many.return_value = MagicMock(
+        modified_count=2,
+        matched_count=2,
+        acknowledged=True
+    )
+    mock_mongo_collection.delete_one.return_value = MagicMock(
+        deleted_count=1,
+        acknowledged=True
+    )
+    mock_mongo_collection.delete_many.return_value = MagicMock(
+        deleted_count=2,
+        acknowledged=True
+    )
+    mock_mongo_collection.count_documents.return_value = 0
+
+    # Start the patch
+    with patch('pymongo.MongoClient', return_value=mock_mongo_client):
+        yield mock_mongo_client
+
+
+@pytest.fixture
+def mock_celery():
+    """
+    Mock Celery for testing without actual task execution.
+
+    This fixture patches Celery's task.delay() to prevent actual task execution.
+    """
+    # Start the patch
+    with patch('celery.app.task.Task.delay') as mock_delay:
+        mock_delay.return_value = MagicMock(id="mock-task-id")
+        yield mock_delay

apiserver/plane/tests/contract/app/__init__.py

@@ -0,0 +1 @@
+ 

apiserver/plane/tests/contract/app/test_authentication.py

@@ -0,0 +1,459 @@
+import json
+import uuid
+import pytest
+from django.urls import reverse
+from django.utils import timezone
+from rest_framework import status
+from django.test import Client
+from django.core.exceptions import ValidationError
+from unittest.mock import patch, MagicMock
+
+from plane.db.models import User
+from plane.settings.redis import redis_instance
+from plane.license.models import Instance
+
+
+@pytest.fixture
+def setup_instance(db):
+    """Create and configure an instance for authentication tests"""
+    instance_id = uuid.uuid4() if not Instance.objects.exists() else Instance.objects.first().id
+
+    # Create or update instance with all required fields
+    instance, _ = Instance.objects.update_or_create(
+        id=instance_id,
+        defaults={
+            "instance_name": "Test Instance",
+            "instance_id": str(uuid.uuid4()),
+            "current_version": "1.0.0",
+            "domain": "http://localhost:8000",
+            "last_checked_at": timezone.now(),
+            "is_setup_done": True,
+        }
+    )
+    return instance
+
+
+@pytest.fixture
+def django_client():
+    """Return a Django test client with User-Agent header for handling redirects"""
+    client = Client(HTTP_USER_AGENT="Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0.1")
+    return client
+
+
+@pytest.mark.contract
+class TestMagicLinkGenerate:
+    """Test magic link generation functionality"""
+
+    @pytest.fixture
+    def setup_user(self, db):
+        """Create a test user for magic link tests"""
+        user = User.objects.create(email="user@plane.so")
+        user.set_password("user@123")
+        user.save()
+        return user
+
+    @pytest.mark.django_db
+    def test_without_data(self, api_client, setup_user, setup_instance):
+        """Test magic link generation with empty data"""
+        url = reverse("magic-generate")
+        try:
+            response = api_client.post(url, {}, format="json")
+            assert response.status_code == status.HTTP_400_BAD_REQUEST
+        except ValidationError:
+            # If a ValidationError is raised directly, that's also acceptable
+            # as it indicates the empty email was rejected
+            assert True
+
+    @pytest.mark.django_db
+    def test_email_validity(self, api_client, setup_user, setup_instance):
+        """Test magic link generation with invalid email format"""
+        url = reverse("magic-generate")
+        try:
+            response = api_client.post(url, {"email": "useremail.com"}, format="json")
+            assert response.status_code == status.HTTP_400_BAD_REQUEST
+            assert "error_code" in response.data  # Check for error code in response
+        except ValidationError:
+            # If a ValidationError is raised directly, that's also acceptable
+            # as it indicates the invalid email was rejected
+            assert True
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
+    def test_magic_generate(self, mock_magic_link, api_client, setup_user, setup_instance):
+        """Test successful magic link generation"""
+        url = reverse("magic-generate")
+
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+
+        response = api_client.post(url, {"email": "user@plane.so"}, format="json")
+        assert response.status_code == status.HTTP_200_OK
+        assert "key" in response.data  # Check for key in response
+
+        # Verify the mock was called with the expected arguments
+        mock_magic_link.assert_called_once()
+        args = mock_magic_link.call_args[0]
+        assert args[0] == "user@plane.so"  # First arg should be the email
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
+    def test_max_generate_attempt(self, mock_magic_link, api_client, setup_user, setup_instance):
+        """Test exceeding maximum magic link generation attempts"""
+        url = reverse("magic-generate")
+
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+
+        for _ in range(4):
+            api_client.post(url, {"email": "user@plane.so"}, format="json")
+
+        response = api_client.post(url, {"email": "user@plane.so"}, format="json")
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "error_code" in response.data  # Check for error code in response
+
+
+@pytest.mark.contract
+class TestSignInEndpoint:
+    """Test sign-in functionality"""
+
+    @pytest.fixture
+    def setup_user(self, db):
+        """Create a test user for authentication tests"""
+        user = User.objects.create(email="user@plane.so")
+        user.set_password("user@123")
+        user.save()
+        return user
+
+    @pytest.mark.django_db
+    def test_without_data(self, django_client, setup_user, setup_instance):
+        """Test sign-in with empty data"""
+        url = reverse("sign-in")
+        response = django_client.post(url, {}, follow=True)
+
+        # Check redirect contains error code
+        assert "REQUIRED_EMAIL_PASSWORD_SIGN_IN" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    def test_email_validity(self, django_client, setup_user, setup_instance):
+        """Test sign-in with invalid email format"""
+        url = reverse("sign-in")
+        response = django_client.post(
+            url, {"email": "useremail.com", "password": "user@123"}, follow=True
+        )
+
+        # Check redirect contains error code
+        assert "INVALID_EMAIL_SIGN_IN" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    def test_user_exists(self, django_client, setup_user, setup_instance):
+        """Test sign-in with non-existent user"""
+        url = reverse("sign-in")
+        response = django_client.post(
+            url, {"email": "user@email.so", "password": "user123"}, follow=True
+        )
+
+        # Check redirect contains error code
+        assert "USER_DOES_NOT_EXIST" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    def test_password_validity(self, django_client, setup_user, setup_instance):
+        """Test sign-in with incorrect password"""
+        url = reverse("sign-in")
+        response = django_client.post(
+            url, {"email": "user@plane.so", "password": "user123"}, follow=True
+        )
+
+
+        # Check for the specific authentication error in the URL
+        redirect_urls = [url for url, _ in response.redirect_chain]
+        redirect_contents = ' '.join(redirect_urls)
+
+        # The actual error code for invalid password is AUTHENTICATION_FAILED_SIGN_IN
+        assert "AUTHENTICATION_FAILED_SIGN_IN" in redirect_contents
+
+    @pytest.mark.django_db
+    def test_user_login(self, django_client, setup_user, setup_instance):
+        """Test successful sign-in"""
+        url = reverse("sign-in")
+
+        # First make the request without following redirects
+        response = django_client.post(
+            url, {"email": "user@plane.so", "password": "user@123"}, follow=False
+        )
+
+        # Check that the initial response is a redirect (302) without error code
+        assert response.status_code == 302
+        assert "error_code" not in response.url
+
+        # Now follow just the first redirect to avoid 404s
+        response = django_client.get(response.url, follow=False)
+
+        # The user should be authenticated regardless of the final page
+        assert "_auth_user_id" in django_client.session
+
+    @pytest.mark.django_db
+    def test_next_path_redirection(self, django_client, setup_user, setup_instance):
+        """Test sign-in with next_path parameter"""
+        url = reverse("sign-in")
+        next_path = "workspaces"
+
+        # First make the request without following redirects
+        response = django_client.post(
+            url,
+            {"email": "user@plane.so", "password": "user@123", "next_path": next_path},
+            follow=False
+        )
+
+        # Check that the initial response is a redirect (302) without error code
+        assert response.status_code == 302
+        assert "error_code" not in response.url
+
+
+        # In a real browser, the next_path would be used to build the absolute URL
+        # Since we're just testing the authentication logic, we won't check for the exact URL structure
+        # Instead, just verify that we're authenticated
+        assert "_auth_user_id" in django_client.session
+
+
+@pytest.mark.contract
+class TestMagicSignIn:
+    """Test magic link sign-in functionality"""
+
+    @pytest.fixture
+    def setup_user(self, db):
+        """Create a test user for magic sign-in tests"""
+        user = User.objects.create(email="user@plane.so")
+        user.set_password("user@123")
+        user.save()
+        return user
+
+    @pytest.mark.django_db
+    def test_without_data(self, django_client, setup_user, setup_instance):
+        """Test magic link sign-in with empty data"""
+        url = reverse("magic-sign-in")
+        response = django_client.post(url, {}, follow=True)
+
+        # Check redirect contains error code
+        assert "MAGIC_SIGN_IN_EMAIL_CODE_REQUIRED" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    def test_expired_invalid_magic_link(self, django_client, setup_user, setup_instance):
+        """Test magic link sign-in with expired/invalid link"""
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+
+        url = reverse("magic-sign-in")
+        response = django_client.post(
+            url,
+            {"email": "user@plane.so", "code": "xxxx-xxxxx-xxxx"},
+            follow=False
+        )
+
+        # Check that we get a redirect
+        assert response.status_code == 302
+
+        # The actual error code is EXPIRED_MAGIC_CODE_SIGN_IN (when key doesn't exist)
+        # or INVALID_MAGIC_CODE_SIGN_IN (when key exists but code doesn't match)
+        assert "EXPIRED_MAGIC_CODE_SIGN_IN" in response.url or "INVALID_MAGIC_CODE_SIGN_IN" in response.url
+
+    @pytest.mark.django_db
+    def test_user_does_not_exist(self, django_client, setup_instance):
+        """Test magic sign-in with non-existent user"""
+        url = reverse("magic-sign-in")
+        response = django_client.post(
+            url,
+            {"email": "nonexistent@plane.so", "code": "xxxx-xxxxx-xxxx"},
+            follow=True
+        )
+
+        # Check redirect contains error code
+        assert "USER_DOES_NOT_EXIST" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
+    def test_magic_code_sign_in(self, mock_magic_link, django_client, api_client, setup_user, setup_instance):
+        """Test successful magic link sign-in process"""
+        # First generate a magic link token
+        gen_url = reverse("magic-generate")
+        response = api_client.post(gen_url, {"email": "user@plane.so"}, format="json")
+
+        # Check that the token generation was successful
+        assert response.status_code == status.HTTP_200_OK
+
+        # Since we're mocking the magic_link task, we need to manually get the token from Redis
+        ri = redis_instance()
+        user_data = json.loads(ri.get("magic_user@plane.so"))
+        token = user_data["token"]
+
+        # Use Django client to test the redirect flow without following redirects
+        url = reverse("magic-sign-in")
+        response = django_client.post(
+            url,
+            {"email": "user@plane.so", "code": token},
+            follow=False
+        )
+
+        # Check that the initial response is a redirect without error code
+        assert response.status_code == 302
+        assert "error_code" not in response.url
+
+        # The user should now be authenticated
+        assert "_auth_user_id" in django_client.session
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
+    def test_magic_sign_in_with_next_path(self, mock_magic_link, django_client, api_client, setup_user, setup_instance):
+        """Test magic sign-in with next_path parameter"""
+        # First generate a magic link token
+        gen_url = reverse("magic-generate")
+        response = api_client.post(gen_url, {"email": "user@plane.so"}, format="json")
+
+        # Check that the token generation was successful
+        assert response.status_code == status.HTTP_200_OK
+
+        # Since we're mocking the magic_link task, we need to manually get the token from Redis
+        ri = redis_instance()
+        user_data = json.loads(ri.get("magic_user@plane.so"))
+        token = user_data["token"]
+
+        # Use Django client to test the redirect flow without following redirects
+        url = reverse("magic-sign-in")
+        next_path = "workspaces"
+        response = django_client.post(
+            url,
+            {"email": "user@plane.so", "code": token, "next_path": next_path},
+            follow=False
+        )
+
+        # Check that the initial response is a redirect without error code
+        assert response.status_code == 302
+        assert "error_code" not in response.url
+
+        # Check that the redirect URL contains the next_path
+        assert next_path in response.url
+
+        # The user should now be authenticated
+        assert "_auth_user_id" in django_client.session
+
+
+@pytest.mark.contract
+class TestMagicSignUp:
+    """Test magic link sign-up functionality"""
+
+    @pytest.mark.django_db
+    def test_without_data(self, django_client, setup_instance):
+        """Test magic link sign-up with empty data"""
+        url = reverse("magic-sign-up")
+        response = django_client.post(url, {}, follow=True)
+
+        # Check redirect contains error code
+        assert "MAGIC_SIGN_UP_EMAIL_CODE_REQUIRED" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    def test_user_already_exists(self, django_client, db, setup_instance):
+        """Test magic sign-up with existing user"""
+        # Create a user that already exists
+        User.objects.create(email="existing@plane.so")
+
+        url = reverse("magic-sign-up")
+        response = django_client.post(
+            url,
+            {"email": "existing@plane.so", "code": "xxxx-xxxxx-xxxx"},
+            follow=True
+        )
+
+        # Check redirect contains error code
+        assert "USER_ALREADY_EXIST" in response.redirect_chain[-1][0]
+
+    @pytest.mark.django_db
+    def test_expired_invalid_magic_link(self, django_client, setup_instance):
+        """Test magic link sign-up with expired/invalid link"""
+        url = reverse("magic-sign-up")
+        response = django_client.post(
+            url,
+            {"email": "new@plane.so", "code": "xxxx-xxxxx-xxxx"},
+            follow=False
+        )
+
+        # Check that we get a redirect
+        assert response.status_code == 302
+
+        # The actual error code is EXPIRED_MAGIC_CODE_SIGN_UP (when key doesn't exist)
+        # or INVALID_MAGIC_CODE_SIGN_UP (when key exists but code doesn't match)
+        assert "EXPIRED_MAGIC_CODE_SIGN_UP" in response.url or "INVALID_MAGIC_CODE_SIGN_UP" in response.url
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
+    def test_magic_code_sign_up(self, mock_magic_link, django_client, api_client, setup_instance):
+        """Test successful magic link sign-up process"""
+        email = "newuser@plane.so"
+
+        # First generate a magic link token
+        gen_url = reverse("magic-generate")
+        response = api_client.post(gen_url, {"email": email}, format="json")
+
+        # Check that the token generation was successful
+        assert response.status_code == status.HTTP_200_OK
+
+        # Since we're mocking the magic_link task, we need to manually get the token from Redis
+        ri = redis_instance()
+        user_data = json.loads(ri.get(f"magic_{email}"))
+        token = user_data["token"]
+
+        # Use Django client to test the redirect flow without following redirects
+        url = reverse("magic-sign-up")
+        response = django_client.post(
+            url,
+            {"email": email, "code": token},
+            follow=False
+        )
+
+        # Check that the initial response is a redirect without error code
+        assert response.status_code == 302
+        assert "error_code" not in response.url
+
+        # Check if user was created
+        assert User.objects.filter(email=email).exists()
+
+        # Check if user is authenticated
+        assert "_auth_user_id" in django_client.session
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
+    def test_magic_sign_up_with_next_path(self, mock_magic_link, django_client, api_client, setup_instance):
+        """Test magic sign-up with next_path parameter"""
+        email = "newuser2@plane.so"
+
+        # First generate a magic link token
+        gen_url = reverse("magic-generate")
+        response = api_client.post(gen_url, {"email": email}, format="json")
+
+        # Check that the token generation was successful
+        assert response.status_code == status.HTTP_200_OK
+
+        # Since we're mocking the magic_link task, we need to manually get the token from Redis
+        ri = redis_instance()
+        user_data = json.loads(ri.get(f"magic_{email}"))
+        token = user_data["token"]
+
+        # Use Django client to test the redirect flow without following redirects
+        url = reverse("magic-sign-up")
+        next_path = "onboarding"
+        response = django_client.post(
+            url,
+            {"email": email, "code": token, "next_path": next_path},
+            follow=False
+        )
+
+        # Check that the initial response is a redirect without error code
+        assert response.status_code == 302
+        assert "error_code" not in response.url
+
+        # In a real browser, the next_path would be used to build the absolute URL
+        # Since we're just testing the authentication logic, we won't check for the exact URL structure
+
+        # Check if user was created
+        assert User.objects.filter(email=email).exists()
+
+        # Check if user is authenticated
+        assert "_auth_user_id" in django_client.session

apiserver/plane/tests/contract/app/test_workspace_app.py

@@ -0,0 +1,79 @@
+import pytest
+from django.urls import reverse
+from rest_framework import status
+from unittest.mock import patch
+
+from plane.db.models import Workspace, WorkspaceMember
+
+
+@pytest.mark.contract
+class TestWorkspaceAPI:
+    """Test workspace CRUD operations"""
+
+    @pytest.mark.django_db
+    def test_create_workspace_empty_data(self, session_client):
+        """Test creating a workspace with empty data"""
+        url = reverse("workspace")
+
+        # Test with empty data
+        response = session_client.post(url, {}, format="json")
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+
+    @pytest.mark.django_db
+    @patch("plane.bgtasks.workspace_seed_task.workspace_seed.delay")
+    def test_create_workspace_valid_data(self, mock_workspace_seed, session_client, create_user):
+        """Test creating a workspace with valid data"""
+        url = reverse("workspace")
+        user = create_user  # Use the create_user fixture directly as it returns a user object
+
+        # Test with valid data - include all required fields
+        workspace_data = {
+            "name": "Plane",
+            "slug": "pla-ne-test",
+            "company_name": "Plane Inc."
+        }
+
+        # Make the request
+        response = session_client.post(url, workspace_data, format="json")
+
+        # Check response status
+        assert response.status_code == status.HTTP_201_CREATED
+
+        # Verify workspace was created
+        assert Workspace.objects.count() == 1
+
+        # Check if the member is created
+        assert WorkspaceMember.objects.count() == 1
+
+        # Check other values
+        workspace = Workspace.objects.get(slug=workspace_data["slug"])
+        workspace_member = WorkspaceMember.objects.filter(
+            workspace=workspace, member=user
+        ).first()
+        assert workspace.owner == user
+        assert workspace_member.role == 20
+
+        # Verify the workspace_seed task was called
+        mock_workspace_seed.assert_called_once_with(response.data["id"])
+
+    @pytest.mark.django_db
+    @patch('plane.bgtasks.workspace_seed_task.workspace_seed.delay')
+    def test_create_duplicate_workspace(self, mock_workspace_seed, session_client):
+        """Test creating a duplicate workspace"""
+        url = reverse("workspace")
+
+        # Create first workspace
+        session_client.post(
+            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
+        )
+
+        # Try to create a workspace with the same slug
+        response = session_client.post(
+            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
+        )
+
+        # The API returns 400 BAD REQUEST for duplicate slugs, not 409 CONFLICT
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+
+        # Optionally check the error message to confirm it's related to the duplicate slug
+        assert "slug" in response.data

apiserver/plane/tests/factories.py

@@ -0,0 +1,82 @@
+import factory
+from uuid import uuid4
+from django.utils import timezone
+
+from plane.db.models import (
+    User,
+    Workspace,
+    WorkspaceMember,
+    Project,
+    ProjectMember
+)
+
+
+class UserFactory(factory.django.DjangoModelFactory):
+    """Factory for creating User instances"""
+    class Meta:
+        model = User
+        django_get_or_create = ('email',)
+
+    id = factory.LazyFunction(uuid4)
+    email = factory.Sequence(lambda n: f'user{n}@plane.so')
+    password = factory.PostGenerationMethodCall('set_password', 'password')
+    first_name = factory.Sequence(lambda n: f'First{n}')
+    last_name = factory.Sequence(lambda n: f'Last{n}')
+    is_active = True
+    is_superuser = False
+    is_staff = False
+
+
+class WorkspaceFactory(factory.django.DjangoModelFactory):
+    """Factory for creating Workspace instances"""
+    class Meta:
+        model = Workspace
+        django_get_or_create = ('slug',)
+
+    id = factory.LazyFunction(uuid4)
+    name = factory.Sequence(lambda n: f'Workspace {n}')
+    slug = factory.Sequence(lambda n: f'workspace-{n}')
+    owner = factory.SubFactory(UserFactory)
+    created_at = factory.LazyFunction(timezone.now)
+    updated_at = factory.LazyFunction(timezone.now)
+
+
+class WorkspaceMemberFactory(factory.django.DjangoModelFactory):
+    """Factory for creating WorkspaceMember instances"""
+    class Meta:
+        model = WorkspaceMember
+
+    id = factory.LazyFunction(uuid4)
+    workspace = factory.SubFactory(WorkspaceFactory)
+    member = factory.SubFactory(UserFactory)
+    role = 20  # Admin role by default
+    created_at = factory.LazyFunction(timezone.now)
+    updated_at = factory.LazyFunction(timezone.now)
+
+
+class ProjectFactory(factory.django.DjangoModelFactory):
+    """Factory for creating Project instances"""
+    class Meta:
+        model = Project
+        django_get_or_create = ('name', 'workspace')
+
+    id = factory.LazyFunction(uuid4)
+    name = factory.Sequence(lambda n: f'Project {n}')
+    workspace = factory.SubFactory(WorkspaceFactory)
+    created_by = factory.SelfAttribute('workspace.owner')
+    updated_by = factory.SelfAttribute('workspace.owner')
+    created_at = factory.LazyFunction(timezone.now)
+    updated_at = factory.LazyFunction(timezone.now)
+
+
+class ProjectMemberFactory(factory.django.DjangoModelFactory):
+    """Factory for creating ProjectMember instances"""
+    class Meta:
+        model = ProjectMember
+
+    id = factory.LazyFunction(uuid4)
+    project = factory.SubFactory(ProjectFactory)
+    member = factory.SubFactory(UserFactory)
+    role = 20  # Admin role by default
+    created_at = factory.LazyFunction(timezone.now)
+    updated_at = factory.LazyFunction(timezone.now)

apiserver/plane/tests/smoke/test_auth_smoke.py

@@ -0,0 +1,100 @@
+import pytest
+import requests
+from django.urls import reverse
+
+
+@pytest.mark.smoke
+class TestAuthSmoke:
+    """Smoke tests for authentication endpoints"""
+
+    @pytest.mark.django_db
+    def test_login_endpoint_available(self, plane_server, create_user, user_data):
+        """Test that the login endpoint is available and responds correctly"""
+        # Get the sign-in URL
+        relative_url = reverse("sign-in")
+        url = f"{plane_server.url}{relative_url}"
+
+        # 1. Test bad login - test with wrong password
+        response = requests.post(
+            url,
+            data={
+                "email": user_data["email"],
+                "password": "wrong-password"
+            }
+        )
+
+        # For bad credentials, any of these status codes would be valid
+        # The test shouldn't be brittle to minor implementation changes
+        assert response.status_code != 500, "Authentication should not cause server errors"
+        assert response.status_code != 404, "Authentication endpoint should exist"
+
+        if response.status_code == 200:
+            # If API returns 200 for failures, check the response body for error indication
+            if hasattr(response, 'json'):
+                try:
+                    data = response.json()
+                    # JSON response might indicate error in its structure
+                    assert "error" in data or "error_code" in data or "detail" in data or response.url.endswith("sign-in"), \
+                        "Error response should contain error details"
+                except ValueError:
+                    # It's ok if response isn't JSON format
+                    pass
+        elif response.status_code in [302, 303]:
+            # If it's a redirect, it should redirect to a login page or error page
+            redirect_url = response.headers.get('Location', '')
+            assert "error" in redirect_url or "sign-in" in redirect_url, \
+                "Failed login should redirect to login page or error page"
+
+        # 2. Test good login with correct credentials
+        response = requests.post(
+            url,
+            data={
+                "email": user_data["email"],
+                "password": user_data["password"]
+            },
+            allow_redirects=False  # Don't follow redirects
+        )
+
+        # Successful auth should not be a client error or server error
+        assert response.status_code not in range(400, 600), \
+            f"Authentication with valid credentials failed with status {response.status_code}"
+
+        # Specific validation based on response type
+        if response.status_code in [302, 303]:
+            # Redirect-based auth: check that redirect URL doesn't contain error
+            redirect_url = response.headers.get('Location', '')
+            assert "error" not in redirect_url and "error_code" not in redirect_url, \
+                "Successful login redirect should not contain error parameters"
+
+        elif response.status_code == 200:
+            # API token-based auth: check for tokens or user session
+            if hasattr(response, 'json'):
+                try:
+                    data = response.json()
+                    # If it's a token response
+                    if "access_token" in data:
+                        assert "refresh_token" in data, "JWT auth should return both access and refresh tokens"
+                    # If it's a user session response
+                    elif "user" in data:
+                        assert "is_authenticated" in data and data["is_authenticated"], \
+                            "User session response should indicate authentication"
+                    # Otherwise it should at least indicate success
+                    else:
+                        assert not any(error_key in data for error_key in ["error", "error_code", "detail"]), \
+                            "Success response should not contain error keys"
+                except ValueError:
+                    # Non-JSON is acceptable if it's a redirect or HTML response
+                    pass
+
+
+@pytest.mark.smoke
+class TestHealthCheckSmoke:
+    """Smoke test for health check endpoint"""
+
+    def test_healthcheck_endpoint(self, plane_server):
+        """Test that the health check endpoint is available and responds correctly"""
+        # Make a request to the health check endpoint
+        response = requests.get(f"{plane_server.url}/")
+
+        # Should be OK
+        assert response.status_code == 200, "Health check endpoint should return 200 OK"

apiserver/plane/tests/unit/models/test_workspace_model.py

@@ -0,0 +1,50 @@
+import pytest
+from uuid import uuid4
+
+from plane.db.models import Workspace, WorkspaceMember, User
+
+
+@pytest.mark.unit
+class TestWorkspaceModel:
+    """Test the Workspace model"""
+
+    @pytest.mark.django_db
+    def test_workspace_creation(self, create_user):
+        """Test creating a workspace"""
+        # Create a workspace
+        workspace = Workspace.objects.create(
+            name="Test Workspace",
+            slug="test-workspace",
+            id=uuid4(),
+            owner=create_user
+        )
+
+        # Verify it was created
+        assert workspace.id is not None
+        assert workspace.name == "Test Workspace"
+        assert workspace.slug == "test-workspace"
+        assert workspace.owner == create_user
+
+    @pytest.mark.django_db
+    def test_workspace_member_creation(self, create_user):
+        """Test creating a workspace member"""
+        # Create a workspace
+        workspace = Workspace.objects.create(
+            name="Test Workspace",
+            slug="test-workspace",
+            id=uuid4(),
+            owner=create_user
+        )
+
+        # Create a workspace member
+        workspace_member = WorkspaceMember.objects.create(
+            workspace=workspace,
+            member=create_user,
+            role=20  # Admin role
+        )
+
+        # Verify it was created
+        assert workspace_member.id is not None
+        assert workspace_member.workspace == workspace
+        assert workspace_member.member == create_user
+        assert workspace_member.role == 20

apiserver/plane/tests/unit/serializers/test_workspace.py

@@ -0,0 +1,71 @@
+import pytest
+from uuid import uuid4
+
+from plane.api.serializers import WorkspaceLiteSerializer
+from plane.db.models import Workspace, User
+
+
+@pytest.mark.unit
+class TestWorkspaceLiteSerializer:
+    """Test the WorkspaceLiteSerializer"""
+
+    def test_workspace_lite_serializer_fields(self, db):
+        """Test that the serializer includes the correct fields"""
+        # Create a user to be the owner
+        owner = User.objects.create(
+            email="test@example.com",
+            first_name="Test",
+            last_name="User"
+        )
+
+        # Create a workspace with explicit ID to test serialization
+        workspace_id = uuid4()
+        workspace = Workspace.objects.create(
+            name="Test Workspace",
+            slug="test-workspace",
+            id=workspace_id,
+            owner=owner
+        )
+
+        # Serialize the workspace
+        serialized_data = WorkspaceLiteSerializer(workspace).data
+
+        # Check fields are present and correct
+        assert "name" in serialized_data
+        assert "slug" in serialized_data
+        assert "id" in serialized_data
+
+        assert serialized_data["name"] == "Test Workspace"
+        assert serialized_data["slug"] == "test-workspace"
+        assert str(serialized_data["id"]) == str(workspace_id)
+
+    def test_workspace_lite_serializer_read_only(self, db):
+        """Test that the serializer fields are read-only"""
+        # Create a user to be the owner
+        owner = User.objects.create(
+            email="test2@example.com",
+            first_name="Test",
+            last_name="User"
+        )
+
+        # Create a workspace
+        workspace = Workspace.objects.create(
+            name="Test Workspace",
+            slug="test-workspace",
+            id=uuid4(),
+            owner=owner
+        )
+
+        # Try to update via serializer
+        serializer = WorkspaceLiteSerializer(
+            workspace,
+            data={"name": "Updated Name", "slug": "updated-slug"}
+        )
+
+        # Serializer should be valid (since read-only fields are ignored)
+        assert serializer.is_valid()
+
+        # Save should not update the read-only fields
+        updated_workspace = serializer.save()
+        assert updated_workspace.name == "Test Workspace"
+        assert updated_workspace.slug == "test-workspace"

apiserver/plane/tests/unit/utils/test_uuid.py

@@ -0,0 +1,49 @@
+import uuid
+import pytest
+from plane.utils.uuid import is_valid_uuid, convert_uuid_to_integer
+
+
+@pytest.mark.unit
+class TestUUIDUtils:
+    """Test the UUID utilities"""
+
+    def test_is_valid_uuid_with_valid_uuid(self):
+        """Test is_valid_uuid with a valid UUID"""
+        # Generate a valid UUID
+        valid_uuid = str(uuid.uuid4())
+        assert is_valid_uuid(valid_uuid) is True
+
+    def test_is_valid_uuid_with_invalid_uuid(self):
+        """Test is_valid_uuid with invalid UUID strings"""
+        # Test with different invalid formats
+        assert is_valid_uuid("not-a-uuid") is False
+        assert is_valid_uuid("123456789") is False
+        assert is_valid_uuid("") is False
+        assert is_valid_uuid("00000000-0000-0000-0000-000000000000") is False  # This is a valid UUID but version 1
+
+    def test_convert_uuid_to_integer(self):
+        """Test convert_uuid_to_integer function"""
+        # Create a known UUID
+        test_uuid = uuid.UUID("f47ac10b-58cc-4372-a567-0e02b2c3d479")
+
+        # Convert to integer
+        result = convert_uuid_to_integer(test_uuid)
+
+        # Check that the result is an integer
+        assert isinstance(result, int)
+
+        # Ensure consistent results with the same input
+        assert convert_uuid_to_integer(test_uuid) == result
+
+        # Different UUIDs should produce different integers
+        different_uuid = uuid.UUID("550e8400-e29b-41d4-a716-446655440000")
+        assert convert_uuid_to_integer(different_uuid) != result
+
+    def test_convert_uuid_to_integer_string_input(self):
+        """Test convert_uuid_to_integer handles string UUID"""
+        # Test with a UUID string
+        test_uuid_str = "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+        test_uuid = uuid.UUID(test_uuid_str)
+
+        # Should get the same result whether passing UUID or string
+        assert convert_uuid_to_integer(test_uuid) == convert_uuid_to_integer(test_uuid_str)

apiserver/plane/utils/url.py

@@ -4,6 +4,14 @@ from typing import Optional
 from urllib.parse import urlparse, urlunparse
 
 
+def contains_url(value: str) -> bool:
+    """
+    Check if the value contains a URL.
+    """
+    url_pattern = re.compile(r"https?://|www\\.")
+    return bool(url_pattern.search(value))
+
+
 def is_valid_url(url: str) -> bool:
     """
     Validates whether the given string is a well-formed URL.
@@ -77,31 +85,3 @@ def normalize_url_path(url: str) -> str:
     normalized_path = re.sub(r"/+", "/", parts.path)
     # Reconstruct the URL
     return urlunparse(parts._replace(path=normalized_path))
-
-
-def clean_value(value: str) -> str:
-    """
-    Clean the value by removing URLs and domain patterns.
-
-    Args:
-        value (str): The value to clean.
-
-    Returns:
-        str: The cleaned value.
-    """
-
-    if not value:
-        return value
-
-    url_pattern = r"(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"  # noqa
-
-    # Remove URLs and domains
-    cleaned_value = re.sub(url_pattern, "", value)
-
-    # Keep only alphanumeric characters and spaces
-    cleaned_value = re.sub(r"[^a-zA-Z0-9\s]", "", cleaned_value)
-
-    # Remove extra spaces and trim
-    cleaned_value = " ".join(cleaned_value.split())
-
-    return cleaned_value

apiserver/pytest.ini

@@ -0,0 +1,17 @@
+[pytest]
+DJANGO_SETTINGS_MODULE = plane.settings.test
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+markers =
+    unit: Unit tests for models, serializers, and utility functions
+    contract: Contract tests for API endpoints
+    smoke: Smoke tests for critical functionality
+    slow: Tests that are slow and might be skipped in some contexts
+
+addopts = 
+    --strict-markers
+    --reuse-db
+    --nomigrations
+    -vs 

apiserver/requirements/base.txt

@@ -1,7 +1,7 @@
 # base requirements
 
 # django
-Django==4.2.21
+Django==4.2.22
 # rest framework
 djangorestframework==3.15.2
 # postgres

apiserver/requirements/test.txt

@@ -1,4 +1,12 @@
 -r base.txt
-# test checker
-pytest==7.1.2
-coverage==6.5.0
+# test framework
+pytest==7.4.0
+pytest-django==4.5.2
+pytest-cov==4.1.0
+pytest-xdist==3.3.1
+pytest-mock==3.11.1
+factory-boy==3.3.0
+freezegun==1.2.2
+coverage==7.2.7
+httpx==0.24.1
+requests==2.32.2

apiserver/run_tests.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run Plane tests")
+    parser.add_argument(
+        "-u", "--unit", 
+        action="store_true", 
+        help="Run unit tests only"
+    )
+    parser.add_argument(
+        "-c", "--contract", 
+        action="store_true", 
+        help="Run contract tests only"
+    )
+    parser.add_argument(
+        "-s", "--smoke", 
+        action="store_true", 
+        help="Run smoke tests only"
+    )
+    parser.add_argument(
+        "-o", "--coverage", 
+        action="store_true", 
+        help="Generate coverage report"
+    )
+    parser.add_argument(
+        "-p", "--parallel", 
+        action="store_true", 
+        help="Run tests in parallel"
+    )
+    parser.add_argument(
+        "-v", "--verbose", 
+        action="store_true", 
+        help="Verbose output"
+    )
+    args = parser.parse_args()
+
+    # Build command
+    cmd = ["python", "-m", "pytest"]
+    markers = []
+
+    # Add test markers
+    if args.unit:
+        markers.append("unit")
+    if args.contract:
+        markers.append("contract")
+    if args.smoke:
+        markers.append("smoke")
+
+    # Add markers filter
+    if markers:
+        cmd.extend(["-m", " or ".join(markers)])
+
+    # Add coverage
+    if args.coverage:
+        cmd.extend(["--cov=plane", "--cov-report=term", "--cov-report=html"])
+
+    # Add parallel
+    if args.parallel:
+        cmd.extend(["-n", "auto"])
+
+    # Add verbose
+    if args.verbose:
+        cmd.append("-v")
+
+    # Add common flags
+    cmd.extend(["--reuse-db", "--nomigrations"])
+
+    # Print command
+    print(f"Running: {' '.join(cmd)}")
+    
+    # Execute command
+    result = subprocess.run(cmd)
+    
+    # Check coverage thresholds if coverage is enabled
+    if args.coverage:
+        print("Checking coverage thresholds...")
+        coverage_cmd = ["python", "-m", "coverage", "report", "--fail-under=90"]
+        coverage_result = subprocess.run(coverage_cmd)
+        if coverage_result.returncode != 0:
+            print("Coverage below threshold (90%)")
+            sys.exit(coverage_result.returncode)
+            
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main() 

apiserver/run_tests.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+# This is a simple wrapper script that calls the main test runner in the tests directory
+exec tests/run_tests.sh "$@" 

apiserver/templates/emails/notifications/issue-updates.html

@@ -3,7 +3,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Updates on issue</title>
+    <title>Updates on {{entity_type}}</title>
     <style type="text/css" emogrify="no"> html { font-family: system-ui; } p, h1, h2, h3, h4, ol, ul { margin: 0; } h-full { height: 100%; } a:hover { color: #3358d4 !important; } </style>
     <style> *[class="gmail-fix"] { display: none !important; } </style>
     <style type="text/css" emogrify="no"> @media (max-width: 600px) { .gmx-killpill { content: " \03D1"; } } </style>
@@ -37,7 +37,7 @@
           {% else %} 
           <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> {{summary}} <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {% if data|length > 0 %} {{ data.0.actor_detail.first_name}} {{data.0.actor_detail.last_name}} {% else %} {{ comments.0.actor_detail.first_name}} {{comments.0.actor_detail.last_name}} {% endif %} </span>and others. </p>
           {% endif %} <!-- {% if actors_involved == 1 %} {% if data|length > 0 and comments|length == 0 %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {{ data.0.actor_detail.first_name}} {{data.0.actor_detail.last_name }} </span> made {{total_updates}} {% if total_updates > 1 %}updates{% else %}update{% endif %} to the issue. </p> {% elif data|length == 0 and comments|length > 0 %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {{ comments.0.actor_detail.first_name}} {{comments.0.actor_detail.last_name }} </span> added {{total_comments}} new {% if total_comments > 1 %}comments{% else %}comment{% endif %}. </p> {% elif data|length > 0 and comments|length > 0 %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {{ data.0.actor_detail.first_name}} {{data.0.actor_detail.last_name }} </span> made {{total_updates}} {% if total_updates > 1 %}updates{% else %}update{% endif %} and added {{total_comments}} new {% if total_comments > 1 %}comments{% else %}comment{% endif %} on the issue. </p> {% endif %} {% else %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> There are {{ total_updates }} new updates and {{total_comments}} new comments on the issue. </p> {% endif %} --> {% for update in data %} {% if update.changes.name %} <!-- Issue title updated --> 
-          <p style="font-size: 1rem; line-height: 28px; color: #1f2d5c"> The issue title has been updated to {{ issue.name}} </p>
+          <p style="font-size: 1rem; line-height: 28px; color: #1f2d5c"> The {{entity_type}} title has been updated to {{ issue.name}} </p>
           {% endif %} <!-- Outer update Box start --> {% if data %} 
           <div style=" background-color: #f7f9ff; border-radius: 8px; border-style: solid; border-width: 1px; border-color: #c1d0ff; padding: 20px; margin-top: 15px; max-width: 100%; " >
             <!-- Block Heading --> 
@@ -209,7 +209,7 @@
                     {% for actor_comment in comment.actor_comments.new_value %} 
                     <tr>
                       <td>
-                        <div style=" padding: 6px 10px; margin-left: 10px; background-color: white; font-size: 0.8rem; color: #525252; margin-top: 5px; border-radius: 4px; display: flex; align-items: center; " >
+                        <div style=" padding: 6px 10px; margin-left: 10px; background-color: white; font-size: 0.8rem; color: #525252; margin-top: 5px; border-radius: 4px; overflow-x: scroll; max-width: 430px;" >
                           <p> {{ actor_comment|safe }} </p>
                         </div>
                       </td>
@@ -224,7 +224,7 @@
           {% endif %} 
         </div>
         <a href="{{ issue_url }}" style="text-decoration: none;">
-          <div style=" max-width: min-content; white-space: nowrap; background-color: #3e63dd; padding: 10px 15px; border: 1px solid #2f4ba8; border-radius: 4px; margin-top: 15px; cursor: pointer; font-size: 0.8rem; color: white; " > View issue </div>
+          <div style=" max-width: min-content; white-space: nowrap; background-color: #3e63dd; padding: 10px 15px; border: 1px solid #2f4ba8; border-radius: 4px; margin-top: 15px; cursor: pointer; font-size: 0.8rem; color: white; " > View {{entity_type}} </div>
         </a>
       </div>
       <!-- Footer --> 
@@ -232,7 +232,7 @@
         <tr>
           <td>
             <div style="font-size: 0.8rem; color: #1c2024">
-              This email was sent to <a href="mailto:{{receiver.email}}" style="color: #3a5bc7; font-weight: 500; text-decoration: none" >{{ receiver.email }}.</a > If you'd rather not receive this kind of email, <a href="{{ issue_url }}" style="color: #3a5bc7; text-decoration: none" >you can unsubscribe to the issue</a > or <a href="{{ user_preference }}" style="color: #3a5bc7; text-decoration: none" >manage your email preferences</a >. <!-- Github | LinkedIn | Twitter --> 
+              This email was sent to <a href="mailto:{{receiver.email}}" style="color: #3a5bc7; font-weight: 500; text-decoration: none" >{{ receiver.email }}.</a > If you'd rather not receive this kind of email, <a href="{{ issue_url }}" style="color: #3a5bc7; text-decoration: none" >you can unsubscribe to the {{entity_type}}</a > or <a href="{{ user_preference }}" style="color: #3a5bc7; text-decoration: none" >manage your email preferences</a >. <!-- Github | LinkedIn | Twitter --> 
               <div style="margin-top: 60px; float: right"> <a href="https://github.com/makeplane" target="_blank" style="margin-left: 10px; text-decoration: none" > <img src="https://creative-assets.mailinblue.com/editor/social-icons/rounded_colored/github_32px.png" width="25" height="25" border="0" style="display: inline-block" /> </a> <a href="https://www.linkedin.com/company/planepowers/" target="_blank" style="margin-left: 10px; text-decoration: none" > <img src="https://creative-assets.mailinblue.com/editor/social-icons/rounded_colored/linkedin_32px.png" width="25" height="25" border="0" style="display: inline-block" /> </a> <a href="https://twitter.com/planepowers" target="_blank" style="margin-left: 10px; text-decoration: none" > <img src="https://creative-assets.mailinblue.com/editor/social-icons/rounded_colored/twitter_32px.png" width="25" height="25" border="0" style="display: inline-block" /> </a> </div>
             </div>
           </td>

deploy/selfhost/README.md

@@ -486,7 +486,7 @@ When you want to restore the previously backed-up data, follow the instructions
 1. Download the restore script using the command below. We suggest downloading it in the same folder as `setup.sh`.
 
    ```bash
-   curl -fsSL -o restore.sh https://raw.githubusercontent.com/makeplane/plane/master/deploy/selfhost/restore.sh
+   curl -fsSL -o restore.sh https://github.com/makeplane/plane/releases/latest/download/restore.sh
    chmod +x restore.sh
    ```
 
@@ -529,6 +529,31 @@ When you want to restore the previously backed-up data, follow the instructions
 
 ---
 
+### Restore for Commercial Air-Gapped (Docker Compose)
+
+When you want to restore the previously backed-up data on Plane Commercial Air-Gapped version, follow the instructions below.
+
+1. Download the restore script using the command below
+
+   ```bash
+   curl -fsSL -o restore-airgapped.sh https://github.com/makeplane/plane/releases/latest/download/restore-airgapped.sh
+   chmod +x restore-airgapped.sh
+   ```
+
+1. Copy the backup folder and the `restore-airgapped.sh` to `Commercial Airgapped Edition` server
+
+1. Make sure that Plane Commercial (Airgapped) is extracted and ready to get started. In case it is running, you would need to stop that.
+
+1. Execute the command below to restore your data.
+
+   ```bash
+   ./restore-airgapped.sh <path to backup folder containing *.tar.gz files>
+   ```
+
+1. After restoration, you are ready to start Plane Commercial (Airgapped) will all your previously saved data. 
+
+---
+
 <details>
    <summary><h2>Upgrading from v0.13.2 to v0.14.x</h2></summary>
 

deploy/selfhost/restore-airgapped.sh

@@ -0,0 +1,144 @@
+#!/bin/bash
++set -euo pipefail
+
+function print_header() {
+clear
+
+cat <<"EOF"
+--------------------------------------------
+ ____  _                          ///////// 
+|  _ \| | __ _ _ __   ___         ///////// 
+| |_) | |/ _` | '_ \ / _ \   /////    ///// 
+|  __/| | (_| | | | |  __/   /////    ///// 
+|_|   |_|\__,_|_| |_|\___|        ////      
+                                  ////      
+--------------------------------------------
+Project management tool from the future
+--------------------------------------------
+EOF
+}
+
+function restoreData() {
+
+    echo ""
+    echo "****************************************************"
+    echo "We are about to restore your data from the backup files."
+    echo "****************************************************"
+    echo ""
+
+    # set the backup folder path
+    BACKUP_FOLDER=${1}
+
+    if [ -z "$BACKUP_FOLDER" ]; then
+        BACKUP_FOLDER="$PWD/backup"
+        read -p "Enter the backup folder path [$BACKUP_FOLDER]: " BACKUP_FOLDER
+        if [ -z "$BACKUP_FOLDER" ]; then
+            BACKUP_FOLDER="$PWD/backup"
+        fi
+    fi
+
+    # check if the backup folder exists
+    if [ ! -d "$BACKUP_FOLDER" ]; then
+        echo "Error: Backup folder not found at $BACKUP_FOLDER"
+        exit 1
+    fi
+
+    # check if there are any .tar.gz files in the backup folder
+    if ! ls "$BACKUP_FOLDER"/*.tar.gz 1> /dev/null 2>&1; then
+        echo "Error: Backup folder does not contain .tar.gz files"
+        exit 1
+    fi
+
+    echo ""
+    echo "Using backup folder: $BACKUP_FOLDER"
+    echo ""
+
+    # ask for current install path
+    AIRGAPPED_INSTALL_PATH="$HOME/planeairgapped"
+    read -p "Enter the airgapped instance install path [$AIRGAPPED_INSTALL_PATH]: " AIRGAPPED_INSTALL_PATH
+    if [ -z "$AIRGAPPED_INSTALL_PATH" ]; then
+        AIRGAPPED_INSTALL_PATH="$HOME/planeairgapped"
+    fi
+
+    # check if the airgapped instance install path exists
+    if [ ! -d "$AIRGAPPED_INSTALL_PATH" ]; then
+        echo "Error: Airgapped instance install path not found at $AIRGAPPED_INSTALL_PATH"
+        exit 1
+    fi
+
+    echo ""
+    echo "Using airgapped instance install path: $AIRGAPPED_INSTALL_PATH"
+    echo ""
+
+    # check if the docker-compose.yaml exists
+    if [ ! -f "$AIRGAPPED_INSTALL_PATH/docker-compose.yml" ]; then
+        echo "Error: docker-compose.yml not found at $AIRGAPPED_INSTALL_PATH/docker-compose.yml"
+        exit 1
+    fi
+
+    local dockerServiceStatus
+    if command -v jq &> /dev/null; then
+        dockerServiceStatus=$($COMPOSE_CMD ls --filter name=plane-airgapped --format=json | jq -r .[0].Status)
+    else
+        dockerServiceStatus=$($COMPOSE_CMD ls --filter name=plane-airgapped | grep -o "running" | head -n 1)
+    fi
+
+    if [[ $dockerServiceStatus == "running" ]]; then
+        echo "Plane Airgapped is running. Please STOP the Plane Airgapped before restoring data."
+        exit 1
+    fi
+
+    CURRENT_USER_ID=$(id -u)
+    CURRENT_GROUP_ID=$(id -g)
+
+    # if the data folder not exists, create it
+    if [ ! -d "$AIRGAPPED_INSTALL_PATH/data" ]; then
+        mkdir -p "$AIRGAPPED_INSTALL_PATH/data"
+        chown -R $CURRENT_USER_ID:$CURRENT_GROUP_ID "$AIRGAPPED_INSTALL_PATH/data"
+    fi
+
+    for BACKUP_FILE in "$BACKUP_FOLDER/*.tar.gz"; do
+        if [ -e "$BACKUP_FILE" ]; then
+
+            # get the basefilename without the extension
+            BASE_FILE_NAME=$(basename "$BACKUP_FILE" ".tar.gz")
+
+            # extract the restoreFile to the airgapped instance install path
+            echo "Restoring $BASE_FILE_NAME"
+            rm -rf "$AIRGAPPED_INSTALL_PATH/data/$BASE_FILE_NAME" || true
+            
+            tar -xvzf "$BACKUP_FILE" -C "$AIRGAPPED_INSTALL_PATH/data/"
+            if [ $? -ne 0 ]; then
+                echo "Error: Failed to extract $BACKUP_FILE"
+                exit 1
+            fi
+            chown -R $CURRENT_USER_ID:$CURRENT_GROUP_ID "$AIRGAPPED_INSTALL_PATH/data/$BASE_FILE_NAME"
+            if [ $? -ne 0 ]; then
+                echo "Error: Failed to change ownership of $AIRGAPPED_INSTALL_PATH/data/$BASE_FILE_NAME"
+                exit 1
+            fi
+        else
+            echo "No .tar.gz files found in the current directory."
+            echo ""
+            echo "Please provide the path to the backup file."
+            echo ""
+            echo "Usage: $0 /path/to/backup"  
+            exit 1
+        fi
+    done
+
+    echo ""
+    echo "Restore completed successfully."
+    echo ""
+}
+
+# if docker-compose is installed
+if command -v docker-compose &> /dev/null
+then
+    COMPOSE_CMD="docker-compose"
+else
+    COMPOSE_CMD="docker compose"
+fi
+
+print_header
+restoreData "$@"

live/package.json

@@ -1,6 +1,6 @@
 {
   "name": "live",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "license": "AGPL-3.0",
   "description": "A realtime collaborative server powers Plane's rich text editor",
   "main": "./src/server.ts",
@@ -57,7 +57,7 @@
     "concurrently": "^9.0.1",
     "nodemon": "^3.1.7",
     "ts-node": "^10.9.2",
-    "tsup": "^8.4.0",
+    "tsup": "8.4.0",
     "typescript": "5.3.3"
   }
 }

package.json

@@ -2,7 +2,7 @@
   "name": "plane",
   "description": "Open-source project management that unlocks customer value",
   "repository": "https://github.com/makeplane/plane.git",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "license": "AGPL-3.0",
   "private": true,
   "workspaces": [
@@ -24,13 +24,15 @@
   "devDependencies": {
     "prettier": "latest",
     "prettier-plugin-tailwindcss": "^0.5.4",
-    "turbo": "^2.5.3"
+    "turbo": "^2.5.4"
   },
   "resolutions": {
     "nanoid": "3.3.8",
     "esbuild": "0.25.0",
     "@babel/helpers": "7.26.10",
-    "@babel/runtime": "7.26.10"
+    "@babel/runtime": "7.26.10",
+    "chokidar": "3.6.0",
+    "tar-fs": "3.0.9"
   },
   "packageManager": "yarn@1.22.22"
 }

packages/constants/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plane/constants",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "private": true,
   "main": "./src/index.ts",
   "license": "AGPL-3.0"

packages/constants/src/analytics-v2/common.ts

@@ -1,105 +0,0 @@
-import { TAnalyticsTabsV2Base } from "@plane/types";
-import { ChartXAxisProperty, ChartYAxisMetric } from "../chart";
-
-export const insightsFields: Record<TAnalyticsTabsV2Base, string[]> = {
-  overview: [
-    "total_users",
-    "total_admins",
-    "total_members",
-    "total_guests",
-    "total_projects",
-    "total_work_items",
-    "total_cycles",
-    "total_intake",
-  ],
-  "work-items": [
-    "total_work_items",
-    "started_work_items",
-    "backlog_work_items",
-    "un_started_work_items",
-    "completed_work_items",
-  ],
-};
-
-export const ANALYTICS_V2_DURATION_FILTER_OPTIONS = [
-  {
-    name: "Yesterday",
-    value: "yesterday",
-  },
-  {
-    name: "Last 7 days",
-    value: "last_7_days",
-  },
-  {
-    name: "Last 30 days",
-    value: "last_30_days",
-  },
-  {
-    name: "Last 3 months",
-    value: "last_3_months",
-  },
-];
-
-export const ANALYTICS_V2_X_AXIS_VALUES: { value: ChartXAxisProperty; label: string }[] = [
-  {
-    value: ChartXAxisProperty.STATES,
-    label: "State name",
-  },
-  {
-    value: ChartXAxisProperty.STATE_GROUPS,
-    label: "State group",
-  },
-  {
-    value: ChartXAxisProperty.PRIORITY,
-    label: "Priority",
-  },
-  {
-    value: ChartXAxisProperty.LABELS,
-    label: "Label",
-  },
-  {
-    value: ChartXAxisProperty.ASSIGNEES,
-    label: "Assignee",
-  },
-  {
-    value: ChartXAxisProperty.ESTIMATE_POINTS,
-    label: "Estimate point",
-  },
-  {
-    value: ChartXAxisProperty.CYCLES,
-    label: "Cycle",
-  },
-  {
-    value: ChartXAxisProperty.MODULES,
-    label: "Module",
-  },
-  {
-    value: ChartXAxisProperty.COMPLETED_AT,
-    label: "Completed date",
-  },
-  {
-    value: ChartXAxisProperty.TARGET_DATE,
-    label: "Due date",
-  },
-  {
-    value: ChartXAxisProperty.START_DATE,
-    label: "Start date",
-  },
-  {
-    value: ChartXAxisProperty.CREATED_AT,
-    label: "Created date",
-  },
-];
-
-export const ANALYTICS_V2_Y_AXIS_VALUES: { value: ChartYAxisMetric; label: string }[] = [
-  {
-    value: ChartYAxisMetric.WORK_ITEM_COUNT,
-    label: "Work item",
-  },
-  {
-    value: ChartYAxisMetric.ESTIMATE_POINT_COUNT,
-    label: "Estimate",
-  },
-];
-
-export const ANALYTICS_V2_DATE_KEYS = ["completed_at", "target_date", "start_date", "created_at"];

packages/constants/src/analytics.ts

@@ -1,81 +0,0 @@
-// types
-import { TXAxisValues, TYAxisValues } from "@plane/types";
-
-export const ANALYTICS_TABS = [
-  {
-    key: "scope_and_demand",
-    i18n_title: "workspace_analytics.tabs.scope_and_demand",
-  },
-  { key: "custom", i18n_title: "workspace_analytics.tabs.custom" },
-];
-
-export const ANALYTICS_X_AXIS_VALUES: { value: TXAxisValues; label: string }[] =
-  [
-    {
-      value: "state_id",
-      label: "State name",
-    },
-    {
-      value: "state__group",
-      label: "State group",
-    },
-    {
-      value: "priority",
-      label: "Priority",
-    },
-    {
-      value: "labels__id",
-      label: "Label",
-    },
-    {
-      value: "assignees__id",
-      label: "Assignee",
-    },
-    {
-      value: "estimate_point__value",
-      label: "Estimate point",
-    },
-    {
-      value: "issue_cycle__cycle_id",
-      label: "Cycle",
-    },
-    {
-      value: "issue_module__module_id",
-      label: "Module",
-    },
-    {
-      value: "completed_at",
-      label: "Completed date",
-    },
-    {
-      value: "target_date",
-      label: "Due date",
-    },
-    {
-      value: "start_date",
-      label: "Start date",
-    },
-    {
-      value: "created_at",
-      label: "Created date",
-    },
-  ];
-
-export const ANALYTICS_Y_AXIS_VALUES: { value: TYAxisValues; label: string }[] =
-  [
-    {
-      value: "issue_count",
-      label: "Work item Count",
-    },
-    {
-      value: "estimate",
-      label: "Estimate",
-    },
-  ];
-
-export const ANALYTICS_DATE_KEYS = [
-  "completed_at",
-  "target_date",
-  "start_date",
-  "created_at",
-];

packages/constants/src/analytics/common.ts

@@ -0,0 +1,178 @@
+import { TAnalyticsTabsBase } from "@plane/types";
+import { ChartXAxisProperty, ChartYAxisMetric } from "../chart";
+
+export interface IInsightField {
+  key: string;
+  i18nKey: string;
+  i18nProps?: {
+    entity?: string;
+    entityPlural?: string;
+    [key: string]: any;
+  };
+}
+
+export const insightsFields: Record<TAnalyticsTabsBase, IInsightField[]> = {
+  overview: [
+    {
+      key: "total_users",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.users",
+      },
+    },
+    {
+      key: "total_admins",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.admins",
+      },
+    },
+    {
+      key: "total_members",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.members",
+      },
+    },
+    {
+      key: "total_guests",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.guests",
+      },
+    },
+    {
+      key: "total_projects",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.projects",
+      },
+    },
+    {
+      key: "total_work_items",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.work_items",
+      },
+    },
+    {
+      key: "total_cycles",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "common.cycles",
+      },
+    },
+    {
+      key: "total_intake",
+      i18nKey: "workspace_analytics.total",
+      i18nProps: {
+        entity: "sidebar.intake",
+      },
+    },
+  ],
+  "work-items": [
+    {
+      key: "total_work_items",
+      i18nKey: "workspace_analytics.total",
+    },
+    {
+      key: "started_work_items",
+      i18nKey: "workspace_analytics.started_work_items",
+    },
+    {
+      key: "backlog_work_items",
+      i18nKey: "workspace_analytics.backlog_work_items",
+    },
+    {
+      key: "un_started_work_items",
+      i18nKey: "workspace_analytics.un_started_work_items",
+    },
+    {
+      key: "completed_work_items",
+      i18nKey: "workspace_analytics.completed_work_items",
+    },
+  ],
+};
+
+export const ANALYTICS_DURATION_FILTER_OPTIONS = [
+  {
+    name: "Yesterday",
+    value: "yesterday",
+  },
+  {
+    name: "Last 7 days",
+    value: "last_7_days",
+  },
+  {
+    name: "Last 30 days",
+    value: "last_30_days",
+  },
+  {
+    name: "Last 3 months",
+    value: "last_3_months",
+  },
+];
+
+export const ANALYTICS_X_AXIS_VALUES: { value: ChartXAxisProperty; label: string }[] = [
+  {
+    value: ChartXAxisProperty.STATES,
+    label: "State name",
+  },
+  {
+    value: ChartXAxisProperty.STATE_GROUPS,
+    label: "State group",
+  },
+  {
+    value: ChartXAxisProperty.PRIORITY,
+    label: "Priority",
+  },
+  {
+    value: ChartXAxisProperty.LABELS,
+    label: "Label",
+  },
+  {
+    value: ChartXAxisProperty.ASSIGNEES,
+    label: "Assignee",
+  },
+  {
+    value: ChartXAxisProperty.ESTIMATE_POINTS,
+    label: "Estimate point",
+  },
+  {
+    value: ChartXAxisProperty.CYCLES,
+    label: "Cycle",
+  },
+  {
+    value: ChartXAxisProperty.MODULES,
+    label: "Module",
+  },
+  {
+    value: ChartXAxisProperty.COMPLETED_AT,
+    label: "Completed date",
+  },
+  {
+    value: ChartXAxisProperty.TARGET_DATE,
+    label: "Due date",
+  },
+  {
+    value: ChartXAxisProperty.START_DATE,
+    label: "Start date",
+  },
+  {
+    value: ChartXAxisProperty.CREATED_AT,
+    label: "Created date",
+  },
+];
+
+export const ANALYTICS_Y_AXIS_VALUES: { value: ChartYAxisMetric; label: string }[] = [
+  {
+    value: ChartYAxisMetric.WORK_ITEM_COUNT,
+    label: "Work item",
+  },
+  {
+    value: ChartYAxisMetric.ESTIMATE_POINT_COUNT,
+    label: "Estimate",
+  },
+];
+
+export const ANALYTICS_V2_DATE_KEYS = ["completed_at", "target_date", "start_date", "created_at"];

packages/constants/src/file.ts

@@ -1 +1,14 @@
 export const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
+
+export const ACCEPTED_AVATAR_IMAGE_MIME_TYPES_FOR_REACT_DROPZONE = {
+  "image/jpeg": [],
+  "image/jpg": [],
+  "image/png": [],
+  "image/webp": [],
+};
+export const ACCEPTED_COVER_IMAGE_MIME_TYPES_FOR_REACT_DROPZONE = {
+  "image/jpeg": [],
+  "image/jpg": [],
+  "image/png": [],
+  "image/webp": [],
+};

packages/constants/src/index.ts

@@ -1,5 +1,4 @@
 export * from "./ai";
-export * from "./analytics";
 export * from "./auth";
 export * from "./chart";
 export * from "./endpoints";
@@ -32,5 +31,6 @@ export * from "./dashboard";
 export * from "./page";
 export * from "./emoji";
 export * from "./subscription";
+export * from "./settings";
 export * from "./icon";
-export * from "./analytics-v2";
+export * from "./analytics";

packages/constants/src/issue/filter.ts

@@ -355,7 +355,7 @@ export const ISSUE_DISPLAY_FILTERS_BY_PAGE: TIssueFiltersToDisplayByPageType = {
   sub_work_items: {
     list: {
       display_properties: SUB_ISSUES_DISPLAY_PROPERTIES_KEYS,
-      filters: ["priority", "state", "project", "issue_type", "assignees", "start_date", "target_date"],
+      filters: ["priority", "state", "issue_type", "assignees", "start_date", "target_date"],
       display_filters: {
         order_by: ["-created_at", "-updated_at", "start_date", "-priority"],
         group_by: ["state", "priority", "assignees", null],

packages/constants/src/payment.ts

@@ -72,23 +72,23 @@ export const PLANE_COMMUNITY_PRODUCTS: Record<string, IPaymentProduct> = {
     prices: [
       {
         id: `price_yearly_${EProductSubscriptionEnum.BUSINESS}`,
-        unit_amount: 0,
+        unit_amount: 15600,
         recurring: "year",
         currency: "usd",
-        workspace_amount: 0,
+        workspace_amount: 15600,
         product: EProductSubscriptionEnum.BUSINESS,
       },
       {
         id: `price_monthly_${EProductSubscriptionEnum.BUSINESS}`,
-        unit_amount: 0,
+        unit_amount: 1500,
         recurring: "month",
         currency: "usd",
-        workspace_amount: 0,
+        workspace_amount: 1500,
         product: EProductSubscriptionEnum.BUSINESS,
       },
     ],
     payment_quantity: 1,
-    is_active: false,
+    is_active: true,
   },
   [EProductSubscriptionEnum.ENTERPRISE]: {
     id: EProductSubscriptionEnum.ENTERPRISE,
@@ -141,8 +141,8 @@ export const SUBSCRIPTION_REDIRECTION_URLS: Record<EProductSubscriptionEnum, Rec
     year: "https://app.plane.so/upgrade/pro/self-hosted?plan=year",
   },
   [EProductSubscriptionEnum.BUSINESS]: {
-    month: TALK_TO_SALES_URL,
-    year: TALK_TO_SALES_URL,
+    month: "https://app.plane.so/upgrade/business/self-hosted?plan=month",
+    year: "https://app.plane.so/upgrade/business/self-hosted?plan=year",
   },
   [EProductSubscriptionEnum.ENTERPRISE]: {
     month: TALK_TO_SALES_URL,

packages/constants/src/profile.ts

@@ -1,39 +1,53 @@
+export const PROFILE_SETTINGS = {
+  profile: {
+    key: "profile",
+    i18n_label: "profile.actions.profile",
+    href: `/settings/account`,
+    highlight: (pathname: string) => pathname === "/settings/account/",
+  },
+  security: {
+    key: "security",
+    i18n_label: "profile.actions.security",
+    href: `/settings/account/security`,
+    highlight: (pathname: string) => pathname === "/settings/account/security/",
+  },
+  activity: {
+    key: "activity",
+    i18n_label: "profile.actions.activity",
+    href: `/settings/account/activity`,
+    highlight: (pathname: string) => pathname === "/settings/account/activity/",
+  },
+  preferences: {
+    key: "preferences",
+    i18n_label: "profile.actions.preferences",
+    href: `/settings/account/preferences`,
+    highlight: (pathname: string) => pathname === "/settings/account/preferences",
+  },
+  notifications: {
+    key: "notifications",
+    i18n_label: "profile.actions.notifications",
+    href: `/settings/account/notifications`,
+    highlight: (pathname: string) => pathname === "/settings/account/notifications/",
+  },
+  "api-tokens": {
+    key: "api-tokens",
+    i18n_label: "profile.actions.api-tokens",
+    href: `/settings/account/api-tokens`,
+    highlight: (pathname: string) => pathname === "/settings/account/api-tokens/",
+  },
+};
 export const PROFILE_ACTION_LINKS: {
   key: string;
   i18n_label: string;
   href: string;
   highlight: (pathname: string) => boolean;
 }[] = [
-  {
-    key: "profile",
-    i18n_label: "profile.actions.profile",
-    href: `/profile`,
-    highlight: (pathname: string) => pathname === "/profile/",
-  },
-  {
-    key: "security",
-    i18n_label: "profile.actions.security",
-    href: `/profile/security`,
-    highlight: (pathname: string) => pathname === "/profile/security/",
-  },
-  {
-    key: "activity",
-    i18n_label: "profile.actions.activity",
-    href: `/profile/activity`,
-    highlight: (pathname: string) => pathname === "/profile/activity/",
-  },
-  {
-    key: "appearance",
-    i18n_label: "profile.actions.appearance",
-    href: `/profile/appearance`,
-    highlight: (pathname: string) => pathname.includes("/profile/appearance"),
-  },
-  {
-    key: "notifications",
-    i18n_label: "profile.actions.notifications",
-    href: `/profile/notifications`,
-    highlight: (pathname: string) => pathname === "/profile/notifications/",
-  },
+  PROFILE_SETTINGS["profile"],
+  PROFILE_SETTINGS["security"],
+  PROFILE_SETTINGS["activity"],
+  PROFILE_SETTINGS["preferences"],
+  PROFILE_SETTINGS["notifications"],
+  PROFILE_SETTINGS["api-tokens"],
 ];
 
 export const PROFILE_VIEWER_TAB = [
@@ -72,6 +86,23 @@ export const PROFILE_ADMINS_TAB = [
   },
 ];
 
+export const PREFERENCE_OPTIONS: {
+  id: string;
+  title: string;
+  description: string;
+}[] = [
+  {
+    id: "theme",
+    title: "theme",
+    description: "select_or_customize_your_interface_color_scheme",
+  },
+  {
+    id: "start_of_week",
+    title: "First day of the week",
+    description: "This will change how all calendars in your app look.",
+  },
+];
+
 /**
  * @description The start of the week for the user
  * @enum {number}

packages/constants/src/settings.ts

@@ -0,0 +1,52 @@
+import { PROFILE_SETTINGS } from ".";
+import { WORKSPACE_SETTINGS } from "./workspace";
+
+export enum WORKSPACE_SETTINGS_CATEGORY {
+  ADMINISTRATION = "administration",
+  FEATURES = "features",
+  DEVELOPER = "developer",
+}
+
+export enum PROFILE_SETTINGS_CATEGORY {
+  YOUR_PROFILE = "your profile",
+  DEVELOPER = "developer",
+}
+
+export enum PROJECT_SETTINGS_CATEGORY {
+  PROJECTS = "projects",
+}
+
+export const WORKSPACE_SETTINGS_CATEGORIES = [
+  WORKSPACE_SETTINGS_CATEGORY.ADMINISTRATION,
+  WORKSPACE_SETTINGS_CATEGORY.FEATURES,
+  WORKSPACE_SETTINGS_CATEGORY.DEVELOPER,
+];
+
+export const PROFILE_SETTINGS_CATEGORIES = [
+  PROFILE_SETTINGS_CATEGORY.YOUR_PROFILE,
+  PROFILE_SETTINGS_CATEGORY.DEVELOPER,
+];
+
+export const PROJECT_SETTINGS_CATEGORIES = [PROJECT_SETTINGS_CATEGORY.PROJECTS];
+
+export const GROUPED_WORKSPACE_SETTINGS = {
+  [WORKSPACE_SETTINGS_CATEGORY.ADMINISTRATION]: [
+    WORKSPACE_SETTINGS["general"],
+    WORKSPACE_SETTINGS["members"],
+    WORKSPACE_SETTINGS["billing-and-plans"],
+    WORKSPACE_SETTINGS["export"],
+  ],
+  [WORKSPACE_SETTINGS_CATEGORY.FEATURES]: [],
+  [WORKSPACE_SETTINGS_CATEGORY.DEVELOPER]: [WORKSPACE_SETTINGS["webhooks"]],
+};
+
+export const GROUPED_PROFILE_SETTINGS = {
+  [PROFILE_SETTINGS_CATEGORY.YOUR_PROFILE]: [
+    PROFILE_SETTINGS["profile"],
+    PROFILE_SETTINGS["preferences"],
+    PROFILE_SETTINGS["notifications"],
+    PROFILE_SETTINGS["security"],
+    PROFILE_SETTINGS["activity"],
+  ],
+  [PROFILE_SETTINGS_CATEGORY.DEVELOPER]: [PROFILE_SETTINGS["api-tokens"]],
+};

packages/constants/src/workspace.ts

@@ -114,13 +114,6 @@ export const WORKSPACE_SETTINGS = {
     access: [EUserWorkspaceRoles.ADMIN],
     highlight: (pathname: string, baseUrl: string) => pathname === `${baseUrl}/settings/webhooks/`,
   },
-  "api-tokens": {
-    key: "api-tokens",
-    i18n_label: "workspace_settings.settings.api_tokens.title",
-    href: `/settings/api-tokens`,
-    access: [EUserWorkspaceRoles.ADMIN],
-    highlight: (pathname: string, baseUrl: string) => pathname === `${baseUrl}/settings/api-tokens/`,
-  },
 };
 
 export const WORKSPACE_SETTINGS_ACCESS = Object.fromEntries(
@@ -139,7 +132,6 @@ export const WORKSPACE_SETTINGS_LINKS: {
   WORKSPACE_SETTINGS["billing-and-plans"],
   WORKSPACE_SETTINGS["export"],
   WORKSPACE_SETTINGS["webhooks"],
-  WORKSPACE_SETTINGS["api-tokens"],
 ];
 
 export const ROLE = {

packages/editor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plane/editor",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Core Editor that powers Plane",
   "license": "AGPL-3.0",
   "private": true,
@@ -81,7 +81,7 @@
     "@types/react": "^18.3.11",
     "@types/react-dom": "^18.2.18",
     "postcss": "^8.4.38",
-    "tsup": "^8.4.0",
+    "tsup": "8.4.0",
     "typescript": "5.3.3"
   },
   "keywords": [

packages/editor/src/ce/constants/utility.ts

@@ -0,0 +1,14 @@
+import { ExtensionFileSetStorageKey } from "@/plane-editor/types/storage";
+
+export const NODE_FILE_MAP: {
+  [key: string]: {
+    fileSetName: ExtensionFileSetStorageKey;
+  };
+} = {
+  image: {
+    fileSetName: "deletedImageSet",
+  },
+  imageComponent: {
+    fileSetName: "deletedImageSet",
+  },
+};

packages/editor/src/ce/extensions/document-extensions.tsx

@@ -1,32 +1,32 @@
 import { HocuspocusProvider } from "@hocuspocus/provider";
-import { Extensions } from "@tiptap/core";
 import { AnyExtension } from "@tiptap/core";
 import { SlashCommands } from "@/extensions";
 // plane editor types
-import { TIssueEmbedConfig } from "@/plane-editor/types";
+import { TEmbedConfig } from "@/plane-editor/types";
 // types
-import { TExtensions, TUserDetails } from "@/types";
+import { TExtensions, TFileHandler, TUserDetails } from "@/types";
 
-type Props = {
-  disabledExtensions?: TExtensions[];
-  issueEmbedConfig: TIssueEmbedConfig | undefined;
-  provider: HocuspocusProvider;
+export type TDocumentEditorAdditionalExtensionsProps = {
+  disabledExtensions: TExtensions[];
+  embedConfig: TEmbedConfig | undefined;
+  fileHandler: TFileHandler;
+  provider?: HocuspocusProvider;
   userDetails: TUserDetails;
 };
 
-type ExtensionConfig = {
+export type TDocumentEditorAdditionalExtensionsRegistry = {
   isEnabled: (disabledExtensions: TExtensions[]) => boolean;
-  getExtension: (props: Props) => AnyExtension;
+  getExtension: (props: TDocumentEditorAdditionalExtensionsProps) => AnyExtension;
 };
 
-const extensionRegistry: ExtensionConfig[] = [
+const extensionRegistry: TDocumentEditorAdditionalExtensionsRegistry[] = [
   {
     isEnabled: (disabledExtensions) => !disabledExtensions.includes("slash-commands"),
-    getExtension: () => SlashCommands({}),
+    getExtension: ({ disabledExtensions }) => SlashCommands({ disabledExtensions }),
   },
 ];
 
-export const DocumentEditorAdditionalExtensions = (_props: Props) => {
+export const DocumentEditorAdditionalExtensions = (_props: TDocumentEditorAdditionalExtensionsProps) => {
   const { disabledExtensions = [] } = _props;
 
   const documentExtensions = extensionRegistry

packages/editor/src/ce/extensions/rich-text/extensions.tsx

@@ -0,0 +1,41 @@
+import { AnyExtension, Extensions } from "@tiptap/core";
+// extensions
+import { SlashCommands } from "@/extensions/slash-commands/root";
+// types
+import { TExtensions, TFileHandler } from "@/types";
+
+export type TRichTextEditorAdditionalExtensionsProps = {
+  disabledExtensions: TExtensions[];
+  fileHandler: TFileHandler;
+};
+
+/**
+ * Registry entry configuration for extensions
+ */
+export type TRichTextEditorAdditionalExtensionsRegistry = {
+  /** Determines if the extension should be enabled based on disabled extensions */
+  isEnabled: (disabledExtensions: TExtensions[]) => boolean;
+  /** Returns the extension instance(s) when enabled */
+  getExtension: (props: TRichTextEditorAdditionalExtensionsProps) => AnyExtension | undefined;
+};
+
+const extensionRegistry: TRichTextEditorAdditionalExtensionsRegistry[] = [
+  {
+    isEnabled: (disabledExtensions) => !disabledExtensions.includes("slash-commands"),
+    getExtension: ({ disabledExtensions }) =>
+      SlashCommands({
+        disabledExtensions,
+      }),
+  },
+];
+
+export const RichTextEditorAdditionalExtensions = (props: TRichTextEditorAdditionalExtensionsProps) => {
+  const { disabledExtensions } = props;
+
+  const extensions: Extensions = extensionRegistry
+    .filter((config) => config.isEnabled(disabledExtensions))
+    .map((config) => config.getExtension(props))
+    .filter((extension): extension is AnyExtension => extension !== undefined);
+
+  return extensions;
+};

packages/editor/src/ce/extensions/rich-text/read-only-extensions.tsx

@@ -0,0 +1,31 @@
+import { AnyExtension, Extensions } from "@tiptap/core";
+// types
+import { TExtensions, TReadOnlyFileHandler } from "@/types";
+
+export type TRichTextReadOnlyEditorAdditionalExtensionsProps = {
+  disabledExtensions: TExtensions[];
+  fileHandler: TReadOnlyFileHandler;
+};
+
+/**
+ * Registry entry configuration for extensions
+ */
+export type TRichTextReadOnlyEditorAdditionalExtensionsRegistry = {
+  /** Determines if the extension should be enabled based on disabled extensions */
+  isEnabled: (disabledExtensions: TExtensions[]) => boolean;
+  /** Returns the extension instance(s) when enabled */
+  getExtension: (props: TRichTextReadOnlyEditorAdditionalExtensionsProps) => AnyExtension | undefined;
+};
+
+const extensionRegistry: TRichTextReadOnlyEditorAdditionalExtensionsRegistry[] = [];
+
+export const RichTextReadOnlyEditorAdditionalExtensions = (props: TRichTextReadOnlyEditorAdditionalExtensionsProps) => {
+  const { disabledExtensions } = props;
+
+  const extensions: Extensions = extensionRegistry
+    .filter((config) => config.isEnabled(disabledExtensions))
+    .map((config) => config.getExtension(props))
+    .filter((extension): extension is AnyExtension => extension !== undefined);
+
+  return extensions;
+};

packages/editor/src/ce/types/storage.ts

@@ -1,13 +1,20 @@
-import { HeadingExtensionStorage } from "@/extensions";
-import { CustomImageExtensionStorage } from "@/extensions/custom-image";
-import { CustomLinkStorage } from "@/extensions/custom-link";
-import { MentionExtensionStorage } from "@/extensions/mentions";
-import { ImageExtensionStorage } from "@/plugins/image";
+// constants
+import { CORE_EXTENSIONS } from "@/constants/extension";
+// extensions
+import { type HeadingExtensionStorage } from "@/extensions";
+import { type CustomImageExtensionStorage } from "@/extensions/custom-image";
+import { type CustomLinkStorage } from "@/extensions/custom-link";
+import { type ImageExtensionStorage } from "@/extensions/image";
+import { type MentionExtensionStorage } from "@/extensions/mentions";
+import { type UtilityExtensionStorage } from "@/extensions/utility";
 
 export type ExtensionStorageMap = {
-  imageComponent: CustomImageExtensionStorage;
-  image: ImageExtensionStorage;
-  link: CustomLinkStorage;
-  headingList: HeadingExtensionStorage;
-  mention: MentionExtensionStorage;
+  [CORE_EXTENSIONS.CUSTOM_IMAGE]: CustomImageExtensionStorage;
+  [CORE_EXTENSIONS.IMAGE]: ImageExtensionStorage;
+  [CORE_EXTENSIONS.CUSTOM_LINK]: CustomLinkStorage;
+  [CORE_EXTENSIONS.HEADINGS_LIST]: HeadingExtensionStorage;
+  [CORE_EXTENSIONS.MENTION]: MentionExtensionStorage;
+  [CORE_EXTENSIONS.UTILITY]: UtilityExtensionStorage;
 };
+
+export type ExtensionFileSetStorageKey = Extract<keyof ImageExtensionStorage, "deletedImageSet">;

packages/editor/src/core/components/editors/document/collaborative-editor.tsx

@@ -7,7 +7,7 @@ import { DocumentContentLoader, PageRenderer } from "@/components/editors";
 // constants
 import { DEFAULT_DISPLAY_CONFIG } from "@/constants/config";
 // extensions
-import { IssueWidget } from "@/extensions";
+import { WorkItemEmbedExtension } from "@/extensions";
 // helpers
 import { getEditorClassNames } from "@/helpers/common";
 // hooks
@@ -39,9 +39,10 @@ const CollaborativeDocumentEditor = (props: ICollaborativeDocumentEditor) => {
   } = props;
 
   const extensions: Extensions = [];
+
   if (embedHandler?.issue) {
     extensions.push(
-      IssueWidget({
+      WorkItemEmbedExtension({
         widgetCallback: embedHandler.issue.widgetCallback,
       })
     );

packages/editor/src/core/components/editors/document/read-only-editor.tsx

@@ -7,7 +7,7 @@ import { PageRenderer } from "@/components/editors";
 // constants
 import { DEFAULT_DISPLAY_CONFIG } from "@/constants/config";
 // extensions
-import { IssueWidget } from "@/extensions";
+import { WorkItemEmbedExtension } from "@/extensions";
 // helpers
 import { getEditorClassNames } from "@/helpers/common";
 // hooks
@@ -53,7 +53,7 @@ const DocumentReadOnlyEditor = (props: IDocumentReadOnlyEditor) => {
   const extensions: Extensions = [];
   if (embedHandler?.issue) {
     extensions.push(
-      IssueWidget({
+      WorkItemEmbedExtension({
         widgetCallback: embedHandler.issue.widgetCallback,
       })
     );

packages/editor/src/core/components/editors/editor-container.tsx

@@ -4,6 +4,7 @@ import { FC, ReactNode, useRef } from "react";
 import { cn } from "@plane/utils";
 // constants
 import { DEFAULT_DISPLAY_CONFIG } from "@/constants/config";
+import { CORE_EXTENSIONS } from "@/constants/extension";
 // types
 import { TDisplayConfig } from "@/types";
 // components
@@ -36,12 +37,12 @@ export const EditorContainer: FC<EditorContainerProps> = (props) => {
       if (
         currentNode.content.size === 0 && // Check if the current node is empty
         !(
-          editor.isActive("orderedList") ||
-          editor.isActive("bulletList") ||
-          editor.isActive("taskItem") ||
-          editor.isActive("table") ||
-          editor.isActive("blockquote") ||
-          editor.isActive("codeBlock")
+          editor.isActive(CORE_EXTENSIONS.ORDERED_LIST) ||
+          editor.isActive(CORE_EXTENSIONS.BULLET_LIST) ||
+          editor.isActive(CORE_EXTENSIONS.TASK_ITEM) ||
+          editor.isActive(CORE_EXTENSIONS.TABLE) ||
+          editor.isActive(CORE_EXTENSIONS.BLOCKQUOTE) ||
+          editor.isActive(CORE_EXTENSIONS.CODE_BLOCK)
         ) // Check if it's an empty node within an orderedList, bulletList, taskItem, table, quote or code block
       ) {
         return;
@@ -53,10 +54,10 @@ export const EditorContainer: FC<EditorContainerProps> = (props) => {
       const lastNode = lastNodePos.node();
 
       // Check if the last node is a  not paragraph
-      if (lastNode && lastNode.type.name !== "paragraph") {
+      if (lastNode && lastNode.type.name !== CORE_EXTENSIONS.PARAGRAPH) {
         // If last node is not a paragraph, insert a new paragraph at the end
         const endPosition = editor?.state.doc.content.size;
-        editor?.chain().insertContentAt(endPosition, { type: "paragraph" }).run();
+        editor?.chain().insertContentAt(endPosition, { type: CORE_EXTENSIONS.PARAGRAPH }).run();
 
         // Focus the newly added paragraph for immediate editing
         editor

packages/editor/src/core/components/editors/link-view-container.tsx

@@ -12,7 +12,7 @@ interface LinkViewContainerProps {
 export const LinkViewContainer: FC<LinkViewContainerProps> = ({ editor, containerRef }) => {
   const [linkViewProps, setLinkViewProps] = useState<LinkViewProps>();
   const [isOpen, setIsOpen] = useState(false);
-  const [virtualElement, setVirtualElement] = useState<any>(null);
+  const [virtualElement, setVirtualElement] = useState<Element | null>(null);
 
   const editorState = useEditorState({
     editor,

packages/editor/src/core/components/editors/read-only-editor-wrapper.tsx

@@ -15,6 +15,7 @@ export const ReadOnlyEditorWrapper = (props: IReadOnlyEditorProps) => {
     disabledExtensions,
     displayConfig = DEFAULT_DISPLAY_CONFIG,
     editorClassName = "",
+    extensions,
     fileHandler,
     forwardedRef,
     id,
@@ -25,6 +26,7 @@ export const ReadOnlyEditorWrapper = (props: IReadOnlyEditorProps) => {
   const editor = useReadOnlyEditor({
     disabledExtensions,
     editorClassName,
+    extensions,
     fileHandler,
     forwardedRef,
     initialValue,