Merge pull request #255 from sparkgeo/254-input-validation-changes

254 input validation changes

Author: vincentsarago

.gitignore

@@ -100,6 +100,9 @@ ENV/
 # mypy
 .mypy_cache/
 
+# IDE
+.vscode
+
 log-config.yml
 
 .pgdata/

CHANGES.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 * disable tests for pre-0.9 pgstac versions
+* address several instances of validation failures returning 500 instead of 4xx HTTP responses
 
 ## 2.0.0 (2026-01-13)
 

pyproject.toml

@@ -27,12 +27,13 @@ classifiers = [
     "Topic :: Scientific/Engineering :: GIS",
 ]
 dependencies = [
-    "titiler.core>=1.1,<1.2",
-    "titiler.mosaic>=1.1,<1.2",
-    "titiler.extensions>=1.1,<1.2",
+    "titiler.core>=1.2,<1.3",
+    "titiler.mosaic>=1.2,<1.3",
+    "titiler.extensions>=1.2,<1.3",
     "cql2>=0.3.6",
     "pydantic>=2.4,<3.0",
     "pydantic-settings~=2.0",
+    "stac-pydantic>=3.5.0,<4",
 ]
 dynamic = ["version"]
 

tests/test_collections.py

@@ -1,5 +1,6 @@
 """Test titiler.pgstac Mosaic endpoints."""
 
+import datetime
 import io
 import json
 from unittest.mock import patch
@@ -692,3 +693,147 @@ def test_collections_cql_filter(filter_expr, filter_lang, app):
     assert len(resp) == 1
     assert list(resp[0]) == ["id", "bbox", "assets", "collection"]
     assert resp[0]["id"] == "20200307aC0853000w361030"
+
+
+def test_datetime_validation(app) -> None:
+    """Ensure datetime parameter validation works as expected."""
+    valid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "datetime": datetime.datetime.now(tz=datetime.UTC).isoformat(),
+        },
+    )
+    assert valid_response.status_code == 200
+    invalid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "datetime": "this is not a valid datetime string",
+        },
+    )
+    assert invalid_response.status_code == 422
+
+
+def test_query_validation(app) -> None:
+    """Ensure query parameter validation works as expected."""
+    valid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "query": json.dumps({"eo:cloud_cover": {"gte": 95}}),
+        },
+    )
+    assert valid_response.status_code == 200
+    invalid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "query": "this is not a valid query string",
+        },
+    )
+    assert invalid_response.status_code == 422
+
+
+def test_query_json_content(app) -> None:
+    """Ensure valid JSON with invalid query content is validated correctly."""
+    invalid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "query": json.dumps({"this": "is not a valid query"}),
+        },
+    )
+    assert invalid_response.status_code == 422
+
+
+def test_filter_json_validation(app) -> None:
+    """Ensure JSON filter parameter validation works as expected."""
+    valid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "filter": json.dumps(
+                {
+                    "op": "lte",
+                    "args": [
+                        {
+                            "property": "gsd",
+                        },
+                        10,
+                    ],
+                }
+            ),
+            "filter-lang": "cql2-json",
+        },
+    )
+    assert valid_response.status_code == 200
+    invalid_content_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "filter": json.dumps({"this": "is invalid content"}),
+        },
+    )
+    assert invalid_content_response.status_code == 422
+    invalid_json_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "filter": "this is not a valid JSON string",
+            "filter-lang": "cql2-json",
+        },
+    )
+    assert invalid_json_response.status_code == 422
+
+
+def test_filter_text_validation(app) -> None:
+    """Ensure text filter parameter validation works as expected."""
+    valid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "filter": "id=irrelevant-value",
+            "filter-lang": "cql2-text",
+        },
+    )
+    assert valid_response.status_code == 200
+    invalid_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "filter": "this is not a valid filter string",
+            "filter-lang": "cql2-text",
+        },
+    )
+    assert invalid_response.status_code == 422
+
+
+def test_bbox_validation(app) -> None:
+    """Ensure bbox parameter validation works as expected."""
+    valid_response_3d = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "bbox": "-180,-90,-1,180,90,1",
+        },
+    )
+    assert valid_response_3d.status_code == 200
+
+    valid_response_2d = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "bbox": "-180,-90,180,90",
+        },
+    )
+    assert valid_response_2d.status_code == 200
+
+    invalid_format_1_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "bbox": "invalid bbox string",
+        },
+    )
+    assert invalid_format_1_response.status_code == 422
+
+    invalid_format_2_response = app.get(
+        f"/collections/{collection_id}/tiles",
+        params={
+            "bbox": "-180,-90,180",
+        },
+    )
+    assert invalid_format_2_response.status_code == 422
+
+    invalid_values_response = app.get(
+        f"/collections/{collection_id}/tiles", params={"bbox": "180,-90,-180,90"}
+    )
+    assert invalid_values_response.status_code == 422

