strawberry-graphql 0.274.3__tar.gz → 0.275.0__tar.gz

{strawberry_graphql-0.274.3 → strawberry_graphql-0.275.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.274.3
+Version: 0.275.0
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async

{strawberry_graphql-0.274.3 → strawberry_graphql-0.275.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strawberry-graphql"
-version = "0.274.3"
+version = "0.275.0"
 description = "A library for creating GraphQL APIs"
 authors = [{ name = "Patrick Arminio", email = "patrick.arminio@gmail.com" }]
 license = { text = "MIT" }

{strawberry_graphql-0.274.3 → strawberry_graphql-0.275.0}/strawberry/cli/__init__.py

@@ -2,6 +2,9 @@ try:
     from .app import app
     from .commands.codegen import codegen as codegen  # noqa: PLC0414
     from .commands.export_schema import export_schema as export_schema  # noqa: PLC0414
+    from .commands.locate_definition import (
+        locate_definition as locate_definition,  # noqa: PLC0414
+    )
     from .commands.schema_codegen import (
         schema_codegen as schema_codegen,  # noqa: PLC0414
     )

strawberry_graphql-0.275.0/strawberry/cli/commands/locate_definition.py

@@ -0,0 +1,36 @@
+import sys
+
+import typer
+from rich.console import Console
+
+from strawberry.cli.app import app
+from strawberry.cli.utils import load_schema
+from strawberry.utils.locate_definition import (
+    locate_definition as locate_definition_util,
+)
+
+err_console = Console(stderr=True)
+
+
+@app.command(help="Locate a definition in the schema (output: path:line:column)")
+def locate_definition(
+    schema: str,
+    symbol: str,
+    app_dir: str = typer.Option(
+        ".",
+        "--app-dir",
+        show_default=True,
+        help=(
+            "Look for the module in the specified directory, by adding this to the "
+            "PYTHONPATH. Defaults to the current working directory. "
+            "Works the same as `--app-dir` in uvicorn."
+        ),
+    ),
+) -> None:
+    schema_symbol = load_schema(schema, app_dir)
+
+    if location := locate_definition_util(schema_symbol, symbol):
+        typer.echo(location)
+    else:
+        err_console.print(f"Definition not found: {symbol}")
+        sys.exit(1)

{strawberry_graphql-0.274.3 → strawberry_graphql-0.275.0}/strawberry/exceptions/utils/source_finder.py

@@ -166,7 +166,8 @@ class LibCSTSourceFinder:
         attribute_definitions = m.findall(
             class_def,
             m.AssignTarget(target=m.Name(value=attribute_name))
-            | m.AnnAssign(target=m.Name(value=attribute_name)),
+            | m.AnnAssign(target=m.Name(value=attribute_name))
+            | m.FunctionDef(name=m.Name(value=attribute_name)),
         )
 
         if not attribute_definitions:
@@ -511,7 +512,8 @@ class LibCSTSourceFinder:
         path = Path(scalar_definition._source_file)
         source = path.read_text()
 
-        matcher = m.Call(
+        # Try to find direct strawberry.scalar() calls with name parameter
+        direct_matcher = m.Call(
             func=m.Attribute(value=m.Name(value="strawberry"), attr=m.Name("scalar"))
             | m.Name("scalar"),
             args=[
@@ -525,31 +527,89 @@ class LibCSTSourceFinder:
             ],
         )
 
-        scalar_calls = self._find(source, matcher)
+        direct_calls = self._find(source, direct_matcher)
+        if direct_calls:
+            return self._create_scalar_exception_source(
+                path, source, direct_calls[0], scalar_definition, is_newtype=False
+            )
 
-        if not scalar_calls:
-            return None  # pragma: no cover
+        # Try to find strawberry.scalar() calls with NewType pattern
+        newtype_matcher = m.Call(
+            func=m.Attribute(value=m.Name(value="strawberry"), attr=m.Name("scalar"))
+            | m.Name("scalar"),
+            args=[
+                m.Arg(
+                    value=m.Call(
+                        func=m.Name(value="NewType"),
+                        args=[
+                            m.Arg(
+                                value=m.SimpleString(
+                                    value=f"'{scalar_definition.name}'"
+                                )
+                                | m.SimpleString(value=f'"{scalar_definition.name}"'),
+                            ),
+                            m.ZeroOrMore(),
+                        ],
+                    )
+                ),
+                m.ZeroOrMore(),
+            ],
+        )
 
-        scalar_call_node = scalar_calls[0]
+        newtype_calls = self._find(source, newtype_matcher)
+        if newtype_calls:
+            return self._create_scalar_exception_source(
+                path, source, newtype_calls[0], scalar_definition, is_newtype=True
+            )
 
-        argument_node = m.findall(
-            scalar_call_node,
-            m.Arg(
-                keyword=m.Name(value="name"),
-            ),
-        )
+        return None  # pragma: no cover
+
+    def _create_scalar_exception_source(
+        self,
+        path: Path,
+        source: str,
+        call_node: Any,
+        scalar_definition: ScalarDefinition,
+        is_newtype: bool,
+    ) -> Optional[ExceptionSource]:
+        """Helper method to create ExceptionSource for scalar calls."""
+        import libcst.matchers as m
+
+        if is_newtype:
+            # For NewType pattern, find the string argument within the NewType call
+            newtype_nodes = m.findall(call_node, m.Call(func=m.Name(value="NewType")))
+            if not newtype_nodes:
+                return None  # pragma: no cover
+
+            target_node = newtype_nodes[0]
+            string_nodes = m.findall(
+                target_node,
+                m.SimpleString(value=f"'{scalar_definition.name}'")
+                | m.SimpleString(value=f'"{scalar_definition.name}"'),
+            )
+            if not string_nodes:
+                return None  # pragma: no cover
+
+            target_node = string_nodes[0]
+        else:
+            # For direct calls, find the name argument
+            target_nodes = m.findall(call_node, m.Arg(keyword=m.Name(value="name")))
+            if not target_nodes:
+                return None  # pragma: no cover
+
+            target_node = target_nodes[0]
 
-        position = self._position_metadata[scalar_call_node]
-        argument_node_position = self._position_metadata[argument_node[0]]
+        position = self._position_metadata[call_node]
+        target_position = self._position_metadata[target_node]
 
         return ExceptionSource(
             path=path,
             code=source,
             start_line=position.start.line,
             end_line=position.end.line,
-            error_line=argument_node_position.start.line,
-            error_column=argument_node_position.start.column,
-            error_column_end=argument_node_position.end.column,
+            error_line=target_position.start.line,
+            error_column=target_position.start.column,
+            error_column_end=target_position.end.column,
         )
 
 

{strawberry_graphql-0.274.3 → strawberry_graphql-0.275.0}/strawberry/types/enum.py

@@ -45,6 +45,10 @@ class EnumDefinition(StrawberryType):
     def is_graphql_generic(self) -> bool:
         return False
 
+    @property
+    def origin(self) -> type:
+        return self.wrapped_cls
+
 
 # TODO: remove duplication of EnumValueDefinition and EnumValue
 @dataclasses.dataclass

{strawberry_graphql-0.274.3 → strawberry_graphql-0.275.0}/strawberry/types/union.py

@@ -283,6 +283,10 @@ def union(
             union._source_file = frame.f_code.co_filename
             union._source_line = frame.f_lineno
 
+            # TODO: here union._source_file could be "<string>"
+            # (when using future annotations)
+            # we should find a better way to handle this
+
         return union
 
     warnings.warn(

strawberry_graphql-0.275.0/strawberry/utils/locate_definition.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from strawberry.exceptions.utils.source_finder import SourceFinder
+from strawberry.types.scalar import ScalarDefinition
+from strawberry.types.union import StrawberryUnion
+from strawberry.utils.str_converters import to_snake_case
+
+if TYPE_CHECKING:
+    from strawberry.schema.schema import Schema
+
+
+def locate_definition(schema_symbol: Schema, symbol: str) -> str | None:
+    finder = SourceFinder()
+
+    if "." in symbol:
+        model, field = symbol.split(".", 1)
+    else:
+        model, field = symbol, None
+
+    schema_type = schema_symbol.get_type_by_name(model)
+
+    if not schema_type:
+        return None
+
+    if field:
+        assert not isinstance(schema_type, StrawberryUnion)
+
+        location = finder.find_class_attribute_from_object(
+            schema_type.origin,  # type: ignore
+            to_snake_case(field)
+            if schema_symbol.config.name_converter.auto_camel_case
+            else field,
+        )
+    elif isinstance(schema_type, StrawberryUnion):
+        location = finder.find_annotated_union(schema_type, None)
+    elif isinstance(schema_type, ScalarDefinition):
+        location = finder.find_scalar_call(schema_type)
+    else:
+        location = finder.find_class_from_object(schema_type.origin)
+
+    if not location:
+        return None
+
+    return f"{location.path}:{location.error_line}:{location.error_column + 1}"