I have some dilemma about clean architecture. Please look at the code of some api endpoint (full code in https://github.com/albertalexandrov/clean-architecture-sqlalchemy-details, framework - FastAPI):

# api/get_user.py

from fastapi import Depends
from pydantic import BaseModel
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload

from app import app
from models.users import User
from repositories.users import UsersRepository


class Schema(BaseModel):
    class ProfileSchema(BaseModel):
        id: int
        age: int
        hobby: str
        address: str

    id: int
    first_name: str
    last_name: str
    username: str


class Repository:
    """This endpoint repository that incapsulates getting user with options.
    I had to create it because I had to use selectinload that is a detail of data layer (of SQLAlchemy)
    and according to clean architecture service should not know about it
    """

    def __init__(self, session: AsyncSession = Depends()):
        self._session = session
        self._users_repository = UsersRepository(session)

    async def get_user(self, user_id: int):
        options = [selectinload(User.profile)]
        return await self._users_repository.get_by_pk(user_id, options)


class Service:
    """This endpoint service for demo purposes. It can be much more complex"""

    def __init__(self, repository: Repository = Depends()):
        self._repository = repository

    async def get_user(self, user_id: int):
        # some logic
        user = await self._repository.get_user(user_id)
        # some logic
        return user

    # another methods


@app.get("/user/{user_id}", response_model=Schema)
async def get_user(user_id: int, service: Service = Depends()):
    return await service.get_user(user_id)

options is SQLAlchemy instruction how to select related data (via sql join or make select in).

I split code into framework layer (this is view, @app.get(...)), service layer (business logic) and data layer (SQLAlchemy, repositories).

The users_repository:

class BaseRepository:
    model = None  # SQLAlchemy model

    def __init__(self, session: AsyncSession = Depends()):
        self._session = session

    async def get_by_pk(self, pk, options=()):
        return await self._session.get(self.model, pk, options=options)

    # another methods


class UsersRepository(BaseRepository):
    model = User

Please take a look at Repository.__init__. As it is written there I did like there because I needed to hide details of SQLAlchemy from services layer (need to specify options param to select related data).

If I do like this:

 class Service:
    """This endpoint service for demo purposes. It can be much more complex"""

    def __init__(self, users_repository: UsersRepository = Depends()):
        self._users_repository = users_repository

    async def get_user(self, user_id: int):
        # some logic
        options = [selectinload(User.profile)]
        user = await self._users_repository.get_by_pk(user_id, options)
        # some logic
        return user

    # another methods

then service layer knows about details of SQLAlchemy (how data layer works exactly).

The dilemma is 1) to create Repository to specify options inside Repository.get_user method (thus service layer does not know details about SQLAlchemy) or 2) to specify options inside Service.get_user (then service layer knows about details of SQLAlchemy).

For know I create Repository if I need to specify options. Is that right?

So how to handle such situations?