bootgraph 1.15.0.dev26211__tar.gz → 1.15.0.dev26232__tar.gz

{bootgraph-1.15.0.dev26211 → bootgraph-1.15.0.dev26232}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bootgraph
-Version: 1.15.0.dev26211
+Version: 1.15.0.dev26232
 Summary: A Python library for integrating SQLModel and Strawberry, providing a seamless GraphQL integration with FastAPI and advanced features for database interactions.
 License: MIT
 Author: Matheus Doreto

bootgraph-1.15.0.dev26232/bootgraph/database/filter_builders/__init__.py

@@ -0,0 +1,71 @@
+from enum import Enum
+from typing import List, Tuple, Union
+from sqlmodel import SQLModel
+from sqlalchemy import cast, and_
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy import func
+
+
+def extract_enum_values(values: List[Union[Enum, List[Enum]]]) -> List[str]:
+    """
+    Extracts string values from a list of Enums or nested lists of Enums.
+    Ensures all values are converted to strings.
+    """
+    return [
+        str((item[0] if isinstance(item, list) else item).value)
+        if hasattr((item[0] if isinstance(item, list) else item), "value")
+        else str(item[0] if isinstance(item, list) else item)
+        for item in values
+    ]
+
+
+def apply_jsonb_contains_filter(
+    stmt,
+    count_stmt,
+    filter_value: List[Union[Enum, List[Enum]]],
+    model_class: SQLModel,
+    field_name: str
+) -> Tuple:
+    """
+    Applies a JSONB containment filter (`@>`) on a model field.
+    """
+    if not filter_value:
+        return stmt, count_stmt
+
+    values = extract_enum_values(filter_value)
+    field = getattr(model_class, field_name)
+    condition = cast(field, JSONB).contains(values)
+
+    stmt = stmt.where(condition)
+    if count_stmt is not None:
+        count_stmt = count_stmt.where(condition)
+
+    return stmt, count_stmt
+
+
+def apply_comma_separated_filter(
+    stmt,
+    count_stmt,
+    filter_value: List[Union[Enum, List[Enum]]],
+    model_class: SQLModel,
+    field_name: str
+) -> Tuple:
+    """
+    Filters entries where ALL tags in filter_value are present
+    in the comma-separated string field.
+    """
+    if not filter_value:
+        return stmt, count_stmt
+
+    tag_values = extract_enum_values(filter_value)
+    field = getattr(model_class, field_name)
+    padded_field = func.concat(',', field, ',')
+
+    conditions = [padded_field.ilike(f'%,{tag},%') for tag in tag_values]
+    combined_condition = and_(*conditions)
+
+    stmt = stmt.where(combined_condition)
+    if count_stmt is not None:
+        count_stmt = count_stmt.where(combined_condition)
+
+    return stmt, count_stmt

{bootgraph-1.15.0.dev26211 → bootgraph-1.15.0.dev26232}/bootgraph/models.py

@@ -1,11 +1,12 @@
 import re
-from typing import Any, Optional, Callable
+from enum import Enum
+from typing import Any, Optional, Callable, Dict, Type
 
 from sqlmodel import SQLModel
 from strawberry.types.base import StrawberryType
 
 from .dl import Dl, ManyRelation
-from .schemas.generators import get_dl_function, get_many_relation_function, get_query
+from .schemas.generators import get_dl_function, get_many_relation_function, get_query, OrderBy
 from .setup import Setup
 
 
@@ -46,7 +47,9 @@ class Graphemy(SQLModel):
             specific mutation names to their respective permission classes. This allows
             for fine-grained control over which permissions apply to each mutation. If a
             mutation is not listed, it defaults to having no specific permissions.
-        __default_order_by__ (str): Order by for database queries
+        __default_order_by__ (dict[str, OrderBy] | str): Order by for database queries. Can be a string for
+            backward compatibility or a dictionary with attribute as key and OrderBy as value.
+            Example: {"id": OrderBy.ASC}
     Classes:
         Graphemy: An extended SQLModel that incorporates GraphQL functionalities by using
         Strawberry GraphQL. This class allows defining GraphQL schemas, query names,
