entrygraph 0.1.128__tar.gz → 0.1.129__tar.gz

{entrygraph-0.1.128 → entrygraph-0.1.129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.128
+Version: 0.1.129
 Summary: Language-agnostic code graph: query symbols, entrypoints, and source-to-sink call paths from a SQLite index
 Project-URL: Repository, https://github.com/brettbergin/entrygraph
 Author-email: Brett Bergin <brettberginbc@yahoo.com>

{entrygraph-0.1.128 → entrygraph-0.1.129}/src/entrygraph/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.128'
-__version_tuple__ = version_tuple = (0, 1, 128)
+__version__ = version = '0.1.129'
+__version_tuple__ = version_tuple = (0, 1, 129)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.128 → entrygraph-0.1.129}/src/entrygraph/detect/entrypoints/golang.py

@@ -323,6 +323,47 @@ def _grpc_services(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+# gqlgen's generated wiring instantiates unexported per-type resolver structs
+# (`type queryResolver struct{ *Resolver }`); user code implements the schema as
+# exported methods on them in resolver.go / *.resolvers.go. The lowercase-first
+# anchor excludes both the exported root `Resolver` (whose Query()/Mutation()
+# methods are wiring, not fields) and generated executionContext methods.
+_GQLGEN_RECEIVER = re.compile(r"^([a-z]\w*)Resolver$")
+_GQL_OPERATIONS = {"Query": "query", "Mutation": "mutation", "Subscription": "subscription"}
+
+
+def _gqlgen_resolvers(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol in x.symbols:
+        if symbol.kind is not SymbolKind.METHOD or not symbol.is_exported:
+            continue
+        parent = (symbol.parent_qualified_name or "").rsplit(".", 1)[-1]
+        m = _GQLGEN_RECEIVER.match(parent)
+        if m is None:
+            continue
+        # every gqlgen resolver method takes ctx first — cheap precision guard
+        if "ctx context.Context" not in (symbol.signature or ""):
+            continue
+        parent_type = m.group(1)[:1].upper() + m.group(1)[1:]
+        field = symbol.name[:1].lower() + symbol.name[1:]  # gqlgen lowerCamels fields
+        hints.append(
+            EntrypointHint(
+                rule_id="go.gqlgen.resolver",
+                kind=EntrypointKind.GRAPHQL_RESOLVER,
+                handler_qualified_name=symbol.qualified_name,
+                route=f"{parent_type}.{field}",
+                name=field,
+                framework="gqlgen",
+                span=symbol.span,
+                metadata={
+                    "operation": _GQL_OPERATIONS.get(parent_type, "field"),
+                    "parent_type": parent_type,
+                },
+            )
+        )
+    return hints
+
+
 register(EntrypointRule("go.core.main", "go", None, EntrypointKind.MAIN, _go_main))
 register(
     EntrypointRule("go.nethttp.route", "go", "net/http", EntrypointKind.HTTP_ROUTE, _nethttp_routes)
@@ -343,3 +384,8 @@ register(
 register(
     EntrypointRule("go.grpc.service", "go", "grpc-go", EntrypointKind.RPC_HANDLER, _grpc_services)
 )
+register(
+    EntrypointRule(
+        "go.gqlgen.resolver", "go", "gqlgen", EntrypointKind.GRAPHQL_RESOLVER, _gqlgen_resolvers
+    )
+)

{entrygraph-0.1.128 → entrygraph-0.1.129}/src/entrygraph/detect/entrypoints/javascript.py

@@ -207,6 +207,118 @@ def _nest_routes(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+_GQL_RESOLVER_CLASS = re.compile(r"^@Resolver\b")
+_GQL_FIELD_DECORATOR = re.compile(r"^@(Query|Mutation|Subscription|ResolveField|FieldResolver)\b")
+_GQL_NAME_OPT = re.compile(r"""name\s*:\s*['"]([\w.]+)['"]""")
+_GQL_TYPE_THUNK = re.compile(r"=>\s*\[?\s*([A-Za-z_$][\w$]*)")
+_GQL_OPERATIONS = {"Query": "query", "Mutation": "mutation", "Subscription": "subscription"}
+
+
+def _gql_decorator_resolvers(framework: str):
+    """@Resolver classes with @Query/@Mutation/@Subscription/@ResolveField methods.
+
+    NestJS-GraphQL and TypeGraphQL share this shape (TypeGraphQL says
+    @FieldResolver where Nest says @ResolveField). Requiring the enclosing class
+    to carry @Resolver keeps other libraries' @Query decorators out; when both
+    frameworks are detected the scanner's hint dedup keeps one row.
+    """
+
+    def matcher(x: FileExtraction) -> list[EntrypointHint]:
+        # resolver class qname -> the parent type it resolves for:
+        # @Resolver('User') / @Resolver(() => User) / bare -> class name - "Resolver"
+        targets: dict[str, str] = {}
+        for symbol in x.symbols:
+            if symbol.kind is not SymbolKind.CLASS:
+                continue
+            for decorator in symbol.decorators:
+                if _GQL_RESOLVER_CLASS.match(decorator):
+                    thunk = _GQL_TYPE_THUNK.search(decorator)
+                    targets[symbol.qualified_name] = (
+                        first_string_arg(decorator)
+                        or (thunk.group(1) if thunk else None)
+                        or symbol.name.removesuffix("Resolver")
+                        or symbol.name
+                    )
+        if not targets:
+            return []
+        hints = []
+        for symbol in x.symbols:
+            if symbol.kind is not SymbolKind.METHOD or symbol.parent_qualified_name not in targets:
+                continue
+            for decorator in symbol.decorators:
+                m = _GQL_FIELD_DECORATOR.match(decorator)
+                if not m:
+                    continue
+                kind = m.group(1)
+                if kind in ("ResolveField", "FieldResolver"):
+                    parent = targets[symbol.parent_qualified_name]
+                    field = first_string_arg(decorator) or symbol.name
+                    operation = "field"
+                else:
+                    parent, operation = kind, _GQL_OPERATIONS[kind]
+                    named = _GQL_NAME_OPT.search(decorator)
+                    field = named.group(1) if named else symbol.name
+                hints.append(
+                    EntrypointHint(
+                        rule_id=f"javascript.{framework}.resolver",
+                        kind=EntrypointKind.GRAPHQL_RESOLVER,
+                        handler_qualified_name=symbol.qualified_name,
+                        route=f"{parent}.{field}",
+                        name=field,
+                        framework=framework,
+                        span=symbol.span,
+                        metadata={"operation": operation, "parent_type": parent},
+                    )
+                )
+        return hints
+
+    return matcher
+
+
+_RESOLVERS_VAR = re.compile(r"resolvers?$", re.IGNORECASE)
+
+
+def _apollo_resolvers(x: FileExtraction) -> list[EntrypointHint]:
+    """Apollo resolver-map objects: `const resolvers = { Query: { user() {} } }`.
+
+    Keys off the object-literal method symbols the JS extractor emits with
+    key-path qnames. Query/Mutation/Subscription parents match anywhere; other
+    TitleCase parents (type-field resolvers like `User: { posts }`) only inside
+    a *resolvers*-named or `Resolvers`-typed container. Shorthand *references*
+    (`Query: { user }` where `user` is imported) emit no symbol and are a known
+    gap.
+    """
+    typed_vars = {
+        b.name for b in x.bindings if b.kind == "declared" and b.type_text.endswith("Resolvers")
+    }
+    hints = []
+    for symbol in x.symbols:
+        if symbol.kind is not SymbolKind.METHOD or not symbol.parent_qualified_name:
+            continue
+        parts = symbol.parent_qualified_name.split(".")
+        parent_type = parts[-1]
+        container = parts[-2] if len(parts) >= 2 else ""
+        operation = _GQL_OPERATIONS.get(parent_type)
+        if operation is None:
+            in_map = bool(_RESOLVERS_VAR.search(container)) or container in typed_vars
+            if not in_map or not parent_type[:1].isupper():
+                continue
+            operation = "field"
+        hints.append(
+            EntrypointHint(
+                rule_id="javascript.apollo.resolver",
+                kind=EntrypointKind.GRAPHQL_RESOLVER,
+                handler_qualified_name=symbol.qualified_name,
+                route=f"{parent_type}.{symbol.name}",
+                name=symbol.name,
+                framework="apollo",
+                span=symbol.span,
+                metadata={"operation": operation, "parent_type": parent_type},
+            )
+        )
+    return hints
+
+
 def _next_handlers(x: FileExtraction) -> list[EntrypointHint]:
     """Next.js App Router route handlers in app/**/route.{ts,js}.
 
@@ -382,3 +494,30 @@ register(
         _next_pages_handlers,
     )
 )
+register(
+    EntrypointRule(
+        "javascript.apollo.resolver",
+        "javascript",
+        "apollo",
+        EntrypointKind.GRAPHQL_RESOLVER,
+        _apollo_resolvers,
+    )
+)
+register(
+    EntrypointRule(
+        "javascript.nestjs-graphql.resolver",
+        "javascript",
+        "nestjs-graphql",
+        EntrypointKind.GRAPHQL_RESOLVER,
+        _gql_decorator_resolvers("nestjs-graphql"),
+    )
+)
+register(
+    EntrypointRule(
+        "javascript.type-graphql.resolver",
+        "javascript",
+        "type-graphql",
+        EntrypointKind.GRAPHQL_RESOLVER,
+        _gql_decorator_resolvers("type-graphql"),
+    )
+)

{entrygraph-0.1.128 → entrygraph-0.1.129}/src/entrygraph/detect/entrypoints/ruby.py

@@ -9,13 +9,15 @@ level) — the block body's calls still resolve as ordinary edges.
 
 from __future__ import annotations
 
+import re
+
 from entrygraph.detect.entrypoints.base import (
     EntrypointRule,
     first_string_arg,
     register,
 )
 from entrygraph.extract.ir import EntrypointHint, FileExtraction
-from entrygraph.kinds import EntrypointKind
+from entrygraph.kinds import EntrypointKind, SymbolKind
 
 _SINATRA_VERBS = frozenset({"get", "post", "put", "delete", "patch"})
 _RAILS_VERBS = frozenset({"get", "post", "put", "patch", "delete", "resources", "resource", "root"})
@@ -155,6 +157,116 @@ def _sidekiq_workers(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+# ---------------- graphql-ruby ----------------
+
+# base-class shapes marking a graphql-ruby type / mutation / resolver class
+_GQL_TYPE_BASE = re.compile(r"(::BaseObject$|^GraphQL::Schema::Object$|^Types::Base)")
+_GQL_MUTATION_BASE = re.compile(r"(BaseMutation$|^GraphQL::Schema::(RelayClassic)?Mutation$)")
+_GQL_RESOLVER_BASE = re.compile(r"(BaseResolver$|^GraphQL::Schema::Resolver$)")
+_GQL_RESOLVER_OPT = re.compile(r"(?:resolver|mutation)\s*(?:=>|:)\s*([A-Za-z_][\w:]*)")
+_GQL_ROOT_OPERATIONS = {
+    "QueryType": "query",
+    "MutationType": "mutation",
+    "SubscriptionType": "subscription",
+}
+
+
+def _camelize(name: str) -> str:
+    """graphql-ruby camelizes snake_case field names by default."""
+    head, *rest = name.split("_")
+    return head + "".join(s.title() for s in rest)
+
+
+def _graphql_field_hints(x: FileExtraction) -> list[EntrypointHint]:
+    """`field :posts, ...` declarations in graphql-ruby type classes.
+
+    The convention handler is an instance method named after the field; a
+    ``resolver:``/``mutation:`` option delegates to a class instead (recorded in
+    metadata, handler left unbound for the linking pass / span fallback).
+    """
+    type_classes = [
+        s
+        for s in x.symbols
+        if s.kind is SymbolKind.CLASS and any(_GQL_TYPE_BASE.search(b) for b in s.bases)
+    ]
+    if not type_classes:
+        return []
+    # innermost-first so a nested class wins span containment
+    type_classes.sort(key=lambda s: s.span.start_line, reverse=True)
+    hints = []
+    for ref in x.references:
+        if ref.kind != "call" or ref.receiver_text is not None or ref.callee_name != "field":
+            continue
+        if not ref.arg_preview:
+            continue
+        cls = next(
+            (
+                s
+                for s in type_classes
+                if s.span.start_line <= ref.span.start_line <= s.span.end_line
+            ),
+            None,
+        )
+        if cls is None:
+            continue
+        name = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        if name is None:
+            # symbol first arg like `:posts` — same fallback the rake rule uses
+            stripped = ref.arg_preview.strip("()").lstrip(":").split(",", 1)[0]
+            name = stripped.split(" ", 1)[0].strip() or None
+        if not name:
+            continue
+        operation = _GQL_ROOT_OPERATIONS.get(cls.name, "field")
+        parent = cls.name.removesuffix("Type") or cls.name
+        resolver_opt = _GQL_RESOLVER_OPT.search(ref.arg_preview)
+        metadata: dict = {"operation": operation, "parent_type": parent}
+        if resolver_opt:
+            metadata["resolver_class"] = resolver_opt.group(1)
+        hints.append(
+            EntrypointHint(
+                rule_id="ruby.graphql-ruby.field",
+                kind=EntrypointKind.GRAPHQL_RESOLVER,
+                handler_qualified_name=None if resolver_opt else f"{cls.qualified_name}.{name}",
+                route=f"{parent}.{_camelize(name)}",
+                name=name,
+                framework="graphql-ruby",
+                span=ref.span,
+                metadata=metadata,
+            )
+        )
+    return hints
+
+
+def _graphql_resolver_classes(x: FileExtraction) -> list[EntrypointHint]:
+    """Mutation/Resolver classes: `class CreateOrder < BaseMutation` with a
+    `resolve` method. Mutations get a best-effort `Mutation.<camelized name>`
+    route (the default when mounted as `field :create_order, mutation: ...`);
+    plain resolvers leave the route to the mounting field's hint."""
+    hints = []
+    for cls in x.symbols:
+        if cls.kind is not SymbolKind.CLASS:
+            continue
+        if any(_GQL_MUTATION_BASE.search(b) for b in cls.bases):
+            operation, route = "mutation", f"Mutation.{cls.name[:1].lower()}{cls.name[1:]}"
+        elif any(_GQL_RESOLVER_BASE.search(b) for b in cls.bases):
+            operation, route = "field", None
+        else:
+            continue
+        hints.append(
+            EntrypointHint(
+                rule_id="ruby.graphql-ruby.resolver",
+                kind=EntrypointKind.GRAPHQL_RESOLVER,
+                handler_qualified_name=f"{cls.qualified_name}.resolve",
+                route=route,
+                name=cls.name,
+                framework="graphql-ruby",
+                span=cls.span,
+                metadata={"operation": operation, "parent_type": "Mutation" if route else None},
+            )
+        )
+    return hints
+
+
 register(
     EntrypointRule(
         "ruby.sinatra.route", "ruby", "sinatra", EntrypointKind.HTTP_ROUTE, _sinatra_routes
@@ -170,3 +282,21 @@ register(
     EntrypointRule("ruby.rails.routes", "ruby", "rails", EntrypointKind.HTTP_ROUTE, _rails_routes)
 )
 register(EntrypointRule("ruby.rake.task", "ruby", "rake", EntrypointKind.CLI_COMMAND, _rake_tasks))
+register(
+    EntrypointRule(
+        "ruby.graphql-ruby.field",
+        "ruby",
+        "graphql-ruby",
+        EntrypointKind.GRAPHQL_RESOLVER,
+        _graphql_field_hints,
+    )
+)
+register(
+    EntrypointRule(
+        "ruby.graphql-ruby.resolver",
+        "ruby",
+        "graphql-ruby",
+        EntrypointKind.GRAPHQL_RESOLVER,
+        _graphql_resolver_classes,
+    )
+)

{entrygraph-0.1.128 → entrygraph-0.1.129}/src/entrygraph/detect/frameworks.py

@@ -546,6 +546,58 @@ FRAMEWORKS: list[FrameworkSpec] = [
             FrameworkSignal("import", "tokio", 0.7),
         ),
     ),
+    # --- GraphQL server frameworks. Deliberately no signal for the bare npm
+    # `graphql` package: it is a peer dep of every GraphQL *client* (apollo-client,
+    # urql, relay) and would fire on repos that only consume GraphQL.
+    FrameworkSpec(
+        "apollo",
+        "javascript",
+        (
+            FrameworkSignal("manifest_dep", "@apollo/server", 0.8),  # v4
+            FrameworkSignal("manifest_dep", "apollo-server*", 0.8),  # v2/3 + -express/-koa/...
+            FrameworkSignal("manifest_dep", "@apollo/subgraph", 0.6),
+            FrameworkSignal("import", "@apollo/server*", 0.7),
+            FrameworkSignal("import", "apollo-server*", 0.7),
+        ),
+    ),
+    FrameworkSpec(
+        "nestjs-graphql",
+        "javascript",
+        (
+            FrameworkSignal("manifest_dep", "@nestjs/graphql", 0.8),
+            FrameworkSignal("import", "@nestjs/graphql", 0.7),
+        ),
+    ),
+    FrameworkSpec(
+        "type-graphql",
+        "javascript",
+        (
+            FrameworkSignal("manifest_dep", "type-graphql", 0.8),
+            FrameworkSignal("import", "type-graphql", 0.7),
+        ),
+    ),
+    FrameworkSpec(
+        "graphql-ruby",
+        "ruby",
+        (
+            # the `graphql` gem IS graphql-ruby (the server library); the client
+            # ships as `graphql-client`, so the exact-name match stays quiet for
+            # consumer-only repos. `require 'graphql/client'` also surfaces top
+            # segment "graphql", so the import signal is corroborative-only.
+            FrameworkSignal("manifest_dep", "graphql", 0.8),
+            FrameworkSignal("import", "graphql", 0.4),
+            FrameworkSignal("file_presence", "*app/graphql/*", 0.4),
+        ),
+    ),
+    FrameworkSpec(
+        "gqlgen",
+        "go",
+        (
+            FrameworkSignal("manifest_dep", "github.com/99designs/gqlgen", 0.8),
+            FrameworkSignal("import", "github.com/99designs/gqlgen*", 0.7),
+            FrameworkSignal("file_presence", "*gqlgen.y*ml", 0.6),
+        ),
+    ),
 ]
 
 

{entrygraph-0.1.128 → entrygraph-0.1.129}/src/entrygraph/extract/javascript.py

@@ -108,6 +108,7 @@ class JavaScriptExtractor:
             error_count=1 if root.has_error else 0,
         )
         self._definitions(root, ctx, out)
+        self._object_literal_callables(root, ctx, out)
         self._imports(root, ctx, out)
         self._calls(root, ctx, out)
         self._bindings(root, ctx, out)
@@ -239,6 +240,8 @@ class JavaScriptExtractor:
         for node in caps.get("def.function", []):
             self._add_callable(node, ctx, out, SymbolKind.FUNCTION)
         for node in caps.get("def.method", []):
+            if node.parent is not None and node.parent.type == "object":
+                continue  # object-literal shorthand: emitted with a key-path qname below
             self._add_callable(node, ctx, out, SymbolKind.METHOD)
 
         for node in caps.get("def.class", []):
@@ -340,6 +343,104 @@ class JavaScriptExtractor:
             )
         )
 
+    # ---------------- object-literal callables ----------------
+
+    def _object_literal_callables(self, root, ctx, out) -> None:
+        """Function-valued object-literal properties become METHOD symbols with
+        key-path qnames: `const resolvers = { Query: { user: () => {} } }` ->
+        ``mod.resolvers.Query.user``. Covers shorthand methods (`user() {}`) and
+        arrow/function-expression pairs; makes Apollo-style resolver maps (and any
+        handler-map idiom) addressable/bindable. Members with no stable path
+        anchor (`module.exports = { run() {} }`) keep their previous flat qname.
+        """
+        stack = [root]
+        while stack:
+            n = stack.pop()
+            stack.extend(n.named_children)
+            if n.type == "method_definition" and n.parent is not None and n.parent.type == "object":
+                name = self._key_name(n.child_by_field_name("name"))
+                if name is not None:
+                    self._emit_object_member(n, name, ctx, out)
+            elif n.type == "pair":
+                value = n.child_by_field_name("value")
+                if value is None or value.type not in ("arrow_function", "function_expression"):
+                    continue
+                name = self._key_name(n.child_by_field_name("key"))
+                if name is not None:
+                    self._emit_object_member(n, name, ctx, out)
+
+    def _emit_object_member(self, node, name, ctx, out) -> None:
+        parent_path = self._object_parent_path(node, ctx)
+        if parent_path is None:
+            qname, parent_q = self._qualify(node, name, ctx)
+        else:
+            qname, parent_q = f"{parent_path}.{name}", parent_path
+        out.symbols.append(
+            RawSymbol(
+                kind=SymbolKind.METHOD,
+                name=name,
+                qualified_name=qname,
+                span=span_of(node),
+                parent_qualified_name=parent_q,
+                signature=self._signature(node),
+                is_exported=self._exported(node),
+                return_type_text=self._return_type_text(node),
+            )
+        )
+
+    def _key_name(self, key_node) -> str | None:
+        if key_node is None:
+            return None
+        if key_node.type == "property_identifier":
+            return node_text(key_node)
+        if key_node.type == "string":
+            text = node_text(key_node).strip("'\"`")
+            return text or None
+        return None  # computed / numeric keys carry no stable name
+
+    # An object member's path stops at 4 key segments — deeper nesting is config
+    # data, not a handler map.
+    _OBJECT_PATH_MAX_KEYS = 4
+
+    def _object_parent_path(self, node, ctx) -> str | None:
+        """Dotted parent path of an object-literal member: enclosing pair keys up
+        to a variable/assignment anchor (`const resolvers = ...` -> resolvers).
+        An object passed inline as a call argument uses its keys alone
+        (`new ApolloServer({resolvers: {Query: ...}})` -> mod.resolvers.Query).
+        None when there is neither anchor nor keys (flat-qname fallback).
+        """
+        keys: list[str] = []
+        anchor: str | None = None
+        current = node.parent
+        while current is not None:
+            t = current.type
+            if t in ("object", "parenthesized_expression"):
+                current = current.parent
+                continue
+            if t == "pair":
+                key = self._key_name(current.child_by_field_name("key"))
+                if key is None or len(keys) >= self._OBJECT_PATH_MAX_KEYS:
+                    return None
+                keys.append(key)
+                current = current.parent
+                continue
+            if t == "variable_declarator":
+                name = current.child_by_field_name("name")
+                if name is not None and name.type == "identifier":
+                    anchor = node_text(name)
+                break
+            if t == "assignment_expression":
+                left = current.child_by_field_name("left")
+                if left is not None and left.type == "identifier":
+                    anchor = node_text(left)
+                break
+            break  # arguments / export_statement / return_statement / program ...
+        if not keys and anchor is None:
+            return None
+        segments = ([anchor] if anchor else []) + list(reversed(keys))
+        chain = self._scope_chain(node)
+        return ".".join([ctx.module_path, *chain, *segments])
+
     # value-preserving generic wrappers: `Promise<T>` (awaited) and `Awaited<T>`
     # still denote a T; `Array<T>`/`Readonly<T>` do not, so they don't unwrap.
     _RETURN_TYPE_UNWRAP = frozenset({"Promise", "Awaited"})
@@ -740,7 +841,21 @@ class JavaScriptExtractor:
             if current.type in ("function_declaration", "method_definition"):
                 name = current.child_by_field_name("name")
                 if name is not None:
+                    # object-literal shorthand: same key-path qname its symbol got,
+                    # so body call edges attach to the resolver, not a flat alias.
+                    if current.parent is not None and current.parent.type == "object":
+                        key = self._key_name(name)
+                        path = self._object_parent_path(current, ctx)
+                        if key is not None and path is not None:
+                            return f"{path}.{key}"
                     return self._qualify(current, node_text(name), ctx)[0]
+            if current.type == "pair":
+                value = current.child_by_field_name("value")
+                if value is not None and value.type in ("arrow_function", "function_expression"):
+                    key = self._key_name(current.child_by_field_name("key"))
+                    path = self._object_parent_path(current, ctx)
+                    if key is not None and path is not None:
+                        return f"{path}.{key}"
             if current.type == "variable_declarator":
                 value = current.child_by_field_name("value")
                 if value is not None and value.type in ("arrow_function", "function_expression"):

{entrygraph-0.1.128 → entrygraph-0.1.129}/tests/test_entrypoints_go.py

@@ -223,3 +223,71 @@ def test_go_test_route_paths_classified_centrally():
     refs = [_call("Get", "r", '("/users", h)')]
     assert _chi_rule().match(_go_ext(refs, path="middleware/compress_test.go"))
     assert _chi_rule().match(_go_ext(refs, path="middleware/compress.go"))
+
+
+# ---------------- gqlgen ----------------
+
+from entrygraph.extract.ir import RawSymbol
+from entrygraph.kinds import EntrypointKind, SymbolKind
+
+
+def _gql_method(name, receiver, signature, exported=True):
+    parent = f"internal.graph.{receiver}"
+    return RawSymbol(
+        kind=SymbolKind.METHOD,
+        name=name,
+        qualified_name=f"{parent}.{name}",
+        span=Span(10, 0, 20, 1),
+        parent_qualified_name=parent,
+        signature=signature,
+        is_exported=exported,
+    )
+
+
+def _gqlgen_ext(symbols):
+    return FileExtraction(
+        path="internal/graph/schema.resolvers.go",
+        language="go",
+        module_path="internal.graph",
+        parse_ok=True,
+        error_count=0,
+        symbols=list(symbols),
+    )
+
+
+def _gqlgen_rule():
+    return {r.id: r for r in rules_for("go", {"gqlgen"})}["go.gqlgen.resolver"]
+
+
+def test_gqlgen_query_resolver_method():
+    sym = _gql_method(
+        "Todos",
+        "queryResolver",
+        "func (r *queryResolver) Todos(ctx context.Context) ([]*Todo, error)",
+    )
+    (hint,) = _gqlgen_rule().match(_gqlgen_ext([sym]))
+    assert hint.kind is EntrypointKind.GRAPHQL_RESOLVER
+    assert hint.route == "Query.todos"
+    assert hint.handler_qualified_name == "internal.graph.queryResolver.Todos"
+    assert hint.metadata["operation"] == "query"
+    assert hint.http_methods == []
+
+
+def test_gqlgen_type_field_resolver():
+    sym = _gql_method(
+        "Owner",
+        "todoResolver",
+        "func (r *todoResolver) Owner(ctx context.Context, obj *Todo) (*User, error)",
+    )
+    (hint,) = _gqlgen_rule().match(_gqlgen_ext([sym]))
+    assert hint.route == "Todo.owner"
+    assert hint.metadata["operation"] == "field"
+
+
+def test_gqlgen_root_resolver_wiring_and_helpers_excluded():
+    wiring = _gql_method("Query", "Resolver", "func (r *Resolver) Query() generated.QueryResolver")
+    no_ctx = _gql_method(
+        "helper", "queryResolver", "func (r *queryResolver) helper() int", exported=False
+    )
+    no_ctx_exported = _gql_method("Helper", "queryResolver", "func (r *queryResolver) Helper() int")
+    assert _gqlgen_rule().match(_gqlgen_ext([wiring, no_ctx, no_ctx_exported])) == []