wip: splits backend and router for root and product.

Co-authored-by: Jarrett Keifer <[email protected]>

Author: parksjr

src/stapi_fastapi/backends/product_backend.py

@@ -1,35 +1,39 @@
+from __future__ import annotations
+
 from typing import Protocol
 
 from fastapi import Request
 
+import stapi_fastapi
 from stapi_fastapi.models.opportunity import Opportunity, OpportunityRequest
 from stapi_fastapi.models.order import Order
-from stapi_fastapi.models.product import Product
 
 
 class ProductBackend(Protocol):
-    def product(self, product_id: str, request: Request) -> Product | None:
-        """
-        Return the product identified by `product_id` or `None` if it isn't
-        supported.
-        """
-
     async def search_opportunities(
-        self, product_id: str, search: OpportunityRequest, request: Request
+        self,
+        product: stapi_fastapi.models.product.Product,
+        search: OpportunityRequest,
+        request: Request,
     ) -> list[Opportunity]:
         """
         Search for ordering opportunities for the  given search parameters.
 
         Backends must validate search constraints and raise
         `stapi_fastapi.backend.exceptions.ConstraintsException` if not valid.
         """
+        ...
 
     async def create_order(
-        self, product_id: str, search: OpportunityRequest, request: Request
+        self,
+        product: stapi_fastapi.models.product.Product,
+        search: OpportunityRequest,
+        request: Request,
     ) -> Order:
         """
         Create a new order.
 
         Backends must validate order payload and raise
         `stapi_fastapi.backend.exceptions.ConstraintsException` if not valid.
         """
+        ...

src/stapi_fastapi/backends/root_backend.py

@@ -3,19 +3,14 @@
 from fastapi import Request
 
 from stapi_fastapi.models.order import Order
-from stapi_fastapi.models.product import Product
 
 
 class RootBackend(Protocol):
-    def products(self, request: Request) -> list[Product]:
-        """
-        Return a list of supported products.
-        """
-
-    def orders(self, request: Request) -> list[Order]:
+    async def get_orders(self, request: Request) -> list[Order]:
         """
         Return a list of existing orders.
         """
+        ...
 
     async def get_order(self, order_id: str, request: Request) -> Order:
         """
@@ -24,3 +19,4 @@ async def get_order(self, order_id: str, request: Request) -> Order:
         Backends must raise `stapi_fastapi.backend.exceptions.NotFoundException`
         if not found or access denied.
         """
+        ...

src/stapi_fastapi/models/opportunity.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, TypeVar, Generic
+from typing import Literal, Optional
 
 from geojson_pydantic import Feature, FeatureCollection
 from geojson_pydantic.geometries import Geometry
@@ -8,29 +8,26 @@
 from stapi_fastapi.types.datetime_interval import DatetimeInterval
 from stapi_fastapi.types.filter import CQL2Filter
 
-# Generic type definition for Opportunity Properties
-T = TypeVar("T")
 
 # Copied and modified from https://github.com/stac-utils/stac-pydantic/blob/main/stac_pydantic/item.py#L11
-class OpportunityProperties(BaseModel, Generic[T]):
+class OpportunityProperties(BaseModel):
     datetime: DatetimeInterval
     model_config = ConfigDict(extra="allow")
 
+
 class OpportunityRequest(BaseModel):
     datetime: DatetimeInterval
     geometry: Geometry
     # TODO: validate the CQL2 filter?
     filter: Optional[CQL2Filter] = None
     model_config = ConfigDict(strict=True)
 
-# Generic type definition for Opportunity
-P = TypeVar("P", bound=OpportunityProperties)
-K = TypeVar("K", bound=Geometry)
 
-# Each product implements its own opportunity model
-class Opportunity(Feature[K, P], Generic[K, P]):
+# GENERIC: Each product needs an opportunity model (constraints/parameters)
+class Opportunity(Feature[Geometry, OpportunityProperties]):
     type: Literal["Feature"] = "Feature"
     links: list[Link] = []
 
-class OpportunityCollection(FeatureCollection[Opportunity[K, P]], Generic[K, P]):
+
+class OpportunityCollection(FeatureCollection[Opportunity]):
     type: Literal["FeatureCollection"] = "FeatureCollection"

src/stapi_fastapi/models/product.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
+from copy import deepcopy
 from enum import Enum
 from typing import Literal, Optional, Self
 
 from pydantic import AnyHttpUrl, BaseModel, Field
 
 from stapi_fastapi.backends.product_backend import ProductBackend
+from stapi_fastapi.models.opportunity import OpportunityProperties
 from stapi_fastapi.models.shared import Link
-from stapi_fastapi.types.json_schema_model import JsonSchemaModel
 
 
 class ProviderRole(str, Enum):
@@ -23,7 +26,7 @@ class Provider(BaseModel):
 
 
 class Product(BaseModel):
-    type: Literal["Product"] = "Product"
+    type_: Literal["Product"] = Field(default="Product", alias="type")
     conformsTo: list[str] = Field(default_factory=list)
     id: str
     title: str = ""
