entrygraph 0.1.38__tar.gz → 0.1.40__tar.gz

{entrygraph-0.1.38 → entrygraph-0.1.40}/PKG-INFO

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

{entrygraph-0.1.38 → entrygraph-0.1.40}/src/entrygraph/detect/entrypoints/golang.py

@@ -116,6 +116,62 @@ def _gin_style(framework: str):
     return matcher
 
 
+def _compose_prefixes(parts: list[str]) -> str:
+    segs = [p.strip("/") for p in parts if p and p.strip("/")]
+    return "/" + "/".join(segs)
+
+
+def _chi_routes(x: FileExtraction) -> list[EntrypointHint]:
+    """chi routes, with `r.Route("/prefix", func(r){...})` sub-router prefixes.
+
+    Route nests its sub-routes in an inline closure, so a verb route whose line
+    falls inside a Route call's span gets that prefix (nested Routes stack). Mount
+    (`r.Mount("/api", subRouter())`) points at a router built in another function,
+    which is out of static reach, so its prefix isn't composed."""
+    scopes: list[tuple[int, int, str]] = []
+    for ref in x.references:
+        if (
+            ref.kind == "call"
+            and ref.callee_name in ("Route", "Mount")
+            and ref.receiver_text is not None
+            and ref.arg_preview
+            and ref.span.end_line > ref.span.start_line  # has an inline closure body
+        ):
+            prefix = first_string_arg("(" + ref.arg_preview.lstrip("("))
+            if prefix and prefix.startswith("/"):
+                scopes.append((ref.span.start_line, ref.span.end_line, prefix))
+    scopes.sort()
+
+    hints = []
+    for ref in x.references:
+        if (
+            ref.kind != "call"
+            or ref.receiver_text is None
+            or ref.callee_name not in _GIN_METHODS
+            or not ref.arg_preview
+        ):
+            continue
+        route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        if route is None or not route.startswith("/"):
+            continue
+        verb = ref.callee_name.upper()
+        method = verb if verb in _HTTP_VERBS else "*"
+        line = ref.span.start_line
+        prefixes = [p for (s, e, p) in scopes if s < line <= e]
+        hints.append(
+            EntrypointHint(
+                rule_id="go.chi.route",
+                kind=EntrypointKind.HTTP_ROUTE,
+                handler_qualified_name=ref.caller_qualified_name,
+                route=_compose_prefixes([*prefixes, route]),
+                http_methods=[method],
+                framework="chi",
+                metadata={"registration": ref.arg_preview},
+            )
+        )
+    return hints
+
+
 _QUOTED = re.compile(r'"([^"]+)"')
 
 
@@ -185,7 +241,7 @@ register(
     EntrypointRule("go.nethttp.route", "go", "net/http", EntrypointKind.HTTP_ROUTE, _nethttp_routes)
 )
 register(EntrypointRule("go.gin.route", "go", "gin", EntrypointKind.HTTP_ROUTE, _gin_routes))
-register(EntrypointRule("go.chi.route", "go", "chi", EntrypointKind.HTTP_ROUTE, _gin_style("chi")))
+register(EntrypointRule("go.chi.route", "go", "chi", EntrypointKind.HTTP_ROUTE, _chi_routes))
 register(
     EntrypointRule("go.fiber.route", "go", "fiber", EntrypointKind.HTTP_ROUTE, _gin_style("fiber"))
 )

{entrygraph-0.1.38 → entrygraph-0.1.40}/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.40/tests/test_entrypoints_go.py

@@ -0,0 +1,73 @@
+"""Go 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, RawReference, Span
+
+
+def _go_ext(references, path="main.go"):
+    return FileExtraction(
+        path=path,
+        language="go",
+        module_path="app",
+        parse_ok=True,
+        error_count=0,
+        symbols=[],
+        references=list(references),
+    )
+
+
+def _call(callee, receiver, arg, start=1, end=None):
+    return RawReference(
+        kind="call",
+        callee_text=f"{receiver}.{callee}" if receiver else callee,
+        callee_name=callee,
+        receiver_text=receiver,
+        span=Span(start, 0, end if end is not None else start, 40),
+        caller_qualified_name="app.routes",
+        arg_preview=arg,
+    )
+
+
+def _chi_rule():
+    return {r.id: r for r in rules_for("go", {"chi"})}["go.chi.route"]
+
+
+def test_chi_route_prefix_is_composed():
+    # r.Route("/admin", func(r){ r.Get("/users", h); r.Post("/users", h) }) — the
+    # inner verb routes fall inside the Route call's span and get the prefix (#37).
+    refs = [
+        _call("Get", "r", '("/health", health)', start=2),
+        _call("Route", "r", '("/admin", func(r chi.Router) { ... })', start=3, end=6),
+        _call("Get", "r", '("/users", listUsers)', start=4),
+        _call("Post", "r", '("/users", createUser)', start=5),
+    ]
+    got = {(h.http_methods[0], h.route) for h in _chi_rule().match(_go_ext(refs))}
+    assert got == {
+        ("GET", "/health"),  # top-level, no prefix
+        ("GET", "/admin/users"),  # composed with the enclosing Route prefix
+        ("POST", "/admin/users"),
+    }
+
+
+def test_chi_nested_route_prefixes_stack():
+    refs = [
+        _call("Route", "r", '("/api", func(r){ ... })', start=1, end=6),
+        _call("Route", "r", '("/v1", func(r){ ... })', start=2, end=5),
+        _call("Get", "r", '("/users", h)', start=3),
+    ]
+    got = {(h.http_methods[0], h.route) for h in _chi_rule().match(_go_ext(refs))}
+    assert got == {("GET", "/api/v1/users")}  # both enclosing prefixes stack
+
+
+def test_chi_mount_prefix_not_composed_across_functions():
+    # r.Mount("/api", apiRouter()) points at a router built elsewhere (single-line,
+    # no inline body) — its prefix is out of static reach and must not be applied.
+    refs = [
+        _call("Mount", "r", '("/api", apiRouter())', start=1),
+        _call("Get", "r", '("/health", h)', start=2),
+    ]
+    got = {(h.http_methods[0], h.route) for h in _chi_rule().match(_go_ext(refs))}
+    assert got == {("GET", "/health")}  # no phantom /api prefix

entrygraph-0.1.40/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) == []