entrygraph 0.1.39__tar.gz → 0.1.41__tar.gz

{entrygraph-0.1.39 → entrygraph-0.1.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.39
+Version: 0.1.41
 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.39 → entrygraph-0.1.41}/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.39'
-__version_tuple__ = version_tuple = (0, 1, 39)
+__version__ = version = '0.1.41'
+__version_tuple__ = version_tuple = (0, 1, 41)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.39 → entrygraph-0.1.41}/src/entrygraph/detect/entrypoints/golang.py

@@ -236,6 +236,51 @@ def _cobra_commands(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+# gRPC service registration: `pb.RegisterFooServer(grpcServer, impl)`. The `Server`
+# suffix anchor keeps grpc-gateway's `RegisterFooHandler` / `...HandlerFromEndpoint`
+# out. Definitions (`func RegisterFooServer(...)`) are not call references, so only
+# real registration call sites match.
+_GRPC_REGISTER = re.compile(r"^Register(?P<service>[A-Za-z0-9]+)Server$")
+
+
+def _grpc_services(x: FileExtraction) -> list[EntrypointHint]:
+    """Mark each registered gRPC service as an RPC entrypoint (one per service).
+
+    This is a service-level marker: the implementation (arg 2) is almost always a
+    field/local var (`t.Ingester`, `frontendV1`) whose concrete type the IR can't
+    infer, so the entrypoint anchors on the registration file's module rather than
+    expanding to the impl's individual RPC methods. The service name rides in
+    `route` — the Entrypoint row has no name column, and it keeps distinct services
+    from collapsing in dedup (they all share `handler_qualified_name=None`).
+    """
+    if x.path.endswith("_test.go"):
+        return []  # test harnesses spin up real services; not production surface (#33)
+    hints = []
+    seen: set[str] = set()
+    for ref in x.references:
+        if ref.kind != "call":
+            continue
+        m = _GRPC_REGISTER.match(ref.callee_name)
+        if m is None:
+            continue
+        service = m.group("service")
+        if service in seen:
+            continue
+        seen.add(service)
+        hints.append(
+            EntrypointHint(
+                rule_id="go.grpc.service",
+                kind=EntrypointKind.RPC_HANDLER,
+                handler_qualified_name=None,
+                route=f"/{service}",
+                name=service,
+                framework="grpc-go",
+                span=ref.span,
+            )
+        )
+    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)
@@ -253,3 +298,6 @@ register(
 register(
     EntrypointRule("go.cobra.command", "go", "cobra", EntrypointKind.CLI_COMMAND, _cobra_commands)
 )
+register(
+    EntrypointRule("go.grpc.service", "go", "grpc-go", EntrypointKind.RPC_HANDLER, _grpc_services)
+)

{entrygraph-0.1.39 → entrygraph-0.1.41}/src/entrygraph/detect/entrypoints/javascript.py

@@ -199,25 +199,42 @@ def _nest_routes(x: FileExtraction) -> list[EntrypointHint]:
 
 
 def _next_handlers(x: FileExtraction) -> list[EntrypointHint]:
-    """Next.js app-router route handlers: exported GET/POST in app/**/route.{ts,js}."""
-    if not (x.path.endswith(("route.ts", "route.js")) and "/app/" in f"/{x.path}"):
+    """Next.js App Router route handlers in app/**/route.{ts,js}.
+
+    Matches both the plain `export async function GET() {}` form and the
+    wrapper-const form `export const GET = withAuth(getHandler)` — calcom's
+    dominant idiom, where nearly every method export wraps the real handler in
+    a responder. In the wrapper form the exported symbol is a VARIABLE whose own
+    qname is not the handler body, so we leave the handler unbound and set
+    `span` to the declaration line: the scanner then binds the route to the
+    handler passed by reference into the wrapper (the callback edge emitted at
+    that same line), falling back to the module when nothing was passed inline.
+    """
+    normalized = f"/{x.path}"  # leading slash so a top-level `app/` dir also matches
+    if not (x.path.endswith(("route.ts", "route.js")) and "/app/" in normalized):
         return []
+    route = "/" + normalized.split("/app/", 1)[1].rsplit("/", 1)[0]
     hints = []
     for symbol in x.symbols:
-        if (
-            symbol.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD)
-            and symbol.name in _HTTP_METHODS_UPPER
-        ):
-            hints.append(
-                EntrypointHint(
-                    rule_id="javascript.next.route",
-                    kind=EntrypointKind.HTTP_ROUTE,
-                    handler_qualified_name=symbol.qualified_name,
-                    route="/" + x.path.split("/app/", 1)[1].rsplit("/", 1)[0],
-                    http_methods=[symbol.name],
-                    framework="next",
-                )
+        if symbol.name not in _HTTP_METHODS_UPPER:
+            continue
+        if symbol.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD):
+            handler, span = symbol.qualified_name, None
+        elif symbol.kind is SymbolKind.VARIABLE:
+            handler, span = None, symbol.span
+        else:
+            continue
+        hints.append(
+            EntrypointHint(
+                rule_id="javascript.next.route",
+                kind=EntrypointKind.HTTP_ROUTE,
+                handler_qualified_name=handler,
+                route=route,
+                http_methods=[symbol.name],
+                framework="next",
+                span=span,
             )
+        )
     return hints
 
 

