Merge branch 'main' into pjh/asynchronous-opportunity-search

pjhartzell · pjhartzell · commit d2b849aa0276 · 2025-02-06T11:49:57.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
   token.
 - Moved `OrderCollection` construction from the root backend to the `RootRouter`
   `get_orders` method.
+- Renamed `OpportunityRequest` to `OpportunityPayload` so that would not be confused as
+  being a subclass of the Starlette/FastAPI Request class.
+
+### Fixed
+
+- Opportunities Search result now has the search body in the `create-order` link.
 
 ## [v0.5.0] - 2025-01-08
 
diff --git a/src/stapi_fastapi/backends/product_backend.py b/src/stapi_fastapi/backends/product_backend.py
@@ -9,14 +9,14 @@
 from stapi_fastapi.models.opportunity import (
     Opportunity,
     OpportunityCollection,
-    OpportunityRequest,
+    OpportunityPayload,
     OpportunitySearchRecord,
 )
 from stapi_fastapi.models.order import Order, OrderPayload
 from stapi_fastapi.routers.product_router import ProductRouter
 
 SearchOpportunities = Callable[
-    [ProductRouter, OpportunityRequest, str | None, int, Request],
+    [ProductRouter, OpportunityPayload, str | None, int, Request],
     Coroutine[Any, Any, ResultE[tuple[list[Opportunity], Maybe[str]]]],
 ]
 """
@@ -25,7 +25,7 @@
 
 Args:
     product_router (ProductRouter): The product router.
-    search (OpportunityRequest): The search parameters.
+    search (OpportunityPayload): The search parameters.
     next (str | None): A pagination token.
     limit (int): The maximum number of opportunities to return in a page.
     request (Request): FastAPI's Request object.
@@ -43,7 +43,7 @@
 """
 
 SearchOpportunitiesAsync = Callable[
-    [ProductRouter, OpportunityRequest, Request],
+    [ProductRouter, OpportunityPayload, Request],
     Coroutine[Any, Any, ResultE[OpportunitySearchRecord]],
 ]
 """
@@ -52,7 +52,7 @@
 
 Args:
     product_router (ProductRouter): The product router.
-    search (OpportunityRequest): The search parameters.
+    search (OpportunityPayload): The search parameters.
     request (Request): FastAPI's Request object.
 
 Returns:
diff --git a/src/stapi_fastapi/models/opportunity.py b/src/stapi_fastapi/models/opportunity.py
@@ -1,5 +1,5 @@
 from enum import StrEnum
-from typing import Literal, TypeVar
+from typing import Any, Literal, TypeVar
 
 from geojson_pydantic import Feature, FeatureCollection
 from geojson_pydantic.geometries import Geometry
@@ -17,13 +17,22 @@ class OpportunityProperties(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
-class OpportunityRequest(BaseModel):
+class OpportunityPayload(BaseModel):
     datetime: DatetimeInterval
     geometry: Geometry
-    # TODO: validate the CQL2 filter?
     filter: CQL2Filter | None = None
+
+    next: str | None = None
+    limit: int = 10
+
     model_config = ConfigDict(strict=True)
 
+    def search_body(self) -> dict[str, Any]:
+        return self.model_dump(mode="json", include={"datetime", "geometry", "filter"})
+
+    def body(self) -> dict[str, Any]:
+        return self.model_dump(mode="json")
+
 
 G = TypeVar("G", bound=Geometry)
 P = TypeVar("P", bound=OpportunityProperties)
@@ -59,7 +68,7 @@ class OpportunitySearchStatus(BaseModel):
 class OpportunitySearchRecord(BaseModel):
     id: str
     product_id: str
-    opportunity_request: OpportunityRequest
+    opportunity_request: OpportunityPayload
     status: OpportunitySearchStatus
     links: list[Link] = Field(default_factory=list)
 
diff --git a/src/stapi_fastapi/routers/product_router.py b/src/stapi_fastapi/routers/product_router.py
@@ -2,11 +2,10 @@
 
 import logging
 import traceback
-from typing import TYPE_CHECKING, Annotated, Self
+from typing import TYPE_CHECKING, Self
 
 from fastapi import (
     APIRouter,
-    Body,
     Depends,
     Header,
     HTTPException,
@@ -23,7 +22,7 @@
 from stapi_fastapi.exceptions import ConstraintsException, NotFoundException
 from stapi_fastapi.models.opportunity import (
     OpportunityCollection,
-    OpportunityRequest,
+    OpportunityPayload,
     OpportunitySearchRecord,
     Prefer,
 )
@@ -225,11 +224,9 @@ def get_product(self: Self, request: Request) -> Product:
 
     async def search_opportunities(
         self: Self,
-        search: OpportunityRequest,
+        search: OpportunityPayload,
         request: Request,
         response: Response,
-        next: Annotated[str | None, Body()] = None,
-        limit: Annotated[int, Body()] = 10,
         prefer: Prefer | None = Depends(get_preference),
     ) -> OpportunityCollection | Response:
         """
