refactor: sub-work items components, hooks and types

* add workspace slug to setting link function

* add params in the function

apiserver/plane/api/serializers/cycle.py

@@ -39,7 +39,15 @@ class CycleSerializer(BaseSerializer):
             data.get("start_date", None) is not None
             and data.get("end_date", None) is not None
         ):
-            project_id = self.initial_data.get("project_id") or self.instance.project_id
+            project_id = self.initial_data.get("project_id") or (
+                self.instance.project_id
+                if self.instance and hasattr(self.instance, "project_id")
+                else None
+            )
+
+            if not project_id:
+                raise serializers.ValidationError("Project ID is required")
+
             is_start_date_end_date_equal = (
                 True
                 if str(data.get("start_date")) == str(data.get("end_date"))

apiserver/plane/api/serializers/project.py

@@ -16,7 +16,6 @@ class ProjectSerializer(BaseSerializer):
     member_role = serializers.IntegerField(read_only=True)
     is_deployed = serializers.BooleanField(read_only=True)
     cover_image_url = serializers.CharField(read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
 
     class Meta:
         model = Project

apiserver/plane/api/urls/intake.py

@@ -4,16 +4,6 @@ from plane.api.views import IntakeIssueAPIEndpoint
 
 
 urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
         IntakeIssueAPIEndpoint.as_view(),

apiserver/plane/api/views/cycle.py

@@ -141,8 +141,10 @@ class CycleAPIEndpoint(BaseAPIView):
         if pk:
             queryset = self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
             data = CycleSerializer(
-                queryset, fields=self.fields,
-                expand=self.expand, context={"project": project}
+                queryset,
+                fields=self.fields,
+                expand=self.expand,
+                context={"project": project},
             ).data
             return Response(data, status=status.HTTP_200_OK)
         queryset = self.get_queryset().filter(archived_at__isnull=True)
@@ -154,8 +156,11 @@ class CycleAPIEndpoint(BaseAPIView):
                 start_date__lte=timezone.now(), end_date__gte=timezone.now()
             )
             data = CycleSerializer(
-                queryset, many=True, fields=self.fields,
-                expand=self.expand, context={"project": project}
+                queryset,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+                context={"project": project},
             ).data
             return Response(data, status=status.HTTP_200_OK)
 
@@ -166,8 +171,11 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields,
-                    expand=self.expand, context={"project": project}
+                    cycles,
+                    many=True,
+                    fields=self.fields,
+                    expand=self.expand,
+                    context={"project": project},
                 ).data,
             )
 
@@ -178,8 +186,11 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields,
-                    expand=self.expand, context={"project": project}
+                    cycles,
+                    many=True,
+                    fields=self.fields,
+                    expand=self.expand,
+                    context={"project": project},
                 ).data,
             )
 
@@ -190,8 +201,11 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields,
-                    expand=self.expand, context={"project": project}
+                    cycles,
+                    many=True,
+                    fields=self.fields,
+                    expand=self.expand,
+                    context={"project": project},
                 ).data,
             )
 
@@ -204,16 +218,22 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields,
-                    expand=self.expand, context={"project": project}
+                    cycles,
+                    many=True,
+                    fields=self.fields,
+                    expand=self.expand,
+                    context={"project": project},
                 ).data,
             )
         return self.paginate(
             request=request,
             queryset=(queryset),
             on_results=lambda cycles: CycleSerializer(
-                cycles, many=True, fields=self.fields,
-                expand=self.expand, context={"project": project}
+                cycles,
+                many=True,
+                fields=self.fields,
+                expand=self.expand,
+                context={"project": project},
             ).data,
         )
 

apiserver/plane/api/views/issue.py

@@ -57,6 +57,7 @@ from plane.settings.storage import S3Storage
 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
 
 
 class WorkspaceIssueAPIEndpoint(BaseAPIView):
@@ -322,6 +323,17 @@ class IssueAPIEndpoint(BaseAPIView):
                 current_instance=None,
                 epoch=int(timezone.now().timestamp()),
             )
+
+            # Send the model activity
+            model_activity.delay(
+                model_name="issue",
+                model_id=str(serializer.data["id"]),
+                requested_data=request.data,
+                current_instance=None,
+                actor_id=request.user.id,
+                slug=slug,
+                origin=base_host(request=request, is_app=True),
+            )
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 

apiserver/plane/api/views/project.py

@@ -32,6 +32,7 @@ from plane.bgtasks.webhook_task import model_activity, webhook_activity
 from .base import BaseAPIView
 from plane.utils.host import base_host
 
+
 class ProjectAPIEndpoint(BaseAPIView):
     """Project Endpoints to create, update, list, retrieve and delete endpoint"""
 
@@ -238,7 +239,7 @@ class ProjectAPIEndpoint(BaseAPIView):
             if "already exists" in str(e):
                 return Response(
                     {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )
         except Workspace.DoesNotExist:
             return Response(
@@ -247,7 +248,7 @@ class ProjectAPIEndpoint(BaseAPIView):
         except ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
+                status=status.HTTP_409_CONFLICT,
             )
 
     def patch(self, request, slug, pk):
@@ -258,9 +259,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                 ProjectSerializer(project).data, cls=DjangoJSONEncoder
             )
 
-            intake_view = request.data.get(
-                "inbox_view", request.data.get("intake_view", project.intake_view)
-            )
+            intake_view = request.data.get("intake_view", project.intake_view)
 
             if project.archived_at:
                 return Response(
@@ -307,7 +306,7 @@ class ProjectAPIEndpoint(BaseAPIView):
             if "already exists" in str(e):
                 return Response(
                     {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )
         except (Project.DoesNotExist, Workspace.DoesNotExist):
             return Response(
@@ -316,7 +315,7 @@ class ProjectAPIEndpoint(BaseAPIView):
         except ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
+                status=status.HTTP_409_CONFLICT,
             )
 
     def delete(self, request, slug, pk):

apiserver/plane/app/serializers/issue.py

@@ -352,8 +352,19 @@ class IssueRelationSerializer(BaseSerializer):
             "state_id",
             "priority",
             "assignee_ids",
+            "created_by",
+            "created_at",
+            "updated_at",
+            "updated_by",
+        ]
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "created_at",
+            "updated_by",
+            "updated_at",
         ]
-        read_only_fields = ["workspace", "project"]
 
 
 class RelatedIssueSerializer(BaseSerializer):
@@ -383,8 +394,19 @@ class RelatedIssueSerializer(BaseSerializer):
             "state_id",
             "priority",
             "assignee_ids",
+            "created_by",
+            "created_at",
+            "updated_by",
+            "updated_at",
+        ]
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "created_at",
+            "updated_by",
+            "updated_at",
         ]
-        read_only_fields = ["workspace", "project"]
 
 
 class IssueAssigneeSerializer(BaseSerializer):

apiserver/plane/app/urls/intake.py

@@ -1,7 +1,11 @@
 from django.urls import path
 
 
-from plane.app.views import IntakeViewSet, IntakeIssueViewSet
+from plane.app.views import (
+    IntakeViewSet,
+    IntakeIssueViewSet,
+    IntakeWorkItemDescriptionVersionEndpoint,
+)
 
 
 urlpatterns = [
@@ -53,4 +57,14 @@ urlpatterns = [
         ),
         name="inbox-issue",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-work-items/<uuid:work_item_id>/description-versions/",
+        IntakeWorkItemDescriptionVersionEndpoint.as_view(),
+        name="intake-work-item-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-work-items/<uuid:work_item_id>/description-versions/<uuid:pk>/",
+        IntakeWorkItemDescriptionVersionEndpoint.as_view(),
+        name="intake-work-item-versions",
+    ),
 ]

apiserver/plane/app/urls/issue.py

@@ -25,7 +25,7 @@ from plane.app.views import (
     IssueAttachmentV2Endpoint,
     IssueBulkUpdateDateEndpoint,
     IssueVersionEndpoint,
-    IssueDescriptionVersionEndpoint,
+    WorkItemDescriptionVersionEndpoint,
     IssueMetaEndpoint,
     IssueDetailIdentifierEndpoint,
 )
@@ -263,22 +263,22 @@ urlpatterns = [
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/versions/",
         IssueVersionEndpoint.as_view(),
-        name="page-versions",
+        name="issue-versions",
     ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/versions/<uuid:pk>/",
         IssueVersionEndpoint.as_view(),
-        name="page-versions",
+        name="issue-versions",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/description-versions/",
-        IssueDescriptionVersionEndpoint.as_view(),
-        name="page-versions",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/work-items/<uuid:work_item_id>/description-versions/",
+        WorkItemDescriptionVersionEndpoint.as_view(),
+        name="work-item-versions",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/description-versions/<uuid:pk>/",
-        IssueDescriptionVersionEndpoint.as_view(),
-        name="page-versions",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/work-items/<uuid:work_item_id>/description-versions/<uuid:pk>/",
+        WorkItemDescriptionVersionEndpoint.as_view(),
+        name="work-item-versions",
     ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/meta/",

apiserver/plane/app/views/__init__.py

@@ -144,7 +144,7 @@ from .issue.sub_issue import SubIssuesEndpoint
 
 from .issue.subscriber import IssueSubscriberViewSet
 
-from .issue.version import IssueVersionEndpoint, IssueDescriptionVersionEndpoint
+from .issue.version import IssueVersionEndpoint, WorkItemDescriptionVersionEndpoint
 
 from .module.base import (
     ModuleViewSet,
@@ -184,7 +184,11 @@ from .estimate.base import (
     EstimatePointEndpoint,
 )
 
-from .intake.base import IntakeViewSet, IntakeIssueViewSet
+from .intake.base import (
+    IntakeViewSet,
+    IntakeIssueViewSet,
+    IntakeWorkItemDescriptionVersionEndpoint,
+)
 
 from .analytic.base import (
     AnalyticsEndpoint,

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

@@ -27,16 +27,22 @@ from plane.db.models import (
     Project,
     ProjectMember,
     CycleIssue,
+    IssueDescriptionVersion,
 )
 from plane.app.serializers import (
     IssueCreateSerializer,
-    IssueSerializer,
+    IssueDetailSerializer,
     IntakeSerializer,
     IntakeIssueSerializer,
     IntakeIssueDetailSerializer,
+    IssueDescriptionVersionDetailSerializer,
 )
 from plane.utils.issue_filters import issue_filters
 from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.issue_description_version_task import issue_description_version_task
+from plane.app.views.base import BaseAPIView
+from plane.utils.timezone_converter import user_timezone_converter
+from plane.utils.global_paginator import paginate
 from plane.utils.host import base_host
 
 
@@ -88,7 +94,7 @@ class IntakeIssueViewSet(BaseViewSet):
     serializer_class = IntakeIssueSerializer
     model = IntakeIssue
 
-    filterset_fields = ["statulls"]
+    filterset_fields = ["status"]
 
     def get_queryset(self):
         return (
@@ -219,7 +225,7 @@ class IntakeIssueViewSet(BaseViewSet):
                 workspace__slug=slug,
                 project_id=project_id,
                 member=request.user,
-                role=5,
+                role=ROLE.GUEST.value,
                 is_active=True,
             ).exists()
             and not project.guest_view_all_features
@@ -287,6 +293,13 @@ class IntakeIssueViewSet(BaseViewSet):
                 origin=base_host(request=request, is_app=True),
                 intake=str(intake_issue.id),
             )
+            # updated issue description version
+            issue_description_version_task.delay(
+                updated_issue=json.dumps(request.data, cls=DjangoJSONEncoder),
+                issue_id=str(serializer.data["id"]),
+                user_id=request.user.id,
+                is_creating=True,
+            )
             intake_issue = (
                 IntakeIssue.objects.select_related("issue")
                 .prefetch_related("issue__labels", "issue__assignees")
@@ -386,13 +399,16 @@ class IntakeIssueViewSet(BaseViewSet):
                     ),
                     "description": issue_data.get("description", issue.description),
                 }
+            current_instance = json.dumps(
+                IssueDetailSerializer(issue).data, cls=DjangoJSONEncoder
+            )
 
             issue_serializer = IssueCreateSerializer(
                 issue, data=issue_data, partial=True, context={"project_id": project_id}
             )
 
             if issue_serializer.is_valid():
-                current_instance = issue
+
                 # Log all the updates
                 requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
                 if issue is not None:
@@ -402,15 +418,18 @@ class IntakeIssueViewSet(BaseViewSet):
                         actor_id=str(request.user.id),
                         issue_id=str(issue.id),
                         project_id=str(project_id),
-                        current_instance=json.dumps(
-                            IssueSerializer(current_instance).data,
-                            cls=DjangoJSONEncoder,
-                        ),
+                        current_instance=current_instance,
                         epoch=int(timezone.now().timestamp()),
                         notification=True,
                         origin=base_host(request=request, is_app=True),
                         intake=str(intake_issue.id),
                     )
+                    # updated issue description version
+                    issue_description_version_task.delay(
+                        updated_issue=current_instance,
+                        issue_id=str(pk),
+                        user_id=request.user.id,
+                    )
                 issue_serializer.save()
             else:
                 return Response(
@@ -550,7 +569,7 @@ class IntakeIssueViewSet(BaseViewSet):
                 workspace__slug=slug,
                 project_id=project_id,
                 member=request.user,
-                role=5,
+                role=ROLE.GUEST.value,
                 is_active=True,
             ).exists()
             and not project.guest_view_all_features
@@ -558,7 +577,7 @@ class IntakeIssueViewSet(BaseViewSet):
         ):
             return Response(
                 {"error": "You are not allowed to view this issue"},
-                status=status.HTTP_400_BAD_REQUEST,
+                status=status.HTTP_403_FORBIDDEN,
             )
         issue = IntakeIssueDetailSerializer(intake_issue).data
         return Response(issue, status=status.HTTP_200_OK)
@@ -585,3 +604,81 @@ class IntakeIssueViewSet(BaseViewSet):
 
         intake_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IntakeWorkItemDescriptionVersionEndpoint(BaseAPIView):
+
+    def process_paginated_result(self, fields, results, timezone):
+        paginated_data = results.values(*fields)
+
+        datetime_fields = ["created_at", "updated_at"]
+        paginated_data = user_timezone_converter(
+            paginated_data, datetime_fields, timezone
+        )
+
+        return paginated_data
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, work_item_id, pk=None):
+        project = Project.objects.get(pk=project_id)
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=work_item_id
+        )
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not issue.created_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        if pk:
+            issue_description_version = IssueDescriptionVersion.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=work_item_id,
+                pk=pk,
+            )
+
+            serializer = IssueDescriptionVersionDetailSerializer(
+                issue_description_version
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        cursor = request.GET.get("cursor", None)
+
+        required_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "last_saved_at",
+            "owned_by",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+
+        issue_description_versions_queryset = IssueDescriptionVersion.objects.filter(
+            workspace__slug=slug, project_id=project_id, issue_id=work_item_id
+        )
+
+        paginated_data = paginate(
+            base_queryset=issue_description_versions_queryset,
+            queryset=issue_description_versions_queryset,
+            cursor=cursor,
+            on_result=lambda results: self.process_paginated_result(
+                required_fields, results, request.user.user_timezone
+            ),
+        )
+        return Response(paginated_data, status=status.HTTP_200_OK)

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

@@ -63,6 +63,7 @@ from plane.bgtasks.webhook_task import model_activity
 from plane.bgtasks.issue_description_version_task import issue_description_version_task
 from plane.utils.host import base_host
 
+
 class IssueListEndpoint(BaseAPIView):
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def get(self, request, slug, project_id):
@@ -565,7 +566,7 @@ class IssueViewSet(BaseViewSet):
         ):
             return Response(
                 {"error": "You are not allowed to view this issue"},
-                status=status.HTTP_400_BAD_REQUEST,
+                status=status.HTTP_403_FORBIDDEN,
             )
 
         recent_visited_task.delay(
@@ -632,7 +633,7 @@ class IssueViewSet(BaseViewSet):
             )
 
         current_instance = json.dumps(
-            IssueSerializer(issue).data, cls=DjangoJSONEncoder
+            IssueDetailSerializer(issue).data, cls=DjangoJSONEncoder
         )
 
         requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
@@ -1034,9 +1035,17 @@ class IssueBulkUpdateDateEndpoint(BaseAPIView):
         """
         Validate that start date is before target date.
         """
+        from datetime import datetime
+
         start = new_start or current_start
         target = new_target or current_target
 
+        # Convert string dates to datetime objects if they're strings
+        if isinstance(start, str):
+            start = datetime.strptime(start, "%Y-%m-%d").date()
+        if isinstance(target, str):
+            target = datetime.strptime(target, "%Y-%m-%d").date()
+
         if start and target and start > target:
             return False
         return True
