@@ -0,0 +1,89 @@
+---
+title: Opaque 500s on drawing-geometry and simulate from GenericMotor null fields, RocketPy ValueErrors and malformed ids
+date: 2026-10-18
+category: runtime-errors
+module: services/motor, controllers/interface, repositories/interface, api
+problem_type: runtime_error
+component: service_object
+severity: critical
+symptoms:
+  - "GET /motors/{id}/drawing-geometry, /rockets/{id}/drawing-geometry, /rockets/{id}/simulate and /flights/{id}/simulate return HTTP 500 'Unexpected error' for any GENERIC motor saved with chamber_position (or chamber_radius / chamber_height / propellant_initial_mass) = null"
+  - "app.log: AttributeError: 'NoneType' object has no attribute 'shape' inside rocketpy motor.center_of_propellant_mass -> Function(self.chamber_position)"
+  - "Liquid motor with an overfilled tank: RocketPy ValueError at MassFlowRateBasedTank construction surfaced as 500 instead of the message"
+  - "PUT /rockets/undefined (jarvis client bug) -> bson InvalidId -> 500 'Unexpected error ocurred'"
+  - "422 bodies were a bare JSON string ('RequestValidationError: [...]') so jarvis showed 'Unknown validation error'"
+  - "jarvis Discord alerting escalated every one of these as P0 INTERNAL_SERVER_ERROR"
+root_cause: missing_validation
+resolution_type: code_fix
+related_components:
+  - src/services/motor.py
+  - src/controllers/interface.py
+  - src/repositories/interface.py
+  - src/api.py
+  - rocketpy.GenericMotor
+tags:
+  - rocketpy
+  - generic-motor
+  - error-handling
+  - http-422
+  - validation
+  - objectid
+  - jarvis
+---
+
+## Problem
+
+Between 2026-10-16 and 2026-10-18 the jarvis instrumentation channel received
+dozens of P0 alerts on `motor.drawingGeometry`, `rocket.drawingGeometry`,
+`rocket.simulate`, `flight.simulate` and `rocket.update`. Replaying the
+production entities (fetched from `api.rocketpy.org`) against a local
+Infinity showed four distinct faults, all answered with an opaque 500.
+
+1. **GenericMotor null fields.** `GenericMotor(chamber_position=None, ...)`
+   constructs without complaint and only crashes when `center_of_propellant_mass`
+   is first evaluated (`Function(None)` → `'NoneType' has no attribute 'shape'`).
+   jarvis' COTS import fills chamber radius/height/propellant from the catalogue
+   but never a chamber position, so every COTS-based GENERIC motor hit this.
+2. **RocketPy `ValueError` treated as a server fault.** An overfilled tank, a
+   bad parachute trigger, inconsistent geometry — RocketPy raises `ValueError`
+   with a good message; the controller wrapper turned it into 500.
+3. **Malformed ids.** `ObjectId("undefined")` raises `InvalidId`, which the
+   repository wrapper turned into 500.
+4. **Non-standard 422 body.** The `RequestValidationError` handler returned
+   `parse_error(exc)` (a string) as the whole body, so clients looking for
+   `detail` found nothing.
+
+## Solution
+
+- `MotorService.from_motor_model`, GENERIC branch: collect
+  `burn_time, chamber_radius, chamber_height, chamber_position,
+  propellant_initial_mass`; if any is `None` raise
+  `HTTPException(422, "Generic motor requires: a, b")`. Same "requires:" shape
+  as the tank-kind guard so jarvis can paint field-level errors.
+- `controller_exception_handler`: `except ValueError` → 422 with the
+  whitespace-collapsed message (logged at warning). Only genuine
+  programming errors stay 500.
+- `repository_exception_handler`: let `HTTPException` through;
+  `find_by_id` returns `None` for an invalid id (→ 404 upstream);
+  `update_by_id` / `delete_by_id` raise 404 via `_object_id_or_404`.
+- `validation_exception_handler`: respond with FastAPI's standard
+  `{"detail": [{"loc", "msg", "type"}]}` (dropping `input`/`ctx`, which is
+  what made the original author stringify the error).
+
+Follow-up (same day): `RocketModel.motor` is now `Optional`. A rocket saved
+before its motor exists goes on the wire with `motor: null`, Infinity keeps the
+`EmptyMotor` rocketpy constructs every `Rocket` with (drawing already handled
+it), and `RocketService.require_motor()` answers 422 "Rocket has no motor yet"
+on rocket/flight simulate. jarvis sends `null` until `ids.motorId` is set, so
+the placeholder GENERIC motor never reaches Infinity any more.
+
+## Prevention
+
+- Any RocketPy constructor argument with no default must be validated at the
+  API boundary; "constructs fine, crashes on first use" is the pattern to
+  look for (RocketPy's lazy `Function` properties).
+- Keep `ValueError` → 422 in the controller wrapper; it is RocketPy's
+  user-input error channel.
+- Run `python3 -I /Users/aasitvora/Desktop/chintu/regression-suite/run.py`
+  before changing a model or service: it covers all 17 official designs and
+  replays these incidents.
@@ -86,8 +86,21 @@ async def validation_exception_handler(
 ):
     exc_str = parse_error(exc)
     logger.error("%s: %s", request, exc_str)
+    # Answer in FastAPI's standard `{"detail": [{loc, msg, type}]}` shape.
+    # `input` and `ctx` are dropped: `ctx` can carry raw exception objects
+    # that are not JSON serialisable (the reason this handler originally
+    # stringified the whole error), and `input` echoes the request body.
+    detail = [
+        {
+            "loc": list(error.get("loc", ())),
+            "msg": error.get("msg", ""),
+            "type": error.get("type", ""),
+        }
+        for error in exc.errors()
+    ]
     return JSONResponse(
-        content=exc_str, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+        content={"detail": detail},
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
     )
 
 
 
@@ -22,6 +22,17 @@ async def wrapper(self, *args, **kwargs):
             )
         except HTTPException as e:
             raise e from e