titiler/pgstac/dependencies.py

@@ -17,14 +17,18 @@
 from psycopg import errors as pgErrors
 from psycopg.rows import class_row, dict_row
 from psycopg_pool import ConnectionPool
+from pydantic import BeforeValidator
+from stac_pydantic.shared import validate_datetime
 from starlette.requests import Request
 from typing_extensions import Annotated
 
 from titiler.core.dependencies import DefaultDependency
+from titiler.core.validation import validate_json
 from titiler.pgstac import model
 from titiler.pgstac.errors import MosaicNotFoundError, ReadOnlyPgSTACError
 from titiler.pgstac.settings import CacheSettings, RetrySettings
 from titiler.pgstac.utils import retry
+from titiler.pgstac.validation import parse_and_validate_bbox, validate_filter
 
 cache_config = CacheSettings()
 retry_config = RetrySettings()
@@ -215,6 +219,7 @@ def CollectionIdParams(
     ] = None,
     bbox: Annotated[
         str | None,
+        BeforeValidator(parse_and_validate_bbox),
         Query(
             description="Filters items intersecting this bounding box",
             openapi_examples={
@@ -225,6 +230,7 @@ def CollectionIdParams(
     ] = None,
     datetime: Annotated[
         str | None,
+        BeforeValidator(validate_datetime),
         Query(
             description="""Filters items that have a temporal property that intersects this value.\n
 Either a date-time or an interval, open or closed. Date and time expressions adhere to RFC 3339. Open intervals are expressed using double-dots.""",
@@ -242,6 +248,7 @@ def CollectionIdParams(
     # Extensions
     query: Annotated[
         str | None,
+        BeforeValidator(validate_json),
         Query(
             description="Allows additional filtering based on the properties of Item objects",
             openapi_examples={
@@ -285,6 +292,7 @@ def CollectionIdParams(
     ] = "cql2-text",
 ) -> str:
     """Collection endpoints Parameters"""
+    validate_filter(filter_expr=filter_expr, filter_lang=filter_lang)
     return get_collection_id(
         request.app.state.dbpool,
         collection_id=collection_id,

titiler/pgstac/main.py

@@ -6,10 +6,11 @@
 
 import jinja2
 import rasterio
-from fastapi import FastAPI, Path, Query
+from fastapi import FastAPI, Path, Query, status
 from psycopg import OperationalError
 from psycopg.rows import dict_row
 from psycopg_pool import PoolTimeout
+from pydantic import ValidationError
 from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import Request
 from starlette.templating import Jinja2Templates
@@ -103,7 +104,12 @@ async def lifespan(app: FastAPI):
 # Fix OpenAPI response header for OGC Common compatibility
 update_openapi(app)
 
-ERRORS = {**DEFAULT_STATUS_CODES, **MOSAIC_STATUS_CODES, **PGSTAC_STATUS_CODES}
+ERRORS = {
+    **DEFAULT_STATUS_CODES,
+    **MOSAIC_STATUS_CODES,
+    **PGSTAC_STATUS_CODES,
+    ValidationError: status.HTTP_422_UNPROCESSABLE_CONTENT,
+}
 add_exception_handlers(app, ERRORS)
 
 

titiler/pgstac/model.py

@@ -16,6 +16,7 @@
 from typing_extensions import Annotated
 
 from titiler.core.resources.enums import MediaType
+from titiler.pgstac.validation import validate_bbox as validate_bbox_common
 
 # ref: https://github.com/stac-api-extensions/query
 # TODO: add "startsWith", "endsWith", "contains", "in"
@@ -204,34 +205,9 @@ def validate_spatial(cls, v: Geometry | None, info: ValidationInfo):
         return v
 
     @field_validator("bbox")
-    def validate_bbox(cls, v: BBox):
+    def validate_bbox(cls, value: BBox | None):
         """Validate BBOX."""
-        if v:
-            # Validate order
-            if len(v) == 4:
-                xmin, ymin, xmax, ymax = v
-            else:
-                xmin, ymin, min_elev, xmax, ymax, max_elev = v
-                if max_elev < min_elev:
-                    raise ValueError(
-                        "Maximum elevation must greater than minimum elevation"
-                    )
-
-            if xmax < xmin:
-                raise ValueError(
-                    "Maximum longitude must be greater than minimum longitude"
-                )
-
-            if ymax < ymin:
-                raise ValueError(
-                    "Maximum longitude must be greater than minimum longitude"
-                )
-
-            # Validate against WGS84
-            if xmin < -180 or ymin < -90 or xmax > 180 or ymax > 90:
-                raise ValueError("Bounding box must be within (-180, -90, 180, 90)")
-
-        return v
+        return validate_bbox_common(value)
 
 
 class RegisterMosaic(PgSTACSearch):

titiler/pgstac/validation.py

@@ -0,0 +1,78 @@
+"""
+Validation functions for caller-provided data.
+"""
+
+from typing import Literal, cast
+
+from cql2 import Expr
+from geojson_pydantic.types import BBox
+from pydantic import ValidationError
+
+from titiler.core.validation import validate_json
+
+
+def validate_filter(
+    filter_expr: str | None, filter_lang: Literal["cql2-text", "cql2-json"]
+) -> None:
+    """
+    Verify that a filter string can be parsed, parsing is determined by the language used.
+    :param filter_expr: Caller-provided filter value.
+    :type filter_expr: str | None
+    :param filter_lang: Caller-provided language value.
+    :type filter_lang: str
+    """
+    if filter_expr is None:
+        return
+    if filter_lang == "cql2-json":
+        try:
+            validate_json(json_str=filter_expr)
+        except ValueError as e:
+            raise ValidationError(str(e), []) from e
+    elif filter_lang == "cql2-text":
+        try:
+            Expr(filter_expr).validate()
+        except Exception as e:
+            raise ValidationError(str(e), []) from e
+
+
+def validate_bbox(v: BBox | None):
+    """Validate BBOX values."""
+    if v:
+        # Validate order
+        if len(v) == 4:
+            xmin, ymin, xmax, ymax = v
+        elif len(v) == 6:
+            xmin, ymin, min_elev, xmax, ymax, max_elev = v
+            if max_elev < min_elev:
+                raise ValueError(
+                    "Maximum elevation must greater than minimum elevation"
+                )
+        else:
+            raise ValueError("Bounding box must have 4 or 6 numbers")
+
+        if xmax < xmin:
+            raise ValueError("Maximum longitude must be greater than minimum longitude")
+
+        if ymax < ymin:
+            raise ValueError("Maximum longitude must be greater than minimum longitude")
+
+        # Validate against WGS84
+        if xmin < -180 or ymin < -90 or xmax > 180 or ymax > 90:
+            raise ValueError("Bounding box must be within (-180, -90, 180, 90)")
+
+    return v
+
+
+def parse_and_validate_bbox(value: str | None):
+    """Validate BBOX format and values."""
+    if value is None:
+        return None
+    try:
+        parsed_value = cast(BBox, [float(x) for x in value.split(",")])
+    except ValueError as e:
+        raise ValueError(
+            "Bounding box must be a comma-separated list of numbers"
+        ) from e
+
+    validate_bbox(parsed_value)
+    return value