@@ -69,7 +72,7 @@ class Graphemy(SQLModel):
     __enable_query__: bool | None = None
     __queryname__: str = ""
     __enginename__: str = "default"
-    __default_order_by__: str = "id"
+    __default_order_by__: Dict[str, OrderBy] = {"id": OrderBy.ASC}
     __filter_attributes__: Optional[dict[str, dict[str, Any]]] = None
     __custom_resolvers__: Optional[list[Callable]] = None
     __custom_mutations__: Optional[list[Callable]] = None

{bootgraph-1.15.0.dev26211 → bootgraph-1.15.0.dev26232}/bootgraph/schemas/generators.py

@@ -22,10 +22,12 @@ from sqlalchemy.inspection import inspect
 from strawberry.federation.schema_directives import Shareable
 from strawberry.tools import merge_types
 from strawberry.types.field import StrawberryField
-
+from .models import OrderBy, OrderByInput
 from ..database.operations import delete_item, get_items, put_item
 from ..dl import Dl, ManyRelation
 
+
+
 if TYPE_CHECKING:
     from ..models import Graphemy
 
@@ -41,6 +43,53 @@ class GraphemyFilterMode:
     CUSTOM_FILTER_BUILDER = "CUSTOM_FILTER_BUILDER"
 
 
+
+def process_order_by(cls, orderBy, stmt):
+    """
+    Process the orderBy parameter and return the order column and a statement with ordering applied.
+    
+    Args:
+        cls: The model class
+        orderBy: Either a string column name, an OrderByInput instance, or a list of OrderByInput instances
+        
+    Returns:
+        Tuple of (primary_order_column, stmt_with_ordering_applied)
+    """
+    if isinstance(orderBy, list) and orderBy:
+        # List of OrderByInput objects
+        primary_order = orderBy[0]  # First one is the primary for cursors
+        primary_order_column = getattr(cls, primary_order.field)
+        
+        # Apply all orderings
+        for order_item in orderBy:
+            col = getattr(cls, order_item.field)
+            if order_item.direction == OrderBy.DESC:
+                stmt = stmt.order_by(col.desc())
+            else:
+                stmt = stmt.order_by(col.asc())
+        
+        return primary_order_column, stmt
+    
+    # Default ordering from the model
+    default_order_by = cls.__default_order_by__
+    if isinstance(default_order_by, dict):
+        # For dict-based ordering, use the first key as the primary order column for cursors
+        column_name = next(iter(default_order_by))
+        direction = default_order_by[column_name]
+        order_column = getattr(cls, column_name)
+        
+        # Apply all orderings to the statement
+        for col_name, dir_value in default_order_by.items():
+            col = getattr(cls, col_name)
+            if dir_value == "DESC":
+                stmt = stmt.order_by(col.desc())
+            else:
+                stmt = stmt.order_by(col.asc())
+    else:
+        raise Exception(f"Invalid orderBy on {cls.__name__} {cls.__default_order_by__}")
+    
+    return order_column, stmt
+
 def set_schema(
         cls: "Graphemy",
         functions: Dict[str, Tuple[Callable, "Graphemy"]],
@@ -176,7 +225,7 @@ def get_many_relation_function(
                     ]
                     | None
             ) = None,
-            orderBy: Optional[str] = None,
+            orderBy: Optional[list[OrderByInput]] = None,
     ) -> return_type:
         # Check permissions asynchronously
         if not await Setup.has_permission(cls, info.context, "query"):
@@ -222,7 +271,7 @@ def get_many_relation_function(
             .filter(source_field == source_value).select_from(cls))
 
         # Apply filters if provided
-        apply_filters(stmt, count_stmt, cls, filters)
+        stmt, count_stmt = apply_filters(stmt, count_stmt, cls, filters)
 
         # Apply any additional query filters defined by Setup
         qf = Setup.query_filter(cls, info.context)
