feat: frontend URL handling with absolute URL generation. (#36)

* feat: frontend URL handling with absolute URL generation.

* refactor: use request context to handle frontend protocol or http as fallback

* refactor: simplify get_absolute_frontend_url path handling

* test: add unit tests for `get_absolute_frontend_url` utility

* fix: remove unused imports from utils module

* fix: remove unused imports from serializers

Author: metaforx

README.md

@@ -180,6 +180,12 @@ INSTALLED_APPS = [
 ]
 ```
 
+Set up frontend protocol and caching in your `settings.py`:
+```python
+# Set frontend protocol
+FRONTEND_PROTOCOL = 'http'  # or 'https', needed for absolute URLs in API responses
+```
+
 ```python
 # Enabled Caching
 CONTENT_CACHE_DURATION = 60  # Overwrites default from django CMS

djangocms_rest/serializers/pages.py

@@ -5,6 +5,7 @@
 from rest_framework import serializers
 
 from djangocms_rest.serializers.placeholders import PlaceholderRelationSerializer
+from djangocms_rest.utils import get_absolute_frontend_url
 
 
 class BasePageSerializer(serializers.Serializer):
@@ -38,30 +39,33 @@ class PreviewMixin:
 
 class BasePageContentMixin:
     def get_base_representation(self, page_content: PageContent) -> Dict:
-        relative_url = page_content.page.get_path(page_content.language)
-        absolute_url = page_content.page.get_absolute_url(page_content.language) or ""
+        request = getattr(self, "request", None)
+        path = page_content.page.get_path(page_content.language)
+        absolute_url = get_absolute_frontend_url(request,path)
+        redirect = str(page_content.redirect or "")
         xframe_options = str(page_content.xframe_options or "")
+        application_namespace = str(page_content.page.application_namespace or "")
         limit_visibility_in_menu = bool(page_content.limit_visibility_in_menu)
 
         return {
             "title": page_content.title,
             "page_title": page_content.page_title or page_content.title,
             "menu_title": page_content.menu_title or page_content.title,
             "meta_description": page_content.meta_description,
-            "redirect": page_content.redirect,
+            "redirect": redirect,
             "in_navigation": page_content.in_navigation,
             "soft_root": page_content.soft_root,
             "template": page_content.template,
             "xframe_options": xframe_options,
             "limit_visibility_in_menu": limit_visibility_in_menu,
             "language": page_content.language,
-            "path": relative_url,
+            "path": path,
             "absolute_url": absolute_url,
             "is_home": page_content.page.is_home,
             "login_required": page_content.page.login_required,
             "languages": page_content.page.get_languages(),
             "is_preview": getattr(self, "is_preview", False),
-            "application_namespace": page_content.page.application_namespace,
+            "application_namespace": application_namespace,
             "creation_date": page_content.creation_date,
             "changed_date": page_content.changed_date,
         }
@@ -78,9 +82,7 @@ def tree_to_representation(self, item: PageContent) -> Dict:
         serialized_data = self.child.to_representation(item)
         serialized_data["children"] = []
         if item.page in self.tree:
-            serialized_data["children"] = [
-                self.tree_to_representation(child) for child in self.tree[item.page]
-            ]
+            serialized_data["children"] = [self.tree_to_representation(child) for child in self.tree[item.page]]
         return serialized_data
 
     def to_representation(self, data: Dict) -> list[Dict]:
@@ -152,6 +154,7 @@ def to_representation(self, page_content: PageContent) -> Dict:
 
 class PreviewPageContentSerializer(PageContentSerializer, PreviewMixin):
     """Serializer specifically for preview/draft page content"""
+
     placeholders = PlaceholderRelationSerializer(many=True, required=False)
 
     def to_representation(self, page_content: PageContent) -> Dict:

djangocms_rest/utils.py

@@ -1,6 +1,8 @@
 from cms.models import Page, PageUrl
 from django.contrib.sites.models import Site
+from django.contrib.sites.shortcuts import get_current_site
 from django.http import Http404
+from rest_framework.request import Request
 
 
 def get_object(site: Site, path: str) -> Page:
@@ -15,3 +17,25 @@ def get_object(site: Site, path: str) -> Page:
     else:
         page.urls_cache = {url.language: url for url in page_urls}
     return page
+
+
+def get_absolute_frontend_url(request: Request, path: str) -> str:
+    """
+    Creates an absolute URL for a given relative path using the current site's domain and protocol.
+
+    Args:
+        request: The HTTP request object
+        path: The relative path to the page
+
+    Returns:
+        An absolute URL formatted as a string.
+    """
+
+    if path.startswith('/'):
+        raise ValueError(f"Path should not start with '/': {path}")
+
+    site = get_current_site(request) if request else Site.objects.get(id=1)
+    domain = site.domain.rstrip('/')
+    protocol = getattr(request, "scheme", "http")
+
+    return f"{protocol}://{domain}/{path}"

djangocms_rest/views.py

@@ -115,7 +115,7 @@ def get(self, request, language):
         except PageContent.DoesNotExist:
             raise NotFound()
 
-        serializer = self.serializer_class(pages, many=True, read_only=True)
+        serializer = self.serializer_class(pages, many=True, read_only=True, context={"request": request})
         return Response(serializer.data)
 
 
@@ -134,7 +134,7 @@ def get(self, request: Request, language: str, path: str = "") -> Response:
             page_content = page.get_content_obj(language, fallback=True)
             if page_content is None:
                 raise PageContent.DoesNotExist()
-            serializer = self.serializer_class(page_content, read_only=True)
+            serializer = self.serializer_class(page_content, read_only=True, context={"request": request})
             return Response(serializer.data)
         except PageContent.DoesNotExist:
             raise NotFound()
@@ -250,7 +250,7 @@ def get(self, request: Request, language: str, path: str = "") -> Response:
         except PageContent.DoesNotExist:
             raise NotFound()
 
-        serializer = self.serializer_class(page_content, read_only=True)
+        serializer = self.serializer_class(page_content, read_only=True, context={"request": request})
         return Response(serializer.data)
 
 #NOTE: This is working, but might need refactoring
@@ -279,7 +279,7 @@ def get(self, request, language):
         except PageContent.DoesNotExist:
             raise NotFound()
 
-        serializer = self.serializer_class(pages, many=True, read_only=True)
+        serializer = self.serializer_class(pages, many=True, read_only=True, context={"request": request})
         return Response(serializer.data)
 
 class PreviewPageListView(BaseListAPIView):

tests/core/__init__.py

@@ -0,0 +1,55 @@
+from django.contrib.sites.models import Site
+from rest_framework.test import APIRequestFactory
+
+from djangocms_rest.utils import get_absolute_frontend_url
+from tests.base import BaseCMSRestTestCase
+
+
+class UrlUtilsTestCase(BaseCMSRestTestCase):
+    """
+    Test the get_absolute_frontend_url utility function.
+
+    Verifies:
+    - Function correctly builds absolute URLs for frontend paths
+    - Function raises proper ValueError for invalid paths
+    - Function works correctly with both a request object and None
+    - All URLs use the correct domain from a Site object
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.factory = APIRequestFactory()
+
+    def test_get_absolute_frontend_url_valid_path(self):
+        """Test that get_absolute_frontend_url works with valid paths."""
+
+        request = self.factory.get("/dummy")
+        site = Site.objects.get_current()
+        result = get_absolute_frontend_url(request, "valid/path")
+
+        # Validation
+        expected_url = f"http://{site.domain}/valid/path"
+        self.assertEqual(result, expected_url)
+
+    def test_get_absolute_frontend_url_with_leading_slash(self):
+        """Test that get_absolute_frontend_url raises ValueError with paths starting with /."""
+        request = self.factory.get("/dummy")
+
+        # Function execution and validation
+        with self.assertRaises(ValueError) as context:
+            get_absolute_frontend_url(request, "/invalid/path")
+
+        # Error message validation
+        error_message = str(context.exception)
+        self.assertIn("Path should not start with '/'", error_message)
+        self.assertIn("/invalid/path", error_message)
+
+    def test_get_absolute_frontend_url_without_request(self):
+        """Test that get_absolute_frontend_url works with request=None."""
+
+        result = get_absolute_frontend_url(None, "valid/path")
+
+        # Validation
+        site = Site.objects.get(id=1)
+        expected_url = f"http://{site.domain}/valid/path"
+        self.assertEqual(result, expected_url)

tests/core/test_utils.py

@@ -181,3 +181,4 @@ def __getitem__(self, item):
 }
 
 USE_TZ = True
+