fix: revert back to a clunky, but functional, opportunity search endpoint

Author: pjhartzell

src/stapi_fastapi/models/opportunity.py

@@ -59,7 +59,7 @@ class OpportunitySearchStatus(BaseModel):
 class OpportunitySearchRecord(BaseModel):
     id: str
     product_id: str
-    request: OpportunityRequest
+    opportunity_request: OpportunityRequest
     status: OpportunitySearchStatus
     links: list[Link] = Field(default_factory=list)
 

src/stapi_fastapi/routers/product_router.py

@@ -14,6 +14,7 @@
     Response,
     status,
 )
+from fastapi.responses import JSONResponse
 from geojson_pydantic.geometries import Geometry
 from returns.maybe import Maybe, Some
 from returns.result import Failure, Success
@@ -48,7 +49,7 @@ def get_preference(prefer: str | None = Header(None)) -> str | None:
             detail=f"Invalid Prefer header value: {prefer}",
         )
 
-    return prefer
+    return Prefer(prefer)
 
 
 class ProductRouter(APIRouter):
@@ -129,7 +130,10 @@ async def _create_order(
             tags=["Products"],
         )
 
-        if product.supports_opportunity_search:
+        if (
+            product.supports_opportunity_search
+            or root_router.supports_async_opportunity_search
+        ):
             self.add_api_route(
                 path="/opportunities",
                 endpoint=self.search_opportunities,
@@ -141,21 +145,17 @@ async def _create_order(
                     Geometry,
                     self.product.opportunity_properties,  # type: ignore
                 ],
+                responses={
+                    201: {
+                        "model": OpportunitySearchRecord,
+                        "content": {TYPE_JSON: {}},
+                    }
+                },
                 summary="Search Opportunities for the product",
                 tags=["Products"],
             )
 
         if root_router.supports_async_opportunity_search:
-            self.add_api_route(
-                path="/opportunities",
-                endpoint=self.search_opportunities_async,
-                name=f"{self.root_router.name}:{self.product.id}:search-opportunities",
-                methods=["POST"],
-                status_code=status.HTTP_201_CREATED,
-                summary="Search Opportunities for the product",
-                tags=["Products"],
-            )
-
             self.add_api_route(
                 path="/opportunities/{opportunity_collection_id}",
                 endpoint=self.get_opportunity_collection,
@@ -216,18 +216,19 @@ def get_product(self: Self, request: Request) -> Product:
             ],
         )
 
-    async def search_opportunities(
+    async def search_opportunities(  # noqa: C901
         self: Self,
         search: OpportunityRequest,
         request: Request,
-        response: GeoJSONResponse,
-        prefer: str | None = Depends(get_preference),
+        response: Response,
         next: Annotated[str | None, Body()] = None,
         limit: Annotated[int, Body()] = 10,
-    ) -> OpportunityCollection:
+        prefer: str | None = Depends(get_preference),
+    ) -> OpportunityCollection | Response:
         """
         Explore the opportunities available for a particular set of constraints
         """
+        # synchronous opportunities search
         if (
             not self.root_router.supports_async_opportunity_search
             or prefer is Prefer.wait
@@ -268,6 +269,44 @@ async def search_opportunities(
 
             return OpportunityCollection(features=features, links=links)
 
+        # asynchronous opportunities search
+        if (
+            prefer is None
+            or prefer is Prefer.respond_async
+            or (prefer is Prefer.wait and not self.product.supports_opportunity_search)
+        ):
+            match await self.product._search_opportunities_async(self, search, request):
+                case Success(search_record):
+                    self.root_router.add_opportunity_search_record_self_link(
+                        search_record, request
+                    )
+                    headers = {}
+                    headers["Location"] = str(
+                        self.root_router.generate_opportunity_search_record_href(
+                            request, search_record.id
+                        )
+                    )
+                    if prefer is not None:
+                        headers["Preference-Applied"] = "respond-async"
+                    return JSONResponse(
+                        status_code=201,
+                        content=search_record.model_dump(mode="json"),
+                        headers=headers,
+                    )
+                case Failure(e) if isinstance(e, ConstraintsException):
+                    raise e
+                case Failure(e):
+                    logger.error(
+                        "An error occurred while initiating an asynchronous opportunity search: %s",
+                        traceback.format_exception(e),
+                    )
+                    raise HTTPException(
+                        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        detail="Error initiating an asynchronous opportunity search",
+                    )
+                case y:
+                    raise AssertionError(f"Expected code to be unreachable: {y}")
+
         raise AssertionError("Expected code to be unreachable")
 
     async def search_opportunities_async(