Workspace search (baserow#4076)

Adds ability to search various items in workspace

Author: bram2w

backend/pytest.ini

@@ -50,3 +50,4 @@ markers =
     websockets: All tests related to handeling web socket connections
     import_export_workspace: All tests related to importing and exporting workspaces
     data_sync: All tests related to data sync functionality
+    workspace_search: All tests related to workspace search functionality

backend/src/baserow/api/search/constants.py

@@ -0,0 +1 @@
+DEFAULT_SEARCH_LIMIT = 20

backend/src/baserow/api/search/serializers.py

@@ -1,5 +1,6 @@
 from rest_framework import serializers
 
+from baserow.api.search.constants import DEFAULT_SEARCH_LIMIT
 from baserow.contrib.database.search.handler import ALL_SEARCH_MODES
 
 
@@ -10,3 +11,43 @@ class SearchQueryParamSerializer(serializers.Serializer):
         default=None,
         choices=ALL_SEARCH_MODES,
     )
+
+
+class WorkspaceSearchSerializer(serializers.Serializer):
+    """Serializer for workspace search requests."""
+
+    query = serializers.CharField(min_length=1, max_length=100)
+    limit = serializers.IntegerField(
+        default=DEFAULT_SEARCH_LIMIT,
+        min_value=1,
+        max_value=100,
+        help_text="Maximum number of results per type",
+    )
+    offset = serializers.IntegerField(
+        default=0, min_value=0, help_text="Number of results to skip"
+    )
+
+
+class SearchResultSerializer(serializers.Serializer):
+    """Serializer for individual search results."""
+
+    type = serializers.CharField()
+    id = serializers.IntegerField()
+    title = serializers.CharField()
+    subtitle = serializers.CharField(required=False, allow_null=True)
+    description = serializers.CharField(required=False, allow_null=True)
+    metadata = serializers.DictField(required=False, allow_null=True)
+    created_on = serializers.CharField(required=False, allow_null=True)
+    updated_on = serializers.CharField(required=False, allow_null=True)
+
+
+class WorkspaceSearchResponseSerializer(serializers.Serializer):
+    """Serializer for workspace search responses."""
+
+    results = serializers.ListField(
+        child=SearchResultSerializer(),
+        help_text="Priority-ordered search results",
+    )
+    has_more = serializers.BooleanField(
+        help_text="Whether there are more results available for pagination"
+    )

backend/src/baserow/api/search/urls.py

@@ -0,0 +1,17 @@
+from django.urls import path
+
+from baserow.api.search.views import WorkspaceSearchView
+from baserow.core.feature_flags import FF_WORKSPACE_SEARCH, feature_flag_is_enabled
+
+app_name = "baserow.api.search"
+
+urlpatterns = []
+
+if feature_flag_is_enabled(FF_WORKSPACE_SEARCH):
+    urlpatterns = [
+        path(
+            "workspace/<int:workspace_id>/",
+            WorkspaceSearchView.as_view(),
+            name="workspace_search",
+        ),
+    ]

backend/src/baserow/api/search/views.py