{entrygraph-0.1.39 → entrygraph-0.1.41}/src/entrygraph/kinds.py

@@ -40,6 +40,7 @@ class EntrypointKind(enum.Enum):
     LAMBDA_HANDLER = "lambda_handler"
     EVENT_HANDLER = "event_handler"
     MIDDLEWARE = "middleware"  # request/response interceptor (before_request, app.use, ...)
+    RPC_HANDLER = "rpc_handler"  # gRPC / RPC service registration (RegisterXxxServer)
 
 
 class Confidence(enum.IntEnum):

{entrygraph-0.1.39 → entrygraph-0.1.41}/tests/test_entrypoints_go.py

@@ -71,3 +71,50 @@ def test_chi_mount_prefix_not_composed_across_functions():
     ]
     got = {(h.http_methods[0], h.route) for h in _chi_rule().match(_go_ext(refs))}
     assert got == {("GET", "/health")}  # no phantom /api prefix
+
+
+def _grpc_rule():
+    return {r.id: r for r in rules_for("go", {"grpc-go"})}["go.grpc.service"]
+
+
+def test_grpc_service_registration_detected():
+    # pb.RegisterPusherServer(grpcServer, t.Ingester) -> one RPC entrypoint whose
+    # service name rides in `route` (no name column; keeps services distinct in
+    # dedup since they all share handler=None). Impl type is unresolvable, so the
+    # handler is left unbound (scanner anchors it on the module) (#37).
+    refs = [
+        _call("RegisterPusherServer", "logproto", "(t.Server.GRPC, t.Ingester)"),
+        _call("RegisterQuerierServer", "logproto", "(t.Server.GRPC, t.Ingester)", start=2),
+    ]
+    hints = _grpc_rule().match(_go_ext(refs, path="pkg/loki/modules.go"))
+    got = {(h.route, h.name, h.framework, h.handler_qualified_name) for h in hints}
+    assert got == {
+        ("/Pusher", "Pusher", "grpc-go", None),
+        ("/Querier", "Querier", "grpc-go", None),
+    }
+
+
+def test_grpc_same_service_deduped_within_file():
+    refs = [
+        _call("RegisterPusherServer", "logproto", "(s, t.distributor)"),
+        _call("RegisterPusherServer", "logproto", "(s, t.Ingester)", start=2),
+    ]
+    hints = _grpc_rule().match(_go_ext(refs, path="pkg/loki/modules.go"))
+    assert [h.route for h in hints] == ["/Pusher"]
+
+
+def test_grpc_gateway_and_non_server_calls_ignored():
+    # grpc-gateway registrars end in `Handler`/`HandlerFromEndpoint`, not `Server`,
+    # and must not be treated as service registrations.
+    refs = [
+        _call("RegisterPusherHandler", "gw", "(ctx, mux, conn)"),
+        _call("RegisterPusherHandlerFromEndpoint", "gw", "(ctx, mux, addr, opts)", start=2),
+        _call("Serve", "grpcServer", "(lis)", start=3),
+    ]
+    assert _grpc_rule().match(_go_ext(refs, path="pkg/loki/modules.go")) == []
+
+
+def test_grpc_test_harness_registrations_excluded():
+    # A real service registered inside a *_test.go harness is not production surface.
+    refs = [_call("RegisterFrontendServer", "frontendv1pb", "(grpcServer, v1)")]
+    assert _grpc_rule().match(_go_ext(refs, path="pkg/frontend/frontend_test.go")) == []

