Merge pull request #1482 from RS-PYTHON/feat-rspy519/implement-first-last-stacbrowser

feat-rspy519/implement-first-last-stacbrowser

Author: astanga-cs

.github/workflows/publish-binaries.yml

@@ -371,7 +371,7 @@ jobs:
       - name: Copy layer-cleanup.sh script
         run: cp -t ./build_context_path ./.github/scripts/layer-cleanup.sh
         shell: bash
-        
+
       - name: Copy debug mode dependencies
         if: ${{ needs.set-env.outputs.debug_mode }} == true
         run: cp -t ./build_context_path ./.github/scripts/git_debug_image.sh
@@ -417,7 +417,7 @@ jobs:
       - name: Copy layer-cleanup.sh script
         run: cp -t ./build_context_path ./.github/scripts/layer-cleanup.sh
         shell: bash
-        
+
       - name: Copy debug mode dependencies
         if: ${{ needs.set-env.outputs.debug_mode }} == true
         run: cp -t ./build_context_path ./.github/scripts/git_debug_image.sh
@@ -464,7 +464,7 @@ jobs:
       - name: Copy layer-cleanup.sh script
         run: cp -t ./build_context_path ./.github/scripts/layer-cleanup.sh
         shell: bash
-        
+
       - name: Copy debug mode dependencies
         if: ${{ needs.set-env.outputs.debug_mode }} == true
         run: cp -t ./build_context_path ./.github/scripts/git_debug_image.sh
@@ -511,7 +511,7 @@ jobs:
       - name: Copy layer-cleanup.sh script
         run: cp -t ./build_context_path ./.github/scripts/layer-cleanup.sh
         shell: bash
-        
+
       - id: publish-docker
         uses: ./.github/actions/publish-docker
         with:

services/catalog/rs_server_catalog/app.py

@@ -35,6 +35,7 @@
 from rs_server_common.middlewares import (
     AuthenticationMiddleware,
     HandleExceptionsMiddleware,
+    PaginationLinksMiddleware,
     apply_middlewares,
     insert_middleware_after,
 )
@@ -126,6 +127,7 @@ async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -
 if common_settings.CLUSTER_MODE:
     app = apply_middlewares(app)
 
+app.add_middleware(PaginationLinksMiddleware)
 
 logger.debug(f"Middlewares: {app.user_middleware}")
 

services/common/rs_server_common/fastapi_app.py

@@ -30,6 +30,7 @@
 from rs_server_common.authentication.oauth2 import AUTH_PREFIX
 from rs_server_common.middlewares import (
     HandleExceptionsMiddleware,
+    PaginationLinksMiddleware,
     StacLinksTitleMiddleware,
 )
 from rs_server_common.schemas.health_schema import HealthSchema
@@ -224,6 +225,10 @@ async def patched_landing_page(self, request, **kwargs):
 
     # This middleware allows to have consistant http/https protocol in stac links
     app.add_middleware(ProxyHeaderMiddleware)
+
+    # Middleware for implementing first and last buttons in STAC Browser
+    app.add_middleware(PaginationLinksMiddleware)
+
     app.add_middleware(StacLinksTitleMiddleware, title="My STAC Title")
     # Add CORS requests from the STAC browser
     if settings.CORS_ORIGINS:

services/common/rs_server_common/middlewares.py

@@ -17,9 +17,10 @@
 import os
 import traceback
 from collections.abc import Callable
-from typing import ParamSpec, TypedDict
+from typing import Any, ParamSpec, TypedDict
 from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
 
+import brotli
 from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
 from rs_server_common import settings as common_settings
@@ -131,6 +132,111 @@ def is_bad_request(self, request: Request, e: Exception) -> bool:
         )
 
 