+        except ValueError as e:
+            # RocketPy raises ValueError for physically invalid input
+            # (overfilled tank, bad parachute trigger, inconsistent
+            # geometry). That is the client's design, not a server fault:
+            # return it as 422 with the message instead of a bare 500.
+            detail = " ".join(str(e).split())
+            logger.warning(f"{method.__name__}: Invalid input {detail}")
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=detail,
+            ) from e
         except Exception as e:
             logger.exception(f"{method.__name__}: Unexpected error {e}")
             raise HTTPException(
 
@@ -26,8 +26,11 @@ class RocketModel(ApiBaseModel):
     NAME: ClassVar = "rocket"
     METHODS: ClassVar = ("POST", "GET", "PUT", "DELETE")
 
-    # Required parameters
-    motor: MotorModel
+    # A rocket may be created before its motor exists (jarvis saves the
+    # airframe first). `None` maps to rocketpy's `EmptyMotor`, which a
+    # Rocket carries by default: the rocket persists and draws, and the
+    # simulate endpoints answer 422 until a real motor is attached.
+    motor: Optional[MotorModel] = None
     radius: float
     mass: float
     motor_position: float
 
@@ -16,6 +16,7 @@
 
 from fastapi import HTTPException, status
 from bson import ObjectId
+from bson.errors import InvalidId
 
 from src import logger
 from src.secrets import Secrets
@@ -61,6 +62,10 @@ async def wrapper(self, *args, **kwargs):
                 f"{method.__name__} - Repository not initialized: {e}"
             )
             raise
