Request for some more examples using generic controllers

[pavdwest]

In trying to figure out how to implement a generic controller class that works for all my database models, dtos, inheritance & swagger docs I came across this enhancement: #1311
I also found this in the tests, which I've expanded a bit with a (I think) clearer working example:

from dataclasses import dataclass
from typing import TypeVar, Generic

from litestar import Litestar
from litestar import Controller, Router, post


T = TypeVar("T")


class GenericController(Controller, Generic[T]):
    model_class: T

    def __class_getitem__(cls, model_class: type) -> type:
        cls_dict = {"model_class": model_class}
        return type(f"GenericController[{model_class.__name__}", (cls,), cls_dict)

    def __init__(self, owner: Router) -> None:
        super().__init__(owner)
        self.signature_namespace[T] = self.model_class  # type: ignore[misc]

class BaseController(GenericController[T]):
    @post()
    async def create(self, data: T) -> T:
        print(self.model_class)
        return data

@dataclass
class AppModel:
    id: int

@dataclass
class User(AppModel):
    name: str
    password: str

@dataclass
class UserRead:
    name: str
    # Note that the password field is not included here

@dataclass
class Post(AppModel):
    title: str
    content: str

class UserController(BaseController[User]):  # type: ignore[valid-type]
    path = "/user"

class PostController(BaseController[Post]):  # type: ignore[valid-type]
    path = "/post"

app = Litestar(route_handlers=[UserController, PostController])

I would appreciate some help on how to amend the above GenericController to allow returning a dto, e.g. the UserController's post method should return an instance of UserRead (not User, which would be my database model)?

Hope this is clear enough. Thanks!

[pavdwest]

FYI, couldn't figure this out with generic controllers so just went the poor man's route and fully generated new classes, e.g.

def generate_controller_class(
    ModelClass: Type[SharedModel],
    CreateClass: Type[CreateDTO],
    ReadClass: Type[ReadDTO],
    UpdateClass: Type[UpdateDTO],
) -> type[AppController]:
    controller_class = type(f"{ModelClass}Controller", (AppController,), {})
    controller_class.model_class = ModelClass
    controller_class.create_class = CreateClass
    controller_class.read_class = ReadClass
    controller_class.update_class = UpdateClass
    controller_class.path = f"/{ModelClass.__name__.lower()}"

    # Create
    @post(
        "/",
        summary=f"{ModelClass.__name__}: Create",
        description=f"Create a new {ModelClass.__name__}.",
        dto=CreateClass,
        return_dto=ReadClass,
        status_code=status_codes.HTTP_201_CREATED,
    )
    async def create(self, data: ModelClass) -> ModelClass:
        return await self.model_class.create(data)

    controller_class.create = create

    ...

    return controller_class

Which can then be used to generate controllers e.g.

NoteControllerBase = generate_controller_class(
    ModelClass=Note,
    CreateClass=NoteCreate,
    ReadClass=NoteRead,
    UpdateClass=NoteUpdate,
)


class NoteController(NoteControllerBase):
    pass

Seems to work so far.