entrygraph-0.1.41/tests/test_entrypoints_javascript.py

@@ -0,0 +1,75 @@
+"""JavaScript/TypeScript entrypoint-rule tests (kept per-language so PRs touching
+different languages don't serially conflict on one shared test module)."""
+
+from __future__ import annotations
+
+from entrygraph.detect.entrypoints import rules_for
+from entrygraph.extract.ir import FileExtraction, RawSymbol, Span
+from entrygraph.kinds import EntrypointKind, SymbolKind
+
+
+def _js_ext(symbols=(), path="apps/web/app/api/me/route.ts"):
+    return FileExtraction(
+        path=path,
+        language="typescript",
+        module_path=path.rsplit("/", 1)[0].replace("/", "."),
+        parse_ok=True,
+        error_count=0,
+        symbols=list(symbols),
+    )
+
+
+def _sym(name, kind, line=1):
+    qname = f"apps.web.app.api.me.route.{name}"
+    return RawSymbol(kind=kind, name=name, qualified_name=qname, span=Span(line, 0, line, 40))
+
+
+def _next_rule():
+    return {r.id: r for r in rules_for("javascript", {"next"})}["javascript.next.route"]
+
+
+def test_next_wrapper_const_handlers_detected():
+    # calcom's dominant App Router idiom: `export const GET = wrap(getHandler)` —
+    # the export is a VARIABLE, not a function, and was previously missed (#37).
+    symbols = [
+        _sym("getHandler", SymbolKind.FUNCTION, line=1),
+        _sym("postHandler", SymbolKind.FUNCTION, line=2),
+        _sym("GET", SymbolKind.VARIABLE, line=10),
+        _sym("POST", SymbolKind.VARIABLE, line=11),
+    ]
+    hints = _next_rule().match(_js_ext(symbols))
+    by_method = {h.http_methods[0]: h for h in hints}
+    assert set(by_method) == {"GET", "POST"}
+    assert all(h.route == "/api/me" for h in hints)
+    # handler left unbound + span set to the declaration line, so the scanner
+    # binds the route to the handler passed by reference into the wrapper.
+    assert by_method["GET"].handler_qualified_name is None
+    assert by_method["GET"].span is not None
+    assert by_method["GET"].span.start_line == 10
+
+
+def test_next_plain_function_handler_still_bound_directly():
+    # `export async function GET() {}` — the function IS the handler, so its qname
+    # is bound directly (no callback indirection needed).
+    hint = _next_rule().match(_js_ext([_sym("GET", SymbolKind.FUNCTION)]))[0]
+    assert hint.kind is EntrypointKind.HTTP_ROUTE
+    assert hint.handler_qualified_name == "apps.web.app.api.me.route.GET"
+    assert hint.span is None
+    assert hint.route == "/api/me"
+
+
+def test_next_route_at_top_level_app_dir():
+    # A repo whose app-router lives at the top level yields paths like
+    # `app/api/me/route.ts` (no leading slash before `app`); route derivation must
+    # still resolve rather than IndexError.
+    ext = _js_ext([_sym("GET", SymbolKind.FUNCTION)], path="app/api/me/route.ts")
+    hint = _next_rule().match(ext)[0]
+    assert hint.route == "/api/me"
+
+
+def test_next_ignores_non_method_symbols_and_non_route_files():
+    # A non-method export in a route file, and a method-named export outside a
+    # route file, must both be ignored.
+    assert _next_rule().match(_js_ext([_sym("helper", SymbolKind.VARIABLE)])) == []
+    off_route = _js_ext([_sym("GET", SymbolKind.VARIABLE)], path="apps/web/app/api/me/page.ts")
+    assert _next_rule().match(off_route) == []