strawberry-orm 0.2.0__tar.gz → 0.3.0__tar.gz

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strawberry-orm
-Version: 0.2.0
+Version: 0.3.0
 Summary: Unified, backend-agnostic ORM abstraction for Strawberry GraphQL
 Author: James Davidson, Patrick Arminio
 Author-email: James Davidson <jamie.t.davidson@gmail.com>, Patrick Arminio <patrick.arminio@gmail.com>
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: strawberry-graphql>=0.311.0
+Requires-Dist: greenlet>=3.3.2 ; extra == 'dev'
 Requires-Dist: pytest>=8.0 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24 ; extra == 'dev'
 Requires-Dist: pytest-django>=4.8 ; extra == 'dev'
@@ -54,9 +55,9 @@ Backend-agnostic schema generation for [Strawberry GraphQL](https://strawberry.r
 uv add strawberry-orm
 
 # With a backend
-uv add strawberry-orm[django]
-uv add strawberry-orm[sqlalchemy]
-uv add strawberry-orm[tortoise]
+uv add "strawberry-orm[django]"
+uv add "strawberry-orm[sqlalchemy]"
+uv add "strawberry-orm[tortoise]"
 ```
 
 You can do the same with `pip`:
@@ -65,6 +66,8 @@ You can do the same with `pip`:
 pip install "strawberry-orm[sqlalchemy]"
 ```
 
+If you are using `zsh`, keep the quotes around extras such as `"strawberry-orm[sqlalchemy]"`. Unquoted square brackets are treated as shell glob syntax before `uv` or `pip` sees the package name.
+
 Requirements:
 
 - Python `>=3.12`
@@ -640,6 +643,143 @@ In practice:
 
 ---
 
+### Recursive Node Mutations
+
+`orm.mutations.create_node(...)` and `orm.mutations.update_node(...)` generate catch-all Relay `Node` mutations with recursive nested inputs.
+
+If you want to implement the resolver logic yourself, you can generate the root input types directly with `orm.mutations.create_node_input(...)` and `orm.mutations.update_node_input(...)`:
+
+```python
+import strawberry
+from strawberry import relay
+
+
+@orm.type(User)
+class UserNode(relay.Node):
+    id: relay.NodeID[int]
+    name: auto
+    email: auto
+
+
+@orm.type(Post)
+class PostNode(relay.Node):
+    id: relay.NodeID[int]
+    title: auto
+    body: auto
+
+
+CreateNodeInput = orm.mutations.create_node_input()
+UpdateNodeInput = orm.mutations.update_node_input()
+
+
+@strawberry.type
+class Mutation:
+    create_node = orm.mutations.create_node()
+    update_node = orm.mutations.update_node()
+
+    @strawberry.field
+    def custom_create_node(self, input: CreateNodeInput) -> str:
+        return "implement your own create logic here"
+
+    @strawberry.field
+    def custom_update_node(self, input: UpdateNodeInput) -> str:
+        return "implement your own update logic here"
+```
+
+List relations use `items`, while singular relations use explicit `create` / `update` branches:
+
+```graphql
+mutation {
+  createNode(input: {
+    post: {
+      title: "Hello"
+      body: "World"
+      author: {
+        create: {
+          name: "Alice"
+          email: "alice@example.com"
+        }
+      }
+      tags: {
+        items: [{ create: { name: "python" } }]
+        mode: REPLACE
+        onRemove: DELETE
+      }
+    }
+  }) {
+    __typename
+  }
+}
+```
+
+#### Projection And Policy Config
+
+Pass `project={...}` to restrict recursion depth and configure relation semantics in one dict:
+
+```python
+project = {
+    "post": {
+        "author": {
+            "_meta": {"onReplace": ["DISCONNECT", "DELETE"]},
+        },
+        "comments": {
+            "_meta": {
+                "mode": ["PATCH", "REPLACE"],
+                "onRemove": ["DISCONNECT", "DELETE"],
+            },
+            "author": {
+                "_meta": {"onReplace": ["DISCONNECT", "DELETE"]},
+            },
+        },
+        "tags": {
+            "_meta": {
+                "mode": "REPLACE",
+                "onRemove": "DELETE",
+            },
+        },
+    },
+    "comment": {
+        "author": {
+            "_meta": {"onReplace": ["DISCONNECT", "DELETE"]},
+        },
+    },
+}
+
+
+@strawberry.type
+class Mutation:
+    create_node = orm.mutations.create_node(project=project)
+    update_node = orm.mutations.update_node(project=project)
+```
+
+Rules for the config object:
+
+- Root keys are model names (`post`, `comment`, `user`, ...).
+- Nested keys are relation names available on that model.
+- `_meta` is optional and configures behavior for that relation subtree.
+- Omitted relations still exist as shallow nested inputs, but recursion stops after one more level.
+
+`_meta` supports:
+
+- `mode`: list relation merge strategy (`PATCH` or `REPLACE`)
+- `onRemove`: what to do with removed items from a list relation (`DISCONNECT` or `DELETE`)
+- `onReplace`: what to do with the previous object when replacing a singular relation (`DISCONNECT` or `DELETE`)
+
+The `_meta` values can be either:
+
+- an array of enum strings, which means the GraphQL input exposes that field and the caller may choose from those options
+- a single enum string, which fixes that behavior for the relation and omits the corresponding GraphQL field
+
+Default behavior when a field is exposed but omitted in the mutation input:
+
+- `mode` defaults to `PATCH` when allowed
+- `onRemove` defaults to `DISCONNECT` when allowed
+- `onReplace` defaults to `DISCONNECT` when allowed
+
+If the preferred default is not included in the allowed array, the first configured value is used.
+
+---
+
 ## Query Optimization
 
 Add the optimizer extension to your schema:

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/README.md

@@ -20,9 +20,9 @@ Backend-agnostic schema generation for [Strawberry GraphQL](https://strawberry.r
 uv add strawberry-orm
 
 # With a backend
-uv add strawberry-orm[django]
-uv add strawberry-orm[sqlalchemy]
-uv add strawberry-orm[tortoise]
+uv add "strawberry-orm[django]"
+uv add "strawberry-orm[sqlalchemy]"
+uv add "strawberry-orm[tortoise]"
 ```
 
 You can do the same with `pip`:
@@ -31,6 +31,8 @@ You can do the same with `pip`:
 pip install "strawberry-orm[sqlalchemy]"
 ```
 
+If you are using `zsh`, keep the quotes around extras such as `"strawberry-orm[sqlalchemy]"`. Unquoted square brackets are treated as shell glob syntax before `uv` or `pip` sees the package name.
+
 Requirements:
 
 - Python `>=3.12`
@@ -606,6 +608,143 @@ In practice:
 
 ---
 
+### Recursive Node Mutations
+
+`orm.mutations.create_node(...)` and `orm.mutations.update_node(...)` generate catch-all Relay `Node` mutations with recursive nested inputs.
+
+If you want to implement the resolver logic yourself, you can generate the root input types directly with `orm.mutations.create_node_input(...)` and `orm.mutations.update_node_input(...)`:
+
+```python
+import strawberry
+from strawberry import relay
+
+
+@orm.type(User)
+class UserNode(relay.Node):
+    id: relay.NodeID[int]
+    name: auto
+    email: auto
+
+
+@orm.type(Post)
+class PostNode(relay.Node):
+    id: relay.NodeID[int]
+    title: auto
+    body: auto
+
+
+CreateNodeInput = orm.mutations.create_node_input()
+UpdateNodeInput = orm.mutations.update_node_input()
+
+
+@strawberry.type
+class Mutation:
+    create_node = orm.mutations.create_node()
+    update_node = orm.mutations.update_node()
+
+    @strawberry.field
+    def custom_create_node(self, input: CreateNodeInput) -> str:
+        return "implement your own create logic here"
+
+    @strawberry.field
+    def custom_update_node(self, input: UpdateNodeInput) -> str:
+        return "implement your own update logic here"
+```
+
+List relations use `items`, while singular relations use explicit `create` / `update` branches:
+
+```graphql
+mutation {
+  createNode(input: {
+    post: {
+      title: "Hello"
+      body: "World"
+      author: {
+        create: {
+          name: "Alice"
+          email: "alice@example.com"
+        }
+      }
+      tags: {
+        items: [{ create: { name: "python" } }]
+        mode: REPLACE
+        onRemove: DELETE
+      }
+    }
+  }) {
+    __typename
+  }
+}
+```
+
+#### Projection And Policy Config
+
+Pass `project={...}` to restrict recursion depth and configure relation semantics in one dict:
+
+```python
+project = {
+    "post": {
+        "author": {
+            "_meta": {"onReplace": ["DISCONNECT", "DELETE"]},
+        },
+        "comments": {
+            "_meta": {
+                "mode": ["PATCH", "REPLACE"],
+                "onRemove": ["DISCONNECT", "DELETE"],
+            },
+            "author": {
+                "_meta": {"onReplace": ["DISCONNECT", "DELETE"]},
+            },
+        },
+        "tags": {
+            "_meta": {
+                "mode": "REPLACE",
+                "onRemove": "DELETE",
+            },
+        },
+    },
+    "comment": {
+        "author": {
+            "_meta": {"onReplace": ["DISCONNECT", "DELETE"]},
+        },
+    },
+}
+
+
+@strawberry.type
+class Mutation:
+    create_node = orm.mutations.create_node(project=project)
+    update_node = orm.mutations.update_node(project=project)
+```
+
+Rules for the config object:
+
+- Root keys are model names (`post`, `comment`, `user`, ...).
+- Nested keys are relation names available on that model.
+- `_meta` is optional and configures behavior for that relation subtree.
+- Omitted relations still exist as shallow nested inputs, but recursion stops after one more level.
+
+`_meta` supports:
+
+- `mode`: list relation merge strategy (`PATCH` or `REPLACE`)
+- `onRemove`: what to do with removed items from a list relation (`DISCONNECT` or `DELETE`)
+- `onReplace`: what to do with the previous object when replacing a singular relation (`DISCONNECT` or `DELETE`)
+
+The `_meta` values can be either:
+
+- an array of enum strings, which means the GraphQL input exposes that field and the caller may choose from those options
+- a single enum string, which fixes that behavior for the relation and omits the corresponding GraphQL field
+
+Default behavior when a field is exposed but omitted in the mutation input:
+
+- `mode` defaults to `PATCH` when allowed
+- `onRemove` defaults to `DISCONNECT` when allowed
+- `onReplace` defaults to `DISCONNECT` when allowed
+
+If the preferred default is not included in the allowed array, the first configured value is used.
+
+---
+
 ## Query Optimization
 
 Add the optimizer extension to your schema:

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strawberry-orm"
-version = "0.2.0"
+version = "0.3.0"
 description = "Unified, backend-agnostic ORM abstraction for Strawberry GraphQL"
 readme = "README.md"
 license = "MIT"
@@ -33,6 +33,7 @@ django = ["django>=4.2"]
 sqlalchemy = ["sqlalchemy>=2.0"]
 tortoise = ["tortoise-orm>=0.25.0"]
 dev = [
+    "greenlet>=3.3.2",
     "pytest>=8.0",
     "pytest-asyncio>=0.24",
     "pytest-django>=4.8",
@@ -46,6 +47,7 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
+    "pytest-cov>=7.0.0",
     "starlette>=0.52.1",
     "typer>=0.24.1",
     "uvicorn>=0.41.0",

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/src/strawberry_orm/backends/_base.py

@@ -58,6 +58,7 @@ class BaseBackend:
         self._store = OptimizerStore()
         self._filter_overrides: dict[type, type] = kwargs.get("filter_overrides") or {}
         self._type_registry: dict[str, type] = {}
+        self._graphql_type_registry: dict[type, type] = {}
         self._type_querysets: dict[type, Any] = {}
         self._warn_sensitive: bool = kwargs.get("warn_sensitive", True)
         self._exclude_sensitive_fields: bool = kwargs.get(
@@ -312,10 +313,7 @@ class BaseBackend:
         cls.__orm_model__ = model  # type: ignore[attr-defined]
 
         if self._warn_sensitive:
-            excluded = set(exclude or [])
             for field_name in annotations:
-                if field_name in excluded:
-                    continue
                 if _SENSITIVE_PATTERNS.search(field_name):
                     warnings.warn(
                         f"Field '{field_name}' on {model.__name__} looks sensitive "
@@ -350,15 +348,9 @@ class BaseBackend:
                         ),
                     )
                 else:
-                    try:
-                        delattr(cls, attr_name)
-                    except AttributeError:
-                        pass
-            elif getattr(val, "_orm_auto_field", False):
-                try:
                     delattr(cls, attr_name)
-                except AttributeError:
-                    pass
+            elif getattr(val, "_orm_auto_field", False):
+                delattr(cls, attr_name)
 
         return type_name
 
@@ -372,4 +364,5 @@ class BaseBackend:
         """Call ``strawberry.type()`` and register the model in the type registry."""
         result = strawberry.type(cls, name=name if name else None)
         self._type_registry[type_name] = model
+        self._graphql_type_registry[model] = result
         return result

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/src/strawberry_orm/backends/django.py

@@ -48,6 +48,10 @@ _DJANGO_FIELD_MAP: dict[str, type] = {
 }
 
 
+def _primary_key(value: Any) -> Any:
+    return getattr(value, "pk", getattr(value, "id", None))
+
+
 class DjangoBackend(BaseBackend):
     """Backend adapter for Django."""
 
@@ -216,10 +220,17 @@ class DjangoBackend(BaseBackend):
         *,
         authorize: Any | None = None,
         mode: str = "replace",
+        hard_delete_removed: bool | None = None,
     ) -> Any:
         def apply() -> None:
             manager = getattr(instance, field)
             rel_model = manager.model
+            hard_delete = (
+                self._hard_delete_refs
+                if hard_delete_removed is None
+                else hard_delete_removed
+            )
+            existing_related = list(manager.all())
 
             new_related: list[Any] = []
             to_delete: list[Any] = []
@@ -260,12 +271,21 @@ class DjangoBackend(BaseBackend):
                     manager.add(*new_related)
                 if to_delete:
                     manager.remove(*rel_model.objects.filter(pk__in=to_delete))
-                    if self._hard_delete_refs:
+                    if hard_delete:
                         rel_model.objects.filter(pk__in=to_delete).delete()
             else:
                 manager.set(new_related)
-                if to_delete and self._hard_delete_refs:
+                if to_delete and hard_delete:
                     rel_model.objects.filter(pk__in=to_delete).delete()
+                if hard_delete:
+                    new_ids = {_primary_key(obj) for obj in new_related}
+                    removed_ids = [
+                        _primary_key(obj)
+                        for obj in existing_related
+                        if _primary_key(obj) not in new_ids
+                    ]
+                    if removed_ids:
+                        rel_model.objects.filter(pk__in=removed_ids).delete()
 
         return run_sync(apply, thread_sensitive=True)
 
@@ -301,12 +321,9 @@ class DjangoBackend(BaseBackend):
         return qs
 
     def is_query_object(self, value: Any) -> bool:
-        try:
-            from django.db.models import QuerySet
+        from django.db.models import QuerySet
 
-            return isinstance(value, QuerySet)
-        except ImportError:
-            return False
+        return isinstance(value, QuerySet)
 
     def materialize_query(self, query: Any, info: Any) -> Any:
         return run_sync(list, query, thread_sensitive=True)

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/src/strawberry_orm/backends/protocol.py

@@ -89,6 +89,7 @@ class Backend(Protocol):
         *,
         authorize: Any | None = None,
         mode: str = "replace",
+        hard_delete_removed: bool | None = None,
     ) -> AwaitableOrValue[None]:
         """Apply a list of ref operations to *instance*'s *field* relation.
 

{strawberry_orm-0.2.0 → strawberry_orm-0.3.0}/src/strawberry_orm/backends/sqlalchemy.py

@@ -19,6 +19,10 @@ from strawberry_orm.backends._base import (
 from strawberry_orm.optimizer import OptimizerExtension
 
 
+def _primary_key(value: Any) -> Any:
+    return getattr(value, "id", getattr(value, "pk", None))
+
+
 class SQLAlchemyBackend(BaseBackend):
     """Backend adapter for SQLAlchemy."""
 
@@ -182,6 +186,7 @@ class SQLAlchemyBackend(BaseBackend):
         *,
         authorize: Callable[..., bool] | None = None,
         mode: str = "replace",
+        hard_delete_removed: bool | None = None,
     ) -> Any:
         session = self._get_session(info)
         if self._is_async_session(session):
@@ -193,6 +198,7 @@ class SQLAlchemyBackend(BaseBackend):
                 info,
                 authorize=authorize,
                 mode=mode,
+                hard_delete_removed=hard_delete_removed,
             )
 
         return self._apply_ref_list_sync(
@@ -203,6 +209,7 @@ class SQLAlchemyBackend(BaseBackend):
             info,
             authorize,
             mode,
+            hard_delete_removed,
         )
 
     # -- Query application ----------------------------------------------------
@@ -240,12 +247,9 @@ class SQLAlchemyBackend(BaseBackend):
         return stmt
 
     def is_query_object(self, value: Any) -> bool:
-        try:
-            from sqlalchemy.sql import Select
+        from sqlalchemy.sql import Select
 
-            return isinstance(value, Select)
-        except ImportError:
-            return False
+        return isinstance(value, Select)
 
     def materialize_query(self, query: Any, info: Any) -> Any:
         return self._execute_stmt(query, info)
@@ -487,10 +491,7 @@ class SQLAlchemyBackend(BaseBackend):
         )
 
     def _is_async_session(self, session: Any) -> bool:
-        try:
-            from sqlalchemy.ext.asyncio import AsyncSession
-        except ImportError:
-            return False
+        from sqlalchemy.ext.asyncio import AsyncSession
 
         return isinstance(session, AsyncSession)
 
@@ -530,9 +531,16 @@ class SQLAlchemyBackend(BaseBackend):
         info: Any,
         authorize: Callable[..., bool] | None,
         mode: str,
+        hard_delete_removed: bool | None,
     ) -> None:
         relationship = getattr(type(instance), field).property
         target_model = relationship.mapper.class_
+        existing_related = list(getattr(instance, field))
+        hard_delete = (
+            self._hard_delete_refs
+            if hard_delete_removed is None
+            else hard_delete_removed
+        )
 
         new_related: list[Any] = []
         to_remove: list[Any] = []
@@ -572,7 +580,7 @@ class SQLAlchemyBackend(BaseBackend):
                 obj = session.get(target_model, ref_delete.id)
                 if obj is not None:
                     to_remove.append(obj)
-                    if self._hard_delete_refs:
+                    if hard_delete:
                         session.delete(obj)
 
         if mode == "patch":
@@ -584,6 +592,11 @@ class SQLAlchemyBackend(BaseBackend):
             setattr(instance, field, merged)
         else:
             setattr(instance, field, new_related)
+            if hard_delete:
+                new_ids = {_primary_key(obj) for obj in new_related}
+                for obj in existing_related:
+                    if _primary_key(obj) not in new_ids:
+                        session.delete(obj)
 
     async def _apply_ref_list_async(
         self,
@@ -595,9 +608,17 @@ class SQLAlchemyBackend(BaseBackend):
         *,
         authorize: Callable[..., bool] | None,
         mode: str,
+        hard_delete_removed: bool | None,
     ) -> None:
         relationship = getattr(type(instance), field).property
         target_model = relationship.mapper.class_
+        await session.refresh(instance, [field])
+        existing_related = list(getattr(instance, field))
+        hard_delete = (
+            self._hard_delete_refs
+            if hard_delete_removed is None
+            else hard_delete_removed
+        )
 
         new_related: list[Any] = []
         to_remove: list[Any] = []
@@ -637,7 +658,7 @@ class SQLAlchemyBackend(BaseBackend):
                 obj = await session.get(target_model, ref_delete.id)
                 if obj is not None:
                     to_remove.append(obj)
-                    if self._hard_delete_refs:
+                    if hard_delete:
                         await session.delete(obj)
 
         if mode == "patch":
@@ -650,6 +671,11 @@ class SQLAlchemyBackend(BaseBackend):
             setattr(instance, field, merged)
         else:
             setattr(instance, field, new_related)
+            if hard_delete:
+                new_ids = {_primary_key(obj) for obj in new_related}
+                for obj in existing_related:
+                    if _primary_key(obj) not in new_ids:
+                        await session.delete(obj)
 
 
 # ---------------------------------------------------------------------------