bootgraph 1.9.0.dev24129__tar.gz → 1.11.0.dev24840__tar.gz

{bootgraph-1.9.0.dev24129 → bootgraph-1.11.0.dev24840}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: bootgraph
-Version: 1.9.0.dev24129
+Version: 1.11.0.dev24840
 Summary: A Python library for integrating SQLModel and Strawberry, providing a seamless GraphQL integration with FastAPI and advanced features for database interactions.
-Home-page: https://github.com/MDoreto/graphemy
 License: MIT
 Author: Matheus Doreto
 Author-email: matheusdoreto.md@gmail.com
@@ -23,6 +22,7 @@ Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: strawberry-graphql[debug-server] (>=0.240.0,<0.241.0)
 Project-URL: Bug Tracker, https://github.com/MDoreto/graphemy/issues
 Project-URL: Documentation, https://graphemy.readthedocs.io/en/latest/
+Project-URL: Homepage, https://github.com/MDoreto/graphemy
 Project-URL: Repository, https://github.com/MDoreto/graphemy
 Description-Content-Type: text/markdown
 

{bootgraph-1.9.0.dev24129 → bootgraph-1.11.0.dev24840}/bootgraph/models.py

@@ -44,6 +44,7 @@ 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
     Classes:
         Graphemy: An extended SQLModel that incorporates GraphQL functionalities by using
         Strawberry GraphQL. This class allows defining GraphQL schemas, query names,
@@ -66,6 +67,7 @@ class Graphemy(SQLModel):
     __enable_query__: bool | None = None
     __queryname__: str = ""
     __enginename__: str = "default"
+    __default_order_by__: str = "id"
     __filter_attributes__: Optional[dict[str, dict[str, Any]]] = None
     __custom_resolvers__: Optional[list[Callable]] = None
     __custom_mutations__: Optional[list[Callable]] = None

{bootgraph-1.9.0.dev24129 → bootgraph-1.11.0.dev24840}/bootgraph/router.py

@@ -11,6 +11,7 @@ from fastapi import Request, Response
 from graphql.error import GraphQLError
 from graphql.error.graphql_error import format_error as format_graphql_error
 from sqlalchemy.engine.base import Engine
+from sqlalchemy.ext.asyncio import AsyncEngine
 from strawberry.fastapi import GraphQLRouter
 from strawberry.http import GraphQLHTTPResponse
 from strawberry.types import ExecutionResult
@@ -112,7 +113,7 @@ class GraphemyRouter(GraphQLRouter):
         permission_getter: Callable | None = None,
         dl_filter: Callable | None = None,
         query_filter: Callable | None = None,
-        engine: Engine | Dict[str, Engine] = None,
+        engine: AsyncEngine | Engine | Dict[str, Engine] = None,
         extensions: list = None,
         enable_queries: bool = True,
         enable_put_mutations: bool = False,
@@ -169,11 +170,16 @@ class GraphemyRouter(GraphQLRouter):
             # model_mutation_fields = {}
             if cls_mutations:
                 # Create a resolver that returns an instance of ModelMutations
-                def model_mutations_resolver() -> cls_mutations:
-                    return cls_mutations()
+                def make_mutation_resolver(mutations):
+                    def resolver() -> mutations:
+                        return mutations()
+
+                    return resolver
+
+                resolver = make_mutation_resolver(cls_mutations)
 
                 # Create a Strawberry field for this query
-                mutation_field = strawberry.field(description=f"Mutations for {cls.__queryname__}")(model_mutations_resolver)
+                mutation_field = strawberry.field(description=f"Mutations for {cls.__queryname__}")(resolver)
 
                 need_mutation = False
                 setattr(mutation, cls.__queryname__, mutation_field)
@@ -185,9 +191,15 @@ class GraphemyRouter(GraphQLRouter):
             )
 
         async def get_context(request: Request, response: Response) -> dict:
