[DESIGN DISCUSSION] Allow a custom filter class with the purpose of using all the base filters, and adding graphene-sqlalchemy-filter filters

[adiberk]

So a pretty important use case at my company is the ability to add custom filters that aren't field specific
Here is an example use case (I am using my "hack" which I discuss later)

class UserNode(SQLAlchemyObjectType):
    class Meta:
        model = User
        interfaces = (LevNode,)
        filter = UserFilter # NOTE THIS IS NEW and part of my change to allow such customization

class UserFilter(GrapheneSQLAlchemyFilter):
    user_has_contact = graphene.Boolean()
    is_valid = graphene.Boolean()

    @staticmethod
    def user_has_contact_filter(info: LevResolveInfo, query: Query, value: bool) -> Query:
        return query.join(Contact).filter(Contact.id.is_not(None))
    
    @staticmethod
    def is_valid_filter(info: LevResolveInfo, query: Query, value: bool) -> ColumnElement:
        if value:
            return User.deleted_at.is_(None)
        else:
            return User.deleted_at.is_not(None)

Step 1. Update BaseTypeFilter class to allow for "filter" as a _meta field. We get all the custom filter functions from the classes that extend GrapheneSQLAlchemyFilter. We ensure those functions contain the correct variables. and then add the fields to the filter fields list.

class GrapheneSQLAlchemyFilter(graphene.InputObjectType):
    pass

class BaseTypeFilter(graphene.InputObjectType):
    @classmethod
    def __init_subclass_with_meta__(
        cls, filter_fields=None, model=None, _meta=None, custom_filter_class=None, **options
    ):
        from graphene_sqlalchemy.converter import convert_sqlalchemy_type

        # Init meta options class if it doesn't exist already
        if not _meta:
            _meta = InputObjectTypeOptions(cls)
        _meta.filter_class = custom_filter_class
        logic_functions = _get_functions_by_regex(".+_logic$", "_logic$", cls)
        custom_filter_fields = {}
        if custom_filter_class and issubclass(custom_filter_class, GrapheneSQLAlchemyFilter):
            custom_filter_fields = yank_fields_from_attrs(custom_filter_class.__dict__, _as=graphene.InputField)
            functions = dict(_get_functions_by_regex(".+_filter$", "_filter$", custom_filter_class))
            for field_name in custom_filter_fields.keys():
                assert functions.get(field_name), f"Custom filter field {field_name} must have a corresponding filter method"
                annotations = functions.get(field_name)
                assert annotations.get('info'), "Each custom filter method must have an info field with valid type annotations"
                assert annotations.get('query'), "Each custom filter method must have a query field with valid type annotations"
                assert annotations.get('value'), "Each custom filter method must have a value field with valid type annotations"
        new_filter_fields = custom_filter_fields
       ..........

Then override the execute_filters method. We have it accept a "resolve_info" or "info" so that we can pass those to the custom filter functions

    @classmethod
    def execute_filters(
        cls, query, filter_dict: Dict[str, Any], model_alias=None, info=None
    ) -> Tuple[Query, List[Any]]:
        model = cls._meta.model
        .....
        # Here we first check if this is input field that isn't a model_attr and is part of the filter_class (we set that on the meta earlier)
        else:
                # Allow custom filter class to be used for custom filtering over 
                if not hasattr(input_field, "model_attr") and cls._meta.filter_class:
                    clause = getattr(cls._meta.filter_class, field + "_filter")(info, query, field_filters)
                    if isinstance(clause, tuple):
                        query, clause = clause
                    elif isinstance(clause, Query):
                        query = clause
                        continue
                    clauses.append(clause)
                else:
                    model_field = getattr(model, input_field.model_attr or field)

Update SQLAlchemy base to accept a "filter" field

class SQLAlchemyObjectTypeOptions(ObjectTypeOptions):
    .....
    filter = None

[adiberk]

Another thing that might be great is moving some of this logic into class methods instead of global methods. This way one can customize some of the logic to their own liking