django-gisserver 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

gisserver/parsers/fes20/operators.py

@@ -92,7 +92,11 @@ class DistanceOperatorName(TagNameEnum):
 
 
 class SpatialOperatorName(TagNameEnum):
-    """XML tag names for geometry operators"""
+    """XML tag names for geometry operators.
+
+    The values correspond with GeoDjango operators. So a ``BBOX`` query
+    will translate into ``geometry__intersects=Polygon(...)``.
+    """
 
     # (A Within B) implies that (B Contains A)
 
@@ -263,9 +267,9 @@ class NonIdOperator(Operator):
             # e.g. deny <PropertyIsLessThanOrEqualTo> against <gml:boundedBy>
             if xsd_element.is_geometry and not self.allow_geometries:
                 raise OperationProcessingFailed(
-                    "filter",
                     f"Operator '{tag}' does not support comparing"
                     f" geometry properties: '{xsd_element.xml_name}'.",
+                    locator="filter",
                     status_code=400,  # not HTTP 500 here. Spec allows both.
                 )
 
@@ -616,7 +620,7 @@ class LogicalOperator(NonIdOperator):
 @tag_registry.register("And")
 @tag_registry.register("Or")
 class BinaryLogicOperator(LogicalOperator):
-    """Apply an AND or OR operator"""
+    """Apply an 'AND' or 'OR' operator"""
 
     operands: list[NonIdOperator]
     operatorType: BinaryLogicType

gisserver/parsers/fes20/query.py

@@ -84,7 +84,9 @@ class CompiledQuery:
         """Read the desired result ordering from a ``<fes:SortBy>`` element."""
         self.ordering += sort_by.build_ordering(self.feature_type)
 
-    def add_value_reference(self, value_reference: expressions.ValueReference) -> str:
+    def add_value_reference(
+        self, value_reference: expressions.ValueReference
+    ) -> expressions.RhsTypes:
         """Add a reference that should be returned by the query.
 
         This includes the XPath expression to the query, in case that adds
@@ -92,8 +94,16 @@ class CompiledQuery:
          ``queryset.values()`` result. This is needed to support cases like
         these in the future: ``addresses/Address[street="Oxfordstrasse"]/number``
         """
+        # The actual limiting of fields happens inside the decorate_queryset() of the renderer.
         return value_reference.build_rhs(self)
 
+    def add_property_name(self, property_name: expressions.ValueReference) -> expressions.RhsTypes:
+        """Define which field should be returned by the query."""
+        # Make sure any xpath [attr=value] lookups work.
+        # This will also validate the name because it resolves the ORM path.
+        # The actual limiting of fields happens inside the decorate_queryset() of the renderer.
+        return property_name.build_rhs(self)
+
     def apply_extra_lookups(self, comparison: Q) -> Q:
         """Combine stashed lookups with the provided Q object.
 

gisserver/parsers/fes20/sorting.py

@@ -20,7 +20,9 @@ class SortOrder(Enum):
         try:
             return cls[direction]
         except KeyError:
-            raise InvalidParameterValue("sortby", "Expect ASC/DESC ordering direction") from None
+            raise InvalidParameterValue(
+                "Expect ASC/DESC ordering direction", locator="sortby"
+            ) from None
 
 
 @dataclass

gisserver/parsers/gml/base.py

@@ -14,7 +14,7 @@ class AbstractGeometry(BaseNode):
     """
 
     def build_rhs(self, compiler):
-        # Allow the value to be used in an binary operator
+        # Allow the value to be used in a binary operator
         raise NotImplementedError()
 
 

gisserver/queries/__init__.py

@@ -13,6 +13,7 @@ The "GetFeatureById" is a mandatory built-in stored query.
 
 from .adhoc import AdhocQuery
 from .base import QueryExpression