-            context = {"engine": engine}
-            if context_session:
-                context = {"session": context_session(engine)}
+            if type(engine) == AsyncEngine:
+                context = {"engine": engine}
+                if context_session:
+                    session_generator = context_session()
+                    context = {"session": await anext(session_generator)}
+            else:
+                context = {"engine": engine}
+                if context_session:
+                    context = {"session": context_session(engine)}
             if context_getter:
                 context = await context_getter(request, response, context)
             for k, (func, return_class) in functions.items():

{bootgraph-1.9.0.dev24129 → bootgraph-1.11.0.dev24840}/bootgraph/schemas/generators.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -11,6 +12,9 @@ from typing import (
     Type
 )
 
+from sqlalchemy.dialects.postgresql import array
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Mapped
 from sqlalchemy import ForeignKeyConstraint, func
 from sqlalchemy.inspection import inspect
@@ -31,6 +35,7 @@ class GraphemyFilterMode:
     STARTSWITH = "STARTSWITH"
     ENDSWITH = "ENDSWITH"
     IN = "IN"
+    IN_STRING_ARRAY = "IN_STRING_ARRAY"
 
 
 def set_schema(
@@ -227,7 +232,7 @@ def get_many_relation_function(
 
         # 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, "id")
+        order_column = getattr(cls, orderBy) if orderBy else getattr(cls, cls.__default_order_by__)
         stmt = stmt.order_by(order_column.asc())
 
         # Handle pagination cursors: decode them and apply filters
@@ -564,14 +569,17 @@ def create_filter_input(cls: Type[SQLModel], name_suffix="Filter"):
     class FilterInput:
         pass
 
+    internal_type_filters = set()
     for field_name, field_type in cls.__annotations__.items():
         if field_name in declared_filters:
-            if declared_filters[field_name].get("required"):
-                graphql_type = field_type
-            else:
-                graphql_type = Optional[field_type]
+            internal_type_filters.add(field_name)
             if declared_filters[field_name].get("is_list"):
-                graphql_type = List[graphql_type]
+                graphql_type = List[field_type]
+            else:
+                graphql_type = field_type
+
+            if not declared_filters[field_name].get("required"):
+                graphql_type = Optional[graphql_type]
             setattr(
                 FilterInput,
                 field_name,
@@ -580,6 +588,25 @@ def create_filter_input(cls: Type[SQLModel], name_suffix="Filter"):
                     description=declared_filters[field_name].get("description"),
                 ),
             )
+
+    # process external field_names
+    for field_name in (set(declared_filters.keys()) - internal_type_filters):
+        graphql_type = declared_filters[field_name]["type"]
+        if declared_filters[field_name].get("is_list"):
+            graphql_type = List[graphql_type]
+        else:
+            graphql_type = graphql_type
+
+        if not declared_filters[field_name].get("required"):
+            graphql_type = Optional[graphql_type]
+        setattr(
+            FilterInput,
+            field_name,
+            strawberry.field(
+                default=declared_filters[field_name].get("default"), graphql_type=graphql_type,
+                description=declared_filters[field_name].get("description"),
+            ),
+        )
     return strawberry.input(name=f"{cls.__name__}{name_suffix}")(FilterInput)
 
 
@@ -657,8 +684,26 @@ def get_query(cls: "Graphemy"):
             for k, v in vars(filter).items():
                 if v is None or k not in declared_filters:
                     continue
-                column = getattr(cls, k)
                 mode = declared_filters[k].get("mode", GraphemyFilterMode.EXACT)
+
+                # Check if this is a simple direct column filter or a join-based filter
+                join_model = declared_filters[k].get("join_model")
+                join_source_col = declared_filters[k].get("join_source_col")
+                join_target_col = declared_filters[k].get("join_target_col")
+
+                if join_model and join_source_col and join_target_col:
+                    # We have a join-based filter. Something like:
+                    #   stmt.join(CategoryShop, CategoryShop.shop_id == Shop.id)
+                    #   stmt.filter(CategoryShop.category_id.in_(v))
+                    stmt = stmt.join(join_model, getattr(join_model, join_source_col) == cls.id)
+                    count_stmt = count_stmt.join(join_model, getattr(join_model, join_source_col) == cls.id)
+
+                    # Because `mode` is likely IN or EXACT, handle accordingly
+                    if mode == GraphemyFilterMode.IN:
+                        stmt = stmt.where(getattr(join_model, join_target_col).in_(v))
+                        count_stmt = count_stmt.where(getattr(join_model, join_target_col).in_(v))
+                    continue
+                column = getattr(cls, k)
                 if mode == GraphemyFilterMode.EXACT:
                     stmt = stmt.filter(column.ilike(v))
                     count_stmt = count_stmt.filter(column.ilike(v))
@@ -674,6 +719,19 @@ def get_query(cls: "Graphemy"):
                 elif mode == GraphemyFilterMode.IN:
                     stmt = stmt.where(column.in_(v))
                     count_stmt = count_stmt.filter(column.in_(v))
+                elif mode == GraphemyFilterMode.IN_STRING_ARRAY:
+                    if v and isinstance(v[0], list):
+                        v = v[0]
+                    if v and type(v[0]) == Enum:
+                        v = [enum_type.value for enum_type in v]
+                    stmt = stmt.where(
+                            func.string_to_array(column, ",")
+                            .op("&&")(array(v))
+                        )
+                    count_stmt = count_stmt.filter(
+                            func.string_to_array(column, ",")
+                            .op("&&")(array(v))
+                        )
 
         # Apply any additional query filters defined by Setup
         qf = Setup.query_filter(cls, info.context)
@@ -682,7 +740,7 @@ def get_query(cls: "Graphemy"):
 
         # 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, "id")
+        order_column = getattr(cls, orderBy) if orderBy else getattr(cls, cls.__default_order_by__)
 
         # 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.
@@ -759,28 +817,6 @@ def get_query(cls: "Graphemy"):
     return ModelQuery, Filter
 
 
-def get_put_mutation(cls: "Graphemy") -> StrawberryField:
-    pk = [pk.name for pk in inspect(cls).primary_key]
-
-    class Filter:
-        pass
-
-    for field_name, field in cls.__annotations__.items():
-        setattr(
-            Filter,
-            field_name,
-            strawberry.field(default=None, graphql_type=Optional[field]),
-        )
-    input = strawberry.input(name=f"{cls.__name__}Input")(Filter)
-
-    async def mutation(self, params: input) -> cls.__strawberry_schema__:
-        return await put_item(cls, params, pk)
-
-    return strawberry.mutation(
-        mutation,
-        permission_classes=[Setup.get_auth(cls, "mutation")],
-    )
-
 
 def get_delete_mutation(cls: "Graphemy") -> StrawberryField:
     pk = [pk.name for pk in inspect(cls).primary_key]
@@ -882,6 +918,7 @@ def get_mutations(cls: "Graphemy"):
     """
     fields = {}
 
+    @strawberry.type
     class ModelMutations:
         pass
 
@@ -911,6 +948,10 @@ def get_mutations(cls: "Graphemy"):
             for permission_class in permission_classes:
                 permission_class.item_model = cls
 
+            fields[f"{custom_mutation.__name__}Model"] = strawberry.mutation(
+                    resolver=custom_mutation,
+                    permission_classes=permission_classes
+                )
             setattr(
                 ModelMutations,
                 custom_mutation.__name__,

{bootgraph-1.9.0.dev24129 → bootgraph-1.11.0.dev24840}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "bootgraph"
-version = "v1.9.0.dev24129"
+version = "v1.11.0.dev24840"
 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"
@@ -51,6 +51,8 @@ jinja2 = "^3.1.2"
 mdx-include = "^1.4.2"
 mkdocstrings = "^0.26.1"
 mkdocstrings-python = "^1.11.1"
+asyncpg = ">=0.29.0"
+greenlet = ">=3.0.3"
 
 [build-system]
 requires = ["poetry-core"]