entrygraph 0.1.41__tar.gz → 0.1.43__tar.gz

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

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

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

@@ -67,7 +67,41 @@ def _nethttp_routes(x: FileExtraction) -> list[EntrypointHint]:
     return hints
 
 
+def _group_prefixes(x: FileExtraction) -> dict[str, str]:
+    """Map each gin/fiber router-group variable to its composed path prefix.
+
+    `api := app.Group("/api"); v1 := api.Group("/v1")` -> {api: /api, v1: /api/v1}.
+    A nested group inherits its parent group's prefix; Go requires a variable to be
+    declared before use, so ascending line order resolves the chain in one pass. A
+    group with no assign target (`h(app.Group("/x"))`, passed straight into another
+    function) is out of static reach and contributes no prefix.
+    """
+    prefixes: dict[str, str] = {}
+    groups = sorted(
+        (
+            ref
+            for ref in x.references
+            if ref.kind == "call"
+            and ref.callee_name == "Group"
+            and ref.assign_target
+            and ref.receiver_text is not None
+            and ref.arg_preview
+        ),
+        key=lambda r: r.span.start_line,
+    )
+    for ref in groups:
+        if ref.arg_preview is None:  # already filtered above; narrows for the type-checker
+            continue
+        local = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        if local is None:
+            continue  # closure-only group (chi-style middleware group) — no prefix
+        parent = prefixes.get(ref.receiver_text or "", "")
+        prefixes[ref.assign_target or ""] = _compose_prefixes([parent, local])
+    return prefixes
+
+
 def _gin_routes(x: FileExtraction) -> list[EntrypointHint]:
+    prefixes = _group_prefixes(x)
     hints = []
     for ref in x.references:
         if (
@@ -77,20 +111,30 @@ def _gin_routes(x: FileExtraction) -> list[EntrypointHint]:
             and ref.arg_preview
         ):
             route = first_string_arg("(" + ref.arg_preview.lstrip("("))
-            if route is not None and route.startswith("/"):
-                verb = ref.callee_name.upper()
-                method = verb if verb in _HTTP_VERBS else "*"
-                hints.append(
-                    EntrypointHint(
-                        rule_id="go.gin.route",
-                        kind=EntrypointKind.HTTP_ROUTE,
-                        handler_qualified_name=ref.caller_qualified_name,
-                        route=route,
-                        http_methods=[method],
-                        framework="gin",
-                        metadata={"registration": ref.arg_preview},
-                    )
+            if route is None:
+                continue
+            verb = ref.callee_name.upper()
+            is_verb = verb in _HTTP_VERBS
+            group_prefix = prefixes.get(ref.receiver_text)
+            # A grouped route often drops the leading slash (`v1.GET("users")`) since
+            # the group carries the prefix; accept that only for a concrete verb on a
+            # known group var. Otherwise keep the conservative leading-slash check
+            # (guards against Handle/Any's method-first arg and stray string args).
+            if not route.startswith("/") and not (is_verb and group_prefix is not None):
+                continue
+            method = verb if is_verb else "*"
+            full = _compose_prefixes([group_prefix or "", route])
+            hints.append(
+                EntrypointHint(
+                    rule_id="go.gin.route",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=ref.caller_qualified_name,
+                    route=full,
+                    http_methods=[method],
+                    framework="gin",
+                    metadata={"registration": ref.arg_preview},
                 )
+            )
     return hints
 
 

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

@@ -239,6 +239,47 @@ def _next_handlers(x: FileExtraction) -> list[EntrypointHint]:
 
 
 _HTTP_METHODS_UPPER = frozenset(m.upper() for m in _HTTP_METHODS)
+_NEXT_PAGES_EXTS = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs")
+
+
+def _next_pages_handlers(x: FileExtraction) -> list[EntrypointHint]:
+    """Next.js Pages Router API routes: every file under `pages/api/**` is a route
+    (file-based routing), whatever the default-export shape — a named `handler`
+    function, a `createNextApiHandler(router)` wrapper, or a bare arrow. The IR has
+    no `export default` marker to key on, so we rely on the file convention itself.
+
+    The handler dispatches on `req.method` internally, so the route carries no
+    specific verb. Bind to a `handler`-named function when present (the Pages
+    Router convention) so taint reaches the real body; otherwise the module.
+    """
+    normalized = f"/{x.path}"  # leading slash so a top-level `pages/` dir also matches
+    if "/pages/api/" not in normalized or not x.path.endswith(_NEXT_PAGES_EXTS):
+        return []
+    if x.path.endswith(".d.ts") or ".test." in x.path or ".spec." in x.path:
+        return []  # type decls and colocated tests aren't routes (#33)
+    tail = normalized.split("/pages/api/", 1)[1].rsplit(".", 1)[0]  # after prefix, no ext
+    if tail == "index":
+        tail = ""
+    elif tail.endswith("/index"):
+        tail = tail[: -len("/index")]
+    route = "/api" + (f"/{tail}" if tail else "")
+    handler = next(
+        (
+            s.qualified_name
+            for s in x.symbols
+            if s.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD) and s.name == "handler"
+        ),
+        None,
+    )
+    return [
+        EntrypointHint(
+            rule_id="javascript.next.pages-route",
+            kind=EntrypointKind.HTTP_ROUTE,
+            handler_qualified_name=handler,
+            route=route,
+            framework="next",
+        )
+    ]
 
 
 register(
@@ -323,3 +364,12 @@ register(
         "javascript.next.route", "javascript", "next", EntrypointKind.HTTP_ROUTE, _next_handlers
     )
 )