@@ -231,9 +280,7 @@ def get_many_relation_function(
             count_stmt = qf(count_stmt)
 
         # Determine ordering
-        # Assume `orderBy` is the name of a column in `cls`. If not provided, default to primary key.
-        order_column = getattr(cls, orderBy) if orderBy else getattr(cls, cls.__default_order_by__)
-        stmt = stmt.order_by(order_column.asc())
+        order_column, stmt = process_order_by(cls, orderBy, stmt)
 
         # Handle pagination cursors: decode them and apply filters
         # We assume the cursors are encoded in a way that allows retrieval of the order_column value.
@@ -505,9 +552,8 @@ def apply_filters(
         elif mode == GraphemyFilterMode.CUSTOM_FILTER_BUILDER:
             filter_builder = cfg.get("filter_builder")
             if callable(filter_builder):
-                stmt, count_stmt = filter_builder(stmt, count_stmt, value, cls)
-
-    return (stmt, count_stmt)
+                stmt, count_stmt = filter_builder(stmt, count_stmt, value, cls, key)
+    return stmt, count_stmt
 
 
 async def get_one(cls: Type[SQLModel], filter_obj: Any, query_filter: callable = None):
@@ -791,17 +837,21 @@ def get_query(cls: "Graphemy"):
     async def many_resolver(
             self,
             info: "Info",
-            first: Optional[int] = None,
+            first: Optional[int] = 100,
             after: Optional[str] = None,
             last: Optional[int] = None,
             before: Optional[str] = None,
             filter: Optional[Filter] = None,
-            orderBy: Optional[str] = None,
+            orderBy: Optional[list[OrderByInput]] = None,
     ) -> CountableConnectionForModel:
         # Check permissions asynchronously
         if not await Setup.has_permission(cls, info.context, "query"):
             # Return empty connection if no permission
             return convert_to_countable_connection([], first, after, last, before, CountableConnectionForModel)
+        
+        if first and first > 100 or last and last > 100:
+            raise ValueError("first and last must be less than 100")
+        
 
         # Obtain the engine for this model
         engine = Setup.engine[cls.__enginename__]
@@ -816,10 +866,10 @@ def get_query(cls: "Graphemy"):
         qf = Setup.query_filter(cls, info.context)
         if qf and callable(qf):
             stmt = qf(stmt)
+            count_stmt = qf(count_stmt)
 
         # Determine ordering
-        # Assume `orderBy` is the name of a column in `cls`. If not provided, default to primary key.
-        order_column = getattr(cls, orderBy) if orderBy else getattr(cls, cls.__default_order_by__)
+        order_column, stmt = process_order_by(cls, orderBy, stmt)
 
         # Handle pagination cursors: decode them and apply filters
         # We assume the cursors are encoded in a way that allows retrieval of the order_column value.

bootgraph-1.15.0.dev26232/bootgraph/schemas/models.py

@@ -0,0 +1,26 @@
+from datetime import date
+import enum
+
+import strawberry
+
+
+@strawberry.input
+class DateFilter:
+    range: list[date | None] | None = None
+    items: list[date] | None = None
+    year: int | None = None
+
+
+@strawberry.enum
+class OrderBy(str, enum.Enum):
+    """
+    Enum representing the ordering direction for database queries.
+    """
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+@strawberry.input
+class OrderByInput:
+    field: str
+    direction: OrderBy = OrderBy.ASC

{bootgraph-1.15.0.dev26211 → bootgraph-1.15.0.dev26232}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "bootgraph"
-version = "v1.15.0.dev26211"
+version = "v1.15.0.dev26232"
 description = "A Python library for integrating SQLModel and Strawberry, providing a seamless GraphQL integration with FastAPI and advanced features for database interactions."
 authors = ["Matheus Doreto <matheusdoreto.md@gmail.com>", "Pavel Mulin <mulin.pasha@gmail.com>"]
 readme = "README.md"

bootgraph-1.15.0.dev26211/bootgraph/schemas/models.py

@@ -1,10 +0,0 @@
-from datetime import date
-
-import strawberry
-
-
-@strawberry.input
-class DateFilter:
-    range: list[date | None] | None = None
-    items: list[date] | None = None
-    year: int | None = None