Endpoint Tracer
A VS Code extension that takes a backend endpoint URL and jumps you to the
NestJS controller and exact handler method that serves it — useful in large
codebases and monorepos where routes are assembled from several layers.
http://localhost:3000/users/list?search=
→ ListUsersController.listUsers
src/users/web/list-users.controller.ts:34
What it understands
A full route is composed of up to three layers, and the extension resolves all
of them statically (via the TypeScript AST — no running server required):
| Layer |
Source |
Example |
| RouterModule prefix |
RouterModule.register([{ path, module }]) |
billing/invoices |
| Controller prefix |
@Controller("...") |
orders |
| Method path |
@Get/@Post/@Put/@Patch/@Delete("...") |
/:orderId/items |
So GET /billing/invoices/orders/abc/items is traced to the right handler,
capturing orderId = abc.
It correctly handles:
- Module prefixes via
RouterModule (including nested children).
- Prefix routes and paths combined from different fragments (module +
controller + method), with slashes normalised.
- Path params —
:id in decorators and [id] folder segments are matched
against any value, and the captured values are shown.
- Same-named modules in different files — modules and controllers are
disambiguated by their resolved import file path, not by class name, so a
controller never inherits a prefix from an unrelated module that happens to
share a name.
- Multi-path decorators (
@Get(["a", "b"])) and @Controller({ path }) form.
- Query strings, hosts and verbs in the input are stripped/parsed:
GET http://localhost:3000/foo?x=1 → verb GET, path /foo.
Usage
Open your NestJS project as the workspace, then either:
- Click the Endpoint Tracer icon in the activity bar, paste an endpoint, and
press Trace endpoint (or
Enter). Click any result to open it at the
handler line.
- Run
Endpoint Tracer: Find Controller for Endpoint from the command
palette for a quick-pick flow.
If no route matches exactly, the closest partial matches (by leading path
segments) are shown instead.
Configuration
| Setting |
Default |
Description |
endpointTracer.sourceRoots |
["src", "apps/*/src", "libs/*/src", "packages/*/src"] |
Folders scanned for *.controller.ts / *.module.ts, relative to each workspace folder. A trailing * segment is expanded one level. The first existing root wins; the rest are fallbacks. Add your own layout here if it differs. |
endpointTracer.maxResults |
30 |
Max matches shown. |
The index builds on activation and rebuilds automatically when any
*.controller.ts / *.module.ts changes. Use Endpoint Tracer: Rebuild Route Index to force a refresh.
Develop
npm install
npm run compile # or: npm run watch
Press F5 to launch an Extension Development Host. The bundled Run Extension
launch config opens a sibling ../backend folder as the test workspace — edit
.vscode/launch.json to point it at any NestJS project you want to trace.
How it works
- Index — every
*.controller.ts is parsed for its @Controller path(s)
and HTTP-method decorators; every *.module.ts is parsed for its
controllers: [...] membership (expanding ...spread of local const
arrays) and any RouterModule.register prefixes. Imports are resolved to
absolute file paths so identically-named classes stay distinct.
- Resolve — prefixes flow module → controller (by file path), and each
handler becomes one or more fully-qualified routes.
- Match — the queried URL is normalised to segments and matched against the
route table segment-by-segment, with
:param segments acting as wildcards
and exact (literal) matches ranked above param-heavy ones.
Limitations
Matching is purely static path matching. It does not evaluate guards, a global
prefix set via app.setGlobalPrefix(...), controller-level API versioning
(@Controller({ version })), or routes registered dynamically at runtime.
License
MIT