+        except HTTPException:
+            # Deliberate client-facing errors raised inside a repository
+            # method (e.g. malformed id → 404) must not be re-wrapped as 500.
+            raise
         except Exception as e:
             logger.exception(
                 f"{method.__name__} - caught unexpected error: {e}"
@@ -258,13 +263,20 @@ async def insert(self, data: dict):
     async def update_by_id(self, data: dict, *, data_id: str):
         collection = self.get_collection()
         assert self.model.model_validate(data)
-        await collection.update_one({"_id": ObjectId(data_id)}, {"$set": data})
+        object_id = self._object_id_or_404(data_id)
+        await collection.update_one({"_id": object_id}, {"$set": data})
         return self
 
     @repository_exception_handler
     async def find_by_id(self, *, data_id: str):
         collection = self.get_collection()
-        read_data = await collection.find_one({"_id": ObjectId(data_id)})
+        try:
+            object_id = ObjectId(data_id)
+        except InvalidId:
+            # A malformed id can never match a document; treat it exactly
+            # like a missing one so the controller answers 404, not 500.
+            return None
+        read_data = await collection.find_one({"_id": object_id})
         if read_data:
             parsed_model = self.model.model_validate(read_data)
             parsed_model.set_id(str(read_data["_id"]))
@@ -274,9 +286,24 @@ async def find_by_id(self, *, data_id: str):
     @repository_exception_handler
     async def delete_by_id(self, *, data_id: str):
         collection = self.get_collection()
-        await collection.delete_one({"_id": ObjectId(data_id)})
+        await collection.delete_one({"_id": self._object_id_or_404(data_id)})
         return self
 
+    def _object_id_or_404(self, data_id: str) -> ObjectId:
+        """Parse a path id, answering 404 for a malformed one.
+
+        The jarvis client was observed issuing PUT /rockets/undefined; bson
+        raises InvalidId for that, which the generic handler used to turn
+        into a 500 "Unexpected error ocurred".
+        """
+        try:
+            return ObjectId(data_id)
+        except InvalidId as exc:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"{self.model.NAME} not found",
+            ) from exc
+
     @repository_exception_handler
     async def find_by_query(self, query: dict):
         collection = self.get_collection()
 
@@ -61,7 +61,9 @@ def from_flight_model(cls, flight: FlightModel) -> Self:
         rocketpy_env = EnvironmentService.from_env_model(
             flight.environment
         ).environment
