Extending SQL Alchemy Router

[hay-kot]

I just started implementing the SQL Router for a small project I'm working on and love the concept. I'm running into a few issues with creating nested models and the way I've implemented the database 'interface' class. Basically, I'd like to extend the SQL Alchemy router to overwrite some of the route generation.

Something like this...

class MyCustomerCRUDRouter(SQLAlchemyCRUDRouter):
    def _create(self, *args: Any, **kwargs: Any) -> Callable[..., Model]:
        def route(
            model: self.create_schema,  # type: ignore
            db: Session = Depends(self.db_func),
        ) -> Model:
            try:
                db_model: Model =  some_custom_create_func()
                return db_model
            except IntegrityError:
                db.rollback()
                raise HTTPException(422, "Key already exists")

        return route

    def _update(self, *args: Any, **kwargs: Any) -> Callable[..., Model]:
        def route(
            item_id: self._pk_type,  # type: ignore
            model: self.update_schema,  # type: ignore
            db: Session = Depends(self.db_func),
        ) -> Model:
            try:
                db_model: Model = some_custom_update_func()
                return db_model
            except IntegrityError as e:
                db.rollback()
                raise HTTPException(422, ", ".join(e.args))

        return route

Is that a use case of the library or am I playing with fire?

[awtkns]

@hay-kot I believe this should work for your intended use case. Another option would be to just override the routes (docs: https://fastapi-crudrouter.awtkns.com/routing) but that would need to be done per router (not sure how many you are creating).

[hay-kot]

I had started with overriding the routes, but ended up duplicating a lot of the same code. My use case is essentially what issue #56 describes. I was able to get around this by defining the __init__ function on the models and using a decorator (see below) to write to the nested models. That way I don't need to overwrite the router, I can take care of some of that custom logic in the model itself.

I'll still likely create a subset router that has some additional common code. If that's a use-case you're interested in supporting, once I get it nailed down I can submit a PR to provide some documentation and examples on how to do it.

Thanks for an awesome library!

Nested Model Decorator

from functools import wraps
from typing import Union

from sqlalchemy.orm import ONETOMANY


def auto_init(exclude: Union[set, list] = None):
    """Wraps the `__init__` method of a class to automatically set the common
    attributes.

    Args:
        exclude (Union[set, list], optional): [description]. Defaults to None.
    """

    exclude = exclude or set()

    def decorator(init):
        @wraps(init)
        def wrapper(self, *args, **kwargs):
            """
            Custom initializer that allows nested children initialization.
            Only keys that are present as instance's class attributes are allowed.
            These could be, for example, any mapped columns or relationships.

            Code inspired from GitHub.
            Ref: https://github.com/tiangolo/fastapi/issues/2194
            """
            cls = self.__class__
            model_columns = self.__mapper__.columns
            relationships = self.__mapper__.relationships

            for key, val in kwargs.items():
                if key in exclude:
                    continue

                if not hasattr(cls, key):
                    continue
                    # raise TypeError(f"Invalid keyword argument: {key}")

                if key in model_columns:
                    setattr(self, key, val)
                    continue

                if key in relationships:
                    relation_dir = relationships[key].direction.name
                    relation_cls = relationships[key].mapper.entity

                    if relation_dir == ONETOMANY.name:
                        instances = [relation_cls(**elem) for elem in val]
                        setattr(self, key, instances)

            return init(self, *args, **kwargs)

        return wrapper

    return decorator

class CustomerContactModel(SqlAlchemyBase):
    ...

    @auto_init(exclude={"complex_property"})
    def __init__(self, **_):
        self.complex_property = determine_property()

[awtkns]

I'll still likely create a subset router that has some additional common code. If that's a use-case you're interested in supporting, once I get it nailed down I can submit a PR to provide some documentation and examples on how to do it.

That would be awesome! It's always something I've been thinking of supporting. I've always been a little hesitant though because I've always wanted the project to be as simple to use as possible.

Maybe adding a factory function that would allow the composition of new 'custom' router would be a clean solution.