strawberry-graphql 0.229.2.dev1715881453__tar.gz → 0.230.0.dev1716318708__tar.gz

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.229.2.dev1715881453
+Version: 0.230.0.dev1716318708
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.229.2.dev.1715881453"
+version = "0.230.0.dev.1716318708"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/federation/object_type.py

@@ -31,6 +31,7 @@ def _impl_type(
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
+    one_of: Optional[bool] = None,
     directives: Iterable[object] = (),
     authenticated: bool = False,
     keys: Iterable[Union["Key", str]] = (),
@@ -54,6 +55,7 @@ def _impl_type(
         Shareable,
         Tag,
     )
+    from strawberry.schema_directives import OneOf
 
     directives = list(directives)
 
@@ -83,6 +85,9 @@ def _impl_type(
     if is_interface_object:
         directives.append(InterfaceObject())
 
+    if one_of:
+        directives.append(OneOf())
+
     return base_type(  # type: ignore
         cls,
         name=name,
@@ -180,6 +185,7 @@ def input(
     cls: T,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
@@ -197,6 +203,7 @@ def input(
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
+    one_of: Optional[bool] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
     tags: Iterable[str] = (),
@@ -207,6 +214,7 @@ def input(
     cls: Optional[T] = None,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
@@ -219,6 +227,7 @@ def input(
         directives=directives,
         inaccessible=inaccessible,
         is_input=True,
+        one_of=one_of,
         tags=tags,
     )
 

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/object_type.py

@@ -293,6 +293,7 @@ def input(
     cls: T,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ) -> T: ...
@@ -305,6 +306,7 @@ def input(
 def input(
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ) -> Callable[[T], T]: ...
@@ -314,6 +316,7 @@ def input(
     cls: Optional[T] = None,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ):
@@ -324,6 +327,11 @@ def input(
     >>>     field_abc: str = "ABC"
     """
 
+    from strawberry.schema_directives import OneOf
+
+    if one_of:
+        directives = (*(directives or ()), OneOf())
+
     return type(  # type: ignore # not sure why mypy complains here
         cls,
         name=name,

strawberry_graphql-0.230.0.dev1716318708/strawberry/permission.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import abc
+import inspect
+from functools import cached_property
+from inspect import iscoroutinefunction
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Dict,
+    List,
+    Optional,
+    Type,
+    Union,
+)
+
+from strawberry.exceptions import StrawberryGraphQLError
+from strawberry.exceptions.permission_fail_silently_requires_optional import (
+    PermissionFailSilentlyRequiresOptionalError,
+)
+from strawberry.extensions import FieldExtension
+from strawberry.schema_directive import Location, StrawberrySchemaDirective
+from strawberry.type import StrawberryList, StrawberryOptional
+from strawberry.utils.await_maybe import await_maybe
+
+if TYPE_CHECKING:
+    from graphql import GraphQLError, GraphQLErrorExtensions
+
+    from strawberry.extensions.field_extension import (
+        AsyncExtensionResolver,
+        SyncExtensionResolver,
+    )
+    from strawberry.field import StrawberryField
+    from strawberry.types import Info
+
+
+class BasePermission(abc.ABC):
+    """
+    Base class for creating permissions
+    """
+
+    message: Optional[str] = None
+
+    error_extensions: Optional[GraphQLErrorExtensions] = None
+
+    error_class: Type[GraphQLError] = StrawberryGraphQLError
+
+    _schema_directive: Optional[object] = None
+
+    @abc.abstractmethod
+    def has_permission(
+        self, source: Any, info: Info, **kwargs: Any
+    ) -> Union[bool, Awaitable[bool]]:
+        raise NotImplementedError(
+            "Permission classes should override has_permission method"
+        )
+
+    def on_unauthorized(self) -> None:
+        """
+        Default error raising for permissions.
+        This can be overridden to customize the behavior.
+        """
+
+        # Instantiate error class
+        error = self.error_class(self.message or "")
+
+        if self.error_extensions:
+            # Add our extensions to the error
+            if not error.extensions:
+                error.extensions = dict()
+            error.extensions.update(self.error_extensions)
+
+        raise error
+
+    @property
+    def schema_directive(self) -> object:
+        if not self._schema_directive:
+
+            class AutoDirective:
+                __strawberry_directive__ = StrawberrySchemaDirective(
+                    self.__class__.__name__,
+                    self.__class__.__name__,
+                    [Location.FIELD_DEFINITION],
+                    [],
+                )
+
+            self._schema_directive = AutoDirective()
+
+        return self._schema_directive
+
+
+class PermissionExtension(FieldExtension):
+    """
+    Handles permissions for a field
+    Instantiate this as a field extension with all of the permissions you want to apply
+
+    fail_silently: bool = False will return None or [] if the permission fails
+    instead of raising an exception. This is only valid for optional or list fields.
+
+    NOTE:
+    Currently, this is automatically added to the field, when using
+    field.permission_classes
+    This is deprecated behavior, please manually add the extension to field.extensions
+    """
+
+    def __init__(
+        self,
+        permissions: List[BasePermission],
+        use_directives: bool = True,
+        fail_silently: bool = False,
+    ) -> None:
+        self.permissions = permissions
+        self.fail_silently = fail_silently
+        self.return_empty_list = False
+        self.use_directives = use_directives
+
+    def apply(self, field: StrawberryField) -> None:
+        """
+        Applies all of the permission directives to the schema
+        and sets up silent permissions
+        """
+        if self.use_directives:
+            field.directives.extend(
+                p.schema_directive for p in self.permissions if p.schema_directive
+            )
+        # We can only fail silently if the field is optional or a list
+        if self.fail_silently:
+            if isinstance(field.type, StrawberryOptional):
+                if isinstance(field.type.of_type, StrawberryList):
+                    self.return_empty_list = True
+            elif isinstance(field.type, StrawberryList):
+                self.return_empty_list = True
+            else:
+                errror = PermissionFailSilentlyRequiresOptionalError(field)
+                raise errror
+
+    def _on_unauthorized(self, permission: BasePermission) -> Any:
+        if self.fail_silently:
+            return [] if self.return_empty_list else None
+        return permission.on_unauthorized()
+
+    def resolve(
+        self,
+        next_: SyncExtensionResolver,
+        source: Any,
+        info: Info,
+        **kwargs: Dict[str, Any],
+    ) -> Any:
+        """
+        Checks if the permission should be accepted and
+        raises an exception if not
+        """
+        for permission in self.permissions:
+            if not permission.has_permission(source, info, **kwargs):
+                return self._on_unauthorized(permission)
+        return next_(source, info, **kwargs)
+
+    async def resolve_async(
+        self,
+        next_: AsyncExtensionResolver,
+        source: Any,
+        info: Info,
+        **kwargs: Dict[str, Any],
+    ) -> Any:
+        for permission in self.permissions:
+            has_permission = await await_maybe(
+                permission.has_permission(source, info, **kwargs)
+            )
+
+            if not has_permission:
+                return self._on_unauthorized(permission)
+        next = next_(source, info, **kwargs)
+        if inspect.isasyncgen(next):
+            return next
+        return await next
+
+    @cached_property
+    def supports_sync(self) -> bool:
+        """The Permission extension always supports async checking using await_maybe,
+        but only supports sync checking if there are no async permissions"""
+        async_permissions = [
+            True
+            for permission in self.permissions
+            if iscoroutinefunction(permission.has_permission)
+        ]
+        return len(async_permissions) == 0

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/schema/execute.py

@@ -23,6 +23,7 @@ from graphql.validation import validate
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.extensions.runner import SchemaExtensionsRunner
+from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types import ExecutionResult
 
 from .exceptions import InvalidOperationTypeError
@@ -55,6 +56,10 @@ def validate_document(
     document: DocumentNode,
     validation_rules: Tuple[Type[ASTValidationRule], ...],
 ) -> List[GraphQLError]:
+    validation_rules = (
+        *validation_rules,
+        OneOfInputValidationRule,
+    )
     return validate(
         schema,
         document,

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/schema/schema.py

@@ -16,6 +16,8 @@ from typing import (
 )
 
 from graphql import (
+    GraphQLBoolean,
+    GraphQLField,
     GraphQLNamedType,
     GraphQLNonNull,
     GraphQLSchema,
@@ -168,6 +170,7 @@ class Schema(BaseSchema):
 
         self._warn_for_federation_directives()
         self._resolve_node_ids()
+        self._extend_introspection()
 
         # Validate schema early because we want developers to know about
         # possible issues as soon as possible
@@ -375,6 +378,14 @@ class Schema(BaseSchema):
                 stacklevel=3,
             )
 
+    def _extend_introspection(self):
+        def _resolve_is_one_of(obj: Any, info: Any) -> bool:
+            return obj.extensions["strawberry-definition"].is_one_of
+
+        instrospection_type = self._schema.type_map["__Type"]
+        instrospection_type.fields["isOneOf"] = GraphQLField(GraphQLBoolean)  # type: ignore[attr-defined]
+        instrospection_type.fields["isOneOf"].resolve = _resolve_is_one_of  # type: ignore[attr-defined]
+
     def as_str(self) -> str:
         return print_schema(self)
 

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/schema/schema_converter.py

@@ -26,6 +26,7 @@ from graphql import (
     GraphQLDirective,
     GraphQLEnumType,
     GraphQLEnumValue,
+    GraphQLError,
     GraphQLField,
     GraphQLInputField,
     GraphQLInputObjectType,
@@ -411,6 +412,27 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_object_type, GraphQLInputObjectType)  # For mypy
             return graphql_object_type
 
+        def check_one_of(value: dict[str, Any]) -> dict[str, Any]:
+            if len(value) != 1:
+                raise GraphQLError(
+                    f"OneOf Input Object '{type_name}' must specify exactly one key."
+                )
+
+            first_key, first_value = next(iter(value.items()))
+
+            if first_value is None or first_value is UNSET:
+                raise GraphQLError(
+                    f"Value for member field '{first_key}' must be non-null"
+                )
+
+            return value
+
+        out_type = (
+            check_one_of
+            if type_definition.is_input and type_definition.is_one_of
+            else None
+        )
+
         graphql_object_type = GraphQLInputObjectType(
             name=type_name,
             fields=lambda: self.get_graphql_input_fields(type_definition),
@@ -418,6 +440,7 @@ class GraphQLCoreConverter:
             extensions={
                 GraphQLCoreConverter.DEFINITION_BACKREF: type_definition,
             },
+            out_type=out_type,
         )
 
         self.type_map[type_name] = ConcreteType(

strawberry_graphql-0.230.0.dev1716318708/strawberry/schema/validation_rules/one_of.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from graphql import (
+    ExecutableDefinitionNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    VariableDefinitionNode,
+    get_named_type,
+)
+
+
+class OneOfInputValidationRule(ValidationRule):
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_operation_definition(
+        self, node: ExecutableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions: dict[str, VariableDefinitionNode] = {}
+
+    def enter_variable_definition(
+        self, node: VariableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions[node.variable.name.value] = node
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        type_ = get_named_type(self.context.get_input_type())
+
+        if not type_:
+            return
+
+        strawberry_type = type_.extensions.get("strawberry-definition")
+
+        if strawberry_type and strawberry_type.is_one_of:
+            self.validate_one_of(node, type_)
+
+    def validate_one_of(self, node: ObjectValueNode, type: GraphQLNamedType) -> None:
+        field_node_map = {field.name.value: field for field in node.fields}
+        keys = list(field_node_map.keys())
+        is_not_exactly_one_field = len(keys) != 1
+
+        if is_not_exactly_one_field:
+            self.report_error(
+                GraphQLError(
+                    f"OneOf Input Object '{type.name}' must specify exactly one key.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        value = field_node_map[keys[0]].value
+        is_null_literal = not value or value.kind == "null_value"
+        is_variable = value.kind == "variable"
+
+        if is_null_literal:
+            self.report_error(
+                GraphQLError(
+                    f"Field '{type.name}.{keys[0]}' must be non-null.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        if is_variable:
+            variable_name = value.name.value  # type: ignore
+            definition = self.variable_definitions[variable_name]
+            is_nullable_variable = definition.type.kind != "non_null_type"
+
+            if is_nullable_variable:
+                self.report_error(
+                    GraphQLError(
+                        f"Variable '{variable_name}' must be non-nullable to be used for OneOf Input Object '{type.name}'.",
+                        nodes=[node],
+                    )
+                )

strawberry_graphql-0.230.0.dev1716318708/strawberry/schema_directives.py

@@ -0,0 +1,8 @@
+from strawberry.schema_directive import Location, schema_directive
+
+
+@schema_directive(locations=[Location.INPUT_OBJECT], name="oneOf")
+class OneOf: ...
+
+
+__all__ = ["OneOf"]

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/type.py

@@ -37,6 +37,10 @@ class StrawberryType(ABC):
     def type_params(self) -> List[TypeVar]:
         return []
 
+    @property
+    def is_one_of(self) -> bool:
+        return False
+
     @abstractmethod
     def copy_with(
         self,

{strawberry_graphql-0.229.2.dev1715881453 → strawberry_graphql-0.230.0.dev1716318708}/strawberry/types/types.py

@@ -225,6 +225,15 @@ class StrawberryObjectDefinition(StrawberryType):
         # All field mappings succeeded. This is a match
         return True
 
+    @property
+    def is_one_of(self) -> bool:
+        from strawberry.schema_directives import OneOf
+
+        if not self.is_input or not self.directives:
+            return False
+
+        return any(isinstance(directive, OneOf) for directive in self.directives)
+
 
 # TODO: remove when deprecating _type_definition
 if TYPE_CHECKING: