feature: added utils to allow apply filters and orderins without using dataclasses (#27)

Author: ViAchKoN

dataclass_sqlalchemy_mixins/base/utils.py

@@ -24,3 +24,61 @@ def get_unary_expressions(
     return SqlAlchemyOrderConverterMixin().get_unary_expressions(
         order_by=order_by, model=model
     )
+
+
+def apply_filters(
+    query,
+    filters: tp.Dict[str, tp.Any],
+    model: tp.Type[DeclarativeMeta] = None,
+):
+    converter = SqlAlchemyFilterConverterMixin()
+
+    filters_binary_expressions = converter.get_models_binary_expressions(
+        model=model,
+        filters=filters,
+    )
+
+    models_to_join = []
+    binary_expressions = []
+
+    for binary_expression in filters_binary_expressions:
+        models_to_join += binary_expression["models"]
+        binary_expressions.append(binary_expression["binary_expression"])
+
+    # Checking if there are other models required to be joined
+    if models_to_join != [
+        model,
+    ]:
+        query = converter.join_models(query=query, models=models_to_join)
+
+    query = query.filter(*binary_expressions)
+    return query
+
+
+def apply_order_by(
+    query,
+    order_by: tp.Union[str, tp.List[str]],
+    model: tp.Type[DeclarativeMeta] = None,
+):
+    converter = SqlAlchemyOrderConverterMixin()
+
+    order_by_unary_expressions = converter.get_models_unary_expressions(
+        model=model,
+        order_by=order_by,
+    )
+
+    models_to_join = []
+    unary_expressions = []
+
+    for binary_expression in order_by_unary_expressions:
+        models_to_join += binary_expression["models"]
+        unary_expressions.append(binary_expression["unary_expression"])
+
+    # Checking if there are other models required to be joined
+    if models_to_join != [
+        model,
+    ]:
+        query = converter.join_models(query=query, models=models_to_join)
+
+    query = query.order_by(*unary_expressions)
+    return query

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dataclass-sqlalchemy-mixins"
-version = "0.2.0"
+version = "0.3.0"
 description = "Allows to convert dataclasses to sqlalchemy filters and orderings."
 authors = ["ViAchKoN"]
 readme = "README.md"

tests/filtering/test_fields_filters.py

@@ -87,6 +87,39 @@ def test_filter__utils__eq__ok(
     assert result.as_dict() == expected_item.as_dict()
 
 
+def test_filter__utils__apply__eq__ok(
+    db_session,
+    get_sqlalchemy_filter_base_model,
+):
+    expected_item_name = "expected_item_name"
+
+    # Create expected item
+    expected_item = models_factory.ItemFactory.create(name=expected_item_name)
+
+    # Create unexpected items
+    models_factory.ItemFactory.create_batch(size=4)
+
+    assert db_session.query(models.Item).count() == 5
+
+    query = db_session.query(models.Item)
+
+    query = utils.apply_filters(
+        query=query,
+        filters={
+            "name": expected_item_name,
+        },
+        model=models.Item,
+    )
+
+    results = query.all()
+
+    assert len(results) == 1
+
+    result = results[0]
+
+    assert result.as_dict() == expected_item.as_dict()
+
+
 @pytest.mark.parametrize(
     "apply_filters",
     [

tests/ordering/test_fields_orderings.py

@@ -94,6 +94,44 @@ def test_order_by_id__utils__ok(
             assert result.as_dict() == expected_item.as_dict()
 
 
+def test_order_by_id__utils__apply__ok(
+    db_session,
+):
+    items = models_factory.ItemFactory.create_batch(size=5)
+
+    for order_by in [
+        "id",
+        [
+            "id",
+        ],
+        "-id",
+        [
+            "-id",
+        ],
+    ]:
+        expected_items = items
+        if order_by in [
+            "-id",
+            [
+                "-id",
+            ],
+        ]:
+            expected_items = list(reversed(items))
+
+        query = db_session.query(models.Item)
+
+        query = utils.apply_order_by(
+            query=query,
+            order_by=order_by,
+            model=models.Item,
+        )
+
+        results = query.all()
+
+        for expected_item, result in zip(expected_items, results):
+            assert result.as_dict() == expected_item.as_dict()
+
+
 @pytest.mark.parametrize(
     "apply_order_by",
     [