+class PaginationLinksMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to implement 'first' button's functionality in STAC Browser
+    """
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: Callable,
+    ):  # pylint: disable=too-many-branches,too-many-statements
+
+        # Only for /search in auxip, prip, cadip
+        if request.url.path in ["/auxip/search", "/cadip/search", "/prip/search", "/catalog/search"]:
+
+            first_link: dict[str, Any] = {
+                "rel": "first",
+                "type": "application/geo+json",
+                "method": request.method,
+                "href": f"{str(request.base_url).rstrip('/')}{request.url.path}",
+                "title": "First link",
+            }
+
+            if common_settings.CLUSTER_MODE:
+                first_link["href"] = f"https://{str(request.base_url.hostname).rstrip('/')}{request.url.path}"
+
+            if request.method == "GET":
+                # parse query params to remove any 'prev' or 'next'
+                query_dict = dict(request.query_params)
+
+                query_dict.pop("token", None)
+                if "page" in query_dict:
+                    query_dict["page"] = "1"
+                new_query_string = urlencode(query_dict, doseq=True)
+                first_link["href"] += f"?{new_query_string}"
+
+            elif request.method == "POST":
+                try:
+                    query = await request.json()
+                    body = {}
+
+                    for key in ["datetime", "limit"]:
+                        if key in query and query[key] is not None:
+                            body[key] = query[key]
+
+                    if "token" in query and request.url.path != "/catalog/search":
+                        body["token"] = "page=1"  # nosec
+
+                    first_link["body"] = body
+                except Exception:  # pylint: disable = broad-exception-caught
+                    logger.error(traceback.format_exc())
+
+            response = await call_next(request)
+
+            encoding = response.headers.get("content-encoding", "")
+            if encoding == "br":
+                body_bytes = b"".join([section async for section in response.body_iterator])
+                response_body = brotli.decompress(body_bytes)
+
+                if request.url.path == "/catalog/search":
+                    first_link["auth:refs"] = ["apikey", "openid", "oauth2"]
+            else:
+                response_body = b""
+                async for chunk in response.body_iterator:
+                    response_body += chunk
+
+            try:
+                data = json.loads(response_body)
+
+                links = data.get("links", [])
+                has_prev = any(link.get("rel") == "previous" for link in links)
+
+                if has_prev is True:
+                    links.append(first_link)
+                    data["links"] = links
+
+                headers = dict(response.headers)
+                headers.pop("content-length", None)
+
+                if encoding == "br":
+                    new_body = brotli.compress(json.dumps(data).encode("utf-8"))
+                else:
+                    new_body = json.dumps(data).encode("utf-8")
+
+                response = Response(
+                    content=new_body,
+                    status_code=response.status_code,
+                    headers=headers,
+                    media_type="application/json",
+                )
+            except Exception:  # pylint: disable = broad-exception-caught
+                headers = dict(response.headers)
+                headers.pop("content-length", None)
+
+                response = Response(
+                    content=response_body,
+                    status_code=response.status_code,
+                    headers=headers,
+                    media_type=response.headers.get("content-type"),
+                )
+        else:
+            return await call_next(request)
+
+        return response
+
+
 def get_link_title(link: dict, entity: dict) -> str:
     """
     Determine a human-readable STAC link title based on the link relation and context.

tests/test_stac_pagination.py

@@ -0,0 +1,90 @@
+# Copyright 2025 CS Group
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Unit tests for the stac pagination."""
+
+import json
+
+import brotli
+import httpx
+import pytest
+from fastapi import FastAPI, Response
+from fastapi.testclient import TestClient
+from rs_server_common.middlewares import (
+    HandleExceptionsMiddleware,
+    PaginationLinksMiddleware,
+)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("anyio_backend", ["asyncio"], ids=["asyncio"])
+@pytest.mark.parametrize("use_br", [True, False], ids=["br", "no_br"])
+async def test_pagination_links_middleware_catalog_authrefs(use_br):
+    """
+    Tests for cluster where there must be set the 'br' encoding and authentication references for /catalog
+    """
+    app = FastAPI()
+    app.add_middleware(HandleExceptionsMiddleware)
+    app.add_middleware(PaginationLinksMiddleware)
+
+    @app.post("/catalog/search")
+    def catalog_search():
+        payload = {"links": [{"rel": "previous"}], "features": []}
+        raw = json.dumps(payload).encode("utf-8")
+        if use_br:
+            body = brotli.compress(raw)
+            headers = {"content-type": "application/json", "content-encoding": "br"}
+            return Response(content=body, status_code=200, headers=headers)
+        return Response(content=raw, status_code=200, media_type="application/json")
+
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
+        if use_br:
+            # checks if the headers were kept
+            async with client.stream("POST", "/catalog/search", json={"limit": 1}) as resp:
+                assert resp.status_code == 200
+                assert resp.headers.get("content-type") == "application/json"
+                assert resp.headers.get("content-encoding") == "br"
+        else:
+            resp = await client.post("/catalog/search", json={"limit": 1})
+            assert resp.status_code == 200
+            assert resp.headers.get("content-type") == "application/json"
+            assert resp.headers.get("content-encoding") is None
+
+            # checks if 'first' was added when there is 'previous'
+            data = resp.json()
+            assert any(rel.get("rel") == "first" for rel in data.get("links", []))
+
+
+@pytest.mark.anyio
+def test_pagination_links_middleware_handles_malformed_json():
+    """
+    Test case with a malformed JSON
+    """
+    app = FastAPI()
+    app.add_middleware(HandleExceptionsMiddleware)
+    app.add_middleware(PaginationLinksMiddleware)
+
+    @app.post("/auxip/search")
+    def auxip_search():
+        headers = {"content-type": "application/json"}
+        return Response(content=b"not-json", status_code=200, headers=headers)
+
+    client = TestClient(app)
+    resp = client.post("/auxip/search", json={"limit": 1})
+
+    assert resp.status_code == 200
+    assert resp.headers.get("content-type") == "application/json"
+    assert resp.headers.get("content-encoding") is None
+    assert resp.text == "not-json"