@@ -1278,7 +1287,7 @@ class IssueDetailIdentifierEndpoint(BaseAPIView):
         ):
             return Response(
                 {"error": "You are not allowed to view this issue"},
-                status=status.HTTP_400_BAD_REQUEST,
+                status=status.HTTP_403_FORBIDDEN,
             )
 
         recent_visited_task.delay(

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

@@ -3,7 +3,13 @@ from rest_framework import status
 from rest_framework.response import Response
 
 # Module imports
-from plane.db.models import IssueVersion, IssueDescriptionVersion
+from plane.db.models import (
+    IssueVersion,
+    IssueDescriptionVersion,
+    Project,
+    ProjectMember,
+    Issue,
+)
 from ..base import BaseAPIView
 from plane.app.serializers import (
     IssueVersionDetailSerializer,
@@ -66,7 +72,7 @@ class IssueVersionEndpoint(BaseAPIView):
         return Response(paginated_data, status=status.HTTP_200_OK)
 
 
-class IssueDescriptionVersionEndpoint(BaseAPIView):
+class WorkItemDescriptionVersionEndpoint(BaseAPIView):
     def process_paginated_result(self, fields, results, timezone):
         paginated_data = results.values(*fields)
 
@@ -78,10 +84,34 @@ class IssueDescriptionVersionEndpoint(BaseAPIView):
         return paginated_data
 
     @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def get(self, request, slug, project_id, issue_id, pk=None):
+    def get(self, request, slug, project_id, work_item_id, pk=None):
+        project = Project.objects.get(pk=project_id)
+        issue = Issue.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=work_item_id
+        )
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not issue.created_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
         if pk:
             issue_description_version = IssueDescriptionVersion.objects.get(
-                workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=work_item_id,
+                pk=pk,
             )
 
             serializer = IssueDescriptionVersionDetailSerializer(
@@ -105,8 +135,8 @@ class IssueDescriptionVersionEndpoint(BaseAPIView):
         ]
 
         issue_description_versions_queryset = IssueDescriptionVersion.objects.filter(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id
-        )
+            workspace__slug=slug, project_id=project_id, issue_id=work_item_id
+        ).order_by("-created_at")
         paginated_data = paginate(
             base_queryset=issue_description_versions_queryset,
             queryset=issue_description_versions_queryset,

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

@@ -41,6 +41,7 @@ from plane.bgtasks.recent_visited_task import recent_visited_task
 from plane.utils.exception_logger import log_exception
 from plane.utils.host import base_host
 
+
 class ProjectViewSet(BaseViewSet):
     serializer_class = ProjectListSerializer
     model = Project
@@ -341,7 +342,7 @@ class ProjectViewSet(BaseViewSet):
             if "already exists" in str(e):
                 return Response(
                     {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )
         except Workspace.DoesNotExist:
             return Response(
@@ -350,7 +351,7 @@ class ProjectViewSet(BaseViewSet):
         except serializers.ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
+                status=status.HTTP_409_CONFLICT,
             )
 
     def partial_update(self, request, slug, pk=None):
@@ -419,7 +420,7 @@ class ProjectViewSet(BaseViewSet):
             if "already exists" in str(e):
                 return Response(
                     {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )
         except (Project.DoesNotExist, Workspace.DoesNotExist):
             return Response(
@@ -428,7 +429,7 @@ class ProjectViewSet(BaseViewSet):
         except serializers.ValidationError:
             return Response(
                 {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
+                status=status.HTTP_409_CONFLICT,
             )
 
     def destroy(self, request, slug, pk):

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

@@ -432,7 +432,7 @@ class IssueViewViewSet(BaseViewSet):
         ):
             return Response(
                 {"error": "You are not allowed to view this issue"},
-                status=status.HTTP_400_BAD_REQUEST,
+                status=status.HTTP_403_FORBIDDEN,
             )
 
         serializer = IssueViewSerializer(issue_view)

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

@@ -29,7 +29,7 @@ class WebhookEndpoint(BaseAPIView):
             if "already exists" in str(e):
                 return Response(
                     {"error": "URL already exists for the workspace"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )
             raise IntegrityError
 

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

@@ -119,7 +119,9 @@ class WorkSpaceViewSet(BaseViewSet):
                 )
 
                 # Get total members and role
-                total_members=WorkspaceMember.objects.filter(workspace_id=serializer.data["id"]).count()
+                total_members = WorkspaceMember.objects.filter(
+                    workspace_id=serializer.data["id"]
+                ).count()
                 data = serializer.data
                 data["total_members"] = total_members
                 data["role"] = 20
@@ -134,7 +136,7 @@ class WorkSpaceViewSet(BaseViewSet):
             if "already exists" in str(e):
                 return Response(
                     {"slug": "The workspace with the slug already exists"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )
 
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
@@ -167,10 +169,9 @@ class UserWorkSpacesEndpoint(BaseAPIView):
             .values("count")
         )
 
-        role = (
-            WorkspaceMember.objects.filter(workspace=OuterRef("id"), member=request.user, is_active=True)
-            .values("role")
-        )
+        role = WorkspaceMember.objects.filter(
+            workspace=OuterRef("id"), member=request.user, is_active=True
+        ).values("role")
 
         workspace = (
             Workspace.objects.prefetch_related(

apiserver/plane/bgtasks/issue_activities_task.py

@@ -32,7 +32,7 @@ from plane.settings.redis import redis_instance
 from plane.utils.exception_logger import log_exception
 from plane.bgtasks.webhook_task import webhook_activity
 from plane.utils.issue_relation_mapper import get_inverse_relation
-from plane.utils.valid_uuid import is_valid_uuid
+from plane.utils.uuid import is_valid_uuid
 
 
 # Track Changes in name
@@ -307,6 +307,10 @@ def track_labels(
 
     # Set of newly added labels
     for added_label in added_labels:
+        # validate uuids
+        if not is_valid_uuid(added_label):
+            continue
+
         label = Label.objects.get(pk=added_label)
         issue_activities.append(
             IssueActivity(
@@ -327,6 +331,10 @@ def track_labels(
 
     # Set of dropped labels
     for dropped_label in dropped_labels:
+        # validate uuids
+        if not is_valid_uuid(dropped_label):
+            continue
+
         label = Label.objects.get(pk=dropped_label)
         issue_activities.append(
             IssueActivity(
@@ -373,6 +381,10 @@ def track_assignees(
 
     bulk_subscribers = []
     for added_asignee in added_assignees:
+        # validate uuids
+        if not is_valid_uuid(added_asignee):
+            continue
+
         assignee = User.objects.get(pk=added_asignee)
         issue_activities.append(
             IssueActivity(
@@ -406,6 +418,10 @@ def track_assignees(
     )
 
     for dropped_assignee in dropped_assginees:
+        # validate uuids
+        if not is_valid_uuid(dropped_assignee):
+            continue
+
         assignee = User.objects.get(pk=dropped_assignee)
         issue_activities.append(
             IssueActivity(

apiserver/plane/db/management/commands/fix_duplicate_sequences.py

@@ -0,0 +1,102 @@
+# Django imports
+from django.core.management.base import BaseCommand, CommandError
+from django.db.models import Max
+from django.db import connection, transaction
+
+# Module imports
+from plane.db.models import Project, Issue, IssueSequence
+from plane.utils.uuid import convert_uuid_to_integer
+
+
+class Command(BaseCommand):
+    help = "Fix duplicate sequences"
+
+    def add_arguments(self, parser):
+        # Positional argument
+        parser.add_argument("issue_identifier", type=str, help="Issue Identifier")
+
+    def strict_str_to_int(self, s):
+        if not s.isdigit() and not (s.startswith("-") and s[1:].isdigit()):
+            raise ValueError("Invalid integer string")
+        return int(s)
+
+    def handle(self, *args, **options):
+        workspace_slug = input("Workspace slug: ")
+
+        if not workspace_slug:
+            raise CommandError("Workspace slug is required")
+
+        issue_identifier = options.get("issue_identifier", False)
+
+        # Validate issue_identifier
+        if not issue_identifier:
+            raise CommandError("Issue identifier is required")
+
+        # Validate issue identifier
+        try:
+            identifier = issue_identifier.split("-")
+
+            if len(identifier) != 2:
+                raise ValueError("Invalid issue identifier format")
+
+            project_identifier = identifier[0]
+            issue_sequence = self.strict_str_to_int(identifier[1])
+
+            # Fetch the project
+            project = Project.objects.get(
+                identifier__iexact=project_identifier, workspace__slug=workspace_slug
+            )
+
+            # Get the issues
+            issues = Issue.objects.filter(project=project, sequence_id=issue_sequence)
+            # Check if there are duplicate issues
+            if not issues.count() > 1:
+                raise CommandError(
+                    "No duplicate issues found with the given identifier"
+                )
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"{issues.count()} issues found with identifier {issue_identifier}"
+                )
+            )
+            with transaction.atomic():
+                # This ensures only one transaction per project can execute this code at a time
+                lock_key = convert_uuid_to_integer(project.id)
+
+                # Acquire an exclusive lock using the project ID as the lock key
+                with connection.cursor() as cursor:
+                    # Get an exclusive lock using the project ID as the lock key
+                    cursor.execute("SELECT pg_advisory_xact_lock(%s)", [lock_key])
+
+                # Get the maximum sequence ID for the project
+                last_sequence = IssueSequence.objects.filter(project=project).aggregate(
+                    largest=Max("sequence")
+                )["largest"]
+
+                bulk_issues = []
+                bulk_issue_sequences = []
+
+                issue_sequence_map = {
+                    isq.issue_id: isq
+                    for isq in IssueSequence.objects.filter(project=project)
+                }
+
+                # change the ids of duplicate issues
+                for index, issue in enumerate(issues[1:]):
+                    updated_sequence_id = last_sequence + index + 1
+                    issue.sequence_id = updated_sequence_id
+                    bulk_issues.append(issue)
+
+                    # Find the same issue sequence instance from the above queryset
+                    sequence_identifier = issue_sequence_map.get(issue.id)
+                    if sequence_identifier:
+                        sequence_identifier.sequence = updated_sequence_id
+                        bulk_issue_sequences.append(sequence_identifier)
+
+                Issue.objects.bulk_update(bulk_issues, ["sequence_id"])
+                IssueSequence.objects.bulk_update(bulk_issue_sequences, ["sequence"])
+
+            self.stdout.write(self.style.SUCCESS("Sequence IDs updated successfully"))
+        except Exception as e:
+            raise CommandError(str(e))

apiserver/plane/db/migrations/0093_page_moved_to_page_page_moved_to_project_and_more.py

@@ -0,0 +1,31 @@
+# Generated by Django 4.2.17 on 2025-03-04 19:29
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("db", "0092_alter_deprecateddashboardwidget_unique_together_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="page",
+            name="moved_to_page",
+            field=models.UUIDField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="page",
+            name="moved_to_project",
+            field=models.UUIDField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="pageversion",
+            name="sub_pages_data",
+            field=models.JSONField(blank=True, default=dict),
+        ),
+    ]

apiserver/plane/db/models/__init__.py

@@ -82,4 +82,4 @@ from .label import Label
 
 from .device import Device, DeviceSession
 
-from .sticky import Sticky
+from .sticky import Sticky

apiserver/plane/db/models/issue.py

@@ -6,7 +6,7 @@ from django.conf import settings
 from django.contrib.postgres.fields import ArrayField
 from django.core.exceptions import ValidationError
 from django.core.validators import MaxValueValidator, MinValueValidator
-from django.db import models, transaction
+from django.db import models, transaction, connection
 from django.utils import timezone
 from django.db.models import Q
 from django import apps
@@ -15,8 +15,8 @@ from django import apps
 from plane.utils.html_processor import strip_tags
 from plane.db.mixins import SoftDeletionManager
 from plane.utils.exception_logger import log_exception
-from .base import BaseModel
 from .project import ProjectBaseModel
+from plane.utils.uuid import convert_uuid_to_integer
 
 
 def get_default_properties():
@@ -209,11 +209,18 @@ class Issue(ProjectBaseModel):
 
         if self._state.adding:
             with transaction.atomic():
-                last_sequence = (
-                    IssueSequence.objects.filter(project=self.project)
-                    .select_for_update()
-                    .aggregate(largest=models.Max("sequence"))["largest"]
-                )
+                # Create a lock for this specific project using an advisory lock
+                # This ensures only one transaction per project can execute this code at a time
+                lock_key = convert_uuid_to_integer(self.project.id)
+
+                with connection.cursor() as cursor:
+                    # Get an exclusive lock using the project ID as the lock key
+                    cursor.execute("SELECT pg_advisory_xact_lock(%s)", [lock_key])
+
+                # Get the last sequence for the project
+                last_sequence = IssueSequence.objects.filter(
+                    project=self.project
+                ).aggregate(largest=models.Max("sequence"))["largest"]
                 self.sequence_id = last_sequence + 1 if last_sequence else 1
                 # Strip the html tags using html parser
                 self.description_stripped = (

apiserver/plane/db/models/page.py

@@ -50,6 +50,8 @@ class Page(BaseModel):
     projects = models.ManyToManyField(
         "db.Project", related_name="pages", through="db.ProjectPage"
     )
+    moved_to_page = models.UUIDField(null=True, blank=True)
+    moved_to_project = models.UUIDField(null=True, blank=True)
 
     class Meta:
         verbose_name = "Page"
@@ -172,6 +174,7 @@ class PageVersion(BaseModel):
     description_html = models.TextField(blank=True, default="<p></p>")
     description_stripped = models.TextField(blank=True, null=True)
     description_json = models.JSONField(default=dict, blank=True)
+    sub_pages_data = models.JSONField(default=dict, blank=True)
 
     class Meta:
         verbose_name = "Page Version"

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

@@ -109,5 +109,5 @@ class InstanceWorkSpaceEndpoint(BaseAPIView):
             if "already exists" in str(e):
                 return Response(
                     {"slug": "The workspace with the slug already exists"},
-                    status=status.HTTP_410_GONE,
+                    status=status.HTTP_409_CONFLICT,
                 )

apiserver/plane/middleware/logger.py

@@ -0,0 +1,71 @@
+# Python imports
+import logging
+import time
+
+# Django imports
+from django.http import HttpRequest
+
+# Third party imports
+from rest_framework.request import Request
+
+# Module imports
+from plane.utils.ip_address import get_client_ip
+
+api_logger = logging.getLogger("plane.api")
+
+
+class RequestLoggerMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def _should_log_route(self, request: Request | HttpRequest) -> bool:
+        """
+        Determines whether a route should be logged based on the request and status code.
+        """
+        # Don't log health checks
+        if request.path == "/" and request.method == "GET":
+            return False
+        return True
+
+    def __call__(self, request):
+        # get the start time
+        start_time = time.time()
+
+        # Get the response
+        response = self.get_response(request)
+
+        # calculate the duration
+        duration = time.time() - start_time
+
+        # Check if logging is required
+        log_true = self._should_log_route(request=request)
+
+        # If logging is not required, return the response
+        if not log_true:
+            return response
+
+        user_id = (
+            request.user.id
+            if getattr(request, "user")
+            and getattr(request.user, "is_authenticated", False)
+            else None
+        )
+
+        user_agent = request.META.get("HTTP_USER_AGENT", "")
+
+        # Log the request information
+        api_logger.info(
+            f"{request.method} {request.get_full_path()} {response.status_code}",
+            extra={
+                "path": request.path,
+                "method": request.method,
+                "status_code": response.status_code,
+                "duration_ms": int(duration * 1000),
+                "remote_addr": get_client_ip(request),
+                "user_agent": user_agent,
+                "user_id": user_id,
+            },
+        )
+
+        # return the response
+        return response

apiserver/plane/settings/common.py

@@ -59,6 +59,7 @@ MIDDLEWARE = [
     "crum.CurrentRequestUserMiddleware",
     "django.middleware.gzip.GZipMiddleware",
     "plane.middleware.api_log_middleware.APITokenLogMiddleware",
+    "plane.middleware.logger.RequestLoggerMiddleware",
 ]
 
 # Rest Framework settings

apiserver/plane/settings/local.py

@@ -37,26 +37,31 @@ if not os.path.exists(LOG_DIR):
 
 LOGGING = {
     "version": 1,
-    "disable_existing_loggers": False,
+    "disable_existing_loggers": True,
     "formatters": {
         "verbose": {
             "format": "{levelname} {asctime} {module} {process:d} {thread:d} {message}",
             "style": "{",
-        }
+        },
+        "json": {
+            "()": "pythonjsonlogger.jsonlogger.JsonFormatter",
+            "fmt": "%(levelname)s %(asctime)s %(module)s %(name)s %(message)s",
+        },
     },
     "handlers": {
         "console": {
             "level": "DEBUG",
             "class": "logging.StreamHandler",
-            "formatter": "verbose",
+            "formatter": "json",
         }
     },
     "loggers": {
-        "django.request": {
+        "plane.api": {"level": "INFO", "handlers": ["console"], "propagate": False},
+        "plane.worker": {"level": "INFO", "handlers": ["console"], "propagate": False},
+        "plane.exception": {
+            "level": "ERROR",
             "handlers": ["console"],
-            "level": "DEBUG",
             "propagate": False,
         },
-        "plane": {"handlers": ["console"], "level": "DEBUG", "propagate": False},
     },
 }

apiserver/plane/settings/production.py

@@ -26,11 +26,10 @@ if not os.path.exists(LOG_DIR):
 # Logging configuration
 LOGGING = {
     "version": 1,
-    "disable_existing_loggers": False,
+    "disable_existing_loggers": True,
     "formatters": {
         "verbose": {
-            "format": "{levelname} {asctime} {module} {process:d} {thread:d} {message}",
-            "style": "{",
+            "format": "%(asctime)s [%(process)d] %(levelname)s %(name)s: %(message)s"
         },
         "json": {
             "()": "pythonjsonlogger.jsonlogger.JsonFormatter",
@@ -40,7 +39,7 @@ LOGGING = {
     "handlers": {
         "console": {
             "class": "logging.StreamHandler",
-            "formatter": "verbose",
+            "formatter": "json",
             "level": "INFO",
         },
         "file": {
@@ -59,15 +58,19 @@ LOGGING = {
         },
     },
     "loggers": {
-        "django": {"handlers": ["console", "file"], "level": "INFO", "propagate": True},
-        "django.request": {
-            "handlers": ["console", "file"],
-            "level": "INFO",
+        "plane.api": {
+            "level": "DEBUG" if DEBUG else "INFO",
+            "handlers": ["console"],
             "propagate": False,
         },
-        "plane": {
+        "plane.worker": {
+            "level": "DEBUG" if DEBUG else "INFO",
+            "handlers": ["console"],
+            "propagate": False,
+        },
+        "plane.exception": {
             "level": "DEBUG" if DEBUG else "ERROR",
-            "handlers": ["console", "file"],
+            "handlers": ["console"],
             "propagate": False,
         },
     },

apiserver/plane/tests/api/test_workspace.py

@@ -41,4 +41,4 @@ class WorkSpaceCreateReadUpdateDelete(AuthenticatedAPITest):
         response = self.client.post(
             url, {"name": "Plane", "slug": "pla-ne"}, format="json"
         )
-        self.assertEqual(response.status_code, status.HTTP_410_GONE)
+        self.assertEqual(response.status_code, status.HTTP_409_CONFLICT)

apiserver/plane/utils/exception_logger.py

@@ -8,8 +8,8 @@ from django.conf import settings
 
 def log_exception(e):
     # Log the error
-    logger = logging.getLogger("plane")
-    logger.error(e)
+    logger = logging.getLogger("plane.exception")
+    logger.error(str(e))
 
     if settings.DEBUG:
         # Print the traceback if in debug mode

apiserver/plane/utils/uuid.py

@@ -0,0 +1,22 @@
+# Python imports
+import uuid
+import hashlib
+
+
+def is_valid_uuid(uuid_str):
+    """Check if a string is a valid UUID version 4"""
+    try:
+        uuid_obj = uuid.UUID(uuid_str)
+        return uuid_obj.version == 4
+    except ValueError:
+        return False
+
+
+def convert_uuid_to_integer(uuid_val: uuid.UUID) -> int:
+    """Convert a UUID to a 64-bit signed integer"""
+    # Ensure UUID is a string
+    uuid_value: str = str(uuid_val)
+    # Hash to 64-bit signed int
+    h: bytes = hashlib.sha256(uuid_value.encode()).digest()
+    bigint: int = int.from_bytes(h[:8], byteorder="big", signed=True)
+    return bigint

apiserver/plane/utils/valid_uuid.py

@@ -1,8 +0,0 @@
-import uuid
-
-def is_valid_uuid(uuid_str):
-    try:
-        uuid.UUID(uuid_str, version=4)
-        return True
-    except ValueError:
-        return False

apiserver/requirements/base.txt

@@ -43,7 +43,7 @@ scout-apm==3.1.0
 # xlsx generation
 openpyxl==3.1.2
 # logging
-python-json-logger==2.0.7
+python-json-logger==3.3.0
 # html parser
 beautifulsoup4==4.12.3
 # analytics

live/.babelrc

@@ -0,0 +1,23 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "modules": false
+      }
+    ],
+    "@babel/preset-typescript"
+  ],
+  "plugins": [
+    [
+      "module-resolver",
+      {
+        "root": ["./src"],
+        "alias": {
+          "@/core": "./src/core",
+          "@/plane-live": "./src/ce"
+        }
+      }
+    ]
+  ]
+}

live/package.json

@@ -3,15 +3,13 @@
   "version": "0.25.3",
   "license": "AGPL-3.0",
   "description": "A realtime collaborative server powers Plane's rich text editor",
-  "main": "./dist/start.js",
-  "module": "./dist/start.mjs",
-  "types": "./dist/start.d.ts",
+  "main": "./src/server.ts",
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "tsup --watch --onSuccess 'node --env-file=.env dist/start.js'",
-    "build": "tsup",
-    "start": "node --env-file=.env dist/start.js",
+    "dev": "PORT=3100 concurrently \"babel src --out-dir dist --extensions '.ts,.js' --watch\" \"nodemon dist/server.js\"",
+    "build": "babel src --out-dir dist --extensions \".ts,.js\"",
+    "start": "node dist/server.js",
     "lint": "eslint src --ext .ts,.tsx",
     "lint:errors": "eslint src --ext .ts,.tsx --quiet"
   },
@@ -23,17 +21,14 @@
     "@hocuspocus/extension-redis": "^2.15.0",
     "@hocuspocus/server": "^2.15.0",
     "@plane/constants": "*",
-    "@plane/decorators": "*",
     "@plane/editor": "*",
-    "@plane/logger": "*",
     "@plane/types": "*",
     "@tiptap/core": "2.10.4",
     "@tiptap/html": "2.11.0",
     "axios": "^1.8.3",
     "compression": "^1.7.4",
-    "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
-    "dotenv": "^16.4.7",
+    "dotenv": "^16.4.5",
     "express": "^4.21.2",
     "express-ws": "^5.0.2",
     "helmet": "^7.1.0",
@@ -42,22 +37,27 @@
     "morgan": "^1.10.0",
     "pino-http": "^10.3.0",
     "pino-pretty": "^11.2.2",
-    "reflect-metadata": "^0.2.2",
     "uuid": "^10.0.0",
     "y-prosemirror": "^1.2.15",
     "y-protocols": "^1.0.6",
-    "yjs": "^13.6.20",
-    "zod": "^3.24.2"
+    "yjs": "^13.6.20"
   },
   "devDependencies": {
+    "@babel/cli": "^7.25.6",
+    "@babel/core": "^7.25.2",
+    "@babel/preset-env": "^7.25.4",
+    "@babel/preset-typescript": "^7.24.7",
     "@types/compression": "^1.7.5",
-    "@types/cookie-parser": "^1.4.8",
     "@types/cors": "^2.8.17",
     "@types/dotenv": "^8.2.0",
     "@types/express": "^4.17.21",
     "@types/express-ws": "^3.0.4",
     "@types/node": "^20.14.9",
-    "tsup": "8.4.0",
+    "babel-plugin-module-resolver": "^5.0.2",
+    "concurrently": "^9.0.1",
+    "nodemon": "^3.1.7",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
     "typescript": "5.3.3"
   }
 }

live/src/ce/document-types/index.ts

@@ -1 +0,0 @@
-export * from "./register";

live/src/ce/document-types/project-page/index.ts

@@ -1,2 +0,0 @@
-export * from "./transformers";
-export * from "./project-page-handler";

live/src/ce/document-types/project-page/project-page-handler.ts

@@ -1,74 +0,0 @@
-import {
-  DocumentHandler,
-  DocumentFetchParams,
-  DocumentStoreParams,
-  HandlerDefinition,
-} from "@/core/types/document-handler";
-import { handlerFactory } from "@/core/handlers/document-handlers/handler-factory";
-import { PageService } from "@/services/page.service";
-import { transformHTMLToBinary } from "./transformers";
-import { getAllDocumentFormatsFromBinaryData } from "@/core/helpers/page";
-
-const pageService = new PageService();
-
-/**
- * Handler for "project_page" document type
- */
-export const projectPageHandler: DocumentHandler = {
-  /**
-   * Fetch project page description
-   */
-  fetch: async ({ pageId, params, context }: DocumentFetchParams) => {
-    const { cookie } = context;
-    const workspaceSlug = params.get("workspaceSlug")?.toString();
-    const projectId = params.get("projectId")?.toString();
-    if (!workspaceSlug || !projectId || !cookie) return null;
-
-    const response = await pageService.fetchDescriptionBinary(workspaceSlug, projectId, pageId, cookie);
-    const binaryData = new Uint8Array(response);
-
-    if (binaryData.byteLength === 0) {
-      const binary = await transformHTMLToBinary(workspaceSlug, projectId, pageId, cookie);
-      if (binary) {
-        return binary;
-      }
-    }
-
-    return binaryData;
-  },
-
-  /**
-   * Store project page description
-   */
-  store: async ({ pageId, state, params, context }: DocumentStoreParams) => {
-    const { cookie } = context;
-    if (!(state instanceof Uint8Array)) {
-      throw new Error("Invalid state: must be an instance of Uint8Array");
-    }
-
-    const workspaceSlug = params?.get("workspaceSlug")?.toString();
-    const projectId = params?.get("projectId")?.toString();
-    if (!workspaceSlug || !projectId || !cookie) return;
-
-    const { contentBinaryEncoded, contentHTML, contentJSON } = getAllDocumentFormatsFromBinaryData(state);
-    const payload = {
-      description_binary: contentBinaryEncoded,
-      description_html: contentHTML,
-      description: contentJSON,
-    };
-
-    await pageService.updateDescription(workspaceSlug, projectId, pageId, payload, cookie);
-  },
-};
-
-// Define the project page handler definition
-export const projectPageHandlerDefinition: HandlerDefinition = {
-  selector: (context) => context.documentType === "project_page",
-  handler: projectPageHandler,
-  priority: 10, // Standard priority
-};
-
-// Register the handler directly from CE
-export function registerProjectPageHandler() {
-  handlerFactory.register(projectPageHandlerDefinition);
-}

live/src/ce/document-types/project-page/transformers.ts

@@ -1,26 +0,0 @@
-import { PageService } from "@/services/page.service";
-import { getBinaryDataFromHTMLString } from "@/core/helpers/page";
-import { logger } from "@plane/logger";
-
-const pageService = new PageService();
-
-/**
- * Transforms HTML description to binary format
- */
-export const transformHTMLToBinary = async (
-  workspaceSlug: string,
-  projectId: string,
-  pageId: string,
-  cookie: string
-) => {
-  if (!workspaceSlug || !projectId || !cookie) return;
-
-  try {
-    const pageDetails = await pageService.fetchDetails(workspaceSlug, projectId, pageId, cookie);
-    const { contentBinary } = getBinaryDataFromHTMLString(pageDetails.description_html ?? "<p></p>");
-    return contentBinary;
-  } catch (error) {
-    logger.error("Error while transforming from HTML to Uint8Array", error);
-    throw error;
-  }
-};

live/src/ce/document-types/register.ts

@@ -1,5 +0,0 @@
-import { registerProjectPageHandler } from "./project-page/project-page-handler";
-
-export function initializeDocumentHandlers() {
-  registerProjectPageHandler();
-}

live/src/ce/lib/fetch-document.ts

@@ -0,0 +1,14 @@
+// types
+import { TDocumentTypes } from "@/core/types/common.js";
+
+type TArgs = {
+  cookie: string | undefined;
+  documentType: TDocumentTypes | undefined;
+  pageId: string;
+  params: URLSearchParams;
+}
+
+export const fetchDocument = async (args: TArgs): Promise<Uint8Array | null> => {
+  const { documentType } = args;
+  throw Error(`Fetch failed: Invalid document type ${documentType} provided.`);
+}

live/src/ce/lib/update-document.ts

@@ -0,0 +1,15 @@
+// types
+import { TDocumentTypes } from "@/core/types/common.js";
+
+type TArgs = {
+  cookie: string | undefined;
+  documentType: TDocumentTypes | undefined;
+  pageId: string;
+  params: URLSearchParams;
+  updatedDescription: Uint8Array;
+}
+
+export const updateDocument = async (args: TArgs): Promise<void> => {
+  const { documentType } = args;
+  throw Error(`Update failed: Invalid document type ${documentType} provided.`);
+}

live/src/ce/types/common.d.ts

@@ -1 +1 @@
-export type TAdditionalDocumentTypes = string;
+export type TAdditionalDocumentTypes = {};

live/src/controllers/collaboration.controller.ts

@@ -1,96 +0,0 @@
-import type { Request } from "express";
-import type { WebSocket as WS } from "ws";
-import type { Hocuspocus } from "@hocuspocus/server";
-import { ErrorCategory } from "@/lib/error-handling/error-handler";
-import { logger } from "@plane/logger";
-import Errors from "@/lib/error-handling/error-factory";
-import { Controller, WebSocket } from "@plane/decorators";
-
-@Controller("/collaboration")
-export class CollaborationController {
-  private metrics = {
-    errors: 0,
-  };
-
-  constructor(private readonly hocusPocusServer: Hocuspocus) {}
-
-  @WebSocket("/")
-  handleConnection(ws: WS, req: Request) {
-    const clientInfo = {
-      ip: req.ip,
-      userAgent: req.get("user-agent"),
-      requestId: req.id || crypto.randomUUID(),
-    };
-
-    try {
-      // Initialize the connection with Hocuspocus
-      this.hocusPocusServer.handleConnection(ws, req);
-
-      // Set up error handling for the connection
-      ws.on("error", (error) => {
-        this.handleConnectionError(error, clientInfo, ws);
-      });
-    } catch (error) {
-      this.handleConnectionError(error, clientInfo, ws);
-    }
-  }
-
-  private handleConnectionError(error: unknown, clientInfo: Record<string, any>, ws: WS) {
-    // Convert to AppError if needed
-    const appError = Errors.convertError(error instanceof Error ? error : new Error(String(error)), {
-      context: {
-        ...clientInfo,
-        component: "WebSocketConnection",
-      },
-    });
-
-    // Log at appropriate level based on error category
-    if (appError.category === ErrorCategory.OPERATIONAL) {
-      logger.info(`WebSocket operational error: ${appError.message}`, {
-        error: appError,
-        clientInfo,
-      });
-    } else {
-      logger.error(`WebSocket error: ${appError.message}`, {
-        error: appError,
-        clientInfo,
-        stack: appError.stack,
-      });
-    }
-
-    // Alert if error threshold is reached
-    if (this.metrics.errors % 10 === 0) {
-      logger.warn(`High WebSocket error rate detected: ${this.metrics.errors} total errors`);
-    }
-
-    // Try to send error to client before closing
-    try {
-      if (ws.readyState === ws.OPEN) {
-        ws.send(
-          JSON.stringify({
-            type: "error",
-            message: appError.category === ErrorCategory.OPERATIONAL ? appError.message : "Internal server error",
-          })
-        );
-      }
-    } catch (sendError) {
-      // Ignore send errors at this point
-    }
-
-    // Close with informative message if connection is still open
-    if (ws.readyState === ws.OPEN) {
-      ws.close(
-        1011,
-        appError.category === ErrorCategory.OPERATIONAL
-          ? `Error: ${appError.message}. Reconnect with exponential backoff.`
-          : "Internal server error. Please retry in a few moments."
-      );
-    }
-  }
-
-  getErrorMetrics() {
-    return {
-      errors: this.metrics.errors,
-    };
-  }
-}

live/src/controllers/document.controller.ts

@@ -1,128 +0,0 @@
-import type { Request, Response } from "express";
-import { z } from "zod";
-// helpers
-import { convertHTMLDocumentToAllFormats } from "@/core/helpers/convert-document";
-// types
-import { TConvertDocumentRequestBody } from "@/core/types/common";
-// decorators
-import { CatchErrors } from "@/lib/error";
-// logger
-import { logger } from "@plane/logger";
-import { Controller, Post } from "@plane/decorators";
-import { AppError } from "@/lib/error-handling/error-handler";
-import { handleError } from "@/lib/error-handling/error-factory";
-
-// Define the schema with more robust validation
-const convertDocumentSchema = z.object({
-  description_html: z
-    .string()
-    .min(1, "HTML content cannot be empty")
-    .refine((html) => html.trim().length > 0, "HTML content cannot be just whitespace")
-    .refine((html) => html.includes("<") && html.includes(">"), "Content must be valid HTML"),
-  variant: z.enum(["rich", "document"]),
-});
-
-@Controller("/convert-document")
-export class DocumentController {
-  private metrics = {
-    conversions: 0,
-    errors: 0,
-  };
-
-  @Post("/")
-  @CatchErrors()
-  async convertDocument(req: Request, res: Response) {
-    const requestId = req.id || crypto.randomUUID();
-    const clientInfo = {
-      ip: req.ip,
-      userAgent: req.get("user-agent"),
-      requestId,
-    };
-
-    try {
-      // Validate request body
-      const validatedData = convertDocumentSchema.parse(req.body as TConvertDocumentRequestBody);
-      const { description_html, variant } = validatedData;
-
-      // Log validated data
-      logger.info("Validated document conversion request", {
-        ...clientInfo,
-        variant,
-        contentLength: description_html.length,
-      });
-
-      // Process document conversion
-      const { description, description_binary } = convertHTMLDocumentToAllFormats({
-        document_html: description_html,
-        variant,
-      });
-
-      // Update metrics
-      this.metrics.conversions++;
-
-      // Log successful conversion
-      logger.info("Document conversion successful", {
-        ...clientInfo,
-        variant,
-        outputLength: description_html.length,
-      });
-
-      // Return successful response
-      res.status(200).json({
-        description,
-        description_binary,
-      });
-    } catch (error) {
-      // Update error metrics
-      this.metrics.errors++;
-
-      let appError: AppError;
-
-      if (error instanceof z.ZodError) {
-        // Handle validation errors
-        appError = handleError(error, {
-          errorType: "unprocessable-entity",
-          message: "Invalid request data",
-          component: "document-conversion-controller",
-          operation: "convertDocument",
-          extraContext: {
-            ...clientInfo,
-            validationErrors: error.errors.map((err) => ({
-              path: err.path.join("."),
-              message: err.message,
-            })),
-          },
-        });
-      } else {
-        // Handle other errors
-        appError = handleError(error, {
-          errorType: "internal",
-          message: "Internal server error",
-          component: "document-conversion-controller",
-          operation: "convertDocument",
-          extraContext: clientInfo,
-        });
-      }
-
-      // Log the error
-      logger.error("Document conversion failed", {
-        error: appError,
-        status: appError.status,
-        context: appError.context,
-      });
-
-      res.status(appError.status).json({
-        message: appError.message,
-        status: appError.status,
-        context: appError.context,
-      });
-    }
-  }
-
-  getMetrics() {
-    return {
-      conversions: this.metrics.conversions,
-      errors: this.metrics.errors,
-    };
-  }
-}

live/src/controllers/health.controller.ts

@@ -1,16 +0,0 @@
-import { CatchErrors } from "@/lib/error";
-import { Controller, Get } from "@plane/decorators";
-import type { Request, Response } from "express";
-
-@Controller("/health")
-export class HealthController {
-  @Get("/")
-  @CatchErrors()
-  async healthCheck(_req: Request, res: Response) {
-    res.status(200).json({
-      status: "OK",
-      timestamp: new Date().toISOString(),
-      version: process.env.APP_VERSION || "1.0.0",
-    });
-  }
-}

live/src/controllers/index.ts

@@ -1,7 +0,0 @@
-import { HealthController } from "./health.controller";
-import { DocumentController } from "./document.controller";
-import { CollaborationController } from "./collaboration.controller";
-
-export const REST_CONTROLLERS = [HealthController, DocumentController];
-
-export const WEBSOCKET_CONTROLLERS = [CollaborationController];

live/src/core/extensions/database.ts

@@ -1,116 +0,0 @@
-import { Database } from "@hocuspocus/extension-database";
-import { catchAsync } from "@/lib/error-handling/error-handler";
-import { handleError } from "@/lib/error-handling/error-factory";
-import { getDocumentHandler } from "../handlers/document-handlers";
-import { type HocusPocusServerContext, type TDocumentTypes } from "@/core/types/common";
-
-export const createDatabaseExtension = () => {
-  return new Database({
-    fetch: handleFetch,
-    store: handleStore,
-  });
-};
-
-const handleFetch = async ({
-  context,
-  documentName: pageId,
-  requestParameters,
-}: {
-  context: HocusPocusServerContext;
-  documentName: TDocumentTypes;
-  requestParameters: URLSearchParams;
-}) => {
-  const { documentType } = context;
-  const params = requestParameters;
-
-  let fetchedData = null;
-  fetchedData = await catchAsync(
-    async () => {
-      if (!documentType) {
-        handleError(null, {
-          errorType: "bad-request",
-          message: "Document type is required",
-          component: "database-extension",
-          operation: "fetch",
-          extraContext: { pageId },
-          throw: true,
-        });
-      }
-
-      const documentHandler = getDocumentHandler(documentType, context);
-      fetchedData = await documentHandler.fetch({
-        context: context as HocusPocusServerContext,
-        pageId,
-        params,
-      });
-
-      if (!fetchedData) {
-        handleError(null, {
-          errorType: "not-found",
-          message: `Failed to fetch document: ${pageId}`,
-          component: "database-extension",
-          operation: "fetch",
-          extraContext: { documentType, pageId },
-        });
-      }
-
-      return fetchedData;
-    },
-    {
-      params: { pageId, documentType: context.documentType },
-      extra: { operation: "fetch" },
-    }
-  )();
-  return fetchedData;
-};
-
-const handleStore = async ({
-  context,
-  state,
-  documentName: pageId,
-  requestParameters,
-}: {
-  context: HocusPocusServerContext;
-  state: Buffer;
-  documentName: TDocumentTypes;
-  requestParameters: URLSearchParams;
-}) => {
-  catchAsync(
-    async () => {
-      if (!state) {
-        handleError(null, {
-          errorType: "bad-request",
-          message: "Loaded binary state is required",
-          component: "database-extension",
-          operation: "store",
-          extraContext: { pageId },
-          throw: true,
-        });
-      }
-      const { documentType } = context as HocusPocusServerContext;
-      const params = requestParameters;
-      if (!documentType) {
-        handleError(null, {
-          errorType: "bad-request",
-          message: "Document type is required",
-          component: "database-extension",
-          operation: "store",
-          extraContext: { pageId },
-          throw: true,
-        });
-      }
-
-      const documentHandler = getDocumentHandler(documentType, context);
-      await documentHandler.store({
-        context: context as HocusPocusServerContext,
-        pageId,
-        state,
-        params,
-      });
-    },
-    {
-      params: { pageId, documentType: context.documentType },
-      extra: { operation: "store" },
-    }
-  )();
-};

live/src/core/extensions/index.ts

@@ -1,26 +1,142 @@
-// hocuspocus extensions and core
+// Third-party libraries
+import { Redis } from "ioredis";
+// Hocuspocus extensions and core
+import { Database } from "@hocuspocus/extension-database";
 import { Extension } from "@hocuspocus/server";
 import { Logger } from "@hocuspocus/extension-logger";
-import { setupRedisExtension } from "@/core/extensions/redis";
-import { createDatabaseExtension } from "@/core/extensions/database";
-import { logger } from "@plane/logger";
+import { Redis as HocusPocusRedis } from "@hocuspocus/extension-redis";
+// core helpers and utilities
+import { manualLogger } from "@/core/helpers/logger.js";
+import { getRedisUrl } from "@/core/lib/utils/redis-url.js";
+// core libraries
+import {
+  fetchPageDescriptionBinary,
+  updatePageDescription,
+} from "@/core/lib/page.js";
+// plane live libraries
+import { fetchDocument } from "@/plane-live/lib/fetch-document.js";
+import { updateDocument } from "@/plane-live/lib/update-document.js";
+// types
+import {
+  type HocusPocusServerContext,
+  type TDocumentTypes,
+} from "@/core/types/common.js";
 
-export const getExtensions = async (): Promise<Extension[]> => {
+export const getExtensions: () => Promise<Extension[]> = async () => {
   const extensions: Extension[] = [
     new Logger({
       onChange: false,
       log: (message) => {
-        logger.info(message);
+        manualLogger.info(message);
+      },
+    }),
+    new Database({
+      fetch: async ({ context, documentName: pageId, requestParameters }) => {
+        const cookie = (context as HocusPocusServerContext).cookie;
+        // query params
+        const params = requestParameters;
+        const documentType = params.get("documentType")?.toString() as
+          | TDocumentTypes
+          | undefined;
+        // TODO: Fix this lint error.
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve) => {
+          try {
+            let fetchedData = null;
+            if (documentType === "project_page") {
+              fetchedData = await fetchPageDescriptionBinary(
+                params,
+                pageId,
+                cookie,
+              );
+            } else {
+              fetchedData = await fetchDocument({
+                cookie,
+                documentType,
+                pageId,
+                params,
+              });
+            }
+            resolve(fetchedData);
+          } catch (error) {
+            manualLogger.error("Error in fetching document", error);
+          }
+        });
+      },
+      store: async ({
+        context,
+        state,
+        documentName: pageId,
+        requestParameters,
+      }) => {
+        const cookie = (context as HocusPocusServerContext).cookie;
+        // query params
+        const params = requestParameters;
+        const documentType = params.get("documentType")?.toString() as
+          | TDocumentTypes
+          | undefined;
+
+        // TODO: Fix this lint error.
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async () => {
+          try {
+            if (documentType === "project_page") {
+              await updatePageDescription(params, pageId, state, cookie);
+            } else {
+              await updateDocument({
+                cookie,
+                documentType,
+                pageId,
+                params,
+                updatedDescription: state,
+              });
+            }
+          } catch (error) {
+            manualLogger.error("Error in updating document:", error);
+          }
+        });
       },
     }),
-    createDatabaseExtension(),
   ];
 
-  // Add Redis extensions if Redis is available
-  const redisExtension = await setupRedisExtension();
-  if (redisExtension) {
-    logger.info("HocusPocus Redis extension configured ✅");
-    extensions.push(redisExtension);
+  const redisUrl = getRedisUrl();
+
+  if (redisUrl) {
+    try {
+      const redisClient = new Redis(redisUrl);
+
+      await new Promise<void>((resolve, reject) => {
+        redisClient.on("error", (error: any) => {
+          if (
+            error?.code === "ENOTFOUND" ||
+            error.message.includes("WRONGPASS") ||
+            error.message.includes("NOAUTH")
+          ) {
+            redisClient.disconnect();
+          }
+          manualLogger.warn(
+            `Redis Client wasn't able to connect, continuing without Redis (you won't be able to sync data between multiple plane live servers)`,
+            error,
+          );
+          reject(error);
+        });
+
+        redisClient.on("ready", () => {
+          extensions.push(new HocusPocusRedis({ redis: redisClient }));
+          manualLogger.info("Redis Client connected ✅");
+          resolve();
+        });
+      });
+    } catch (error) {
+      manualLogger.warn(
+        `Redis Client wasn't able to connect, continuing without Redis (you won't be able to sync data between multiple plane live servers)`,
+        error,
+      );
+    }
+  } else {
+    manualLogger.warn(
+      "Redis URL is not set, continuing without Redis (you won't be able to sync data between multiple plane live servers)",
+    );
   }
 
   return extensions;

live/src/core/extensions/redis.ts

@@ -1,16 +0,0 @@
-import { Redis as HocusPocusRedis } from "@hocuspocus/extension-redis";
-// core helpers and utilities
-import { logger } from "@plane/logger";
-import { getRedisClient } from "@/core/lib/redis-manager";
-
-/**
- * Sets up the Redis extension for HocusPocus using the RedisManager singleton
- * @returns Promise that resolves to a Redis extension array
- */
-export const setupRedisExtension = () => {
-  // Wait for Redis connection
-  return new HocusPocusRedis({
-    redis: getRedisClient(),
-  });
-};
-

live/src/core/handlers/document-handlers/handler-factory.ts

@@ -1,32 +0,0 @@
-import { DocumentHandler, HandlerContext, HandlerDefinition } from "@/core/types/document-handler";
-
-/**
- * Class that manages handler selection based on multiple criteria
- */
-export class DocumentHandlerFactory {
-  private handlers: HandlerDefinition[] = [];
-  
-  /**
-   * Register a handler with its selection criteria
-   */
-  register(definition: HandlerDefinition): void {
-    this.handlers.push(definition);
-    // Sort handlers by priority (highest first)
-    this.handlers.sort((a, b) => b.priority - a.priority);
-  }
-  
-  /**
-   * Get the appropriate handler based on the provided context
-   */
-  getHandler(context: HandlerContext): DocumentHandler {
-    // Find the first handler whose selector returns true
-    const matchingHandler = this.handlers.find(h => h.selector(context));
-    
-    // Return the matching handler or fall back to null/undefined
-    // (This will cause an error if no handlers match, which is good for debugging)
-    return matchingHandler?.handler as DocumentHandler;
-  }
-}
-
-// Create the singleton instance
-export const handlerFactory = new DocumentHandlerFactory(); 

live/src/core/handlers/document-handlers/index.ts

@@ -1,31 +0,0 @@
-import { DocumentHandler, HandlerContext } from "@/core/types/document-handler";
-import { handlerFactory } from "@/core/handlers/document-handlers/handler-factory";
-
-import { HocusPocusServerContext } from "@/core/types/common";
-import { initializeDocumentHandlers } from "@/plane-live/document-types";
-
-// Initialize all CE document handlers
-initializeDocumentHandlers();
-
-/**
- * Get a document handler based on the provided context criteria
- * @param documentType The primary document type
- * @param additionalContext Optional additional context criteria
- * @returns The appropriate document handler
- */
-export function getDocumentHandler(
-  documentType: string,
-  additionalContext: Omit<HocusPocusServerContext, "documentType">
-): DocumentHandler {
-  // Create a context object with all criteria
-  const context: HandlerContext = {
-    documentType: documentType as any,
-    ...additionalContext,
-  };
-
-  // Use the factory to get the appropriate handler
-  return handlerFactory.getHandler(context);
-}
-
-// Export the factory for direct access if needed
-export { handlerFactory };

live/src/core/helpers/error-handler.ts

@@ -0,0 +1,21 @@
+import { ErrorRequestHandler } from "express";
+import { manualLogger } from "@/core/helpers/logger.js";
+
+export const errorHandler: ErrorRequestHandler = (err, _req, res) => {
+  // Log the error
+  manualLogger.error(err);
+
+  // Set the response status
+  res.status(err.status || 500);
+
+  // Send the response
+  res.json({
+    error: {
+      message:
+        process.env.NODE_ENV === "production"
+          ? "An unexpected error occurred"
+          : err.message,
+      ...(process.env.NODE_ENV !== "production" && { stack: err.stack }),
+    },
+  });
+};

live/src/core/helpers/validation.ts

@@ -1,267 +0,0 @@
-import { handleError } from "../../lib/error-handling/error-factory";
-
-/**
- * A simple validation utility that integrates with our error system.
- *
- * This provides a fluent interface for validating data and throwing
- * appropriate errors if validation fails.
- */
-export class Validator<T> {
-  constructor(
-    private readonly data: T,
-    private readonly name: string = "data"
-  ) {}
-
-  /**
-   * Ensures a value is defined (not undefined or null)
-   */
-  required(message?: string): Validator<T> {
-    if (this.data === undefined || this.data === null) {
-      throw handleError(new ValidationError(this.name, message || `${this.name} is required`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateRequired",
-        extraContext: { field: this.name },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Ensures a value is a string
-   */
-  string(message?: string): Validator<T> {
-    if (typeof this.data !== "string") {
-      throw handleError(new ValidationError(this.name, message || `${this.name} must be a string`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateString",
-        extraContext: { field: this.name },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Ensures a string is not empty
-   */
-  notEmpty(message?: string): Validator<T> {
-    if (typeof this.data === "string" && this.data.trim() === "") {
-      throw handleError(new ValidationError(this.name, message || `${this.name} cannot be empty`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateNonEmptyString",
-        extraContext: { field: this.name },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Ensures a value is a number
-   */
-  number(message?: string): Validator<T> {
-    if (typeof this.data !== "number" || isNaN(this.data)) {
-      throw handleError(new ValidationError(this.name, message || `${this.name} must be a valid number`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateNumber",
-        extraContext: { field: this.name },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Ensures an array is not empty
-   */
-  nonEmptyArray(message?: string): Validator<T> {
-    if (!Array.isArray(this.data) || this.data.length === 0) {
-      throw handleError(new ValidationError(this.name, message || `${this.name} must be a non-empty array`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateArray",
-        extraContext: { field: this.name },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Ensures a value matches a regular expression
-   */
-  match(regex: RegExp, message?: string): Validator<T> {
-    if (typeof this.data !== "string" || !regex.test(this.data)) {
-      throw handleError(new ValidationError(this.name, message || `${this.name} has an invalid format`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateFormat",
-        extraContext: { field: this.name, format: regex.toString() },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Ensures a value is one of the allowed values
-   */
-  oneOf(allowedValues: any[], message?: string): Validator<T> {
-    if (!allowedValues.includes(this.data)) {
-      throw handleError(
-        new ValidationError(this.name, message || `${this.name} must be one of: ${allowedValues.join(", ")}`),
-        {
-          errorType: "bad-request",
-          component: "validation",
-          operation: "validateEnum",
-          extraContext: { field: this.name, allowedValues },
-          throw: true,
-        }
-      );
-    }
-    return this;
-  }
-
-  /**
-   * Custom validation function
-   */
-  custom(validationFn: (value: T) => boolean, message?: string): Validator<T> {
-    if (!validationFn(this.data)) {
-      throw handleError(new ValidationError(this.name, message || `${this.name} is invalid`), {
-        errorType: "bad-request",
-        component: "validation",
-        operation: "validateCustom",
-        extraContext: { field: this.name },
-        throw: true,
-      });
-    }
-    return this;
-  }
-
-  /**
-   * Get the validated data
-   */
-  get(): T {
-    return this.data;
-  }
-}
-
-/**
- * Create a new validator for a value
- */
-export const validate = <T>(data: T, name?: string): Validator<T> => {
-  return new Validator(data, name);
-};
-
-export default validate;
-
-export class ValidationError extends Error {
-  constructor(
-    public name: string,
-    message: string
-  ) {
-    super(message);
-    this.name = name;
-  }
-}
-
-export const validateRequired = (value: any, name: string, message?: string) => {
-  if (value === undefined || value === null) {
-    throw handleError(new ValidationError(name, message || `${name} is required`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateRequired",
-      extraContext: { field: name },
-      throw: true,
-    });
-  }
-};
-
-export const validateString = (value: any, name: string, message?: string) => {
-  if (typeof value !== "string") {
-    throw handleError(new ValidationError(name, message || `${name} must be a string`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateString",
-      extraContext: { field: name },
-      throw: true,
-    });
-  }
-};
-
-export const validateNonEmptyString = (value: string, name: string, message?: string) => {
-  if (!value.trim()) {
-    throw handleError(new ValidationError(name, message || `${name} cannot be empty`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateNonEmptyString",
-      extraContext: { field: name },
-      throw: true,
-    });
-  }
-};
-
-export const validateNumber = (value: any, name: string, message?: string) => {
-  if (typeof value !== "number" || isNaN(value)) {
-    throw handleError(new ValidationError(name, message || `${name} must be a valid number`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateNumber",
-      extraContext: { field: name },
-      throw: true,
-    });
-  }
-};
-
-export const validateArray = (value: any, name: string, message?: string) => {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw handleError(new ValidationError(name, message || `${name} must be a non-empty array`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateArray",
-      extraContext: { field: name },
-      throw: true,
-    });
-  }
-};
-
-export const validateFormat = (value: string, name: string, format: RegExp, message?: string) => {
-  if (!format.test(value)) {
-    throw handleError(new ValidationError(name, message || `${name} has an invalid format`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateFormat",
-      extraContext: { field: name, format: format.toString() },
-      throw: true,
-    });
-  }
-};
-
-export const validateEnum = (value: any, name: string, allowedValues: any[], message?: string) => {
-  if (!allowedValues.includes(value)) {
-    throw handleError(new ValidationError(name, message || `${name} must be one of: ${allowedValues.join(", ")}`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateEnum",
-      extraContext: { field: name, allowedValues },
-      throw: true,
-    });
-  }
-};
-
-export const validateCustom = (value: any, name: string, validator: (value: any) => boolean, message?: string) => {
-  if (!validator(value)) {
-    throw handleError(new ValidationError(name, message || `${name} is invalid`), {
-      errorType: "bad-request",
-      component: "validation",
-      operation: "validateCustom",
-      extraContext: { field: name },
-      throw: true,
-    });
-  }
-};

live/src/core/hocuspocus-server.ts

@@ -0,0 +1,73 @@
+import { Server } from "@hocuspocus/server";
+import { v4 as uuidv4 } from "uuid";
+// lib
+import { handleAuthentication } from "@/core/lib/authentication.js";
+// extensions
+import { getExtensions } from "@/core/extensions/index.js";
+import {
+  DocumentCollaborativeEvents,
+  TDocumentEventsServer,
+} from "@plane/editor/lib";
+// editor types
+import { TUserDetails } from "@plane/editor";
+// types
+import { type HocusPocusServerContext } from "@/core/types/common.js";
+
+export const getHocusPocusServer = async () => {
+  const extensions = await getExtensions();
+  const serverName = process.env.HOSTNAME || uuidv4();
+  return Server.configure({
+    name: serverName,
+    onAuthenticate: async ({
+      requestHeaders,
+      context,
+      // user id used as token for authentication
+      token,
+    }) => {
+      let cookie: string | undefined = undefined;
+      let userId: string | undefined = undefined;
+
+      // Extract cookie (fallback to request headers) and userId from token (for scenarios where
+      // the cookies are not passed in the request headers)
+      try {
+        const parsedToken = JSON.parse(token) as TUserDetails;
+        userId = parsedToken.id;
+        cookie = parsedToken.cookie;
+      } catch (error) {
+        // If token parsing fails, fallback to request headers
+        console.error("Token parsing failed, using request headers:", error);
+      } finally {
+        // If cookie is still not found, fallback to request headers
+        if (!cookie) {
+          cookie = requestHeaders.cookie?.toString();
+        }
+      }
+
+      if (!cookie || !userId) {
+        throw new Error("Credentials not provided");
+      }
+
+      // set cookie in context, so it can be used throughout the ws connection
+      (context as HocusPocusServerContext).cookie = cookie;
+
+      try {
+        await handleAuthentication({
+          cookie,
+          userId,
+        });
+      } catch (error) {
+        throw Error("Authentication unsuccessful!");
+      }
+    },
+    async onStateless({ payload, document }) {
+      // broadcast the client event (derived from the server event) to all the clients so that they can update their state
+      const response =
+        DocumentCollaborativeEvents[payload as TDocumentEventsServer].client;
+      if (response) {
+        document.broadcastStateless(response);
+      }
+    },
+    extensions,
+    debounce: 10000,
+  });
+};

live/src/core/lib/authentication.ts

@@ -1,47 +1,27 @@
 // services
-import { UserService } from "@/services/user.service";
-import { handleError } from "@/lib/error-handling/error-factory";
+import { UserService } from "@/core/services/user.service.js";
+// core helpers
+import { manualLogger } from "@/core/helpers/logger.js";
 
 const userService = new UserService();
 
 type Props = {
   cookie: string;
   userId: string;
-  workspaceSlug: string;
 };
 
 export const handleAuthentication = async (props: Props) => {
-  const { cookie, userId, workspaceSlug } = props;
+  const { cookie, userId } = props;
   // fetch current user info
   let response;
   try {
     response = await userService.currentUser(cookie);
   } catch (error) {
-    console.log("caught?");
-    handleError(error, {
-      errorType: "unauthorized",
-      message: "Failed to authenticate user",
-      component: "authentication",
-      operation: "fetch-current-user",
-      extraContext: {
-        userId,
-        workspaceSlug,
-      },
-      throw: true,
-    });
+    manualLogger.error("Failed to fetch current user:", error);
+    throw error;
   }
   if (response.id !== userId) {
-    handleError(null, {
-      errorType: "unauthorized",
-      message: "Authentication failed: Token doesn't match the current user.",
-      component: "authentication",
-      operation: "validate-user",
-      extraContext: {
-        userId,
-        workspaceSlug,
-      },
-      throw: true,
-    });
+    throw Error("Authentication failed: Token doesn't match the current user.");
   }
 
   return {

live/src/core/lib/page.ts

@@ -1,64 +1,112 @@
 // helpers
-import { getAllDocumentFormatsFromBinaryData, getBinaryDataFromHTMLString } from "@/core/helpers/page";
+import {
+  getAllDocumentFormatsFromBinaryData,
+  getBinaryDataFromHTMLString,
+} from "@/core/helpers/page.js";
 // services
-import { PageService } from "@/services/page.service";
+import { PageService } from "@/core/services/page.service.js";
+import { manualLogger } from "../helpers/logger.js";
 const pageService = new PageService();
 
 export const updatePageDescription = async (
   params: URLSearchParams,
   pageId: string,
   updatedDescription: Uint8Array,
-  cookie: string | undefined
+  cookie: string | undefined,
 ) => {
   if (!(updatedDescription instanceof Uint8Array)) {
-    throw new Error("Invalid updatedDescription: must be an instance of Uint8Array");
+    throw new Error(
+      "Invalid updatedDescription: must be an instance of Uint8Array",
+    );
   }
 
   const workspaceSlug = params.get("workspaceSlug")?.toString();
   const projectId = params.get("projectId")?.toString();
   if (!workspaceSlug || !projectId || !cookie) return;
 
-  const { contentBinaryEncoded, contentHTML, contentJSON } = getAllDocumentFormatsFromBinaryData(updatedDescription);
-  const payload = {
-    description_binary: contentBinaryEncoded,
-    description_html: contentHTML,
-    description: contentJSON,
-  };
+  const { contentBinaryEncoded, contentHTML, contentJSON } =
+    getAllDocumentFormatsFromBinaryData(updatedDescription);
+  try {
+    const payload = {
+      description_binary: contentBinaryEncoded,
+      description_html: contentHTML,
+      description: contentJSON,
+    };
 
-  await pageService.updateDescription(workspaceSlug, projectId, pageId, payload, cookie);
+    await pageService.updateDescription(
+      workspaceSlug,
+      projectId,
+      pageId,
+      payload,
+      cookie,
+    );
+  } catch (error) {
+    manualLogger.error("Update error:", error);
+    throw error;
+  }
 };
 
 const fetchDescriptionHTMLAndTransform = async (
   workspaceSlug: string,
   projectId: string,
   pageId: string,
-  cookie: string
+  cookie: string,
 ) => {
   if (!workspaceSlug || !projectId || !cookie) return;
 
-  const pageDetails = await pageService.fetchDetails(workspaceSlug, projectId, pageId, cookie);
-  const { contentBinary } = getBinaryDataFromHTMLString(pageDetails.description_html ?? "<p></p>");
-  return contentBinary;
+  try {
+    const pageDetails = await pageService.fetchDetails(
+      workspaceSlug,
+      projectId,
+      pageId,
+      cookie,
+    );
+    const { contentBinary } = getBinaryDataFromHTMLString(
+      pageDetails.description_html ?? "<p></p>",
+    );
+    return contentBinary;
+  } catch (error) {
+    manualLogger.error(
+      "Error while transforming from HTML to Uint8Array",
+      error,
+    );
+    throw error;
+  }
 };
 
 export const fetchPageDescriptionBinary = async (
   params: URLSearchParams,
   pageId: string,
-  cookie: string | undefined
+  cookie: string | undefined,
 ) => {
   const workspaceSlug = params.get("workspaceSlug")?.toString();
   const projectId = params.get("projectId")?.toString();
   if (!workspaceSlug || !projectId || !cookie) return null;
 
-  const response = await pageService.fetchDescriptionBinary(workspaceSlug, projectId, pageId, cookie);
-  const binaryData = new Uint8Array(response);
+  try {
+    const response = await pageService.fetchDescriptionBinary(
+      workspaceSlug,
+      projectId,
+      pageId,
+      cookie,
+    );
+    const binaryData = new Uint8Array(response);
 
-  if (binaryData.byteLength === 0) {
-    const binary = await fetchDescriptionHTMLAndTransform(workspaceSlug, projectId, pageId, cookie);
-    if (binary) {
-      return binary;
+    if (binaryData.byteLength === 0) {
+      const binary = await fetchDescriptionHTMLAndTransform(
+        workspaceSlug,
+        projectId,
+        pageId,
+        cookie,
+      );
+      if (binary) {
+        return binary;
+      }
     }
-  }
 
-  return binaryData;
+    return binaryData;
+  } catch (error) {
+    manualLogger.error("Fetch error:", error);
+    throw error;
+  }
 };

live/src/core/lib/redis-manager.ts

@@ -1,62 +0,0 @@
-import { Redis } from "ioredis";
-import { logger } from "@plane/logger";
-
-let redisClient: Redis | null = null;
-
-export async function initializeRedis(): Promise<Redis> {
-  const redisUrl = getRedisUrl();
-
-  if (!redisUrl) {
-    logger.error("Redis URL is not configured. Please set REDIS_URL environment variable.");
-    process.exit(1);
-  }
-
-  try {
-    redisClient = new Redis(redisUrl);
-    
-    redisClient.on("error", (error) => {
-      logger.error("Redis connection error:", error);
-      process.exit(1);
-    });
-
-    // Wait for the connection to be ready
-    await new Promise<void>((resolve, reject) => {
-      redisClient!.on("ready", () => {
-        logger.info("Redis connection established successfully");
-        resolve();
-      });
-
-      redisClient!.on("error", (error) => {
-        reject(error);
-      });
-    });
-
-    return redisClient;
-  } catch (error) {
-    logger.error("Failed to initialize Redis:", error);
-    process.exit(1);
-  }
-}
-
-export function getRedisClient(): Redis {
-  if (!redisClient) {
-    throw new Error("Redis client not initialized. Call initializeRedis() first.");
-  }
-  return redisClient;
-}
-
-function getRedisUrl() {
-  const redisUrl = process.env.REDIS_URL?.trim();
-  const redisHost = process.env.REDIS_HOST?.trim();
-  const redisPort = process.env.REDIS_PORT?.trim();
-
-  if (redisUrl) {
-    return redisUrl;
-  }
-
-  if (redisHost && redisPort && !Number.isNaN(Number(redisPort))) {
-    return `redis://${redisHost}:${redisPort}`;
-  }
-
-  return "";
-}

live/src/core/lib/utils/redis-url.ts

@@ -0,0 +1,15 @@
+export function getRedisUrl() {
+  const redisUrl = process.env.REDIS_URL?.trim();
+  const redisHost = process.env.REDIS_HOST?.trim();
+  const redisPort = process.env.REDIS_PORT?.trim();
+
+  if (redisUrl) {
+    return redisUrl;
+  }
+
+  if (redisHost && redisPort && !Number.isNaN(Number(redisPort))) {
+    return `redis://${redisHost}:${redisPort}`;
+  }
+
+  return "";
+}

live/src/core/services/page.service.ts

@@ -0,0 +1,78 @@
+// types
+import { TPage } from "@plane/types";
+// services
+import { API_BASE_URL, APIService } from "@/core/services/api.service.js";
+
+export class PageService extends APIService {
+  constructor() {
+    super(API_BASE_URL);
+  }
+
+  async fetchDetails(
+    workspaceSlug: string,
+    projectId: string,
+    pageId: string,
+    cookie: string
+  ): Promise<TPage> {
+    return this.get(
+      `/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/`,
+      {
+        headers: {
+          Cookie: cookie,
+        },
+      }
+    )
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+
+  async fetchDescriptionBinary(
+    workspaceSlug: string,
+    projectId: string,
+    pageId: string,
+    cookie: string
+  ): Promise<any> {
+    return this.get(
+      `/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/description/`,
+      {
+        headers: {
+          "Content-Type": "application/octet-stream",
+          Cookie: cookie,
+        },
+        responseType: "arraybuffer",
+      }
+    )
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+
+  async updateDescription(
+    workspaceSlug: string,
+    projectId: string,
+    pageId: string,
+    data: {
+      description_binary: string;
+      description_html: string;
+      description: object;
+    },
+    cookie: string
+  ): Promise<any> {
+    return this.patch(
+      `/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/description/`,
+      data,
+      {
+        headers: {
+          Cookie: cookie,
+        },
+      }
+    )
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error;
+      });
+  }
+}

live/src/core/services/user.service.ts

@@ -1,7 +1,7 @@
 // types
 import type { IUser } from "@plane/types";
 // services
-import { API_BASE_URL, APIService } from "@/services/api.service";
+import { API_BASE_URL, APIService } from "@/core/services/api.service.js";
 
 export class UserService extends APIService {
   constructor() {

live/src/core/types/common.d.ts

@@ -1,15 +1,10 @@
 // types
-import { TAdditionalDocumentTypes } from "@/plane-live/types/common";
+import { TAdditionalDocumentTypes } from "@/plane-live/types/common.js";
 
 export type TDocumentTypes = "project_page" | TAdditionalDocumentTypes;
 
 export type HocusPocusServerContext = {
   cookie: string;
-  projectId: string;
-  workspaceSlug: string;
-  documentType: TDocumentTypes;
-  userId: string;
-  agentId: string;
 };
 
 export type TConvertDocumentRequestBody = {

live/src/core/types/document-handler.d.ts

@@ -1,62 +0,0 @@
-import { HocusPocusServerContext, TDocumentTypes } from "@/core/types/common";
-
-/**
- * Parameters for document fetch operations
- */
-export interface DocumentFetchParams {
-  context: HocusPocusServerContext;
-  pageId: string;
-  params: URLSearchParams;
-}
-
-/**
- * Parameters for document store operations
- */
-export interface DocumentStoreParams {
-  context: HocusPocusServerContext;
-  pageId: string;
-  state: any;
-  params: URLSearchParams;
-}
-
-/**
- * Interface defining a document handler
- */
-export interface DocumentHandler {
-  /**
-   * Fetch a document
-   */
-  fetch: (params: DocumentFetchParams) => Promise<any>;
-  
-  /**
-   * Store a document
-   */
-  store: (params: DocumentStoreParams) => Promise<void>;
-}
-
-/**
- * Handler context interface - extend this to add new criteria for handler selection
- */
-export interface HandlerContext {
-  documentType?: TDocumentTypes;
-  agentId?: string;
-}
-
-/**
- * Handler selector function type - determines if a handler should be used based on context
- */
-export type HandlerSelector = (context: HandlerContext) => boolean;
-
-/**
- * Handler definition combining a selector and implementation
- */
-export interface HandlerDefinition {
-  selector: HandlerSelector;
-  handler: DocumentHandler;
-  priority: number; // Higher number means higher priority
-}
-
-/**
- * Type for a handler registration function
- */
-export type RegisterHandler = (definition: HandlerDefinition) => void; 

live/src/ee/document-types/index.ts

@@ -1 +0,0 @@
-export * from "./register";

live/src/ee/document-types/register.ts

@@ -1,5 +0,0 @@
-import { registerProjectPageHandler } from "@/ce/document-types/project-page";
-
-export function initializeDocumentHandlers() {
-  registerProjectPageHandler();
-}

live/src/ee/lib/authentication.ts

@@ -1,2 +1 @@
-export * from "../../core/lib/authentication";
-
+export * from "../../ce/lib/authentication.js"

live/src/ee/lib/fetch-document.ts

@@ -1,2 +1 @@
-export * from "../../ce/lib/fetch-document";
-
+export * from "../../ce/lib/fetch-document.js"

live/src/ee/lib/update-document.ts

@@ -1,2 +1 @@
-export * from "../../ce/lib/update-document";
-
+export * from "../../ce/lib/update-document.js"

live/src/ee/types/common.d.ts

@@ -1 +1 @@
-export * from "../../ce/types/common"
+export * from "../../ce/types/common.js"

live/src/env.ts

@@ -1,42 +0,0 @@
-import * as dotenv from "dotenv";
-import { z } from "zod";
-
-// Load environment variables from .env file
-dotenv.config();
-
-// Define environment schema with validation
-const envSchema = z.object({
-  // Server configuration
-  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
-  PORT: z.string().default("3000").transform(Number),
-  LIVE_BASE_PATH: z.string().default("/live"),
-
-  // CORS configuration
-  CORS_ALLOWED_ORIGINS: z.string().default("*"),
-  // Compression options
-  COMPRESSION_LEVEL: z.string().default("6").transform(Number),
-  COMPRESSION_THRESHOLD: z.string().default("5000").transform(Number),
-
-  // Hocuspocus server configuration
-  HOCUSPOCUS_URL: z.string().optional(),
-  HOCUSPOCUS_USERNAME: z.string().optional(),
-  HOCUSPOCUS_PASSWORD: z.string().optional(),
-
-  // Graceful termination timeout
-  SHUTDOWN_TIMEOUT: z.string().default("10000").transform(Number),
-});
-
-// Validate the environment variables
-function validateEnv() {
-  const result = envSchema.safeParse(process.env);
-
-  if (!result.success) {
-    console.error("❌ Invalid environment variables:", JSON.stringify(result.error.format(), null, 4));
-    process.exit(1);
-  }
-
-  return result.data;
-}
-
-// Export the validated environment
-export const env = validateEnv();

live/src/hocuspocus.ts

@@ -1,145 +0,0 @@
-import { DocumentCollaborativeEvents, TDocumentEventsServer } from "@plane/editor/lib";
-
-import { Logger } from "@hocuspocus/extension-logger";
-import { Database } from "@hocuspocus/extension-database";
-import { Redis } from "@hocuspocus/extension-redis";
-import { Hocuspocus } from "@hocuspocus/server";
-
-import { v4 as uuidv4 } from "uuid";
-import { getRedisClient } from "./redis";
-import { UserService } from "./services/user.service";
-
-// import { handleError } from "@/core/helpers/error-handling/error-factory";
-// import { TDocumentTypes } from "@/core/types/common";
-// import { handleAuthentication } from "@/core/lib/authentication";
-// import { IncomingHttpHeaders } from "http";
-
-export const createHocusPocus = () => {
-  const serverName = process.env.HOSTNAME || uuidv4();
-  return new Hocuspocus({
-    name: serverName,
-    onAuthenticate: onAuthenticate(),
-    onStateless: onStateless(),
-    extensions: [
-      new Logger(),
-      new Database({
-        fetch: handleDataFetch,
-        store: handleDataStore,
-      }),
-      new Redis({ redis: getRedisClient() }),
-    ],
-    debounce: 1000,
-  });
-};
-
-const validateToken = async (token: string | undefined) => {
-  try {
-    if (!token) {
-      throw new Error("Token not provided");
-    }
-    const userService = new UserService();
-    const response = await userService.currentUser(token);
-    return response;
-  } catch (error) {
-    return null;
-  }
-};
-
-const onAuthenticate = () => {
-  return async ({ token }: { token: string | undefined }) => {
-    const user = await validateToken(token);
-    if (!user) {
-      throw new Error("Invalid token");
-    }
-    return user;
-  };
-};
-
-const onStateless = () => {
-  return async ({ payload, document }: any) => {
-    // broadcast the client event (derived from the server event) to all the clients so that they can update their state
-    const response = DocumentCollaborativeEvents[payload as TDocumentEventsServer].client;
-    if (response) {
-      document.broadcastStateless(response);
-    }
-  };
-};
-
-const handleDataFetch = async (data: any) => {
-  try {
-    const { context, documentName, requestParameters } = data;
-    console.log("handleDataFetch", context);
-    console.log("handleDataFetch", documentName);
-    console.log("handleDataFetch", requestParameters);
-    return documentName; // TODO: remove this once the API integration is done
-    // fetch the data using page service
-    // const pageService = new PageService();
-    // const page = await pageService.getPage(documentName);
-    // return page;
-  } catch (error) {
-    console.error("handleDataFetch", error);
-    throw error;
-  }
-};
-
-const handleDataStore = async (data: any) => {
-  try {
-    const { context, documentName, requestParameters } = data;
-    console.log("handleDataStore", context);
-    console.log("handleDataStore", documentName);
-    console.log("handleDataStore", requestParameters);
-    return documentName; // TODO: remove this once the API integration is done
-    // store the data using page service
-    // const pageService = new PageService();
-    // const page = await pageService.updatePage(documentName, requestParameters);
-    // return page;
-  } catch (error) {
-    console.error("handleDataStore", error);
-    throw error;
-  }
-};
-
-// async ({
-//   token,
-//   requestParameters,
-//   requestHeaders,
-// }: {
-//   token: string;
-//   requestParameters: URLSearchParams;
-//   requestHeaders: IncomingHttpHeaders;
-// }) => {
-//   let cookie: string | undefined = undefined;
-//   let userId: string | undefined = undefined;
-
-//   try {
-//     const parsedToken = JSON.parse(token) as { id: string; cookie: string };
-//     userId = parsedToken.id;
-//     cookie = parsedToken.cookie;
-//   } catch (error) {
-//     console.error("Token parsing failed, using request headers:", error);
-//   } finally {
-//     if (!cookie) {
-//       cookie = requestHeaders.cookie?.toString();
-//     }
-//   }
-
-//   if (!cookie || !userId) {
-//     handleError(null, {
-//       errorType: "unauthorized",
-//       message: "Credentials not provided",
-//       component: "hocuspocus",
-//       operation: "authenticate",
-//       extraContext: { tokenProvided: !!token },
-//       throw: true,
-//     });
-//   }
-
-//   const documentType = requestParameters.get("documentType")?.toString() as TDocumentTypes;
-//   const workspaceSlug = requestParameters.get("workspaceSlug")?.toString() as string;
-
-//   return await handleAuthentication({
-//     cookie,
-//     userId,
-//     workspaceSlug,
-//   });
-// }

live/src/lib/error-handling/error-factory.ts

@@ -1,278 +0,0 @@
-import { AppError, HttpStatusCode, ErrorCategory } from "./error-handler";
-
-/**
- * Map of error types to their corresponding factory functions
- * This ensures that error types and their implementations stay in sync
- */
-interface ErrorFactory {
-  statusCode: number;
-  category: ErrorCategory;
-  defaultMessage: string;
-  createError: (message?: string, context?: Record<string, any>) => AppError;
-}
-
-const ERROR_FACTORIES = {
-  "bad-request": {
-    statusCode: HttpStatusCode.BAD_REQUEST,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Bad Request",
-    createError: (message = "Bad Request", context?) =>
-      new AppError(message, HttpStatusCode.BAD_REQUEST, ErrorCategory.OPERATIONAL, context),
-  },
-  unauthorized: {
-    statusCode: HttpStatusCode.UNAUTHORIZED,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Unauthorized",
-    createError: (message = "Unauthorized", context?) =>
-      new AppError(message, HttpStatusCode.UNAUTHORIZED, ErrorCategory.OPERATIONAL, context),
-  },
-  forbidden: {
-    statusCode: HttpStatusCode.FORBIDDEN,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Forbidden",
-    createError: (message = "Forbidden", context?) =>
-      new AppError(message, HttpStatusCode.FORBIDDEN, ErrorCategory.OPERATIONAL, context),
-  },
-  "not-found": {
-    statusCode: HttpStatusCode.NOT_FOUND,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Resource not found",
-    createError: (message = "Resource not found", context?) =>
-      new AppError(message, HttpStatusCode.NOT_FOUND, ErrorCategory.OPERATIONAL, context),
-  },
-  conflict: {
-    statusCode: HttpStatusCode.CONFLICT,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Resource conflict",
-    createError: (message = "Resource conflict", context?) =>
-      new AppError(message, HttpStatusCode.CONFLICT, ErrorCategory.OPERATIONAL, context),
-  },
-  "unprocessable-entity": {
-    statusCode: HttpStatusCode.UNPROCESSABLE_ENTITY,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Unprocessable Entity",
-    createError: (message = "Unprocessable Entity", context?) =>
-      new AppError(message, HttpStatusCode.UNPROCESSABLE_ENTITY, ErrorCategory.OPERATIONAL, context),
-  },
-  "too-many-requests": {
-    statusCode: HttpStatusCode.TOO_MANY_REQUESTS,
-    category: ErrorCategory.OPERATIONAL,
-    defaultMessage: "Too many requests",
-    createError: (message = "Too many requests", context?) =>
-      new AppError(message, HttpStatusCode.TOO_MANY_REQUESTS, ErrorCategory.OPERATIONAL, context),
-  },
-  internal: {
-    statusCode: HttpStatusCode.INTERNAL_SERVER,
-    category: ErrorCategory.PROGRAMMING,
-    defaultMessage: "Internal Server Error",
-    createError: (message = "Internal Server Error", context?) =>
-      new AppError(message, HttpStatusCode.INTERNAL_SERVER, ErrorCategory.PROGRAMMING, context),
-  },
-  "service-unavailable": {
-    statusCode: HttpStatusCode.SERVICE_UNAVAILABLE,
-    category: ErrorCategory.SYSTEM,
-    defaultMessage: "Service Unavailable",
-    createError: (message = "Service Unavailable", context?) =>
-      new AppError(message, HttpStatusCode.SERVICE_UNAVAILABLE, ErrorCategory.SYSTEM, context),
-  },
-  fatal: {
-    statusCode: HttpStatusCode.INTERNAL_SERVER,
-    category: ErrorCategory.FATAL,
-    defaultMessage: "Fatal Error",
-    createError: (message = "Fatal Error", context?) =>
-      new AppError(message, HttpStatusCode.INTERNAL_SERVER, ErrorCategory.FATAL, context),
-  },
-} satisfies Record<string, ErrorFactory>;
-
-// Create the type from the keys of the error factories map
-export type ErrorType = keyof typeof ERROR_FACTORIES;
-
-// -------------------------------------------------------------------------
-// Primary public API - Recommended for most use cases
-// -------------------------------------------------------------------------
-
-/**
- * Base options for handleError function
- */
-type BaseErrorHandlerOptions = {
-  // Error classification options
-  errorType?: ErrorType;
-  message?: string;
-
-  // Context information
-  component: string;
-  operation: string;
-  extraContext?: Record<string, any>;
-
-  // Behavior options
-  rethrowIfAppError?: boolean;
-};
-
-/**
- * Options for throwing variant of handleError - discriminated by throw: true
- */
-export type ThrowingOptions = BaseErrorHandlerOptions & {
-  throw: true;
-};
-
-/**
- * Options for non-throwing variant of handleError - default behavior
- */
-export type NonThrowingOptions = BaseErrorHandlerOptions;
-
-/**
- * Unified error handler that encapsulates common error handling patterns
- *
- * @param error The error to handle
- * @param options Configuration options with throw: true to throw the error instead of returning it
- * @returns Never returns - always throws
- * @example
- * // Throwing version
- * handleError(error, {
- *   errorType: 'not-found',
- *   component: 'user-service',
- *   operation: 'getUserById',
- *   throw: true
- * });
- */
-export function handleError(error: unknown, options: ThrowingOptions): never;
-
-/**
- * Unified error handler that encapsulates common error handling patterns
- *
- * @param error The error to handle
- * @param options Configuration options (non-throwing by default)
- * @returns The AppError instance
- * @example
- * // Non-throwing version (default)
- * const appError = handleError(error, {
- *   errorType: 'not-found',
- *   component: 'user-service',
- *   operation: 'getUserById'
- * });
- * return { error: appError.output() };
- */
-// eslint-disable-next-line no-redeclare
-export function handleError(error: unknown, options: NonThrowingOptions): AppError;
-
-/**
- * Implementation of handleError that handles both throwing and non-throwing cases
- */
-// eslint-disable-next-line no-redeclare
-export function handleError(error: unknown, options: ThrowingOptions | NonThrowingOptions): AppError | never {
-  // Only throw if throw is explicitly true
-  const shouldThrow = (options as ThrowingOptions).throw === true;
-
-  // If the error is already an AppError and we want to rethrow it as is
-  if (options.rethrowIfAppError !== false && error instanceof AppError) {
-    if (shouldThrow) {
-      throw error;
-    }
-    return error;
-  }
-
-  // Format the error message
-  const errorMessage = options.message
-    ? error instanceof Error
-      ? `${options.message}: ${error.message}`
-      : error
-        ? `${options.message}: ${String(error)}`
-        : options.message
-    : error instanceof Error
-      ? error.message
-      : error
-        ? String(error)
-        : "Unknown error occurred";
-
-  // Build context object
-  const context = {
-    component: options.component,
-    operation: options.operation,
-    originalError: error,
-    ...(options.extraContext || {}),
-  };
-
-  // Create the appropriate error type using our factory map
-  const errorType = options.errorType || "internal";
-  const factory = ERROR_FACTORIES[errorType];
-
-  if (!factory) {
-    // If no factory found, default to internal error
-    return ERROR_FACTORIES.internal.createError(errorMessage, context);
-  }
-
-  // Create the error with the factory
-  const appError = factory.createError(errorMessage, context);
-
-  // If we should throw, do so now
-  if (shouldThrow) {
-    throw appError;
-  }
-
-  return appError;
-}
-
-/**
- * Utility function to convert errors or enhance existing AppErrors
- */
-export const convertError = (
-  error: Error,
-  options?: {
-    statusCode?: number;
-    message?: string;
-    category?: ErrorCategory;
-    context?: Record<string, any>;
-  }
-): AppError => {
-  if (error instanceof AppError) {
-    // If it's already an AppError and no overrides, return as is
-    if (!options?.statusCode && !options?.message && !options?.category) {
-      return error;
-    }
-
-    // Create a new AppError with the original as context
-    return new AppError(
-      options?.message || error.message,
-      options?.statusCode || error.status,
-      options?.category || error.category,
-      {
-        ...(error.context || {}),
-        ...(options?.context || {}),
-        originalError: error,
-      }
-    );
-  }
-
-  // Determine the appropriate error type based on status code
-  let errorType: ErrorType = "internal";
-  if (options?.statusCode) {
-    // Find the error type that matches the status code
-    const entry = Object.entries(ERROR_FACTORIES).find(([_, factory]) => factory.statusCode === options.statusCode);
-    if (entry) {
-      errorType = entry[0] as ErrorType;
-    }
-  }
-
-  // Return a new AppError using the factory
-  return handleError(error, {
-    errorType: errorType,
-    message: options?.message,
-    component: options?.context?.component || "unknown",
-    operation: options?.context?.operation || "convert-error",
-    extraContext: options?.context,
-  });
-};
-
-/**
- * Check if an error is an AppError
- */
-export const isAppError = (err: any, statusCode?: number): boolean => {
-  return err instanceof AppError && (!statusCode || err.status === statusCode);
-};
-
-// Export only the public API
-export default {
-  handleError,
-  convertError,
-  isAppError,
-};

live/src/lib/error-handling/error-handler.ts

@@ -1,384 +0,0 @@
-import { ErrorRequestHandler, Request, Response, NextFunction } from "express";
-
-import { env } from "@/env";
-import { logger } from "@plane/logger";
-import { handleError } from "./error-factory";
-import { ErrorContext, reportError } from "./error-reporting";
-import { manualLogger } from "../../core/helpers/logger";
-
-/**
- * HTTP Status Codes
- */
-export enum HttpStatusCode {
-  // 2xx Success
-  OK = 200,
-  CREATED = 201,
-  ACCEPTED = 202,
-  NO_CONTENT = 204,
-
-  // 4xx Client Errors
-  BAD_REQUEST = 400,
-  UNAUTHORIZED = 401,
-  FORBIDDEN = 403,
-  NOT_FOUND = 404,
-  METHOD_NOT_ALLOWED = 405,
-  CONFLICT = 409,
-  GONE = 410,
-  UNPROCESSABLE_ENTITY = 422,
-  TOO_MANY_REQUESTS = 429,
-
-  // 5xx Server Errors
-  INTERNAL_SERVER = 500,
-  NOT_IMPLEMENTED = 501,
-  BAD_GATEWAY = 502,
-  SERVICE_UNAVAILABLE = 503,
-  GATEWAY_TIMEOUT = 504,
-}
-
-/**
- * Error categories to classify errors
- */
-export enum ErrorCategory {
-  OPERATIONAL = "operational", // Expected errors that are part of normal operation (e.g. validation failures)
-  PROGRAMMING = "programming", // Unexpected errors that indicate bugs (e.g. null references)
-  SYSTEM = "system", // System errors (e.g. out of memory, connection failures)
-  FATAL = "fatal", // Severe errors that should crash the app (e.g. unrecoverable state)
-}
-
-/**
- * Base Application Error Class
- * All custom errors extend this class
- */
-export class AppError extends Error {
-  readonly status: number;
-  readonly category: ErrorCategory;
-  readonly context?: Record<string, any>;
-  readonly isOperational: boolean; // Kept for backward compatibility
-
-  constructor(
-    message: string,
-    status: number = HttpStatusCode.INTERNAL_SERVER,
-    category: ErrorCategory = ErrorCategory.PROGRAMMING,
-    context?: Record<string, any>
-  ) {
-    super(message);
-
-    // Set error properties
-    this.name = this.constructor.name;
-    this.status = status;
-    this.category = category;
-    this.isOperational = category === ErrorCategory.OPERATIONAL;
-    this.context = context;
-
-    // Capture stack trace, excluding the constructor call from the stack
-    Error.captureStackTrace(this, this.constructor);
-
-    // Automatically report the error (unless it's being constructed by the error utilities)
-    if (!context?.skipReporting) {
-      this.report();
-    }
-  }
-
-  /**
-   * Creates a formatted representation of the error
-   */
-  output() {
-    return {
-      statusCode: this.status,
-      payload: {
-        statusCode: this.status,
-        error: this.getErrorName(),
-        message: this.message,
-        category: this.category,
-      },
-      headers: {},
-    };
-  }
-
-  /**
-   * Gets a descriptive name for the error based on status code
-   */
-  private getErrorName(): string {
-    const statusCodes: Record<number, string> = {
-      400: "Bad Request",
-      401: "Unauthorized",
-      403: "Forbidden",
-      404: "Not Found",
-      405: "Method Not Allowed",
-      409: "Conflict",
-      410: "Gone",
-      422: "Unprocessable Entity",
-      429: "Too Many Requests",
-      500: "Internal Server Error",
-      501: "Not Implemented",
-      502: "Bad Gateway",
-      503: "Service Unavailable",
-      504: "Gateway Timeout",
-    };
-
-    return statusCodes[this.status] || "Unknown Error";
-  }
-
-  /**
-   * Reports the error to logging and monitoring systems
-   */
-  private report(): void {
-    // Different logging based on error category
-    if (this.category === ErrorCategory.OPERATIONAL) {
-      manualLogger.error(`Operational error: ${this.message}`, {
-        errorName: this.name,
-        errorStatus: this.status,
-        errorCategory: this.category,
-        context: this.context,
-      });
-    } else if (this.category === ErrorCategory.FATAL) {
-      manualLogger.error(`FATAL error: ${this.message}`, {
-        errorName: this.name,
-        errorStatus: this.status,
-        errorCategory: this.category,
-        stack: this.stack,
-        context: this.context,
-      });
-    } else {
-      manualLogger.error(`${this.category} error: ${this.message}`, {
-        errorName: this.name,
-        errorStatus: this.status,
-        errorCategory: this.category,
-        stack: this.stack,
-        context: this.context,
-      });
-    }
-  }
-}
-
-export class FatalError extends AppError {
-  constructor(message: string, context?: Record<string, any>) {
-    super(message, HttpStatusCode.INTERNAL_SERVER, ErrorCategory.FATAL, context);
-  }
-}
-
-/**
- * Main Express error handler middleware
- */
-export const errorHandler: ErrorRequestHandler = (err, req, res, next) => {
-  // Already sent response, let default Express error handler deal with it
-  if (res.headersSent) {
-    return next(err);
-  }
-
-  // Convert to AppError if it's not already one
-  const error = handleError(err, {
-    component: "express",
-    operation: "error-handler",
-    extraContext: {
-      originalError: err,
-      url: req.originalUrl,
-      method: req.method,
-    },
-  });
-
-  // Normalize status code
-  const statusCode = error.status;
-
-  // Set the response status
-  res.status(statusCode);
-
-  // Set any custom headers if provided in the error object
-  if (err.headers && typeof err.headers === "object") {
-    Object.entries(err.headers).forEach(([key, value]) => {
-      res.set(key, value as string);
-    });
-  }
-
-  // Prepare error response
-  const errorResponse: {
-    error: {
-      message: string;
-      status: number;
-      stack?: string;
-    };
-  } = {
-    error: {
-      message:
-        error.category === ErrorCategory.OPERATIONAL || env.NODE_ENV !== "production"
-          ? error.message
-          : "An unexpected error occurred",
-      status: statusCode,
-    },
-  };
-
-  // Add stack trace in non-production environments
-  if (env.NODE_ENV !== "production") {
-    errorResponse.error.stack = error.stack;
-  }
-
-  // Send the response
-  res.json(errorResponse);
-
-  // For fatal errors, log but NEVER terminate the app
-  if (error.category === ErrorCategory.FATAL) {
-    logger.error(`FATAL ERROR OCCURRED BUT APP WILL CONTINUE RUNNING: ${error.message}`);
-  }
-};
-
-export const asyncHandler = (fn: Function) => {
-  return (req: any, res: any, next: any) => {
-    Promise.resolve(fn(req, res, next)).catch((error) => {
-      // Convert to AppError if needed and pass to Express error middleware
-      const appError = handleError(error, {
-        errorType: "internal",
-        component: "express",
-        operation: "route-handler",
-        extraContext: {
-          url: req.originalUrl,
-          method: req.method,
-          body: req.body,
-          query: req.query,
-          params: req.params,
-        },
-      });
-
-      next(appError);
-    });
-  };
-};
-
-export interface CatchAsyncOptions<T, E = Error> {
-  /** Default value to return in case of error, null by default */
-  defaultValue?: T | null;
-
-  /** Whether to report non-AppErrors automatically */
-  reportErrors?: boolean;
-
-  /** Whether to rethrow the error after handling it */
-  rethrow?: boolean;
-
-  /** Custom error transformer function */
-  transformError?: (error: unknown) => E;
-
-  /** Custom error handler function that runs before standard handling */
-  onError?: (error: unknown) => void | Promise<void>;
-
-  /** Custom handler for specific error types */
-  errorHandlers?: {
-    [key: string]: (error: any) => T | null | Promise<T>;
-  };
-}
-
-export const catchAsync = <T, E = Error>(
-  fn: () => Promise<T>,
-  context?: ErrorContext,
-  options: CatchAsyncOptions<T, E> = {}
-): (() => Promise<T | null>) => {
-  const { defaultValue = null, onError, rethrow = false } = options;
-
-  return async () => {
-    try {
-      return await fn();
-    } catch (error) {
-      // Apply custom error handler if provided
-      if (onError) {
-        await Promise.resolve(onError(error));
-      }
-
-      reportError(error, context);
-      if (error instanceof AppError) {
-        error.context;
-      }
-
-      if (rethrow) {
-        // Use handleError to ensure consistent error handling when rethrowing
-        handleError(error, {
-          component: context?.extra?.component || "unknown",
-          operation: context?.extra?.operation || "unknown",
-          extraContext: {
-            ...context,
-            ...(error instanceof AppError ? error.context : {}),
-            originalError: error,
-          },
-          throw: true,
-        });
-      }
-
-      return defaultValue;
-    }
-  };
-};
-
-/**
- * Set up global error handlers for uncaught exceptions and unhandled rejections
- * @param gracefulTerminationHandler Function to call for graceful termination
- */
-export const setupGlobalErrorHandlers = (gracefulTerminationHandler: () => Promise<void>): void => {
-  // Handle promise rejections
-  process.on("unhandledRejection", (reason: unknown) => {
-    logger.error("Unhandled Promise Rejection", { reason });
-
-    // Convert to AppError and handle
-    const appError = handleError(reason, {
-      errorType: "internal",
-      message: reason instanceof Error ? reason.message : String(reason),
-      component: "process",
-      operation: "unhandledRejection",
-      extraContext: { source: "unhandledRejection" },
-    });
-
-    // Log the error but never terminate
-    logger.error(`Unhandled rejection caught and contained: ${appError.message}`);
-  });
-
-  // Handle exceptions
-  process.on("uncaughtException", (error: Error) => {
-    logger.error("Uncaught Exception", {
-      error: error.message,
-      stack: error.stack,
-    });
-
-    // Convert to AppError if needed
-    const appError = handleError(error, {
-      errorType: "internal",
-      component: "process",
-      operation: "uncaughtException",
-      extraContext: {
-        source: "uncaughtException",
-      },
-    });
-
-    // Log the error but never terminate
-    logger.warn(`Uncaught exception contained: ${appError.message}`);
-  });
-
-  // Handle termination signals
-  process.on("SIGTERM", () => {
-    logger.info("SIGTERM received. Starting graceful termination...");
-    gracefulTerminationHandler();
-  });
-
-  process.on("SIGINT", () => {
-    logger.info("SIGINT received. Starting graceful termination...");
-    gracefulTerminationHandler();
-  });
-};
-
-/**
- * Configure error handling middleware for the Express app
- * @param app Express application instance
- */
-export function configureErrorHandlers(app: any): void {
-  // Global error handling middleware
-  app.use(errorHandler);
-
-  // 404 handler must be last
-  app.use((_req: Request, _res: Response, next: NextFunction) => {
-    next(
-      handleError(null, {
-        errorType: "not-found",
-        message: "Resource not found",
-        component: "express",
-        operation: "route-handler",
-        extraContext: { path: _req.path },
-        throw: true,
-      })
-    );
-  });
-}

live/src/lib/error-handling/error-reporting.ts

@@ -1,45 +0,0 @@
-import { AppError, ErrorCategory } from "./error-handler";
-import { logger } from "@plane/logger";
-import { handleError } from "./error-factory";
-
-export interface ErrorContext {
-  url?: string;
-  method?: string;
-  body?: any;
-  query?: any;
-  params?: any;
-  extra?: Record<string, any>;
-}
-
-/**
- * Utility function to report errors that aren't instances of AppError
- * AppError instances automatically report themselves on creation
- * Only use this for external errors that don't use our error system
- */
-export const reportError = (error: Error | unknown, context?: ErrorContext): void => {
-  if (error instanceof AppError) {
-    // if it's an app error, don't report it as it's already been reported
-    return;
-  }
-
-  logger.error(`External error: ${error instanceof Error ? error.stack || error.message : String(error)}`, {
-    error,
-    context,
-  });
-};
-
-export const handleFatalError = (error: Error | unknown, context?: ErrorContext): void => {
-  // Convert to fatal AppError
-  const fatalError = handleError(error, {
-    errorType: "fatal",
-    message: error instanceof Error ? error.message : String(error),
-    component: context?.extra?.component || "system",
-    operation: context?.extra?.operation || "fatal-error-handler",
-    extraContext: {
-      ...context,
-      originalError: error,
-    },
-  });
-
-  process.emit("uncaughtException", fatalError);
-};

live/src/redis.ts

@@ -1,62 +0,0 @@
-import { Redis } from "ioredis";
-import { logger } from "@plane/logger";
-
-let redisClient: Redis | null = null;
-
-export async function initializeRedis(): Promise<Redis> {
-  const redisUrl = getRedisUrl();
-
-  if (!redisUrl) {
-    logger.error("Redis URL is not configured. Please set REDIS_URL environment variable.");
-    process.exit(1);
-  }
-
-  try {
-    redisClient = new Redis(redisUrl);
-
-    redisClient.on("error", (error) => {
-      logger.error("Redis connection error:", error);
-      process.exit(1);
-    });
-
-    // Wait for the connection to be ready
-    await new Promise<void>((resolve, reject) => {
-      redisClient!.on("ready", () => {
-        logger.info("Redis connection established successfully");
-        resolve();
-      });
-
-      redisClient!.on("error", (error) => {
-        reject(error);
-      });
-    });
-
-    return redisClient;
-  } catch (error) {
-    logger.error("Failed to initialize Redis:", error);
-    process.exit(1);
-  }
-}
-
-export function getRedisClient(): Redis {
-  if (!redisClient) {
-    throw new Error("Redis client not initialized. Call initializeRedis() first.");
-  }
-  return redisClient;
-}
-
-function getRedisUrl() {
-  const redisUrl = process.env.REDIS_URL?.trim();
-  const redisHost = process.env.REDIS_HOST?.trim();
-  const redisPort = process.env.REDIS_PORT?.trim();
-
-  if (redisUrl) {
-    return redisUrl;
-  }
-
-  if (redisHost && redisPort && !Number.isNaN(Number(redisPort))) {
-    return `redis://${redisHost}:${redisPort}`;
-  }
-
-  return "";
-}

live/src/server.ts

@@ -1,119 +1,135 @@
-import cookieParser from "cookie-parser";
+import compression from "compression";
 import cors from "cors";
-import express, { Application } from "express";
 import expressWs from "express-ws";
+import express from "express";
 import helmet from "helmet";
-import path from "path";
-import { Hocuspocus } from "@hocuspocus/server";
-// controllers
+// hocuspocus server
+import { getHocusPocusServer } from "@/core/hocuspocus-server.js";
+// helpers
+import { convertHTMLDocumentToAllFormats } from "@/core/helpers/convert-document.js";
+import { logger, manualLogger } from "@/core/helpers/logger.js";
+import { errorHandler } from "@/core/helpers/error-handler.js";
+// types
+import { TConvertDocumentRequestBody } from "@/core/types/common.js";
 
-import { initializeRedis } from "./core/lib/redis-manager";
-import { logger } from "@plane/logger";
-import { createHocusPocus } from "./hocuspocus";
+const app: any = express();
+expressWs(app);
 
-import { registerWebSocketController, registerController } from "@plane/decorators";
-import { REST_CONTROLLERS, WEBSOCKET_CONTROLLERS } from "./controllers";
+app.set("port", process.env.PORT || 3000);
 
-export default class Server {
-  app: Application;
-  PORT: number;
-  BASE_PATH: string;
-  CORS_ALLOWED_ORIGINS: string;
-  hocuspocusServer: Hocuspocus | null = null;
-  private httpServer: any;
+// Security middleware
+app.use(helmet());
 
-  constructor() {
-    this.PORT = parseInt(process.env.PORT || "3000");
-    this.BASE_PATH = process.env.LIVE_BASE_PATH || "/";
-    this.CORS_ALLOWED_ORIGINS = process.env.CORS_ALLOWED_ORIGINS || "*";
-    // Initialize express app
-    this.app = express();
-    expressWs(this.app as any);
-    // Security middleware
-    this.app.use(helmet());
-    // cors
-    this.setupCors();
-    // Cookie parsing
-    this.app.use(cookieParser());
-    // Body parsing middleware
-    this.app.use(express.json());
-    this.app.use(express.urlencoded({ extended: true }));
-    // static files
-    this.app.use(express.static(path.join(__dirname, "public")));
-    // setup redis
-    initializeRedis();
-    // setup hocuspocus server
-    this.hocuspocusServer = createHocusPocus();
-    // setup controllers
-    this.setupControllers();
+// Middleware for response compression
+app.use(
+  compression({
+    level: 6,
+    threshold: 5 * 1000,
+  })
+);
+
+// Logging middleware
+app.use(logger);
+
+// Body parsing middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// cors middleware
+app.use(cors());
+
+const router = express.Router();
+
+const HocusPocusServer = await getHocusPocusServer().catch((err) => {
+  manualLogger.error("Failed to initialize HocusPocusServer:", err);
+  process.exit(1);
+});
+
+router.get("/health", (_req, res) => {
+  res.status(200).json({ status: "OK" });
+});
+
+router.ws("/collaboration", (ws, req) => {
+  try {
+    HocusPocusServer.handleConnection(ws, req);
+  } catch (err) {
+    manualLogger.error("WebSocket connection error:", err);
+    ws.close();
   }
+});
 
-  private setupCors() {
-    const origins = this.CORS_ALLOWED_ORIGINS.split(",").map((origin) => origin.trim());
-    this.app.use(
-      cors({
-        origin: origins,
-        credentials: true,
-        methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-        allowedHeaders: ["Content-Type", "Authorization", "x-api-key"],
-      })
-    );
-  }
-
-  private setupControllers() {
-    const router = express.Router();
-
-    REST_CONTROLLERS.forEach((controller: any) => {
-      registerController(router, controller, [this.hocuspocusServer]);
-    });
-
-    WEBSOCKET_CONTROLLERS.forEach((controller: any) => {
-      registerWebSocketController(router, controller, [this.hocuspocusServer]);
-    });
-
-    this.app.use(this.BASE_PATH, router);
-  }
-
-  start() {
-    this.httpServer = this.app.listen(this.PORT, () => {
-      console.log(`Plane Live server has started at port ${this.PORT}`);
-    });
-
-    // Setup graceful shutdown
-    process.on("SIGTERM", () => this.shutdown("Received SIGTERM"));
-    process.on("SIGINT", () => this.shutdown("Received SIGINT"));
-
-    process.on("uncaughtException", (error) => {
-      logger.error("Uncaught exception:", error);
-    });
-
-    // Handle unhandled promise rejections - create AppError but DON'T terminate
-    process.on("unhandledRejection", (error) => {
-      logger.error("Unhandled rejection:", error);
-    });
-  }
-
-  private async shutdown(error: string): Promise<void> {
-    logger.info(`Initiating graceful shutdown: ${error}`);
-
-    if (!this.httpServer) {
-      logger.info("No HTTP server to close");
+router.post("/convert-document", (req, res) => {
+  const { description_html, variant } = req.body as TConvertDocumentRequestBody;
+  try {
+    if (description_html === undefined || variant === undefined) {
+      res.status(400).send({
+        message: "Missing required fields",
+      });
       return;
     }
-
-    // Close all existing connections
-    this.httpServer.closeAllConnections?.();
-
-    // Close the server
-    return new Promise<void>((resolve) => {
-      this.httpServer.close((error: Error | undefined) => {
-        if (error) {
-          logger.error("Error closing HTTP server:", error);
-        } else {
-          logger.info("HTTP server closed successfully");
-        }
-        resolve();
-      });
+    const { description, description_binary } = convertHTMLDocumentToAllFormats({
+      document_html: description_html,
+      variant,
+    });
+    res.status(200).json({
+      description,
+      description_binary,
+    });
+  } catch (error) {
+    manualLogger.error("Error in /convert-document endpoint:", error);
+    res.status(500).send({
+      message: `Internal server error. ${error}`,
     });
   }
-}
+});
+
+app.use(process.env.LIVE_BASE_PATH || "/live", router);
+
+app.use((_req, res) => {
+  res.status(404).send("Not Found");
+});
+
+app.use(errorHandler);
+
+const liveServer = app.listen(app.get("port"), () => {
+  manualLogger.info(`Plane Live server has started at port ${app.get("port")}`);
+});
+
+const gracefulShutdown = async () => {
+  manualLogger.info("Starting graceful shutdown...");
+
+  try {
+    // Close the HocusPocus server WebSocket connections
+    await HocusPocusServer.destroy();
+    manualLogger.info("HocusPocus server WebSocket connections closed gracefully.");
+
+    // Close the Express server
+    liveServer.close(() => {
+      manualLogger.info("Express server closed gracefully.");
+      process.exit(1);
+    });
+  } catch (err) {
+    manualLogger.error("Error during shutdown:", err);
+    process.exit(1);
+  }
+
+  // Forcefully shut down after 10 seconds if not closed
+  setTimeout(() => {
+    manualLogger.error("Forcing shutdown...");
+    process.exit(1);
+  }, 10000);
+};
+
+// Graceful shutdown on unhandled rejection
+process.on("unhandledRejection", (err: any) => {
+  manualLogger.info("Unhandled Rejection: ", err);
+  manualLogger.info(`UNHANDLED REJECTION! 💥 Shutting down...`);
+  gracefulShutdown();
+});
+
+// Graceful shutdown on uncaught exception
+process.on("uncaughtException", (err: any) => {
+  manualLogger.info("Uncaught Exception: ", err);
+  manualLogger.info(`UNCAUGHT EXCEPTION! 💥 Shutting down...`);
+  gracefulShutdown();
+});

live/src/services/page.service.ts

@@ -1,58 +0,0 @@
-// types
-import { TPage } from "@plane/types";
-// services
-import { API_BASE_URL, APIService } from "@/services/api.service";
-
-export class PageService extends APIService {
-  constructor() {
-    super(API_BASE_URL);
-  }
-
-  async fetchDetails(workspaceSlug: string, projectId: string, pageId: string, cookie: string): Promise<TPage> {
-    return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/`, {
-      headers: {
-        Cookie: cookie,
-      },
-    })
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  async fetchDescriptionBinary(workspaceSlug: string, projectId: string, pageId: string, cookie: string): Promise<any> {
-    return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/description/`, {
-      headers: {
-        "Content-Type": "application/octet-stream",
-        Cookie: cookie,
-      },
-      responseType: "arraybuffer",
-    })
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error?.response?.data;
-      });
-  }
-
-  async updateDescription(
-    workspaceSlug: string,
-    projectId: string,
-    pageId: string,
-    data: {
-      description_binary: string;
-      description_html: string;
-      description: object;
-    },
-    cookie: string
-  ): Promise<any> {
-    return this.patch(`/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/description/`, data, {
-      headers: {
-        Cookie: cookie,
-      },
-    })
-      .then((response) => response?.data)
-      .catch((error) => {
-        throw error;
-      });
-  }
-}

live/src/start.ts

@@ -1,10 +0,0 @@
-import Server from "./server";
-import { env } from "./env";
-import { logger } from "@plane/logger";
-
-// Log server startup details
-logger.info(`Starting Plane Live server in ${env.NODE_ENV} environment`);
-
-// Initialize and start the server
-const server = new Server();
-server.start();

live/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "extends": "@plane/typescript-config/base.json",
   "compilerOptions": {
-    "module": "ES2015",
-    "moduleResolution": "Bundler",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "lib": ["ES2015"],
     "outDir": "./dist",
     "rootDir": ".",
@@ -16,8 +16,6 @@
     "skipLibCheck": true,
     "sourceMap": true,
     "inlineSources": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
     "sourceRoot": "/"
   },
   "include": ["src/**/*.ts", "tsup.config.ts"],

live/tsup.config.ts

@@ -1,15 +1,11 @@
-import { defineConfig } from "tsup";
+import { defineConfig, Options } from "tsup";
 
-export default defineConfig({
-  entry: ["src/start.ts"],
-  format: ["esm", "cjs"],
+export default defineConfig((options: Options) => ({
+  entry: ["src/server.ts"],
+  format: ["cjs", "esm"],
   dts: true,
-  splitting: false,
-  sourcemap: true,
-  minify: false,
-  target: "node18",
-  outDir: "dist",
-  env: {
-    NODE_ENV: process.env.NODE_ENV || "development",
-  },
-});
+  clean: false,
+  external: ["react"],
+  injectStyle: true,
+  ...options,
+}));

packages/constants/src/emoji.ts

@@ -8,3 +8,18 @@ export const ISSUE_REACTION_EMOJI_CODES = [
   "9992",
   "128064",
 ];
+
+export const RANDOM_EMOJI_CODES = [
+  "8986",
+  "9200",
+  "128204",
+  "127773",
+  "127891",
+  "128076",
+  "128077",
+  "128187",
+  "128188",
+  "128512",
+  "128522",
+  "128578",
+];

packages/constants/src/inbox.ts

@@ -1,91 +1,97 @@
 import { TInboxDuplicateIssueDetails, TIssue } from "@plane/types";
 
 export enum EInboxIssueCurrentTab {
-	OPEN = "open",
-	CLOSED = "closed",
+  OPEN = "open",
+  CLOSED = "closed",
 }
 
 export enum EInboxIssueStatus {
-	PENDING = -2,
-	DECLINED = -1,
-	SNOOZED = 0,
-	ACCEPTED = 1,
-	DUPLICATE = 2,
+  PENDING = -2,
+  DECLINED = -1,
+  SNOOZED = 0,
+  ACCEPTED = 1,
+  DUPLICATE = 2,
+}
+
+export enum EInboxIssueSource {
+  IN_APP = "IN_APP",
+  FORMS = "FORMS",
+  EMAIL = "EMAIL",
 }
 
 export type TInboxIssueCurrentTab = EInboxIssueCurrentTab;
 export type TInboxIssueStatus = EInboxIssueStatus;
 export type TInboxIssue = {
-	id: string;
-	status: TInboxIssueStatus;
-	snoozed_till: Date | null;
-	duplicate_to: string | undefined;
-	source: string;
-	issue: TIssue;
-	created_by: string;
-	duplicate_issue_detail: TInboxDuplicateIssueDetails | undefined;
+  id: string;
+  status: TInboxIssueStatus;
+  snoozed_till: Date | null;
+  duplicate_to: string | undefined;
+  source: EInboxIssueSource | undefined;
+  issue: TIssue;
+  created_by: string;
+  duplicate_issue_detail: TInboxDuplicateIssueDetails | undefined;
 };
 
 export const INBOX_STATUS: {
-	key: string;
-	status: TInboxIssueStatus;
-	i18n_title: string;
-	i18n_description: () => string;
+  key: string;
+  status: TInboxIssueStatus;
+  i18n_title: string;
+  i18n_description: () => string;
 }[] = [
-	{
-		key: "pending",
-		i18n_title: "inbox_issue.status.pending.title",
-		status: EInboxIssueStatus.PENDING,
-		i18n_description: () => `inbox_issue.status.pending.description`,
-	},
-	{
-		key: "declined",
-		i18n_title: "inbox_issue.status.declined.title",
-		status: EInboxIssueStatus.DECLINED,
-		i18n_description: () => `inbox_issue.status.declined.description`,
-	},
-	{
-		key: "snoozed",
-		i18n_title: "inbox_issue.status.snoozed.title",
-		status: EInboxIssueStatus.SNOOZED,
-		i18n_description: () => `inbox_issue.status.snoozed.description`,
-	},
-	{
-		key: "accepted",
-		i18n_title: "inbox_issue.status.accepted.title",
-		status: EInboxIssueStatus.ACCEPTED,
-		i18n_description: () => `inbox_issue.status.accepted.description`,
-	},
-	{
-		key: "duplicate",
-		i18n_title: "inbox_issue.status.duplicate.title",
-		status: EInboxIssueStatus.DUPLICATE,
-		i18n_description: () => `inbox_issue.status.duplicate.description`,
-	},
+  {
+    key: "pending",
+    i18n_title: "inbox_issue.status.pending.title",
+    status: EInboxIssueStatus.PENDING,
+    i18n_description: () => `inbox_issue.status.pending.description`,
+  },
+  {
+    key: "declined",
+    i18n_title: "inbox_issue.status.declined.title",
+    status: EInboxIssueStatus.DECLINED,
+    i18n_description: () => `inbox_issue.status.declined.description`,
+  },
+  {
+    key: "snoozed",
+    i18n_title: "inbox_issue.status.snoozed.title",
+    status: EInboxIssueStatus.SNOOZED,
+    i18n_description: () => `inbox_issue.status.snoozed.description`,
+  },
+  {
+    key: "accepted",
+    i18n_title: "inbox_issue.status.accepted.title",
+    status: EInboxIssueStatus.ACCEPTED,
+    i18n_description: () => `inbox_issue.status.accepted.description`,
+  },
+  {
+    key: "duplicate",
+    i18n_title: "inbox_issue.status.duplicate.title",
+    status: EInboxIssueStatus.DUPLICATE,
+    i18n_description: () => `inbox_issue.status.duplicate.description`,
+  },
 ];
 
 export const INBOX_ISSUE_ORDER_BY_OPTIONS = [
-	{
-		key: "issue__created_at",
-		i18n_label: "inbox_issue.order_by.created_at",
-	},
-	{
-		key: "issue__updated_at",
-		i18n_label: "inbox_issue.order_by.updated_at",
-	},
-	{
-		key: "issue__sequence_id",
-		i18n_label: "inbox_issue.order_by.id",
-	},
+  {
+    key: "issue__created_at",
+    i18n_label: "inbox_issue.order_by.created_at",
+  },
+  {
+    key: "issue__updated_at",
+    i18n_label: "inbox_issue.order_by.updated_at",
+  },
+  {
+    key: "issue__sequence_id",
+    i18n_label: "inbox_issue.order_by.id",
+  },
 ];
 
 export const INBOX_ISSUE_SORT_BY_OPTIONS = [
-	{
-		key: "asc",
-		i18n_label: "common.sort.asc",
-	},
-	{
-		key: "desc",
-		i18n_label: "common.sort.desc",
-	},
+  {
+    key: "asc",
+    i18n_label: "common.sort.asc",
+  },
+  {
+    key: "desc",
+    i18n_label: "common.sort.desc",
+  },
 ];

packages/constants/src/index.ts

@@ -14,6 +14,7 @@ export * from "./state";
 export * from "./swr";
 export * from "./tab-indices";
 export * from "./user";
+export * from "./payment";
 export * from "./workspace";
 export * from "./stickies";
 export * from "./cycle";
@@ -29,3 +30,5 @@ export * from "./event-tracker";
 export * from "./spreadsheet";
 export * from "./dashboard";
 export * from "./page";
+export * from "./emoji";
+export * from "./subscription";

packages/constants/src/issue/common.ts

@@ -41,6 +41,7 @@ export enum EIssueGroupBYServerToProperty {
 export enum EIssueServiceType {
   ISSUES = "issues",
   EPICS = "epics",
+  WORK_ITEMS = "work-items",
 }
 
 export enum EIssuesStoreType {

packages/constants/src/payment.ts

@@ -0,0 +1,163 @@
+import { IPaymentProduct, TBillingFrequency, TProductBillingFrequency } from "@plane/types";
+
+/**
+ * Enum representing different product subscription types
+ */
+export enum EProductSubscriptionEnum {
+  FREE = "FREE",
+  ONE = "ONE",
+  PRO = "PRO",
+  BUSINESS = "BUSINESS",
+  ENTERPRISE = "ENTERPRISE",
+}
+
+/**
+ * Default billing frequency for each product subscription type
+ */
+export const DEFAULT_PRODUCT_BILLING_FREQUENCY: TProductBillingFrequency = {
+  [EProductSubscriptionEnum.FREE]: undefined,
+  [EProductSubscriptionEnum.ONE]: undefined,
+  [EProductSubscriptionEnum.PRO]: "month",
+  [EProductSubscriptionEnum.BUSINESS]: "month",
+  [EProductSubscriptionEnum.ENTERPRISE]: "month",
+};
+
+/**
+ * Subscription types that support billing frequency toggle (monthly/yearly)
+ */
+export const SUBSCRIPTION_WITH_BILLING_FREQUENCY = [
+  EProductSubscriptionEnum.PRO,
+  EProductSubscriptionEnum.BUSINESS,
+  EProductSubscriptionEnum.ENTERPRISE,
+];
+
+/**
+ * Mapping of product subscription types to their respective payment product details
+ * Used to provide information about each product's pricing and features
+ */
+export const PLANE_COMMUNITY_PRODUCTS: Record<string, IPaymentProduct> = {
+  [EProductSubscriptionEnum.PRO]: {
+    id: EProductSubscriptionEnum.PRO,
+    name: "Plane Pro",
+    description:
+      "More views, more cycles powers, more pages features, new reports, and better dashboards are waiting to be unlocked.",
+    type: "PRO",
+    prices: [
+      {
+        id: `price_monthly_${EProductSubscriptionEnum.PRO}`,
+        unit_amount: 800,
+        recurring: "month",
+        currency: "usd",
+        workspace_amount: 800,
+        product: EProductSubscriptionEnum.PRO,
+      },
+      {
+        id: `price_yearly_${EProductSubscriptionEnum.PRO}`,
+        unit_amount: 7200,
+        recurring: "year",
+        currency: "usd",
+        workspace_amount: 7200,
+        product: EProductSubscriptionEnum.PRO,
+      },
+    ],
+    payment_quantity: 1,
+    is_active: true,
+  },
+  [EProductSubscriptionEnum.BUSINESS]: {
+    id: EProductSubscriptionEnum.BUSINESS,
+    name: "Plane Business",
+    description:
+      "The earliest packaging of Business at $10 a seat a month billed annually, $12 a seat a month billed monthly for Plane Cloud",
+    type: "BUSINESS",
+    prices: [
+      {
+        id: `price_yearly_${EProductSubscriptionEnum.BUSINESS}`,
+        unit_amount: 0,
+        recurring: "year",
+        currency: "usd",
+        workspace_amount: 0,
+        product: EProductSubscriptionEnum.BUSINESS,
+      },
+      {
+        id: `price_monthly_${EProductSubscriptionEnum.BUSINESS}`,
+        unit_amount: 0,
+        recurring: "month",
+        currency: "usd",
+        workspace_amount: 0,
+        product: EProductSubscriptionEnum.BUSINESS,
+      },
+    ],
+    payment_quantity: 1,
+    is_active: false,
+  },
+  [EProductSubscriptionEnum.ENTERPRISE]: {
+    id: EProductSubscriptionEnum.ENTERPRISE,
+    name: "Plane Enterprise",
+    description: "",
+    type: "ENTERPRISE",
+    prices: [
+      {
+        id: `price_yearly_${EProductSubscriptionEnum.ENTERPRISE}`,
+        unit_amount: 0,
+        recurring: "year",
+        currency: "usd",
+        workspace_amount: 0,
+        product: EProductSubscriptionEnum.ENTERPRISE,
+      },
+      {
+        id: `price_monthly_${EProductSubscriptionEnum.ENTERPRISE}`,
+        unit_amount: 0,
+        recurring: "month",
+        currency: "usd",
+        workspace_amount: 0,
+        product: EProductSubscriptionEnum.ENTERPRISE,
+      },
+    ],
+    payment_quantity: 1,
+    is_active: false,
+  },
+};
+
+/**
+ * URL for the "Talk to Sales" page where users can contact sales team
+ */
+export const TALK_TO_SALES_URL = "https://plane.so/talk-to-sales";
+
+/**
+ * Mapping of subscription types to their respective upgrade/redirection URLs based on billing frequency
+ * Used for self-hosted installations to redirect users to appropriate upgrade pages
+ */
+export const SUBSCRIPTION_REDIRECTION_URLS: Record<EProductSubscriptionEnum, Record<TBillingFrequency, string>> = {
+  [EProductSubscriptionEnum.FREE]: {
+    month: TALK_TO_SALES_URL,
+    year: TALK_TO_SALES_URL,
+  },
+  [EProductSubscriptionEnum.ONE]: {
+    month: TALK_TO_SALES_URL,
+    year: TALK_TO_SALES_URL,
+  },
+  [EProductSubscriptionEnum.PRO]: {
+    month: "https://app.plane.so/upgrade/pro/self-hosted?plan=month",
+    year: "https://app.plane.so/upgrade/pro/self-hosted?plan=year",
+  },
+  [EProductSubscriptionEnum.BUSINESS]: {
+    month: TALK_TO_SALES_URL,
+    year: TALK_TO_SALES_URL,
+  },
+  [EProductSubscriptionEnum.ENTERPRISE]: {
+    month: TALK_TO_SALES_URL,
+    year: TALK_TO_SALES_URL,
+  },
+};
+
+/**
+ * Mapping of subscription types to their respective marketing webpage URLs
+ * Used to direct users to learn more about each plan's features and pricing
+ */
+export const SUBSCRIPTION_WEBPAGE_URLS: Record<EProductSubscriptionEnum, string> = {
+  [EProductSubscriptionEnum.FREE]: TALK_TO_SALES_URL,
+  [EProductSubscriptionEnum.ONE]: TALK_TO_SALES_URL,
+  [EProductSubscriptionEnum.PRO]: "https://plane.so/pro",
+  [EProductSubscriptionEnum.BUSINESS]: "https://plane.so/business",
+  [EProductSubscriptionEnum.ENTERPRISE]: "https://plane.so/business",
+};

packages/constants/src/project.ts

@@ -1,5 +1,7 @@
-// icons
-import { TProjectAppliedDisplayFilterKeys, TProjectOrderByOptions } from "@plane/types";
+// plane imports
+import { IProject, TProjectAppliedDisplayFilterKeys, TProjectOrderByOptions } from "@plane/types";
+// local imports
+import { RANDOM_EMOJI_CODES } from "./emoji";
 
 export type TNetworkChoiceIconKey = "Lock" | "Globe2";
 
@@ -132,3 +134,18 @@ export const PROJECT_ERROR_MESSAGES = {
     i18n_message: "workspace_projects.error.issue_delete",
   },
 };
+
+export const DEFAULT_PROJECT_FORM_VALUES: Partial<IProject> = {
+  cover_image_url: PROJECT_UNSPLASH_COVERS[Math.floor(Math.random() * PROJECT_UNSPLASH_COVERS.length)],
+  description: "",
+  logo_props: {
+    in_use: "emoji",
+    emoji: {
+      value: RANDOM_EMOJI_CODES[Math.floor(Math.random() * RANDOM_EMOJI_CODES.length)],
+    },
+  },
+  identifier: "",
+  name: "",
+  network: 2,
+  project_lead: null,
+};

packages/constants/src/state.ts

@@ -1,9 +1,4 @@
-export type TStateGroups =
-  | "backlog"
-  | "unstarted"
-  | "started"
-  | "completed"
-  | "cancelled";
+export type TStateGroups = "backlog" | "unstarted" | "started" | "completed" | "cancelled";
 
 export type TDraggableData = {
   groupKey: TStateGroups;
@@ -14,40 +9,43 @@ export const STATE_GROUPS: {
   [key in TStateGroups]: {
     key: TStateGroups;
     label: string;
+    defaultStateName: string;
     color: string;
   };
 } = {
   backlog: {
     key: "backlog",
     label: "Backlog",
+    defaultStateName: "Backlog",
     color: "#d9d9d9",
   },
   unstarted: {
     key: "unstarted",
     label: "Unstarted",
+    defaultStateName: "Todo",
     color: "#3f76ff",
   },
   started: {
     key: "started",
     label: "Started",
+    defaultStateName: "In Progress",
     color: "#f59e0b",
   },
   completed: {
     key: "completed",
     label: "Completed",
+    defaultStateName: "Done",
     color: "#16a34a",
   },
   cancelled: {
     key: "cancelled",
     label: "Canceled",
+    defaultStateName: "Cancelled",
     color: "#dc2626",
   },
 };
 
-export const ARCHIVABLE_STATE_GROUPS = [
-  STATE_GROUPS.completed.key,
-  STATE_GROUPS.cancelled.key,
-];
+export const ARCHIVABLE_STATE_GROUPS = [STATE_GROUPS.completed.key, STATE_GROUPS.cancelled.key];
 export const COMPLETED_STATE_GROUPS = [STATE_GROUPS.completed.key];
 export const PENDING_STATE_GROUPS = [
   STATE_GROUPS.backlog.key,

packages/constants/src/subscription.ts

@@ -0,0 +1,42 @@
+export const ENTERPRISE_PLAN_FEATURES = [
+  "Private + managed deployments",
+  "GAC",
+  "LDAP support",
+  "Databases + Formulas",
+  "Unlimited and full Automation Flows",
+  "Full-suite professional services",
+];
+
+export const BUSINESS_PLAN_FEATURES = [
+  "Project Templates",
+  "Workflows + Approvals",
+  "Decision + Loops Automation",
+  "Custom Reports",
+  "Nested Pages",
+  "Intake Forms",
+];
+
+export const PRO_PLAN_FEATURES = [
+  "Dashboards + Reports",
+  "Full Time Tracking + Bulk Ops",
+  "Teamspaces",
+  "Trigger And Action",
+  "Wikis",
+  "Popular integrations",
+];
+
+export const ONE_PLAN_FEATURES = [
+  "OIDC + SAML for SSO",
+  "Active Cycles",
+  "Real-time collab + public views and page",
+  "Link pages in issues and vice-versa",
+  "Time-tracking + limited bulk ops",
+  "Docker, Kubernetes and more",
+];
+
+export const FREE_PLAN_UPGRADE_FEATURES = [
+  "OIDC + SAML for SSO",
+  "Time Tracking and Bulk Ops",
+  "Integrations",
+  "Public Views and Pages",
+];

packages/decorators/src/controller.ts

@@ -20,12 +20,11 @@ interface ControllerConstructor {
   prototype: ControllerInstance;
 }
 
-export function registerController(
+export function registerControllers(
   router: Router,
   Controller: ControllerConstructor,
-  dependencies: any[] = []
 ): void {
-  const instance = new Controller(...dependencies);
+  const instance = new Controller();
   const baseRoute = Reflect.getMetadata("baseRoute", Controller) as string;
 
   Object.getOwnPropertyNames(Controller.prototype).forEach((methodName) => {
@@ -34,14 +33,14 @@ export function registerController(
     const method = Reflect.getMetadata(
       "method",
       instance,
-      methodName
+      methodName,
     ) as HttpMethod;
     const route = Reflect.getMetadata("route", instance, methodName) as string;
     const middlewares =
       (Reflect.getMetadata(
         "middlewares",
         instance,
-        methodName
+        methodName,
       ) as RequestHandler[]) || [];
 
     if (method && route) {

packages/decorators/src/index.ts

@@ -2,8 +2,8 @@
 export { Controller, Middleware } from "./rest";
 export { Get, Post, Put, Patch, Delete } from "./rest";
 export { WebSocket } from "./websocket";
-export { registerController } from "./controller";
-export { registerWebSocketController } from "./websocket-controller";
+export { registerControllers } from "./controller";
+export { registerWebSocketControllers } from "./websocket-controller";
 
 // Also provide namespaced exports for better organization
 import * as RestDecorators from "./rest";
@@ -12,3 +12,4 @@ import * as WebSocketDecorators from "./websocket";
 // Named namespace exports
 export const Rest = RestDecorators;
 export const WebSocketNS = WebSocketDecorators;
+

packages/decorators/src/websocket-controller.ts

@@ -1,3 +1,5 @@
+import { Router, Request } from "express";
+import type { WebSocket } from "ws";
 import "reflect-metadata";
 
 interface ControllerInstance {
@@ -9,19 +11,23 @@ interface ControllerConstructor {
   prototype: ControllerInstance;
 }
 
-export function registerWebSocketController(
-  router: any,
+export function registerWebSocketControllers(
+  router: Router,
   Controller: ControllerConstructor,
-  dependencies: any[] = []
+  existingInstance?: ControllerInstance,
 ): void {
-  const instance = new Controller(...dependencies);
-  const baseRoute = Reflect.getMetadata("baseRoute", Controller);
+  const instance = existingInstance || new Controller();
+  const baseRoute = Reflect.getMetadata("baseRoute", Controller) as string;
 
   Object.getOwnPropertyNames(Controller.prototype).forEach((methodName) => {
     if (methodName === "constructor") return; // Skip the constructor
 
-    const method = Reflect.getMetadata("method", instance, methodName);
-    const route = Reflect.getMetadata("route", instance, methodName);
+    const method = Reflect.getMetadata(
+      "method",
+      instance,
+      methodName,
+    ) as string;
+    const route = Reflect.getMetadata("route", instance, methodName) as string;
 
     if (method === "ws" && route) {
       const handler = instance[methodName] as unknown;
@@ -30,21 +36,50 @@ export function registerWebSocketController(
         typeof handler === "function" &&
         typeof (router as any).ws === "function"
       ) {
-        router.ws(`${baseRoute}${route}`, (ws: any, req: any) => {
-          try {
-            handler.call(instance, ws, req);
-          } catch (error) {
-            console.error(
-              `WebSocket error in ${Controller.name}.${methodName}`,
-              error
-            );
-            ws.close(
-              1011,
-              error instanceof Error ? error.message : "Internal server error"
-            );
-          }
-        });
+        (router as any).ws(
+          `${baseRoute}${route}`,
+          (ws: WebSocket, req: Request) => {
+            try {
+              handler.call(instance, ws, req);
+            } catch (error) {
+              console.error(
+                `WebSocket error in ${Controller.name}.${methodName}`,
+                error,
+              );
+              ws.close(
+                1011,
+                error instanceof Error
+                  ? error.message
+                  : "Internal server error",
+              );
+            }
+          },
+        );
       }
     }
   });
 }
+
+/**
+ * Base controller class for WebSocket endpoints
+ */
+export abstract class BaseWebSocketController {
+  protected router: Router;
+
+  constructor() {
+    this.router = Router();
+  }
+
+  /**
+   * Get the base route for this controller
+   */
+  protected getBaseRoute(): string {
+    return Reflect.getMetadata("baseRoute", this.constructor) || "";
+  }
+
+  /**
+   * Abstract method to handle WebSocket connections
+   * Implement this in your derived class
+   */
+  abstract handleConnection(ws: WebSocket, req: Request): void;
+}

packages/decorators/src/websocket.ts

@@ -9,7 +9,7 @@ export function WebSocket(route: string): MethodDecorator {
   return function (
     target: object,
     propertyKey: string | symbol,
-    descriptor: PropertyDescriptor
+    descriptor: PropertyDescriptor,
   ) {
     Reflect.defineMetadata("method", "ws", target, propertyKey);
     Reflect.defineMetadata("route", route, target, propertyKey);

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

@@ -47,15 +47,23 @@ export const EditorContainer: FC<EditorContainerProps> = (props) => {
         return;
       }
 
-      // Insert a new paragraph at the end of the document
-      const endPosition = editor?.state.doc.content.size;
-      editor?.chain().insertContentAt(endPosition, { type: "paragraph" }).run();
+      // Get the last node in the document
+      const docSize = editor.state.doc.content.size;
+      const lastNodePos = editor.state.doc.resolve(Math.max(0, docSize - 2));
+      const lastNode = lastNodePos.node();
 
-      // Focus the newly added paragraph for immediate editing
-      editor
-        .chain()
-        .setTextSelection(endPosition + 1)
-        .run();
+      // Check if the last node is a  not paragraph
+      if (lastNode && lastNode.type.name !== "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();
+
+        // Focus the newly added paragraph for immediate editing
+        editor
+          .chain()
+          .setTextSelection(endPosition + 1)
+          .run();
+      }
     } catch (error) {
       console.error("An error occurred while handling container click to insert new empty node at bottom:", error);
     }

packages/editor/src/core/extensions/custom-image/read-only-custom-image.ts

@@ -7,7 +7,7 @@ import { CustomImageNode, UploadImageExtensionStorage } from "@/extensions/custo
 import { TReadOnlyFileHandler } from "@/types";
 
 export const CustomReadOnlyImageExtension = (props: TReadOnlyFileHandler) => {
-  const { getAssetSrc } = props;
+  const { getAssetSrc, restore: restoreImageFn } = props;
 
   return Image.extend<Record<string, unknown>, UploadImageExtensionStorage>({
     name: "imageComponent",
@@ -66,6 +66,9 @@ export const CustomReadOnlyImageExtension = (props: TReadOnlyFileHandler) => {
     addCommands() {
       return {
         getImageSource: (path: string) => async () => await getAssetSrc(path),
+        restoreImage: (src) => async () => {
+          await restoreImageFn(src);
+        },
       };
     },
 

packages/editor/src/core/hooks/use-editor.ts

@@ -145,8 +145,8 @@ export const useEditor = (props: CustomEditorProps) => {
       clearEditor: (emitUpdate = false) => {
         editor?.chain().setMeta("skipImageDeletion", true).clearContent(emitUpdate).run();
       },
-      setEditorValue: (content: string) => {
-        editor?.commands.setContent(content, false, { preserveWhitespace: "full" });
+      setEditorValue: (content: string, emitUpdate = false) => {
+        editor?.commands.setContent(content, emitUpdate, { preserveWhitespace: "full" });
       },
       setEditorValueAtCursorPosition: (content: string) => {
         if (editor?.state.selection) {

packages/editor/src/core/hooks/use-read-only-editor.ts

@@ -77,8 +77,8 @@ export const useReadOnlyEditor = (props: CustomReadOnlyEditorProps) => {
     clearEditor: (emitUpdate = false) => {
       editor?.chain().setMeta("skipImageDeletion", true).clearContent(emitUpdate).run();
     },
-    setEditorValue: (content: string) => {
-      editor?.commands.setContent(content, false, { preserveWhitespace: "full" });
+    setEditorValue: (content: string, emitUpdate = false) => {
+      editor?.commands.setContent(content, emitUpdate, { preserveWhitespace: "full" });
     },
     getMarkDown: (): string => {
       const markdownOutput = editor?.storage.markdown.getMarkdown();

packages/editor/src/core/types/editor.ts

@@ -84,7 +84,7 @@ export type EditorReadOnlyRefApi = {
     json: JSONContent | null;
   };
   clearEditor: (emitUpdate?: boolean) => void;
-  setEditorValue: (content: string) => void;
+  setEditorValue: (content: string, emitUpdate?: boolean) => void;
   scrollSummary: (marking: IMarking) => void;
   getDocumentInfo: () => {
     characters: number;

packages/editor/src/styles/variables.css

@@ -151,11 +151,11 @@
 /* end font size and style */
 
 /* layout config */
-#page-header-container {
-  container-name: page-header-container;
+#page-toolbar-container {
+  container-name: page-toolbar-container;
   container-type: inline-size;
 
-  .page-header-content {
+  .page-toolbar-content {
     --header-width: var(--normal-content-width);
 
     &.wide-layout {
@@ -186,23 +186,23 @@
 }
 
 /* keep a static padding of 96px for wide layouts for container width >912px and <1344px */
-@container page-header-container (min-width: 912px) and (max-width: 1344px) {
-  .page-header-content.wide-layout {
+@container page-toolbar-container (min-width: 912px) and (max-width: 1344px) {
+  .page-toolbar-content.wide-layout {
     padding-left: var(--wide-content-margin) !important;
   }
 }
 
 /* keep a static padding of 96px for wide layouts for container width <912px */
-@container page-header-container (max-width: 912) {
-  .page-header-content.wide-layout {
+@container page-toolbar-container (max-width: 912) {
+  .page-toolbar-content.wide-layout {
     padding-left: var(--wide-content-margin) !important;
   }
 }
 /* end layout config */
 
 /* keep a static padding of 20px for wide layouts for container width <760px */
-@container page-header-container (max-width: 760px) {
-  .page-header-content {
+@container page-toolbar-container (max-width: 760px) {
+  .page-toolbar-content {
     padding-left: var(--normal-content-margin) !important;
   }
 }
@@ -211,7 +211,7 @@
 /* keep a static padding of 96px for wide layouts for container width >912px and <1344px */
 @container page-content-container (min-width: 912px) and (max-width: 1344px) {
   .editor-container.wide-layout,
-  .page-title-container {
+  .page-header-container {
     padding-left: var(--wide-content-margin);
     padding-right: var(--wide-content-margin);
   }
@@ -220,7 +220,7 @@
 /* keep a static padding of 20px for wide layouts for container width <912px */
 @container page-content-container (max-width: 912px) {
   .editor-container.wide-layout,
-  .page-title-container {
+  .page-header-container {
     padding-left: var(--normal-content-margin);
     padding-right: var(--normal-content-margin);
   }
@@ -229,7 +229,7 @@
 /* keep a static padding of 20px for normal layouts for container width <760px */
 @container page-content-container (max-width: 760px) {
   .editor-container:not(.wide-layout),
-  .page-title-container {
+  .page-header-container {
     padding-left: var(--normal-content-margin);
     padding-right: var(--normal-content-margin);
   }

packages/i18n/src/locales/cs/translations.json

@@ -590,10 +590,10 @@
         "default": "Zatím nemáte žádné nedávné položky."
       },
       "filters": {
-        "all": "Všechny položky",
+        "all": "Vše",
         "projects": "Projekty",
         "pages": "Stránky",
-        "issues": "Pracovní položky"
+        "issues": "Úkoly"
       }
     },
     "new_at_plane": {
@@ -867,7 +867,8 @@
     "deleting": "Mazání",
     "pending": "Čekající",
     "invite": "Pozvat",
-    "view": "Pohled"
+    "view": "Pohled",
+    "deactivated_user": "Deaktivovaný uživatel"
   },
 
   "chart": {
@@ -1734,32 +1735,111 @@
       }
     },
     "estimates": {
-      "title": "Povolit odhady v projektu",
-      "description": "Pomáhají komunikovat složitost a vytížení týmu."
+      "label": "Odhady",
+      "title": "Povolit odhady pro můj projekt",
+      "description": "Pomáhají vám komunikovat složitost a pracovní zátěž týmu.",
+      "no_estimate": "Bez odhadu",
+      "new": "Nový systém odhadů",
+      "create": {
+        "custom": "Vlastní",
+        "start_from_scratch": "Začít od nuly",
+        "choose_template": "Vybrat šablonu",
+        "choose_estimate_system": "Vybrat systém odhadů",
+        "enter_estimate_point": "Zadat odhad",
+        "step": "Krok {step} z {total}",
+        "label": "Vytvořit odhad"
+      },
+      "toasts": {
+        "created": {
+          "success": {
+            "title": "Odhad vytvořen",
+            "message": "Odhad byl úspěšně vytvořen"
+          },
+          "error": {
+            "title": "Vytvoření odhadu selhalo",
+            "message": "Nepodařilo se vytvořit nový odhad, zkuste to prosím znovu."
+          }
+        },
+        "updated": {
+          "success": {
+            "title": "Odhad upraven",
+            "message": "Odhad byl aktualizován ve vašem projektu."
+          },
+          "error": {
+            "title": "Úprava odhadu selhala",
+            "message": "Nepodařilo se upravit odhad, zkuste to prosím znovu"
+          }
+        },
+        "enabled": {
+          "success": {
+            "title": "Úspěch!",
+            "message": "Odhady byly povoleny."
+          }
+        },
+        "disabled": {
+          "success": {
+            "title": "Úspěch!",
+            "message": "Odhady byly zakázány."
+          },
+          "error": {
+            "title": "Chyba!",
+            "message": "Odhad nemohl být zakázán. Zkuste to prosím znovu"
+          }
+        }
+      },
+      "validation": {
+        "min_length": "Odhad musí být větší než 0.",
+        "unable_to_process": "Nemůžeme zpracovat váš požadavek, zkuste to prosím znovu.",
+        "numeric": "Odhad musí být číselná hodnota.",
+        "character": "Odhad musí být znakový.",
+        "empty": "Hodnota odhadu nemůže být prázdná.",
+        "already_exists": "Hodnota odhadu již existuje.",
+        "unsaved_changes": "Máte neuložené změny. Před kliknutím na hotovo je prosím uložte",
+        "remove_empty": "Odhad nemůže být prázdný. Zadejte hodnotu do každého pole nebo odstraňte ta, pro která nemáte hodnoty."
+      },
+      "systems": {
+        "points": {
+          "label": "Body",
+          "fibonacci": "Fibonacci",
+          "linear": "Lineární",
+          "squares": "Čtverce",
+          "custom": "Vlastní"
+        },
+        "categories": {
+          "label": "Kategorie",
+          "t_shirt_sizes": "Velikosti triček",
+          "easy_to_hard": "Od snadného po těžké",
+          "custom": "Vlastní"
+        },
+        "time": {
+          "label": "Čas",
+          "hours": "Hodiny"
+        }
+      }
     },
     "automations": {
       "label": "Automatizace",
       "auto-archive": {
-        "title": "Automaticky archivovat uzavřené položky",
-        "description": "Plane bude archivovat dokončené nebo zrušené položky.",
-        "duration": "Archivovat položky uzavřené déle než"
+        "title": "Automaticky archivovat uzavřené pracovní položky",
+        "description": "Plane bude automaticky archivovat pracovní položky, které byly dokončeny nebo zrušeny.",
+        "duration": "Automaticky archivovat pracovní položky, které jsou uzavřené po dobu"
       },
       "auto-close": {
-        "title": "Automaticky uzavírat položky",
-        "description": "Plane uzavře neaktivní položky.",
-        "duration": "Uzavřít položky neaktivní déle než",
-        "auto_close_status": "Stav pro automatické uzavření"
+        "title": "Automaticky uzavírat pracovní položky",
+        "description": "Plane automaticky uzavře pracovní položky, které nebyly dokončeny nebo zrušeny.",
+        "duration": "Automaticky uzavřít pracovní položky, které jsou neaktivní po dobu",
+        "auto_close_status": "Stav automatického uzavření"
       }
     },
 
     "empty_state": {
       "labels": {
-        "title": "Žádné štítky",
-        "description": "Vytvářejte štítky pro organizaci položek."
+        "title": "Zatím žádné štítky",
+        "description": "Vytvořte štítky pro organizaci a filtrování pracovních položek ve vašem projektu."
       },
       "estimates": {
-        "title": "Žádné systémy odhadů",
-        "description": "Vytvořte systém odhadů pro komunikaci vytížení.",
+        "title": "Zatím žádné systémy odhadů",
+        "description": "Vytvořte sadu odhadů pro komunikaci množství práce na pracovní položku.",
         "primary_button": "Přidat systém odhadů"
       }
     }
@@ -2372,5 +2452,11 @@
   "module": {
     "label": "{count, plural, one {Modul} few {Moduly} other {Modulů}}",
     "no_module": "Žádný modul"
+  },
+
+  "description_versions": {
+    "last_edited_by": "Naposledy upraveno uživatelem",
+    "previously_edited_by": "Dříve upraveno uživatelem",
+    "edited_by": "Upraveno uživatelem"
   }
 }