@@ -32,11 +35,37 @@ class Product(BaseModel):
     license: str
     providers: list[Provider] = Field(default_factory=list)
     links: list[Link]
-    constraints: JsonSchemaModel
 
-    def __init__(self: Self, backend: ProductBackend, *args, **kwargs):
+    # we don't want to include these in the model fields
+    _constraints: type[OpportunityProperties]
+    _backend: ProductBackend
+
+    def __init__(
+        self: Self,
+        *args,
+        backend: ProductBackend,
+        constraints: type[OpportunityProperties],
+        **kwargs,
+    ) -> None:
         super().__init__(*args, **kwargs)
-        self.backend = backend
+        self._backend = backend
+        self._constraints = constraints
+
+    @property
+    def backend(self: Self) -> ProductBackend:
+        return self._backend
+
+    @property
+    def constraints(self: Self) -> type[OpportunityProperties]:
+        return self._constraints
+
+    def with_links(self: Self, links: list[Link] | None = None) -> Self:
+        if not links:
+            return self
+
+        new = deepcopy(self)
+        new.links.extend(links)
+        return new
 
 
 class ProductsCollection(BaseModel):

src/stapi_fastapi/models/shared.py

@@ -1,19 +1,26 @@
-from typing import Any, Optional, Union
+from typing import Any, Optional, Self, Union
 
 from pydantic import AnyUrl, BaseModel, ConfigDict
 
 
 class Link(BaseModel):
     href: AnyUrl
     rel: str
-    type: Optional[str] = None
+    type: str | None = None
     title: Optional[str] = None
     method: Optional[str] = None
     headers: Optional[dict[str, Union[str, list[str]]]] = None
     body: Any = None
 
     model_config = ConfigDict(extra="allow")
 
+    def model_dump_json(self: Self, *args, **kwargs) -> bytes:
+        # TODO: this isn't working as expected and we get nulls in the output
+        #       maybe need to override python dump too
+        # forcing the call to model_dump_json to exclude unset fields by default
+        kwargs["exclude_unset"] = kwargs.get("exclude_unset", True)
+        return super().model_dump_json(*args, **kwargs)
+
 
 class HTTPException(BaseModel):
     detail: str

src/stapi_fastapi/routers/product_router.py

@@ -1,11 +1,14 @@
 # Generic product router factory
+from __future__ import annotations
+
 from typing import Self
 
 from fastapi import APIRouter, HTTPException, Request, status
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse
 
-from stapi_fastapi.constants import TYPE_GEOJSON
+import stapi_fastapi
+from stapi_fastapi.constants import TYPE_GEOJSON, TYPE_JSON
 from stapi_fastapi.exceptions import ConstraintsException
 from stapi_fastapi.models.opportunity import (
     OpportunityCollection,
@@ -26,33 +29,61 @@ class ProductRouter(APIRouter):
     def __init__(
         self: Self,
         product: Product,
+        root_router: stapi_fastapi.routers.RootRouter,
         *args,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self.product = product
+        self.root_router = root_router
+
+        self.add_api_route(
+            path="",
+            endpoint=self.get_product,
+            name=f"{self.root_router.name}:{self.product.id}:get-product",
+            methods=["GET"],
+            summary="Retrieve this product",
+        )
 
         self.add_api_route(
             path="/opportunities",
             endpoint=self.search_opportunities,
+            name=f"{self.root_router.name}:{self.product.id}:search-opportunities",
             methods=["POST"],
             summary="Search Opportunities for the product",
         )
 
         self.add_api_route(
             path="/constraints",
             endpoint=self.get_product_constraints,
+            name=f"{self.root_router.name}:{self.product.id}:get-constraints",
             methods=["GET"],
             summary="Get constraints for the product",
         )
 
         self.add_api_route(
             path="/order",
             endpoint=self.create_order,
+            name=f"{self.root_router.name}:{self.product.id}:create-order",
             methods=["POST"],
             summary="Create an order for the product",
         )
 
+    def get_product(self, request: Request) -> Product:
+        return self.product.with_links(
+            links=[
+                Link(
+                    href=str(
+                        request.url_for(
+                            f"{self.root_router.name}:{self.product.id}:get-product",
+                        ),
+                    ),
+                    rel="self",
+                    type=TYPE_JSON,
+                ),
+            ],
+        )
+
     async def search_opportunities(
         self, search: OpportunityRequest, request: Request
     ) -> OpportunityCollection:
@@ -75,7 +106,7 @@ async def get_product_constraints(self: Self, request: Request) -> JsonSchemaMod
         Return supported constraints of a specific product
         """
         return {
-            "product_id": self.product.product_id,
+            "product.id": self.product.product.id,
             "constraints": self.product.constraints,
         }
 
@@ -90,9 +121,7 @@ async def create_order(
         except ConstraintsException as exc:
             raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, detail=exc.detail)
 
-        location = str(
-            request.url_for(f"{self.NAME_PREFIX}:get-order", order_id=order.id)
-        )
+        location = self.root_router.generate_order_href(request, order.id)
         order.links.append(Link(href=location, rel="self", type=TYPE_GEOJSON))
         return JSONResponse(
             jsonable_encoder(order, exclude_unset=True),