Alternative to decorators that uses dependency injection

[trashdid]

I have a route that essentially returns a single level BOM for a part. I want to validate that the user requesting the data has access to the top level part and that requires me to call a service function. Originally, I had the two service calls in the router function to validate that the user can see the part, then get the BOM data. I wanted to abstract it out so I can use the same logic on other parts. My first thought was to use a decorator:

def can_user_see_part(func):
    @functools.wraps(func)
    async def wrapper(*args, **kwargs):
        part_number = kwargs.get("part_number")
        part_service: PartService = cast(PartService, kwargs.get("part_service")

        await part_service.can_user_see_part(part_number)
        return await func(*args, **kwargs)

    return wrapper

This will throw an error if the user cannot see the part, and will not execute the function.
In my controller, the function its being used in looks like this:

@get(
        operation_id="GetBom",
        path="/{part_number:str}/bom",
        media_type=MediaType.JSON,
        raises=[NotFoundException],
    )
@can_user_see_part
async def get_part_bom(
     self,
     part_number: str,
     part_service: PartService,
 ) -> list[PartBomComponent]:
     return await part_service.get_part_bom(
        part_number=part_number
    )

My concern with this approach is that it might be an anti-pattern in the litestar framework. I have been trying to look at other approaches like a guard or the before request, but my understanding, which may be wrong, is the dependency resolution occurs after the guard and before requested are executed. Since the Service is resolved via the dependency injector, I have to execute the check after that occurs. Does anyone have any ideas on if there are other ways to achieve this? Is this the best approach? The only other way that I can think of is by using the dependencies and have it look like this:

def can_user_see_part(part_number: str, part_service: PartService) -> str:
     await part_service.can_user_see_part(part_number)
     return part_number

@get(
        operation_id="GetBom",
        path="/{part_number:str}/bom",
        media_type=MediaType.JSON,
        dependencies={"part_number": Provide(can_user_see_part)}
        raises=[NotFoundException],
    )
async def get_part_bom(
     self,
     part_number: str,
     part_service: PartService,
 ) -> list[PartBomComponent]:
     return await part_service.get_part_bom(
        part_number=part_number
    )

Any insights or thoughts on this would be greatly appreciated.