RootBackend protocol uses library types Result and Maybe instead of exceptions (#107)

* RootBackend and ProductBackend protocol uses returns library types Result and Maybe instead of exceptions.

* update pydantic version

* run mypy in github ci correctly

Author: Phil Varner

.github/workflows/pr.yml

@@ -24,5 +24,8 @@ jobs:
         run: |
           python -m pip install pre-commit
           pre-commit run --all-files
+      - name: Type-check code
+        if: ${{ matrix.python-version == 3.12 }}
+        run: poetry run mypy src
       - name: Run tests
         run: poetry run nox

.pre-commit-config.yaml

@@ -19,6 +19,11 @@ repos:
     rev: v1.13.0
     hooks:
       - id: mypy
-        files: ".*\\.py$"
+        args: []  # override default of [--strict, --ignore-missing-imports]
+        files: src/
         additional_dependencies:
           - types-pyRFC3339~=1.1.1
+          - pydantic~=2.10.1
+          - returns~=0.23.0
+          - fastapi~=0.115.0
+          - geojson_pydantic~=1.1.1

CHANGELOG.md

@@ -13,6 +13,8 @@ none
 
 ### Changed
 
+- RootBackend and ProductBackend protocols use `returns` library types Result and Maybe instead of
+  raising exceptions.
 - Create Order endpoint from `.../order` to `.../orders`
 - Order field `id` must be a string, instead of previously allowing int. This is because while an
   order ID may an integral numeric value, it is not a "number" in the sense that math will be performed

bin/server.py

@@ -2,10 +2,11 @@
 from uuid import uuid4
 
 from fastapi import FastAPI, Request
+from returns.maybe import Maybe
+from returns.result import Failure, Result, Success
 
 from stapi_fastapi.backends.product_backend import ProductBackend
 from stapi_fastapi.backends.root_backend import RootBackend
-from stapi_fastapi.exceptions import NotFoundException
 from stapi_fastapi.models.conformance import CORE
 from stapi_fastapi.models.opportunity import (
     Opportunity,
@@ -37,20 +38,20 @@ class MockRootBackend(RootBackend):
     def __init__(self, orders: MockOrderDB) -> None:
         self._orders: MockOrderDB = orders
 
-    async def get_orders(self, request: Request) -> OrderCollection:
+    async def get_orders(self, request: Request) -> Result[OrderCollection, Exception]:
         """
         Show all orders.
         """
-        return OrderCollection(features=list(self._orders.values()))
+        return Success(OrderCollection(features=list(self._orders.values())))
 
-    async def get_order(self, order_id: str, request: Request) -> Order:
+    async def get_order(
+        self, order_id: str, request: Request
+    ) -> Result[Maybe[Order], Exception]:
         """
         Show details for order with `order_id`.
         """
-        try:
-            return self._orders[order_id]
-        except KeyError:
-            raise NotFoundException()
+
+        return Success(Maybe.from_optional(self._orders.get(order_id)))
 
 
 class MockProductBackend(ProductBackend):
@@ -64,41 +65,49 @@ async def search_opportunities(
         product_router: ProductRouter,
         search: OpportunityRequest,
         request: Request,
-    ) -> list[Opportunity]:
-        return [o.model_copy(update=search.model_dump()) for o in self._opportunities]
+    ) -> Result[list[Opportunity], Exception]:
+        try:
+            return Success(
+                [o.model_copy(update=search.model_dump()) for o in self._opportunities]
+            )
+        except Exception as e:
+            return Failure(e)
 
     async def create_order(
         self, product_router: ProductRouter, payload: OrderRequest, request: Request
-    ) -> Order:
+    ) -> Result[Order, Exception]:
         """
         Create a new order.
         """
-        order = Order(
-            id=str(uuid4()),
-            geometry=payload.geometry,
-            properties={
-                "product_id": product_router.product.id,
-                "created": datetime.now(timezone.utc),
-                "status": OrderStatus(
-                    timestamp=datetime.now(timezone.utc),
-                    status_code=OrderStatusCode.accepted,
-                ),
-                "search_parameters": {
-                    "geometry": payload.geometry,
-                    "datetime": payload.datetime,
-                    "filter": payload.filter,
-                },
-                "order_parameters": payload.order_parameters.model_dump(),
-                "opportunity_properties": {
-                    "datetime": "2024-01-29T12:00:00Z/2024-01-30T12:00:00Z",
-                    "off_nadir": 10,
+        try:
+            order = Order(
+                id=str(uuid4()),
+                geometry=payload.geometry,
+                properties={
+                    "product_id": product_router.product.id,
+                    "created": datetime.now(timezone.utc),
+                    "status": OrderStatus(
+                        timestamp=datetime.now(timezone.utc),
+                        status_code=OrderStatusCode.accepted,
+                    ),
+                    "search_parameters": {
+                        "geometry": payload.geometry,
+                        "datetime": payload.datetime,
+                        "filter": payload.filter,
+                    },
+                    "order_parameters": payload.order_parameters.model_dump(),
+                    "opportunity_properties": {
+                        "datetime": "2024-01-29T12:00:00Z/2024-01-30T12:00:00Z",
+                        "off_nadir": 10,
+                    },
                 },
-            },
-            links=[],
-        )
+                links=[],
+            )
 
-        self._orders[order.id] = order
-        return order
+            self._orders[order.id] = order
+            return Success(order)
+        except Exception as e:
+            return Failure(e)
 
 
 class MyOpportunityProperties(OpportunityProperties):