-        rocketpy_rocket = RocketService.from_rocket_model(flight.rocket).rocket
+        rocket_service = RocketService.from_rocket_model(flight.rocket)
+        rocket_service.require_motor()
+        rocketpy_rocket = rocket_service.rocket
         rocketpy_flight = RocketPyFlight(
             rocket=rocketpy_rocket,
             environment=rocketpy_env,
@@ -518,9 +520,7 @@ def get_flight_kml(self) -> bytes:
         Returns:
             bytes (UTF-8 encoded KML)
         """
-        with tempfile.NamedTemporaryFile(
-            suffix=".kml", delete=False
-        ) as tmp:
+        with tempfile.NamedTemporaryFile(suffix=".kml", delete=False) as tmp:
             tmp_path = tmp.name
         try:
             FlightDataExporter(self.flight).export_kml(file_name=tmp_path)
 
@@ -236,14 +236,32 @@ def from_motor_model(cls, motor: MotorModel) -> Self:
                     **optional_params,
                 )
             case _:
-                # GenericMotor requires burn_time even though it's optional
-                # for the other motor kinds — surface the constraint at the
-                # API boundary instead of letting rocketpy raise a
-                # confusing stack trace deeper in construction.
-                if motor.burn_time is None:
+                # GenericMotor has no defaults for burn_time or the chamber
+                # fields. A None here does not fail at construction — it
+                # blows up later as `Function(None)` inside
+                # center_of_propellant_mass when the motor is drawn, added
+                # to a rocket, or flown. Surface the constraint at the API
+                # boundary as a 422 that names every missing field, in the
+                # same "requires: a, b" shape the tank_kind guard uses so
+                # clients can paint field-level errors.
+                generic_params = {
+                    'burn_time': motor.burn_time,
+                    'chamber_radius': motor.chamber_radius,
+                    'chamber_height': motor.chamber_height,
+                    'chamber_position': motor.chamber_position,
+                    'propellant_initial_mass': motor.propellant_initial_mass,
+                }
+                missing = [
+                    key
+                    for key, value in generic_params.items()
+                    if value is None
+                ]
+                if missing:
                     raise HTTPException(
                         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                        detail="burn_time is required for generic motors.",
+                        detail=(
+                            "Generic motor requires: " + ', '.join(missing)
+                        ),
                     )
                 # nozzle_position is already forwarded via motor_core when
                 # the client supplied it; GenericMotor's own default (0)
 
@@ -13,6 +13,7 @@
     Tail as RocketPyTail,
 )
 from rocketpy.rocket.aero_surface.generic_surface import GenericSurface
+from rocketpy.motors.empty_motor import EmptyMotor
 
 from fastapi import HTTPException, status
 
@@ -62,10 +63,13 @@ def from_rocket_model(cls, rocket: RocketModel) -> Self:
             center_of_mass_without_motor=rocket.center_of_mass_without_motor,
             coordinate_system_orientation=rocket.coordinate_system_orientation,
         )
-        rocketpy_rocket.add_motor(
-            MotorService.from_motor_model(rocket.motor).motor,
-            rocket.motor_position,
-        )
+        # No motor yet: keep the EmptyMotor rocketpy constructs the Rocket
+        # with. Drawing works; the simulate paths refuse via require_motor.
+        if rocket.motor is not None:
+            rocketpy_rocket.add_motor(
+                MotorService.from_motor_model(rocket.motor).motor,
+                rocket.motor_position,
+            )
 
         # RailButtons
         if rocket.rail_buttons:
@@ -124,12 +128,23 @@ def get_rocket_simulation(self) -> RocketSimulation:
         Returns:
             RocketSimulation
         """
+        self.require_motor()
         encoded_attributes = collect_attributes(
             self.rocket, [RocketSimulation, MotorSimulation]
         )
         rocket_simulation = RocketSimulation(**encoded_attributes)
         return rocket_simulation
 
+    def require_motor(self) -> None:
+        """Refuse to simulate a rocket that still carries the EmptyMotor."""
+        if isinstance(self._rocket.motor, EmptyMotor):
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=(
+                    "Rocket has no motor yet. Save a motor before simulating."
+                ),
+            )
+
     def get_rocket_binary(self) -> bytes:
         """
         Get the binary representation of the rocket.
 
@@ -94,7 +94,7 @@ class RocketSimulation(MotorSimulation):
 
 class RocketView(RocketModel):
     rocket_id: Optional[str] = None
-    motor: MotorView
+    motor: Optional[MotorView] = None
 
 
 class RocketDrawingGeometry(ApiBaseView):
 
@@ -81,8 +81,10 @@ async def method(self, model, *args, **kwargs):
 
 @pytest.mark.asyncio
 async def test_controller_exception_handler_unexpected_exception(stub_model):
+    # ValueError is now a deliberate 422 (see the test below); use a
+    # RuntimeError as the representative programming error.
     async def method(self, model, *args, **kwargs):
-        raise ValueError('Test Error')
+        raise RuntimeError('Test Error')
 
     wrapped_method = controller_exception_handler(method)
     with patch('src.controllers.interface.logger') as mock_logger:
@@ -225,3 +227,23 @@ async def test_controller_interface_delete_model(stub_controller, stub_model):
                 )
                 == 'Deleted'
             )
+
+
+@pytest.mark.asyncio
+async def test_controller_exception_handler_value_error_is_422(stub_model):
+    # RocketPy raises ValueError for physically invalid input (overfilled
+    # tank, bad parachute trigger, ...). That is a client error, not a
+    # server fault: surface the message as 422 instead of a bare 500.
+    async def method(self, model, *args, **kwargs):
+        raise ValueError(
+            "The tank 'Tank' is overfilled. The gas volume is greater than "
+            "the total volume of the tank.\n\t\tTry increasing the tank height."
+        )
+
+    wrapped_method = controller_exception_handler(method)
+    with patch('src.controllers.interface.logger') as mock_logger:
+        with pytest.raises(HTTPException) as exc:
+            await wrapped_method(None, stub_model)
+        assert exc.value.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+        assert exc.value.detail.startswith("The tank 'Tank' is overfilled")
+        mock_logger.warning.assert_called_once()