eodag 2.12.1__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

eodag/rest/server.py

@@ -19,9 +19,11 @@ from __future__ import annotations
 
 import logging
 import os
+import re
 import traceback
 from contextlib import asynccontextmanager
 from importlib.metadata import version
+from json import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -29,37 +31,39 @@ from typing import (
     Awaitable,
     Callable,
     Dict,
-    List,
     Optional,
-    Union,
 )
 
 from fastapi import APIRouter as FastAPIRouter
 from fastapi import FastAPI, HTTPException, Request
-from fastapi.encoders import jsonable_encoder
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.utils import get_openapi
-from fastapi.responses import ORJSONResponse, StreamingResponse
-from pydantic import BaseModel
+from fastapi.responses import ORJSONResponse
+from pydantic import ValidationError as pydanticValidationError
+from pygeofilter.backends.cql2_json import to_cql2
+from pygeofilter.parsers.cql2_text import parse as parse_cql2_text
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from eodag.config import load_stac_api_config
-from eodag.rest.types.stac_queryables import StacQueryables
-from eodag.rest.utils import (
-    download_stac_item_by_id_stream,
+from eodag.rest.cache import init_cache
+from eodag.rest.core import (
+    all_collections,
+    download_stac_item,
     eodag_api_init,
-    fetch_collection_queryable_properties,
+    get_collection,
     get_detailled_collections_list,
+    get_queryables,
     get_stac_api_version,
     get_stac_catalogs,
-    get_stac_collection_by_id,
-    get_stac_collections,
     get_stac_conformance,
     get_stac_extension_oseo,
-    get_stac_item_by_id,
     search_stac_items,
 )
-from eodag.utils import DEFAULT_ITEMS_PER_PAGE, parse_header, update_nested_dict
+from eodag.rest.types.eodag_search import EODAGSearch
+from eodag.rest.types.queryables import QueryablesGetParams
+from eodag.rest.types.stac_search import SearchPostRequest, sortby2list
+from eodag.rest.utils import format_pydantic_error, str2json, str2list
+from eodag.utils import parse_header, update_nested_dict
 from eodag.utils.exceptions import (
     AuthenticationError,
     DownloadError,
@@ -77,8 +81,15 @@ if TYPE_CHECKING:
     from fastapi.types import DecoratedCallable
     from requests import Response
 
+from starlette.responses import Response as StarletteResponse
 
 logger = logging.getLogger("eodag.rest.server")
+ERRORS_WITH_500_STATUS_CODE = {
+    "MisconfiguredError",
+    "AuthenticationError",
+    "DownloadError",
+    "RequestError",
+}
 
 
 class APIRouter(FastAPIRouter):
@@ -118,6 +129,7 @@ router = APIRouter()
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """API init and tear-down"""
     eodag_api_init()
+    init_cache(app)
     yield
 
 
@@ -127,14 +139,16 @@ app = FastAPI(lifespan=lifespan, title="EODAG", docs_url="/api.html")
 stac_api_config = load_stac_api_config()
 
 
-@router.get("/api", tags=["Capabilities"], include_in_schema=False)
-def eodag_openapi() -> Dict[str, Any]:
+@router.api_route(
+    methods=["GET", "HEAD"], path="/api", tags=["Capabilities"], include_in_schema=False
+)
+async def eodag_openapi(request: Request) -> Dict[str, Any]:
     """Customized openapi"""
     logger.debug("URL: /api")
     if app.openapi_schema:
         return app.openapi_schema
 
-    root_catalog = get_stac_catalogs(url="", fetch_providers=False)
+    root_catalog = await get_stac_catalogs(request=request, url="")
     stac_api_version = get_stac_api_version()
 
     openapi_schema = get_openapi(
@@ -151,11 +165,11 @@ def eodag_openapi() -> Dict[str, Any]:
         openapi_schema["components"] = stac_api_config["components"]
     openapi_schema["tags"] = stac_api_config["tags"]
 
-    detailled_collections_list = get_detailled_collections_list(fetch_providers=False)
+    detailled_collections_list = get_detailled_collections_list()
 
     openapi_schema["info"]["description"] = (
         root_catalog["description"]
-        + " (stac-api-spec {})".format(stac_api_version)
+        + f" (stac-api-spec {stac_api_version})"
         + "<details><summary>Available collections / product types</summary>"
         + "".join(
             [
@@ -195,8 +209,10 @@ async def forward_middleware(
 
     if "forwarded" in request.headers:
         header_forwarded = parse_header(request.headers["forwarded"])
-        forwarded_host = header_forwarded.get_param("host", None) or forwarded_host
-        forwarded_proto = header_forwarded.get_param("proto", None) or forwarded_proto
+        forwarded_host = str(header_forwarded.get_param("host", None)) or forwarded_host
+        forwarded_proto = (
+            str(header_forwarded.get_param("proto", None)) or forwarded_proto
+        )
 
     request.state.url_root = f"{forwarded_proto or request.url.scheme}://{forwarded_host or request.url.netloc}"
     request.state.url = f"{request.state.url_root}{request.url.path}"
@@ -221,13 +237,30 @@ async def default_exception_handler(
     )
 
 
+@app.exception_handler(ValidationError)
+async def handle_invalid_usage_with_validation_error(
+    request: Request, error: ValidationError
+) -> ORJSONResponse:
+    """Invalid usage [400] ValidationError handle"""
+    if error.parameters:
+        for error_param in error.parameters:
+            stac_param = EODAGSearch.to_stac(error_param)
+            error.message = error.message.replace(error_param, stac_param)
+    logger.debug(traceback.format_exc())
+    return await default_exception_handler(
+        request,
+        HTTPException(
+            status_code=400,
+            detail=f"{type(error).__name__}: {str(error.message)}",
+        ),
+    )
+
+
 @app.exception_handler(NoMatchingProductType)
 @app.exception_handler(UnsupportedProductType)
 @app.exception_handler(UnsupportedProvider)
-@app.exception_handler(ValidationError)
 async def handle_invalid_usage(request: Request, error: Exception) -> ORJSONResponse:
     """Invalid usage [400] errors handle"""
-    logger.warning(traceback.format_exc())
     return await default_exception_handler(
         request,
         HTTPException(
@@ -254,8 +287,8 @@ async def handle_resource_not_found(
 @app.exception_handler(MisconfiguredError)
 @app.exception_handler(AuthenticationError)
 async def handle_auth_error(request: Request, error: Exception) -> ORJSONResponse:
-    """AuthenticationError should be sent as internal server error to the client"""
-    logger.error(f"{type(error).__name__}: {str(error)}")
+    """These errors should be sent as internal server error to the client"""
+    logger.error("%s: %s", type(error).__name__, str(error))
     return await default_exception_handler(
         request,
         HTTPException(
@@ -266,9 +299,36 @@ async def handle_auth_error(request: Request, error: Exception) -> ORJSONRespons
 
 
 @app.exception_handler(DownloadError)
+async def handle_download_error(request: Request, error: Exception) -> ORJSONResponse:
+    """DownloadError should be sent as internal server error with details to the client"""
+    logger.error(f"{type(error).__name__}: {str(error)}")
+    return await default_exception_handler(
+        request,
+        HTTPException(
+            status_code=500,
+            detail=f"{type(error).__name__}: {str(error)}",
+        ),
+    )
+
+
 @app.exception_handler(RequestError)
-async def handle_server_error(request: Request, error: Exception) -> ORJSONResponse:
-    """These errors should be sent as internal server error with details to the client"""
+async def handle_request_error(request: Request, error: RequestError) -> ORJSONResponse:
+    """RequestError should be sent as internal server error with details to the client"""
+    if getattr(error, "history", None):
+        error_history_tmp = list(error.history)
+        for i, search_error in enumerate(error_history_tmp):
+            if search_error[1].__class__.__name__ in ERRORS_WITH_500_STATUS_CODE:
+                search_error[1].args = ("an internal error occured",)
+                error_history_tmp[i] = search_error
+                continue
+            if getattr(error, "parameters", None):
+                for error_param in error.parameters:
+                    stac_param = EODAGSearch.to_stac(error_param)
+                    search_error[1].args = (
+                        search_error[1].args[0].replace(error_param, stac_param),
+                    )
+                    error_history_tmp[i] = search_error
+        error.history = set(error_history_tmp)
     logger.error(f"{type(error).__name__}: {str(error)}")
     return await default_exception_handler(
         request,
@@ -292,164 +352,166 @@ async def handle_timeout(request: Request, error: Exception) -> ORJSONResponse:
     )
 
 
-@router.get("/", tags=["Capabilities"])
-def catalogs_root(request: Request) -> Any:
+@router.api_route(methods=["GET", "HEAD"], path="/", tags=["Capabilities"])
+async def catalogs_root(request: Request) -> ORJSONResponse:
     """STAC catalogs root"""
-    logger.debug(f"URL: {request.url}")
+    logger.debug("URL: %s", request.url)
 
-    response = get_stac_catalogs(
+    response = await get_stac_catalogs(
+        request=request,
         url=request.state.url,
-        root=request.state.url_root,
-        catalogs=[],
         provider=request.query_params.get("provider", None),
     )
 
-    return jsonable_encoder(response)
+    return ORJSONResponse(response)
 
 
-@router.get("/conformance", tags=["Capabilities"])
-def conformance() -> Any:
+@router.api_route(methods=["GET", "HEAD"], path="/conformance", tags=["Capabilities"])
+def conformance() -> ORJSONResponse:
     """STAC conformance"""
     logger.debug("URL: /conformance")
     response = get_stac_conformance()
 
-    return jsonable_encoder(response)
+    return ORJSONResponse(response)
 
 
-@router.get("/extensions/oseo/json-schema/schema.json", include_in_schema=False)
-def stac_extension_oseo(request: Request) -> Any:
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/extensions/oseo/json-schema/schema.json",
+    include_in_schema=False,
+)
+def stac_extension_oseo(request: Request) -> ORJSONResponse:
     """STAC OGC / OpenSearch extension for EO"""
-    logger.debug(f"URL: {request.url}")
+    logger.debug("URL: %s", request.url)
     response = get_stac_extension_oseo(url=request.state.url)
 
-    return jsonable_encoder(response)
-
-
-class SearchBody(BaseModel):
-    """
-    class which describes the body of a search request
-    """
+    return ORJSONResponse(response)
 
-    provider: Optional[str] = None
-    collections: Union[List[str], str]
-    datetime: Optional[str] = None
-    bbox: Optional[List[Union[int, float]]] = None
-    intersects: Optional[Dict[str, Any]] = None
-    limit: Optional[int] = DEFAULT_ITEMS_PER_PAGE
-    page: Optional[int] = 1
-    query: Optional[Dict[str, Any]] = None
-    ids: Optional[List[str]] = None
 
-
-@router.get(
-    "/collections/{collection_id}/items/{item_id}/download",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections/{collection_id}/items/{item_id}/download",
     tags=["Data"],
     include_in_schema=False,
 )
 def stac_collections_item_download(
     collection_id: str, item_id: str, request: Request
-) -> StreamingResponse:
+) -> StarletteResponse:
     """STAC collection item download"""
-    logger.debug(f"URL: {request.url}")
+    logger.debug("URL: %s", request.url)
 
     arguments = dict(request.query_params)
     provider = arguments.pop("provider", None)
 
-    return download_stac_item_by_id_stream(
-        catalogs=[collection_id], item_id=item_id, provider=provider, **arguments
+    return download_stac_item(
+        request=request,
+        catalogs=[collection_id],
+        item_id=item_id,
+        provider=provider,
+        **arguments,
     )
 
 
-@router.get(
-    "/collections/{collection_id}/items/{item_id}/download/{asset_filter}",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections/{collection_id}/items/{item_id}/download/{asset}",
     tags=["Data"],
     include_in_schema=False,
 )
 def stac_collections_item_download_asset(
-    collection_id, item_id, asset_filter, request: Request
+    collection_id: str, item_id: str, asset: str, request: Request
 ):
     """STAC collection item asset download"""
-    logger.debug(f"URL: {request.url}")
+    logger.debug("URL: %s", request.url)
 
     arguments = dict(request.query_params)
     provider = arguments.pop("provider", None)
 
-    return download_stac_item_by_id_stream(
+    return download_stac_item(
+        request=request,
         catalogs=[collection_id],
         item_id=item_id,
         provider=provider,
-        asset=asset_filter,
-        **arguments,
+        asset=asset,
     )
 
 
-@router.get(
-    "/collections/{collection_id}/items/{item_id}",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections/{collection_id}/items/{item_id}",
     tags=["Data"],
     include_in_schema=False,
 )
-def stac_collections_item(collection_id: str, item_id: str, request: Request) -> Any:
+def stac_collections_item(
+    collection_id: str, item_id: str, request: Request, provider: Optional[str] = None
+) -> ORJSONResponse:
     """STAC collection item by id"""
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url
-    url_root = request.state.url_root
+    logger.debug("URL: %s", request.url)
 
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
-
-    response = get_stac_item_by_id(
-        url=url,
-        item_id=item_id,
-        root=url_root,
-        catalogs=[collection_id],
-        provider=provider,
-        **arguments,
+    search_request = SearchPostRequest(
+        provider=provider, ids=[item_id], collections=[collection_id], limit=1
     )
 
-    if response:
-        return jsonable_encoder(response)
-    else:
+    item_collection = search_stac_items(request, search_request)
+
+    if not item_collection["features"]:
         raise HTTPException(
             status_code=404,
-            detail="No item found matching `{}` id in collection `{}`".format(
-                item_id, collection_id
-            ),
+            detail=f"Item {item_id} in Collection {collection_id} does not exist.",
         )
 
+    return ORJSONResponse(item_collection["features"][0])
 
-@router.get(
-    "/collections/{collection_id}/items",
+
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections/{collection_id}/items",
     tags=["Data"],
     include_in_schema=False,
 )
-def stac_collections_items(collection_id: str, request: Request) -> Any:
-    """STAC collections items"""
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url
-    url_root = request.state.url_root
-
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
+def stac_collections_items(
+    collection_id: str,
+    request: Request,
+    provider: Optional[str] = None,
+    bbox: Optional[str] = None,
+    datetime: Optional[str] = None,
+    limit: Optional[int] = None,
+    query: Optional[str] = None,
+    page: Optional[int] = None,
+    sortby: Optional[str] = None,
+    filter: Optional[str] = None,
+    filter_lang: Optional[str] = "cql2-text",
+    crunch: Optional[str] = None,
+) -> ORJSONResponse:
+    """Fetch collection's features"""
 
-    response = search_stac_items(
-        url=url,
-        arguments=arguments,
-        root=url_root,
+    return get_search(
+        request=request,
         provider=provider,
-        catalogs=[collection_id],
+        collections=collection_id,
+        bbox=bbox,
+        datetime=datetime,
+        limit=limit,
+        query=query,
+        page=page,
+        sortby=sortby,
+        filter=filter,
+        filter_lang=filter_lang,
+        crunch=crunch,
     )
-    return jsonable_encoder(response)
 
 
-@router.get(
-    "/collections/{collection_id}/queryables",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections/{collection_id}/queryables",
     tags=["Capabilities"],
     include_in_schema=False,
     response_model_exclude_none=True,
 )
-def list_collection_queryables(
-    request: Request, collection_id: str, provider: Optional[str] = None
-) -> Any:
+async def list_collection_queryables(
+    request: Request,
+    collection_id: str,
+) -> ORJSONResponse:
     """Returns the list of queryable properties for a specific collection.
 
     This endpoint provides a list of properties that can be used as filters when querying
@@ -460,118 +522,117 @@ def list_collection_queryables(
     :type request: fastapi.Request
     :param collection_id: The identifier of the collection for which to retrieve queryable properties.
     :type collection_id: str
-    :param provider: (optional) The provider for which to retrieve additional properties.
-    :type provider: str
     :returns: A json object containing the list of available queryable properties for the specified collection.
     :rtype: Any
     """
     logger.debug(f"URL: {request.url}")
-    query_params = request.query_params.items()
-    additional_params = dict(query_params)
-    additional_params.pop("provider", None)
-
-    queryables = StacQueryables(q_id=request.state.url, additional_properties=False)
+    additional_params = dict(request.query_params)
+    provider = additional_params.pop("provider", None)
 
-    collection_queryables = fetch_collection_queryable_properties(
-        collection_id, provider, **additional_params
+    queryables = await get_queryables(
+        request,
+        QueryablesGetParams(collection=collection_id, **additional_params),
+        provider=provider,
     )
-    for key, collection_queryable in collection_queryables.items():
-        queryables[key] = collection_queryable
-    queryables.properties.pop("collections")
 
-    return jsonable_encoder(queryables)
+    return ORJSONResponse(queryables)
 
 
-@router.get(
-    "/collections/{collection_id}",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections/{collection_id}",
     tags=["Capabilities"],
     include_in_schema=False,
 )
-def collection_by_id(collection_id: str, request: Request) -> Any:
+async def collection_by_id(
+    collection_id: str, request: Request, provider: Optional[str] = None
+) -> ORJSONResponse:
     """STAC collection by id"""
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url_root + "/collections"
-    url_root = request.state.url_root
+    logger.debug("URL: %s", request.url)
 
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
-
-    response = get_stac_collection_by_id(
-        url=url,
-        root=url_root,
+    response = await get_collection(
+        request=request,
         collection_id=collection_id,
         provider=provider,
     )
 
-    return jsonable_encoder(response)
+    return ORJSONResponse(response)
 
 
-@router.get(
-    "/collections",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/collections",
     tags=["Capabilities"],
     include_in_schema=False,
 )
-def collections(request: Request) -> Any:
+async def collections(
+    request: Request,
+    provider: Optional[str] = None,
+    q: Optional[str] = None,
+    platform: Optional[str] = None,
+    instrument: Optional[str] = None,
+    constellation: Optional[str] = None,
+    datetime: Optional[str] = None,
+) -> ORJSONResponse:
     """STAC collections
 
-    Can be filtered using parameters: instrument, platform, platformSerialIdentifier, sensorType, processingLevel
+    Can be filtered using parameters: instrument, platform, platformSerialIdentifier, sensorType,
+    processingLevel
     """
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url
-    url_root = request.state.url_root
+    logger.debug("URL: %s", request.url)
 
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
-
-    response = get_stac_collections(
-        url=url,
-        root=url_root,
-        arguments=arguments,
-        provider=provider,
+    collections = await all_collections(
+        request, provider, q, platform, instrument, constellation, datetime
     )
+    return ORJSONResponse(collections)
 
-    return jsonable_encoder(response)
 
-
-@router.get(
-    "/catalogs/{catalogs:path}/items/{item_id}/download",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/catalogs/{catalogs:path}/items/{item_id}/download",
     tags=["Data"],
     include_in_schema=False,
 )
 def stac_catalogs_item_download(
     catalogs: str, item_id: str, request: Request
-) -> StreamingResponse:
+) -> StarletteResponse:
     """STAC Catalog item download"""
-    logger.debug(f"URL: {request.url}")
+    logger.debug("URL: %s", request.url)
 
     arguments = dict(request.query_params)
     provider = arguments.pop("provider", None)
 
     list_catalog = catalogs.strip("/").split("/")
 
-    return download_stac_item_by_id_stream(
-        catalogs=list_catalog, item_id=item_id, provider=provider, **arguments
+    return download_stac_item(
+        request=request,
+        catalogs=list_catalog,
+        item_id=item_id,
+        provider=provider,
+        **arguments,
     )
 
 
-@router.get(
-    "/catalogs/{catalogs:path}/items/{item_id}/download/{asset_filter}",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/catalogs/{catalogs:path}/items/{item_id}/download/{asset_filter}",
     tags=["Data"],
     include_in_schema=False,
 )
 def stac_catalogs_item_download_asset(
-    catalogs, item_id, asset_filter, request: Request
+    catalogs: str, item_id: str, asset_filter: str, request: Request
 ):
     """STAC Catalog item asset download"""
-    logger.debug(f"URL: {request.url}")
+    logger.debug("URL: %s", request.url)
 
     arguments = dict(request.query_params)
     provider = arguments.pop("provider", None)
 
-    catalogs = catalogs.strip("/").split("/")
+    list_catalog = catalogs.strip("/").split("/")
 
-    return download_stac_item_by_id_stream(
-        catalogs=catalogs,
+    return download_stac_item(
+        request,
+        catalogs=list_catalog,
         item_id=item_id,
         provider=provider,
         asset=asset_filter,
@@ -579,99 +640,116 @@ def stac_catalogs_item_download_asset(
     )
 
 
-@router.get(
-    "/catalogs/{catalogs:path}/items/{item_id}",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/catalogs/{catalogs:path}/items/{item_id}",
     tags=["Data"],
     include_in_schema=False,
 )
-def stac_catalogs_item(catalogs: str, item_id: str, request: Request):
+def stac_catalogs_item(
+    catalogs: str, item_id: str, request: Request, provider: Optional[str] = None
+):
     """Fetch catalog's single features."""
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url
-    url_root = request.state.url_root
-
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
+    logger.debug("URL: %s", request.url)
 
     list_catalog = catalogs.strip("/").split("/")
-    response = get_stac_item_by_id(
-        url=url,
-        item_id=item_id,
-        root=url_root,
-        catalogs=list_catalog,
-        provider=provider,
-        **arguments,
-    )
 
-    if response:
-        return jsonable_encoder(response)
-    else:
+    search_request = SearchPostRequest(provider=provider, ids=[item_id], limit=1)
+
+    item_collection = search_stac_items(request, search_request, catalogs=list_catalog)
+
+    if not item_collection["features"]:
         raise HTTPException(
             status_code=404,
-            detail="No item found matching `{}` id in catalog `{}`".format(
-                item_id, catalogs
-            ),
+            detail=f"Item {item_id} in Catalog {catalogs} does not exist.",
         )
 
+    return ORJSONResponse(item_collection["features"][0])
 
-@router.get(
-    "/catalogs/{catalogs:path}/items",
+
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/catalogs/{catalogs:path}/items",
     tags=["Data"],
     include_in_schema=False,
 )
-def stac_catalogs_items(catalogs: str, request: Request) -> Any:
-    """Fetch catalog's features
-    '"""
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url
-    url_root = request.state.url_root
+def stac_catalogs_items(
+    catalogs: str,
+    request: Request,
+    provider: Optional[str] = None,
+    bbox: Optional[str] = None,
+    datetime: Optional[str] = None,
+    limit: Optional[int] = None,
+    page: Optional[int] = None,
+    sortby: Optional[str] = None,
+    crunch: Optional[str] = None,
+) -> ORJSONResponse:
+    """Fetch catalog's features"""
+    logger.debug("URL: %s", request.state.url)
 
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
+    base_args = {
+        "provider": provider,
+        "datetime": datetime,
+        "bbox": str2list(bbox),
+        "limit": limit,
+        "page": page,
+        "sortby": sortby2list(sortby),
+        "crunch": crunch,
+    }
+
+    clean = {k: v for k, v in base_args.items() if v is not None and v != []}
 
     list_catalog = catalogs.strip("/").split("/")
 
+    try:
+        search_request = SearchPostRequest.model_validate(clean)
+    except pydanticValidationError as e:
+        raise HTTPException(status_code=400, detail=format_pydantic_error(e)) from e
+
     response = search_stac_items(
-        url=url,
-        arguments=arguments,
-        root=url_root,
+        request=request,
+        search_request=search_request,
         catalogs=list_catalog,
-        provider=provider,
     )
-    return jsonable_encoder(response)
+    return ORJSONResponse(response)
 
 
-@router.get(
-    "/catalogs/{catalogs:path}",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/catalogs/{catalogs:path}",
     tags=["Capabilities"],
     include_in_schema=False,
 )
-def stac_catalogs(catalogs: str, request: Request) -> Any:
+async def stac_catalogs(
+    catalogs: str, request: Request, provider: Optional[str] = None
+) -> ORJSONResponse:
     """Describe the given catalog and list available sub-catalogs"""
-    logger.debug(f"URL: {request.url}")
-    url = request.state.url
-    url_root = request.state.url_root
+    logger.debug("URL: %s", request.url)
 
-    arguments = dict(request.query_params)
-    provider = arguments.pop("provider", None)
+    if not catalogs:
+        raise HTTPException(
+            status_code=404,
+            detail="Not found",
+        )
 
     list_catalog = catalogs.strip("/").split("/")
-    response = get_stac_catalogs(
-        url=url,
-        root=url_root,
-        catalogs=list_catalog,
+    response = await get_stac_catalogs(
+        request=request,
+        url=request.state.url,
+        catalogs=tuple(list_catalog),
         provider=provider,
     )
-    return jsonable_encoder(response)
+    return ORJSONResponse(response)
 
 
-@router.get(
-    "/queryables",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/queryables",
     tags=["Capabilities"],
     response_model_exclude_none=True,
     include_in_schema=False,
 )
-def list_queryables(request: Request, provider: Optional[str] = None) -> Any:
+async def list_queryables(request: Request) -> ORJSONResponse:
     """Returns the list of terms available for use when writing filter expressions.
 
     This endpoint provides a list of terms that can be used as filters when querying
@@ -684,57 +762,118 @@ def list_queryables(request: Request, provider: Optional[str] = None) -> Any:
     :rtype: Any
     """
     logger.debug(f"URL: {request.url}")
-    query_params = request.query_params.items()
-    additional_params = dict(query_params)
-    additional_params.pop("provider", None)
-    queryables = StacQueryables(q_id=request.state.url)
-    if provider:
-        queryables.properties.update(
-            fetch_collection_queryable_properties(None, provider, **additional_params)
-        )
+    additional_params = dict(request.query_params.items())
+    provider = additional_params.pop("provider", None)
+    queryables = await get_queryables(
+        request, QueryablesGetParams(**additional_params), provider=provider
+    )
 
-    return jsonable_encoder(queryables)
+    return ORJSONResponse(queryables)
 
 
-@router.get(
-    "/search",
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path="/search",
     tags=["STAC"],
     include_in_schema=False,
 )
-@router.post(
-    "/search",
+def get_search(
+    request: Request,
+    provider: Optional[str] = None,
+    collections: Optional[str] = None,
+    ids: Optional[str] = None,
+    bbox: Optional[str] = None,
+    datetime: Optional[str] = None,
+    intersects: Optional[str] = None,
+    limit: Optional[int] = None,
+    query: Optional[str] = None,
+    page: Optional[int] = None,
+    sortby: Optional[str] = None,
+    filter: Optional[str] = None,  # pylint: disable=redefined-builtin
+    filter_lang: Optional[str] = "cql2-text",
+    crunch: Optional[str] = None,
+) -> ORJSONResponse:
+    """Handler for GET /search"""
+    logger.debug("URL: %s", request.state.url)
+
+    query_params = str(request.query_params)
+
+    # Kludgy fix because using factory does not allow alias for filter-lang
+    if filter_lang is None:
+        match = re.search(r"filter-lang=([a-z0-9-]+)", query_params, re.IGNORECASE)
+        if match:
+            filter_lang = match.group(1)
+
+    base_args = {
+        "provider": provider,
+        "collections": str2list(collections),
+        "ids": str2list(ids),
+        "datetime": datetime,
+        "bbox": str2list(bbox),
+        "intersects": str2json("intersects", intersects),
+        "limit": limit,
+        "query": str2json("query", query),
+        "page": page,
+        "sortby": sortby2list(sortby),
+        "crunch": crunch,
+    }
+
+    if filter:
+        if filter_lang == "cql2-text":
+            ast = parse_cql2_text(filter)
+            base_args["filter"] = str2json("filter", to_cql2(ast))  # type: ignore
+            base_args["filter-lang"] = "cql2-json"
+        elif filter_lang == "cql-json":
+            base_args["filter"] = str2json(filter)
+
+    clean = {k: v for k, v in base_args.items() if v is not None and v != []}
+
+    try:
+        search_request = SearchPostRequest.model_validate(clean)
+    except pydanticValidationError as e:
+        raise HTTPException(status_code=400, detail=format_pydantic_error(e)) from e
+
+    response = search_stac_items(
+        request=request,
+        search_request=search_request,
+    )
+    return ORJSONResponse(content=response, media_type="application/json")
+
+
+@router.api_route(
+    methods=["POST", "HEAD"],
+    path="/search",
     tags=["STAC"],
     include_in_schema=False,
 )
-def stac_search(
-    request: Request, search_body: Optional[SearchBody] = None
-) -> ORJSONResponse:
-    """STAC collections items"""
-    logger.debug(f"URL: {request.url}")
-    logger.debug(f"Body: {search_body}")
+async def post_search(request: Request) -> ORJSONResponse:
+    """STAC post search"""
+    logger.debug("URL: %s", request.url)
 
-    url = request.state.url
-    url_root = request.state.url_root
+    content_type = request.headers.get("Content-Type")
 
-    if search_body is None:
-        body = {}
-    else:
-        body = vars(search_body)
+    if content_type is None:
+        raise HTTPException(status_code=400, detail="No Content-Type provided")
+    if content_type != "application/json":
+        raise HTTPException(status_code=400, detail="Content-Type not supported")
 
-    arguments = dict(request.query_params, **body)
-    provider = arguments.pop("provider", None)
+    try:
+        payload = await request.json()
+    except JSONDecodeError as e:
+        raise HTTPException(status_code=400, detail="Invalid JSON data") from e
+
+    try:
+        search_request = SearchPostRequest.model_validate(payload)
+    except pydanticValidationError as e:
+        raise HTTPException(status_code=400, detail=format_pydantic_error(e)) from e
+
+    logger.debug("Body: %s", search_request.model_dump(exclude_none=True))
 
     response = search_stac_items(
-        url=url,
-        arguments=arguments,
-        root=url_root,
-        provider=provider,
-        method=request.method,
-    )
-    resp = ORJSONResponse(
-        content=response, status_code=200, media_type="application/json"
+        request=request,
+        search_request=search_request,
     )
-    return resp
+    return ORJSONResponse(content=response, media_type="application/json")
 
 
 app.include_router(router)