@@ -244,8 +241,6 @@ async def search_opportunities(
                 request,
                 response,
                 prefer,
-                next,
-                limit,
             )
 
         # async
@@ -260,31 +255,24 @@ async def search_opportunities(
 
     async def search_opportunities_sync(
         self: Self,
-        search: OpportunityRequest,
+        search: OpportunityPayload,
         request: Request,
         response: Response,
         prefer: Prefer | None,
-        next: Annotated[str | None, Body()] = None,
-        limit: Annotated[int, Body()] = 10,
     ) -> OpportunityCollection:
         links: list[Link] = []
         match await self.product._search_opportunities(
             self,
             search,
-            next,
-            limit,
+            search.next,
+            search.limit,
             request,
         ):
             case Success((features, Some(pagination_token))):
-                links.append(self.order_link(request))
-                body = {
-                    "search": search.model_dump(mode="json"),
-                    "next": pagination_token,
-                    "limit": limit,
-                }
-                links.append(self.pagination_link(request, body))
+                links.append(self.order_link(request, search))
+                links.append(self.pagination_link(request, search, pagination_token))
             case Success((features, Nothing)):  # noqa: F841
-                links.append(self.order_link(request))
+                links.append(self.order_link(request, search))
             case Failure(e) if isinstance(e, ConstraintsException):
                 raise e
             case Failure(e):
@@ -306,7 +294,7 @@ async def search_opportunities_sync(
 
     async def search_opportunities_async(
         self: Self,
-        search: OpportunityRequest,
+        search: OpportunityPayload,
         request: Request,
         prefer: Prefer | None,
     ) -> JSONResponse:
@@ -366,7 +354,7 @@ async def create_order(
             request,
         ):
             case Success(order):
-                self.root_router.add_order_links(order, request)
+                order.links.extend(self.root_router.order_links(order, request))
                 location = str(self.root_router.generate_order_href(request, order.id))
                 response.headers["Location"] = location
                 return order
@@ -384,7 +372,7 @@ async def create_order(
             case x:
                 raise AssertionError(f"Expected code to be unreachable {x}")
 
-    def order_link(self, request: Request):
+    def order_link(self, request: Request, opp_req: OpportunityPayload):
         return Link(
             href=str(
                 request.url_for(
@@ -394,11 +382,16 @@ def order_link(self, request: Request):
             rel="create-order",
             type=TYPE_JSON,
             method="POST",
+            body=opp_req.search_body(),
         )
 
-    def pagination_link(self, request: Request, body: dict[str, str | dict]):
+    def pagination_link(
+        self, request: Request, opp_req: OpportunityPayload, pagination_token: str
+    ):
+        body = opp_req.body()
+        body["next"] = pagination_token
         return Link(
-            href=str(request.url.remove_query_params(keys=["next", "limit"])),
+            href=str(request.url),
             rel="next",
             type=TYPE_JSON,
             method="POST",
diff --git a/src/stapi_fastapi/routers/root_router.py b/src/stapi_fastapi/routers/root_router.py
@@ -230,7 +230,7 @@ def get_products(
             ),
         ]
         if end > 0 and end < len(self.product_ids):
-            links.append(self.pagination_link(request, self.product_ids[end]))
+            links.append(self.pagination_link(request, self.product_ids[end], limit))
         return ProductsCollection(
             products=[
                 self.product_routers[product_id].get_product(request)
@@ -244,13 +244,14 @@ async def get_orders(
     ) -> OrderCollection:
         links: list[Link] = []
         match await self._get_orders(next, limit, request):
-            case Success((orders, Some(pagination_token))):
+            case Success((orders, maybe_pagination_token)):
                 for order in orders:
-                    order.links.append(self.order_link(request, order))
-                links.append(self.pagination_link(request, pagination_token))
-            case Success((orders, Nothing)):  # noqa: F841
-                for order in orders:
-                    order.links.append(self.order_link(request, order))
+                    order.links.extend(self.order_links(order, request))
+                match maybe_pagination_token:
+                    case Some(x):
+                        links.append(self.pagination_link(request, x, limit))
+                    case Maybe.empty:
+                        pass
             case Failure(ValueError()):
                 raise NotFoundException(detail="Error finding pagination token")
             case Failure(e):
@@ -272,7 +273,7 @@ async def get_order(self: Self, order_id: str, request: Request) -> Order:
         """
         match await self._get_order(order_id, request):
             case Success(Some(order)):
-                self.add_order_links(order, request)
+                order.links.extend(self.order_links(order, request))
                 return order
             case Success(Maybe.empty):
                 raise NotFoundException("Order not found")
@@ -300,7 +301,7 @@ async def get_order_statuses(
         match await self._get_order_statuses(order_id, next, limit, request):
             case Success((statuses, Some(pagination_token))):
                 links.append(self.order_statuses_link(request, order_id))
-                links.append(self.pagination_link(request, pagination_token))
+                links.append(self.pagination_link(request, pagination_token, limit))
             case Success((statuses, Nothing)):  # noqa: F841
                 links.append(self.order_statuses_link(request, order_id))
             case Failure(KeyError()):
@@ -333,28 +334,19 @@ def generate_order_statuses_href(
     ) -> URL:
         return request.url_for(f"{self.name}:list-order-statuses", order_id=order_id)
 
-    def add_order_links(self: Self, order: Order, request: Request):
-        order.links.append(
+    def order_links(self: Self, order: Order, request: Request) -> list[Link]:
+        return [
             Link(
                 href=str(self.generate_order_href(request, order.id)),
                 rel="self",
                 type=TYPE_GEOJSON,
-            )
-        )
-        order.links.append(
+            ),
             Link(
                 href=str(self.generate_order_statuses_href(request, order.id)),
                 rel="monitor",
                 type=TYPE_JSON,
             ),
-        )
-
-    def order_link(self, request: Request, order: Order):
-        return Link(
-            href=str(request.url_for(f"{self.name}:get-order", order_id=order.id)),
-            rel="self",
-            type=TYPE_JSON,
-        )
+        ]
 
     def order_statuses_link(self, request: Request, order_id: str):
         return Link(
@@ -368,9 +360,11 @@ def order_statuses_link(self, request: Request, order_id: str):
             type=TYPE_JSON,
         )
 
-    def pagination_link(self, request: Request, pagination_token: str):
+    def pagination_link(self, request: Request, pagination_token: str, limit: int):
         return Link(
-            href=str(request.url.include_query_params(next=pagination_token)),
+            href=str(
+                request.url.include_query_params(next=pagination_token, limit=limit)
+            ),
             rel="next",
             type=TYPE_JSON,
         )
diff --git a/tests/application.py b/tests/application.py
@@ -20,6 +20,7 @@
 from tests.shared import (
     InMemoryOpportunityDB,
     InMemoryOrderDB,
+    product_test_satellite_provider_sync_opportunity,
     product_test_spotlight_sync_async_opportunity,
 )
 
@@ -44,5 +45,6 @@ async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, Any]]:
     conformances=[CORE, OPPORTUNITIES, ASYNC_OPPORTUNITIES],
 )
 root_router.add_product(product_test_spotlight_sync_async_opportunity)
+root_router.add_product(product_test_satellite_provider_sync_opportunity)
 app: FastAPI = FastAPI(lifespan=lifespan)
 app.include_router(root_router, prefix="")
diff --git a/tests/backends.py b/tests/backends.py
@@ -8,7 +8,7 @@
 from stapi_fastapi.models.opportunity import (
     Opportunity,
     OpportunityCollection,
-    OpportunityRequest,
+    OpportunityPayload,
     OpportunitySearchRecord,
     OpportunitySearchStatus,
     OpportunitySearchStatusCode,
@@ -119,7 +119,7 @@ async def mock_create_order(
 
 async def mock_search_opportunities(
     product_router: ProductRouter,
-    search: OpportunityRequest,
+    search: OpportunityPayload,
     next: str | None,
     limit: int,
     request: Request,
@@ -143,7 +143,7 @@ async def mock_search_opportunities(
 
 async def mock_search_opportunities_async(
     product_router: ProductRouter,
-    search: OpportunityRequest,
+    search: OpportunityPayload,
     request: Request,
 ) -> ResultE[OpportunitySearchRecord]:
     try:
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -164,19 +164,17 @@ def opportunity_search(limit) -> dict[str, Any]:
     end_string = rfc3339_strftime(end, format)
 
     return {
-        "search": {
-            "geometry": {
-                "type": "Point",
-                "coordinates": [0, 0],
-            },
-            "datetime": f"{start_string}/{end_string}",
-            "filter": {
-                "op": "and",
-                "args": [
-                    {"op": ">", "args": [{"property": "off_nadir"}, 0]},
-                    {"op": "<", "args": [{"property": "off_nadir"}, 45]},
-                ],
-            },
+        "geometry": {
+            "type": "Point",
+            "coordinates": [0, 0],
+        },
+        "datetime": f"{start_string}/{end_string}",
+        "filter": {
+            "op": "and",
+            "args": [
+                {"op": ">", "args": [{"property": "off_nadir"}, 0]},
+                {"op": "<", "args": [{"property": "off_nadir"}, 45]},
+            ],
         },
         "limit": limit,
     }
diff --git a/tests/shared.py b/tests/shared.py
diff --git a/tests/test_opportunity.py b/tests/test_opportunity.py
diff --git a/tests/test_order.py b/tests/test_order.py
diff --git a/tests/test_product.py b/tests/test_product.py

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@`
`20`	`20`	`from tests.shared import (`
`21`	`21`	`InMemoryOpportunityDB,`
`22`	`22`	`InMemoryOrderDB,`
	`23`	`+ product_test_satellite_provider_sync_opportunity,`
`23`	`24`	`product_test_spotlight_sync_async_opportunity,`
`24`	`25`	`)`
`25`	`26`
`@@ -44,5 +45,6 @@ async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, Any]]:`
`44`	`45`	`conformances=[CORE, OPPORTUNITIES, ASYNC_OPPORTUNITIES],`
`45`	`46`	`)`
`46`	`47`	`root_router.add_product(product_test_spotlight_sync_async_opportunity)`
	`48`	`+root_router.add_product(product_test_satellite_provider_sync_opportunity)`
`47`	`49`	`app: FastAPI = FastAPI(lifespan=lifespan)`
`48`	`50`	`app.include_router(root_router, prefix="")`