Fix SQLAlchemy JSON array emission, FastAPI Pydantic-safe route annotations, and CLI loads import

- Map OpenAPI 'array' properties ('list' from map_openapi_type_to_python) to 'dict' in openapi_client.sqlalchemy_cdd.emit.emit_sqlalchemy so cdd.emit.sqlalchemy.sqlalchemy emits Column(JSON, default=None) instead of invalid Column(list, default=None) that triggers sqlalchemy.exc.ArgumentError at declarative model import time.

- Introduce _to_fastapi_type in openapi_client.fastapi.emit to normalize component $ref and array-of-$ref schema annotations into Pydantic-safe JSON structures (dict[str, Any] and list[dict[str, Any]]) across route parameters, requestBody, and response_model return annotations, preventing fastapi.exceptions.FastAPIError when generated server models are SQLAlchemy declarative_base() ORM classes.

- Emit 'from json import loads' in openapi_client.cli_sdk_cdd.emit.emit_cli_sdk so cdd.emit.argparse_function's type=loads for dict/requestBody CLI flags resolves at runtime.

- Decorate test_stub_endpoints in openapi_client.tests.emit_server_tests with @patch.dict(os.environ, {}, clear=True) to isolate stub-mode endpoint tests from ambient DATABASE_URL or EPHEMERAL_DB variables.

Author: SamuelMarks

src/openapi_client/cli_sdk_cdd/emit.py

@@ -26,6 +26,7 @@ def emit_cli_sdk(spec: OpenAPI) -> str:
     body = [
         "import argparse",
         "import json",
+        "from json import loads",
         "import os",
         "import sys",
         "from client import Client",

src/openapi_client/fastapi/emit.py

@@ -40,6 +40,27 @@ def _match_model_for_tag(tag: str, spec: OpenAPI) -> str | None:
     return None
 
 
+def _to_fastapi_type(ann: str) -> str:
+    """Normalize a schema type annotation string into a Pydantic-safe FastAPI type.
+
+    Since generated server `models` are SQLAlchemy declarative ORM classes rather than
+    Pydantic `BaseModel` classes, component `$ref` model names are normalized to
+    `dict[str, Any]` (and `list[<Model>]` to `list[dict[str, Any]]`).
+
+    Args:
+        ann: Raw annotation string returned by `get_annotation_for_schema`.
+
+    Returns:
+        A valid Pydantic/FastAPI type annotation string.
+    """
+    if ann in ("Any", "str", "int", "float", "bool", "dict[str, Any]"):
+        return ann
+    if ann.startswith("list[") and ann.endswith("]"):
+        inner = _to_fastapi_type(ann[5:-1])
+        return f"list[{inner}]"
+    return "dict[str, Any]"
+
+
 def _extract_request_body_type(operation: Operation) -> str:
     """Resolve the type annotation string for an operation's requestBody.
 
@@ -54,10 +75,8 @@ def _extract_request_body_type(operation: Operation) -> str:
     if isinstance(content, dict) and content:
         media = content.get("application/json") or next(iter(content.values()))
         schema_obj = getattr(media, "schema_", getattr(media, "schema", None))
-        ann = get_annotation_for_schema(schema_obj)
-        if ann and ann != "Any":
-            if not ann.startswith(("dict", "list", "str", "int", "float", "bool")):
-                return f"models.{ann} | dict[str, Any] | None"
+        ann = _to_fastapi_type(get_annotation_for_schema(schema_obj))
+        if ann != "Any":
             return f"{ann} | None"
     return "dict[str, Any] | None"
 
@@ -81,13 +100,11 @@ def _extract_response_type(operation: Operation) -> str | None:
             media = content.get("application/json") or next(iter(content.values()))
             schema_obj = getattr(media, "schema_", getattr(media, "schema", None))
             if schema_obj is not None:
-                ann = get_annotation_for_schema(schema_obj)
-                if ann and ann != "Any":
-                    if not ann.startswith(
-                        ("dict", "list", "str", "int", "float", "bool")
-                    ):
-                        return f"models.{ann} | dict[str, Any] | None"
-                    return f"{ann} | dict[str, Any] | None"
+                ann = _to_fastapi_type(get_annotation_for_schema(schema_obj))
+                if ann != "Any":
+                    if ann == "dict[str, Any]":
+                        return "dict[str, Any] | list[Any] | None"
+                    return f"{ann} | dict[str, Any] | list[Any] | None"
     return None
 
 
@@ -123,7 +140,7 @@ def _build_route_function(
             if safe_p and safe_p not in seen_params:
                 seen_params.add(safe_p)
                 schema_obj = getattr(param, "schema_", getattr(param, "schema", None))
-                ann_str = get_annotation_for_schema(schema_obj)
+                ann_str = _to_fastapi_type(get_annotation_for_schema(schema_obj))
                 params.append(
                     cst.Param(
                         name=cst.Name(safe_p),

src/openapi_client/sqlalchemy_cdd/emit.py

@@ -52,8 +52,9 @@ def emit_sqlalchemy(spec: OpenAPI) -> dict[str, str]:
                 if prop_name.lower() == "id":
                     doc = f"[PK] {doc}".strip()
 
+                mapped_type = map_openapi_type_to_python(str(p_type))
                 params[prop_name] = {
-                    "typ": map_openapi_type_to_python(str(p_type)),
+                    "typ": "dict" if mapped_type == "list" else mapped_type,
                     "doc": doc,
                     "default": None,
                 }

src/openapi_client/tests/emit_server_tests.py

@@ -114,9 +114,12 @@ def emit_server_tests(spec: OpenAPI) -> dict[str, str]:
     files["test_unit.py"] = "\n".join(unit_lines)
 
     stub_lines = [
+        "import os",
+        "from unittest.mock import patch",
         "from fastapi.testclient import TestClient",
         "from main import app",
         "",
+        "@patch.dict(os.environ, {}, clear=True)",
         "def test_stub_endpoints():",
         '    """Test that endpoints return NotImplemented safely in stub mode."""',
         "    client = TestClient(app)",

tests/test_dao_db_seeder.py

@@ -494,6 +494,7 @@ def test_execute_generated_dao_db_seeder_end_to_end(
                         "id": Schema(type="integer"),
                         "name": Schema(type="string"),
                         "email": Schema(type="string"),
+                        "roles": Schema(type="array", items=Schema(type="string")),
                     },
                 ),
             }

tests/test_fastapi.py

@@ -751,7 +751,12 @@ def include_router(self, router: APIRouter) -> None:
                     operationId="replace_users",
                     requestBody=RequestBody(
                         content={
-                            "application/json": MediaType(schema=Schema(type="object"))
+                            "application/json": MediaType(
+                                schema=Schema(
+                                    type="array",
+                                    items=Reference(ref="#/components/schemas/User"),
+                                )
+                            )
                         }
                     ),
                     responses={"200": Response(description="No content", content={})},