+register(
+    EntrypointRule(
+        "javascript.next.pages-route",
+        "javascript",
+        "next",
+        EntrypointKind.HTTP_ROUTE,
+        _next_pages_handlers,
+    )
+)

{entrygraph-0.1.41 → entrygraph-0.1.43}/src/entrygraph/extract/golang.py

@@ -263,6 +263,7 @@ class GoExtractor:
                     caller_qualified_name=caller,
                     arg_count=len(args.named_children) if args is not None else 0,
                     arg_preview=truncate(node_text(args)) if args is not None else None,
+                    assign_target=self._assign_target(node),
                 )
             )
             self._emit_callbacks(args, caller, out)
@@ -280,6 +281,25 @@ class GoExtractor:
                 )
             )
 
+    def _assign_target(self, call: Node) -> str | None:
+        """LHS variable when `call` is the sole RHS of a single-var `:=`/`=`.
+
+        `api := app.Group("/api")` -> "api". Multi-assignment (`a, b := f()`) and
+        calls nested in a larger expression (`h(app.Group("/x"))`) return None —
+        the group there isn't bound to a reachable variable.
+        """
+        right = call.parent
+        if right is None or right.type != "expression_list":
+            return None
+        stmt = right.parent
+        if stmt is None or stmt.type not in ("short_var_declaration", "assignment_statement"):
+            return None
+        left = stmt.child_by_field_name("left")
+        if left is None or len(left.named_children) != 1 or len(right.named_children) != 1:
+            return None
+        ident = left.named_children[0]
+        return node_text(ident) if ident.type == "identifier" else None
+
     def _emit_callbacks(self, args: Node | None, caller: str | None, out: FileExtraction) -> None:
         """Bare-identifier arguments passed to a call — a function value that may be
         invoked later, e.g. ``http.HandleFunc("/", handler)``. Resolution keeps only

{entrygraph-0.1.41 → entrygraph-0.1.43}/src/entrygraph/extract/ir.py

@@ -58,6 +58,10 @@ class RawReference:
     caller_qualified_name: str | None  # FQN of enclosing def; None = module level
     arg_count: int = 0
     arg_preview: str | None = None  # truncated literal args, for sink triage
+    # LHS variable when this call is the sole RHS of a single-var `:=`/`=`
+    # (`api := app.Group("/api")`). Lets router-group rules link routes registered
+    # on the group var back to its path prefix. Populated by the Go extractor.
+    assign_target: str | None = None
 
 
 @dataclass(slots=True)

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

@@ -19,7 +19,7 @@ def _go_ext(references, path="main.go"):
     )
 
 
-def _call(callee, receiver, arg, start=1, end=None):
+def _call(callee, receiver, arg, start=1, end=None, assign=None):
     return RawReference(
         kind="call",
         callee_text=f"{receiver}.{callee}" if receiver else callee,
@@ -28,6 +28,7 @@ def _call(callee, receiver, arg, start=1, end=None):
         span=Span(start, 0, end if end is not None else start, 40),
         caller_qualified_name="app.routes",
         arg_preview=arg,
+        assign_target=assign,
     )
 
 
@@ -118,3 +119,90 @@ 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")) == []
+
+
+def _gin_rule():
+    return {r.id: r for r in rules_for("go", {"gin"})}["go.gin.route"]
+
+
+def _fiber_rule():
+    return {r.id: r for r in rules_for("go", {"fiber"})}["go.fiber.route"]
+
+
+def test_gin_group_prefix_composed():
+    # api := router.Group("/api"); api.GET("/users", h) -> /api/users (#36). The
+    # group var is bound via the call's assign_target.
+    refs = [
+        _call("Group", "router", '("/api")', start=1, assign="api"),
+        _call("GET", "api", '("/users", listUsers)', start=2),
+        _call("GET", "router", '("/health", health)', start=3),  # ungrouped
+    ]
+    got = {(h.http_methods[0], h.route) for h in _gin_rule().match(_go_ext(refs))}
+    assert got == {("GET", "/api/users"), ("GET", "/health")}
+
+
+def test_gin_nested_groups_stack():
+    # api := app.Group("/api"); v1 := api.Group("/v1"); v1.GET("/users", h)
+    refs = [
+        _call("Group", "app", '("/api")', start=1, assign="api"),
+        _call("Group", "api", '("/v1")', start=2, assign="v1"),
+        _call("GET", "v1", '("/users", h)', start=3),
+    ]
+    got = {(h.http_methods[0], h.route) for h in _gin_rule().match(_go_ext(refs))}
+    assert got == {("GET", "/api/v1/users")}
+
+
+def test_gin_grouped_route_without_leading_slash():
+    # Grouped routes commonly drop the leading slash (gin versioning example);
+    # accept it for a concrete verb on a known group var and still prefix it.
+    refs = [
+        _call("Group", "router", '("/v1")', start=1, assign="apiV1"),
+        _call("GET", "apiV1", '("users", h)', start=2),
+    ]
+    got = {(h.http_methods[0], h.route) for h in _gin_rule().match(_go_ext(refs))}
+    assert got == {("GET", "/v1/users")}
+
+
+def test_gin_ungrouped_route_still_requires_leading_slash():
+    # A slash-less path on a non-group receiver stays filtered (guards against
+    # Handle/Any's method-first arg and stray string args).
+    refs = [_call("GET", "router", '("users", h)', start=1)]
+    assert _gin_rule().match(_go_ext(refs)) == []
+
+
+def test_gin_group_passed_to_function_has_no_prefix():
+    # h(app.Group("/api")) has no assign target — out of static reach, so a later
+    # same-named receiver must not pick up a phantom prefix.
+    refs = [
+        _call("Group", "app", '("/api")', start=1, assign=None),
+        _call("GET", "app", '("/health", h)', start=2),
+    ]
+    got = {(h.http_methods[0], h.route) for h in _gin_rule().match(_go_ext(refs))}
+    assert got == {("GET", "/health")}
+
+
+def test_fiber_group_prefix_end_to_end():
+    # Exercises the real Go extractor (assign_target capture) + fiber rule together.
+    from entrygraph.extract.base import FileContext
+    from entrygraph.extract.golang import GoExtractor
+    from entrygraph.parsing.parsers import parse
+
+    src = (
+        b"package router\n"
+        b"func SetupRoutes(app *fiber.App) {\n"
+        b'	api := app.Group("/api")\n'
+        b'	api.Get("/", handler.Hello)\n'
+        b'	auth := api.Group("/auth")\n'
+        b'	auth.Post("/login", handler.Login)\n'
+        b"}\n"
+    )
+    ctx = FileContext(
+        path="router/router.go",
+        language="go",
+        module_path="router",
+        source=src,
+        is_package=False,
+    )
+    x = GoExtractor().extract(parse("go", src), ctx)
+    got = {(h.http_methods[0], h.route) for h in _fiber_rule().match(x)}
+    assert got == {("GET", "/api"), ("POST", "/api/auth/login")}

{entrygraph-0.1.41 → entrygraph-0.1.43}/tests/test_entrypoints_javascript.py

@@ -73,3 +73,55 @@ def test_next_ignores_non_method_symbols_and_non_route_files():
     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) == []
+
+
+def _pages_rule():
+    return {r.id: r for r in rules_for("javascript", {"next"})}["javascript.next.pages-route"]
+
+
+def _handler_sym(qname="apps.web.pages.api.book.event.handler"):
+    return RawSymbol(
+        kind=SymbolKind.FUNCTION, name="handler", qualified_name=qname, span=Span(1, 0, 1, 40)
+    )
+
+
+def test_next_pages_route_binds_named_handler():
+    # Pages Router is file-based: pages/api/book/event.ts is the route /api/book/event,
+    # and the conventional `export default function handler` binds it (#37).
+    ext = _js_ext([_handler_sym()], path="apps/web/pages/api/book/event.ts")
+    hints = _pages_rule().match(ext)
+    assert len(hints) == 1
+    h = hints[0]
+    assert h.kind is EntrypointKind.HTTP_ROUTE
+    assert h.route == "/api/book/event"
+    assert h.http_methods == []  # method dispatched inside the handler
+    assert h.handler_qualified_name == "apps.web.pages.api.book.event.handler"
+
+
+def test_next_pages_route_without_handler_falls_back_to_module():
+    # `export default createNextApiHandler(router)` (tRPC) defines no handler symbol;
+    # the route is still detected, left unbound for the scanner to anchor on module.
+    ext = _js_ext(path="apps/web/pages/api/trpc/[trpc].ts")
+    hint = _pages_rule().match(ext)[0]
+    assert hint.route == "/api/trpc/[trpc]"
+    assert hint.handler_qualified_name is None
+
+
+def test_next_pages_index_files_map_to_parent():
+    foo = _pages_rule().match(_js_ext(path="apps/web/pages/api/foo/index.ts"))[0]
+    assert foo.route == "/api/foo"
+    assert _pages_rule().match(_js_ext(path="pages/api/index.ts"))[0].route == "/api"
+
+
+def test_next_pages_excludes_tests_and_type_decls():
+    for path in (
+        "apps/web/pages/api/book/recurring-event.test.ts",
+        "apps/web/pages/api/foo.spec.ts",
+        "apps/web/pages/api/types.d.ts",
+    ):
+        assert _pages_rule().match(_js_ext(path=path)) == []
+
+
+def test_next_pages_ignores_non_api_pages():
+    # A React page under pages/ (not pages/api/) is not an API route.
+    assert _pages_rule().match(_js_ext(path="apps/web/pages/about.tsx")) == []