+from .projection import FeatureProjection, FeatureRelation
 from .stored import (
     GetFeatureById,
     QueryExpressionText,
@@ -31,4 +32,6 @@ __all__ = (
     "stored_query_registry",
     "StoredQueryParameter",
     "GetFeatureById",
+    "FeatureProjection",
+    "FeatureRelation",
 )

gisserver/queries/adhoc.py

@@ -30,7 +30,7 @@ class AdhocQuery(QueryExpression):
     """The Ad hoc query expression parameters.
 
     This represents all dynamic queries received as request (hence "adhoc"),
-    such as the "FILTER" and "BBOX" arguments from a HTTP GET.
+    such as the "FILTER" and "BBOX" arguments from an HTTP GET.
 
     The WFS Spec has 3 class levels for this:
     - AdhocQueryExpression (types, projection, selection, sorting)
@@ -39,23 +39,26 @@ class AdhocQuery(QueryExpression):
     For KVP requests, this dataclass is almost identical to **params.
     However, it allows combining the filter parameters. These become
     one single XML request for HTTP POST requests later.
+
+    .. seealso::
+        https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/query_xsd.html#AbstractAdhocQueryExpressionType
     """
 
     typeNames: list[FeatureType]  # typeNames in WFS/FES spec
     # aliases: Optional[List[str]] = None
     handle: str = ""  # only for XML POST requests
 
-    # Projection clause:
-    # propertyName
+    # Projection clause (fes:AbstractProjectionClause)
+    property_names: list[fes20.ValueReference] | None = None
 
-    # Selection clause:
+    # Selection clause (fes:AbstractSelectionClause):
     # - for XML POST this is encoded in a <fes:Query>
     # - for HTTP GET, this is encoded as FILTER, FILTER_LANGUAGE, RESOURCEID, BBOX.
     filter: fes20.Filter | None = None
     filter_language: str = fes20.Filter.query_language
     bbox: BoundingBox | None = None
 
-    # Sorting Clause
+    # Sorting Clause (fes:AbstractSortingClause)
     sortBy: fes20.SortBy | None = None
 
     # Officially part of the GetFeature/GetPropertyValue request object,
@@ -69,24 +72,24 @@ class AdhocQuery(QueryExpression):
 
     @classmethod
     def from_kvp_request(cls, **params):
-        """Build this object from a HTTP GET (key-value-pair) request."""
+        """Build this object from an HTTP GET (key-value-pair) request."""
         # Validate optionally required parameters
         if not params["typeNames"] and not params["resourceID"]:
-            raise MissingParameterValue("typeNames", "Empty TYPENAMES parameter")
+            raise MissingParameterValue("Empty TYPENAMES parameter", locator="typeNames")
 
         # Validate mutually exclusive parameters
         if params["filter"] and (params["bbox"] or params["resourceID"]):
             raise InvalidParameterValue(
-                "filter",
                 "The FILTER parameter is mutually exclusive with BBOX and RESOURCEID",
+                locator="filter",
             )
 
         # Validate mutually exclusive parameters
         if params["resourceID"]:
             if params["bbox"] or params["filter"]:
                 raise InvalidParameterValue(
-                    "resourceID",
                     "The RESOURCEID parameter is mutually exclusive with BBOX and FILTER",
+                    locator="resourceID",
                 )
 
             # When ResourceId + typenames is defined, it should be a value from typenames
@@ -99,13 +102,14 @@ class AdhocQuery(QueryExpression):
                     kvp_type_names = {feature_type.name for feature_type in params["typeNames"]}
                     if not kvp_type_names.issuperset(id_type_names):
                         raise InvalidParameterValue(
-                            "resourceID",
                             "When TYPENAMES and RESOURCEID are combined, "
                             "the RESOURCEID type should be included in TYPENAMES.",
+                            locator="resourceID",
                         )
 
         return AdhocQuery(
             typeNames=params["typeNames"],
+            property_names=params["propertyName"],
             filter=params["filter"],
             filter_language=params["filter_language"],
             bbox=params["bbox"],
@@ -115,7 +119,7 @@ class AdhocQuery(QueryExpression):
         )
 
     def bind(self, *args, **kwargs):
-        """Inform this quey object of the available feature types"""
+        """Inform this query object of the available feature types"""
         super().bind(*args, **kwargs)
 
         if self.resourceId:
@@ -144,7 +148,7 @@ class AdhocQuery(QueryExpression):
     def _compile_non_filter_query(self, feature_type: FeatureType, using=None):
         """Generate the query based on the remaining parameters.
 
-        This is slightly more efficient then generating the fes Filter object
+        This is slightly more efficient than generating the fes Filter object
         from these KVP parameters (which could also be done within the request method).
         """
         compiler = fes20.CompiledQuery(feature_type=feature_type, using=using)

gisserver/queries/base.py

@@ -8,10 +8,17 @@ from gisserver.output import FeatureCollection, SimpleFeatureCollection
 from gisserver.parsers import fes20
 from gisserver.types import split_xml_name
 
+from .projection import FeatureProjection
+
 
 class QueryExpression:
     """WFS base class for all queries.
-    This object type is defined in the WFS spec (as <fes:AbstractQueryExpression>).
+    This object type is defined in the WFS spec (as ``<fes:AbstractQueryExpression>``).
+
+    The WFS server can initiate queries in multiple ways.
+    This class provides the common interface for all these query types;
+    whether the request provided "ad-hoc" parameters or called a stored procedure.
+    Each query type has its own way of generating the actual database statement to perform.
 
     The subclasses can override the following logic:
 
@@ -21,21 +28,33 @@ class QueryExpression:
     For full control, these methods can also be overwritten instead:
 
     * :meth:`get_queryset` defines the full results.
-    * :meth:`get_hits` to return the collection for RESULTTYPE=hits.
-    * :meth:`get_results` to return the collection for RESULTTYPE=results
+    * :meth:`get_hits` to return the collection for ``RESULTTYPE=hits``.
+    * :meth:`get_results` to return the collection for ``RESULTTYPE=results``.
     """
 
     handle = ""
-    value_reference = None
+    value_reference: fes20.ValueReference | None = None
+    property_names: list[fes20.ValueReference] | None = None
+    projections: dict[FeatureType, FeatureProjection] | None = None
 
     def bind(
         self,
         all_feature_types: dict[str, FeatureType],
-        value_reference: fes20.ValueReference | None,
+        value_reference: fes20.ValueReference | None = None,
+        property_names: list[fes20.ValueReference] | None = None,
     ):
-        """Bind the query to presentation-layer logic"""
+        """Bind the query to presentation-layer logic (e.g. request parameters).
+
+        :param all_feature_types: Which features are queried.
+        :param value_reference: Which field is returned (by ``GetPropertyValue``)
+        :param property_name: Which field is returned (by ``GetFeature`` + propertyName parameter)
+        """
+        self.projections = {}
         self.all_feature_types = all_feature_types
-        self.value_reference = value_reference
+        if value_reference is not None:
+            self.value_reference = value_reference
+        if property_names is not None:
+            self.property_names = property_names
 
     def check_permissions(self, request):
         """Verify whether the user has access to view these data sources"""
@@ -44,7 +63,7 @@ class QueryExpression:
 
     def resolve_type_name(self, type_name, locator="typename") -> FeatureType:
         """Find the feature type for a given name.
-        This is an utility that cusstom subclasses can use.
+        This is a utility that custom subclasses can use.
         """
         # Strip the namespace prefix. The Python ElementTree parser does
         # not expose the used namespace prefixes, so text-values can't be
@@ -64,16 +83,21 @@ class QueryExpression:
         Override this method in case you need full control over the response data.
         Otherwise, override :meth:`compile_query` or :meth:`get_queryset`.
         """
-        querysets = self.get_querysets()
-        return FeatureCollection(
-            results=[
-                # Include empty feature collections,
-                # so the selected feature types are still known.
-                SimpleFeatureCollection(feature_type=ft, queryset=qs.none(), start=0, stop=0)
-                for ft, qs in querysets
-            ],
-            number_matched=sum(qs.count() for ft, qs in querysets),
-        )
+        results = []
+        number_matched = 0
+        for feature_type in self.get_type_names():
+            queryset = self.get_queryset(feature_type)
+            number_matched += queryset.count()
+
+            # Include empty feature collections,
+            # so the selected feature types are still known.
+            results.append(
+                SimpleFeatureCollection(
+                    self, feature_type, queryset=queryset.none(), start=0, stop=0
+                )
+            )
+
+        return FeatureCollection(results=results, number_matched=number_matched)
 
     def get_results(self, start_index=0, count=100) -> FeatureCollection:
         """Run the query, return the full paginated results.
@@ -82,24 +106,22 @@ class QueryExpression:
         Otherwise, override :meth:`compile_query` or :meth:`get_queryset`.
         """
         stop = start_index + count
-
-        # The querysets are not executed yet, until the output is reading them.
-        querysets = self.get_querysets()
-        return FeatureCollection(
-            results=[
-                SimpleFeatureCollection(feature_type, qs, start=start_index, stop=stop)
-                for feature_type, qs in querysets
-            ]
-        )
-
-    def get_querysets(self) -> list[tuple[FeatureType, QuerySet]]:
-        """Construct the querysets that return the database results."""
-        results = []
-        for feature_type in self.get_type_names():
-            queryset = self.get_queryset(feature_type)
-            results.append((feature_type, queryset))
-
-        return results
+        results = [
+            # The querysets are not executed yet, until the output is reading them.
+            SimpleFeatureCollection(
+                self,
+                feature_type,
+                queryset=self.get_queryset(feature_type),
+                start=start_index,
+                stop=stop,
+            )
+            for feature_type in self.get_type_names()
+        ]
+
+        # number_matched is not given here, so some rendering formats can count it instead.
+        # For GML it need to be printed at the start, but for GeoJSON it can be rendered
+        # as the last bit of the response. That avoids performing an expensive COUNT query.
+        return FeatureCollection(results=results)
 
     def get_queryset(self, feature_type: FeatureType) -> QuerySet:
         """Generate the queryset for the specific feature type.
@@ -112,6 +134,11 @@ class QueryExpression:
         # Apply filters
         compiler = self.compile_query(feature_type, using=queryset.db)
 
+        # If defined, limit which fields will be queried.
+        if self.property_names:
+            for property_name in self.property_names:
+                compiler.add_property_name(property_name)
+
         if self.value_reference is not None:
             if feature_type.resolve_element(self.value_reference.xpath) is None:
                 raise InvalidParameterValue(
@@ -137,6 +164,19 @@ class QueryExpression:
             f"{self.__class__.__name__}.get_type_names() should be implemented."
         )
 
+    def get_projection(self, feature_type: FeatureType) -> FeatureProjection:
+        """Provide the projection of this query for a given feature.
+
+        NOTE: as the AdhocQuery has a typeNames (plural!) argument,
+        this class still needs to check per feature type which fields to apply to.
+        """
+        try:
+            return self.projections[feature_type]
+        except KeyError:
+            projection = FeatureProjection(feature_type, self.property_names)
+            self.projections[feature_type] = projection
+            return projection
+
     def compile_query(self, feature_type: FeatureType, using=None) -> fes20.CompiledQuery:
         """Define the compiled query that filters the queryset.
 

gisserver/queries/projection.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from functools import cached_property
+from typing import cast
+
+from django.db import models
+
+from gisserver.features import FeatureType
+from gisserver.parsers import fes20
+from gisserver.types import GmlElement, XPathMatch, XsdElement, _XsdElement_WithComplexType
+
+
+class FeatureProjection:
+    """Tell which fields to access and render for a single feature.
+    This is inspired on 'fes:AbstractProjectionClause'.
+
+    Instead of walking over the full XSD object tree,
+    this object wraps that and makes sure only the actual requested fields are used.
+    When a PROPERTYNAME is used in the request, this will limit
+    which fields to retrieve, which to prefetch, and which to render.
+    """
+
+    feature_type: FeatureType
+
+    def __init__(self, feature_type: FeatureType, property_names: list[fes20.ValueReference]):
+        self.feature_type = feature_type
+        self.property_names = property_names
+
+        if property_names:
+            # Discover which elements should be rendered.
+            child_nodes = self._get_child_nodes_subset()
+            self.xsd_root_elements = child_nodes.pop(None)  # Pop it to avoid recursion risks
+            self.xsd_child_nodes = child_nodes
+        else:
+            # Retrieve all elements.
+            self.xsd_root_elements = feature_type.xsd_type.all_elements
+            self.xsd_child_nodes = feature_type.xsd_type.elements_with_children
+
+    def _get_child_nodes_subset(self) -> dict[XsdElement | None, list[XsdElement]]:
+        """Translate the PROPERTYNAME into a dictionary of nodes to render."""
+        child_nodes = defaultdict(list)
+        for xpath_match in self.xpath_matches:
+            # Make sure the tree is known beforehand, and it has no duplicate parent nodes.
+            # (e.g. PROPERTYNAME=node/child1,node/child2)
+            parent = None
+            for xsd_node in xpath_match.nodes:
+                if xsd_node not in child_nodes[parent]:
+                    child_nodes[parent].append(xsd_node)
+                parent = xsd_node
+
+        return dict(child_nodes)
+
+    def add_field(self, xsd_element: XsdElement):
+        """Restore the retrieval of a field that was not asked for in the original query."""
+        if not self.property_names:
+            return
+        if xsd_element.type.is_complex_type:
+            raise NotImplementedError("Can't restore nested elements right now")
+
+        # For now, add to all cached properties:
+        # TODO: have a better approach?
+        self.xsd_root_elements.append(xsd_element)
+        if xsd_element.is_geometry:
+            self.geometry_elements.append(xsd_element)
+
+        if xsd_element.orm_path not in self.only_fields:
+            self.only_fields.append(xsd_element.orm_path)
+
+        if xsd_element.is_flattened:
+            self.flattened_elements.append(xsd_element)
+
+    @cached_property
+    def xpath_matches(self) -> list[XPathMatch]:
+        """Resolve which elements the property names point to"""
+        if not self.property_names:
+            raise RuntimeError("This method is only useful for propertyname projections.")
+
+        return [
+            self.feature_type.resolve_element(property_name.xpath)
+            for property_name in self.property_names
+        ]
+
+    @cached_property
+    def geometry_elements(self) -> list[GmlElement]:
+        """Tell which GML elements will be hit."""
+        gml_elements = []
+        for e in self.xsd_root_elements:
+            if e.is_geometry and e.xml_name != "gml:boundedBy":
+                # Prefetching a flattened relation
+                gml_elements.append(e)
+
+        for xsd_children in self.xsd_child_nodes.values():
+            for e in xsd_children:
+                if e.is_geometry and e.xml_name != "gml:boundedBy":
+                    gml_elements.append(e)
+
+        return gml_elements
+
+    @cached_property
+    def complex_elements(self) -> list[_XsdElement_WithComplexType]:
+        """Shortcut to get all elements with a complex type"""
+        if not self.property_names:
+            return self.feature_type.xsd_type.complex_elements
+        else:
+            return [e for e in self.xsd_root_elements if e.type.is_complex_type]
+
+    @cached_property
+    def flattened_elements(self) -> list[XsdElement]:
+        """Shortcut to get all elements with a flattened model attribute"""
+        if not self.property_names:
+            return self.feature_type.xsd_type.flattened_elements
+        else:
+            return [e for e in self.xsd_root_elements if e.is_flattened]
+
+    @cached_property
+    def main_geometry_element(self) -> GmlElement | None:
+        """Return the field used to describe the geometry of the feature.
+        When the projection excludes the geometry, ``None`` is returned.
+        """
+        main_field = self.feature_type.geometry_field
+        if self.property_names and main_field not in self.xsd_root_elements:
+            return None
+
+        xpath_match = self.feature_type.resolve_element(main_field)
+        return cast(GmlElement, xpath_match.child)
+
+    @cached_property
+    def orm_relations(self) -> list[FeatureRelation]:
+        """Tell which fields will be retrieved from related fields.
+
+        This gives an object layout based on the XSD elements,
+        that can be used for prefetching data.
+        """
+        related_models: dict[str, type[models.Model]] = {}
+        fields: dict[str, set[XsdElement]] = defaultdict(set)
+        elements = defaultdict(list)
+
+        # Check all elements that render as "dotted" flattened relation
+        for xsd_element in self.flattened_elements:
+            if xsd_element.source is not None:
+                # Split "relation.field" notation into path, and take the field as child attribute.
+                obj_path, field = xsd_element.orm_relation
+                elements[obj_path].append(xsd_element)
+                fields[obj_path].add(xsd_element)
+                # field is already on relation:
+                related_models[obj_path] = xsd_element.source.model
+
+        # Check all elements that render as "nested" complex type:
+        for xsd_element in self.complex_elements:
+            # The complex element itself points to the root of the path,
+            # all sub elements become the child attributes.
+            obj_path = xsd_element.orm_path
+            elements[obj_path].append(xsd_element)
+            fields[obj_path] = {
+                f
+                for f in self.xsd_child_nodes[xsd_element]
+                if not f.is_many or f.is_array  # exclude M2M, but include ArrayField
+            }
+            if xsd_element.source:
+                # field references a related object:
+                related_models[obj_path] = xsd_element.source.related_model
+
+        return [
+            FeatureRelation(
+                orm_path=obj_path,
+                sub_fields=sub_fields,
+                related_model=related_models.get(obj_path),
+                xsd_elements=elements[obj_path],
+            )
+            for obj_path, sub_fields in fields.items()
+        ]
+
+    @cached_property
+    def only_fields(self) -> list[str]:
+        """Tell which fields to limit the queryset to.
+        This excludes M2M fields because those are not part of the local model data.
+        """
+        if self.property_names is not None:
+            return [
+                # TODO: While ORM rel__child paths can be passed to .only(),
+                # these may not be accurately applied to foreign keys yet.
+                # Also, this is bypassed by our generated Prefetch() objects.
+                xpath_match.orm_path
+                for xpath_match in self.xpath_matches
+                if not xpath_match.is_many or xpath_match.child.is_array
+            ]
+        else:
+            # Also limit the queryset to the actual fields that are shown.
+            # No need to request more data
+            return [
+                f.orm_field
+                for f in self.feature_type.xsd_type.elements
+                if not f.is_many or f.is_array  # avoid M2M fields for .only(), but keep ArrayField
+            ]
+
+
+@dataclass
+class FeatureRelation:
+    """Tell which related fields are queried by the feature.
+    Each dict holds an ORM-path, with the relevant sub-elements.
+    """
+
+    #: The ORM path that is queried for this particular relation
+    orm_path: str
+    #: The fields that will be retrieved for that path (limited by the projection)
+    sub_fields: set[XsdElement]
+    #: The model that is accessed for this relation (if set)
+    related_model: type[models.Model] | None
+    #: The source elements that access this relation.
+    xsd_elements: list[XsdElement]
+
+    @cached_property
+    def _local_model_field_names(self) -> list[str]:
+        """Tell which local fields of the model will be accessed by this feature."""
+        result = []
+        for field in self.sub_fields:
+            model_field = field.source
+            if not model_field.many_to_many and not model_field.one_to_many:
+                result.append(model_field.name)
+
+        result.extend(self._local_backlink_field_names)
+        return result
+
+    @property
+    def _local_backlink_field_names(self) -> list[str]:
+        # When this relation is retrieved through a ManyToOneRel (reverse FK),
+        # the prefetch_related() also needs to have the original foreign key
+        # in order to link all prefetches to the proper parent instance.
+        return [
+            xsd_element.source.field.name
+            for xsd_element in self.xsd_elements
+            if xsd_element.source is not None and xsd_element.source.one_to_many
+        ]
+
+    @property
+    def geometry_elements(self) -> list[GmlElement]:
+        """Tell which geometry elements this relation will access."""
+        return [f for f in self.sub_fields if f.is_geometry and f.name != "gml:boundedBy"]

gisserver/queries/stored.py

@@ -80,14 +80,14 @@ class StoredQuery(QueryExpression):
                 args[name] = KVP[name]
             except KeyError:
                 raise MissingParameterValue(
-                    name, f"Stored query {cls.meta.id} requires an '{name}' parameter"
+                    f"Stored query {cls.meta.id} requires an '{name}' parameter", locator=name
                 ) from None
 
         # Avoid unexpected behavior, check whether the client also sends adhoc query parameters
         for name in ("filter", "bbox", "resourceID"):
             if name not in args and KVP.get(name.upper()):
                 raise InvalidParameterValue(
-                    name, "Stored query can't be combined with adhoc-query parameters"
+                    "Stored query can't be combined with adhoc-query parameters", locator=name
                 )
 
         return args
@@ -121,7 +121,8 @@ class StoredQueryRegistry:
             return self.stored_queries[query_id]
         except KeyError:
             raise InvalidParameterValue(
-                "STOREDQUERY_ID", f"Stored query does not exist: {query_id}"
+                f"Stored query does not exist: {query_id}",
+                locator="STOREDQUERY_ID",
             ) from None
 
 
@@ -169,7 +170,7 @@ class GetFeatureById(StoredQuery):
             type_name, id = ID.rsplit(".", 1)
         except ValueError:
             # Always report this as 404
-            raise NotFound("ID", "Expected typeName.id for ID parameter") from None
+            raise NotFound("Expected typeName.id for ID parameter", locator="ID") from None
 
         self.type_name = type_name
         self.id = id
@@ -184,7 +185,7 @@ class GetFeatureById(StoredQuery):
         try:
             return super().get_queryset(feature_type)
         except (ValueError, TypeError) as e:
-            raise InvalidParameterValue("ID", f"Invalid ID value: {e}") from e
+            raise InvalidParameterValue(f"Invalid ID value: {e}", locator="ID") from e
 
     def get_results(self, *args, **kwargs) -> FeatureCollection:
         """Override to implement 404 checking."""
@@ -194,7 +195,7 @@ class GetFeatureById(StoredQuery):
         # Avoid having to do that in the output renderer.
         if collection.results[0].first() is None:
             # WFS 2.0.2: Return NotFound instead of InvalidParameterValue
-            raise NotFound("ID", f"Feature not found with ID {self.id}.")
+            raise NotFound(f"Feature not found with ID {self.id}.", locator="ID")
 
         return collection