@@ -0,0 +1,74 @@
+from drf_spectacular.openapi import OpenApiParameter, OpenApiTypes
+from drf_spectacular.utils import extend_schema
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from baserow.api.decorators import map_exceptions, validate_query_parameters
+from baserow.api.errors import ERROR_GROUP_DOES_NOT_EXIST, ERROR_USER_NOT_IN_GROUP
+from baserow.api.schemas import get_error_schema
+from baserow.api.search.serializers import (
+    WorkspaceSearchResponseSerializer,
+    WorkspaceSearchSerializer,
+)
+from baserow.core.exceptions import UserNotInWorkspace, WorkspaceDoesNotExist
+from baserow.core.handler import CoreHandler
+from baserow.core.operations import ReadWorkspaceOperationType
+from baserow.core.search.handler import WorkspaceSearchHandler
+
+
+class WorkspaceSearchView(APIView):
+    """
+    API view for workspace search functionality.
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    @extend_schema(
+        parameters=[
+            OpenApiParameter(
+                name="workspace_id",
+                location=OpenApiParameter.PATH,
+                type=OpenApiTypes.INT,
+                description="Workspace ID to search within",
+            ),
+        ],
+        request=WorkspaceSearchSerializer,
+        responses={
+            200: WorkspaceSearchResponseSerializer,
+            400: get_error_schema(
+                ["ERROR_USER_NOT_IN_GROUP", "ERROR_INVALID_SEARCH_QUERY"]
+            ),
+            404: get_error_schema(["ERROR_GROUP_DOES_NOT_EXIST"]),
+        },
+        tags=["Search"],
+        operation_id="workspace_search",
+        description="Search across all searchable content within a workspace",
+    )
+    @map_exceptions(
+        {
+            UserNotInWorkspace: ERROR_USER_NOT_IN_GROUP,
+            WorkspaceDoesNotExist: ERROR_GROUP_DOES_NOT_EXIST,
+        }
+    )
+    @validate_query_parameters(WorkspaceSearchSerializer, return_validated=True)
+    def get(self, request, workspace_id, query_params):
+        workspace = CoreHandler().get_workspace(workspace_id)
+        CoreHandler().check_permissions(
+            request.user,
+            ReadWorkspaceOperationType.type,
+            workspace=workspace,
+            context=workspace,
+        )
+
+        handler = WorkspaceSearchHandler()
+        result_data = handler.search_workspace(
+            user=request.user,
+            workspace=workspace,
+            query=query_params["query"],
+            limit=query_params["limit"],
+            offset=query_params["offset"],
+        )
+        serializer = WorkspaceSearchResponseSerializer(data=result_data)
+        serializer.is_valid(raise_exception=True)
+        return Response(serializer.data)

backend/src/baserow/api/urls.py

@@ -17,6 +17,7 @@
 from .jobs import urls as jobs_urls
 from .mcp import urls as mcp_urls
 from .notifications import urls as notifications_urls
+from .search import urls as search_urls
 from .settings import urls as settings_urls
 from .snapshots import urls as snapshots_urls
 from .spectacular.views import CachedSpectacularJSONAPIView
@@ -50,6 +51,7 @@
         path("snapshots/", include(snapshots_urls, namespace="snapshots")),
         path("_health/", include(health_urls, namespace="health")),
         path("notifications/", include(notifications_urls, namespace="notifications")),
+        path("search/", include(search_urls, namespace="search")),
         path("admin/", include(admin_urls, namespace="admin")),
         path("mcp/", include(mcp_urls, namespace="mcp")),
         path(

backend/src/baserow/contrib/automation/apps.py

@@ -213,3 +213,9 @@ def ready(self):
             )
 
             connect_to_node_pre_delete_signal()
+
+        from baserow.core.search.registries import workspace_search_registry
+
+        from .search_types import AutomationSearchType
+
+        workspace_search_registry.register(AutomationSearchType())

backend/src/baserow/contrib/automation/search_types.py

@@ -0,0 +1,13 @@
+from baserow.contrib.automation.models import Automation
+from baserow.core.search.search_types import ApplicationSearchType
+
+
+class AutomationSearchType(ApplicationSearchType):
+    """
+    Searchable item type specifically for automations.
+    """
+
+    type = "automation"
+    name = "Automation"
+    model_class = Automation
+    priority = 4

backend/src/baserow/contrib/builder/apps.py

@@ -337,3 +337,8 @@ def ready(self):
         # which need to be filled first.
         import baserow.contrib.builder.signals  # noqa: F403, F401
         import baserow.contrib.builder.ws.signals  # noqa: F403, F401
+        from baserow.core.search.registries import workspace_search_registry
+
+        from .search_types import BuilderSearchType
+
+        workspace_search_registry.register(BuilderSearchType())

backend/src/baserow/contrib/builder/search_types.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from baserow.contrib.builder.models import Builder
+from baserow.core.models import Workspace
+from baserow.core.search.data_types import SearchResult
+from baserow.core.search.search_types import ApplicationSearchType
+
+
+class BuilderSearchType(ApplicationSearchType):
+    """
+    Searchable item type specifically for builders.
+    """
+
+    type = "builder"
+    name = "Builder"
+    model_class = Builder
+    priority = 2
+
+    def serialize_result(
+        self, result, user=None, workspace: "Workspace" = None
+    ) -> Optional[SearchResult]:
+        """Convert builder to search result with builder_id in metadata."""
+
+        return SearchResult(
+            type=self.type,
+            id=result.id,
+            title=result.name,
+            subtitle=self.type,
+            created_on=result.created_on,
+            updated_on=result.updated_on,
+            metadata={
+                "workspace_id": workspace.id,
+                "workspace_name": workspace.name,
+                "builder_id": result.id,
+            },
+        )