Nestor: A NestJS VS Code Extension That Puts the Docs and Design Patterns on Hover

Hover ThrottlerModule in a NestJS project and you get the paragraph from docs.nestjs.com that explains it, a link that opens the full page inside VS Code, and the other sections that mention it. Hover one of your own classes and you get a second thing: which Gang of Four pattern it follows, the role it plays, and where the implementation falls short of the pattern's checklist. That is Nestor, a NestJS VS Code extension I published today. It is free, MIT-licensed, and works with no network connection.

ext install devxmursalin.nestor

I am Md. Emamul Mursalin, a full-stack developer in Rajshahi, Bangladesh. NestJS is my default backend for client work, including the multi-tenant AI SaaS stack I write about here. Nestor came out of two habits I wanted to stop: tabbing out to the docs, and second-guessing whether a class I had just written was actually a Strategy or only named like one.

Why another NestJS VS Code extension

Search the Marketplace for "nestjs" and you get three kinds of extension: snippets, file generators, and extension packs that bundle both with ESLint and Prettier. They are good at one job, which is producing boilerplate faster. nest g service users already does most of that from the CLI.

None of them explains anything. When I hover @SkipThrottle I do not want a snippet; I want to know what it does, what the module option is called, and whether it applies per-route or per-controller. That is a documentation problem, and the documentation lives in a browser tab.

The second gap is bigger. NestJS is built on design patterns: providers are singletons in the DI container, interceptors are decorators around a handler, Passport strategies are the Strategy pattern by name, CQRS is Command plus Observer. The framework never says this out loud, so developers learn the API without learning the shape. When they write their own PaymentStrategy or NotificationFactory, there is nothing in the editor to tell them whether it is complete.

Nestor exists for those two gaps. It does not generate code. It reads the code you have and explains it.

Documentation on hover, offline

Nestor ships the markdown source of docs.nestjs.com, 136 pages, and an index of about 800 @nestjs/* symbols. Nothing is fetched at runtime. That is also the answer to a question that has been open on the NestJS docs repository for years: people wanting the NestJS documentation offline. The extension is one way to have it.

What a hover contains:

• the paragraph from the docs that covers the symbol, trimmed to nestor.hover.excerptLength characters (320 by default)

• a link that opens the full page in a side panel inside VS Code

• links to the other sections that cover the same symbol

• a link back to the docs.nestjs.com original

Links between pages navigate inside the panel; they do not open a browser. If a symbol is not in the index, you still get the installation section for its package: hover registerAs from @nestjs/config and Nestor opens the Configuration page.

The detail I spent the most time on is when a hover fires. Name matching alone is wrong: a project with its own CacheModule class would get the Nest docs for @nestjs/cache-manager on every hover. Nestor asks VS Code's built-in TypeScript server where the symbol resolves, and only shows a hover if the definition lives in an @nestjs/* package. A local class named CacheModule never produces a false hover. If you prefer name-only matching, turn nestor.hover.requireNestImport off.

Search the docs from the keyboard

Ctrl+Alt+N (Cmd+Alt+N on macOS) opens a quick pick over every documentation page and every section heading. Pick a page and it renders in the panel. Pick a heading and the panel scrolls to it. Nestor: Open Docs for Symbol Under Cursor does the same thing for the word under the cursor, without the pick.

Design pattern hover

This is the part that turns Nestor from a docs viewer into a mentor. Hover the name of any TypeScript class, at its declaration or anywhere it is used, and Nestor tells you which of the 22 Gang of Four patterns it follows.

Take a NestJS interceptor:

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    const started = Date.now();
    return next.handle().pipe(
      tap(() => console.log(`${Date.now() - started}ms`)),
    );
  }
}

An interceptor wraps a handler and adds behaviour without touching the handler. That is the Decorator pattern, and NestJS uses it everywhere. Hover TimingInterceptor and the pattern hover shows:

• the pattern, the confidence, and whether the built-in static rules or Groq found it

• the role the class plays, for example ConcreteDecorator, and the code facts behind the match

• the pattern's intent and its top best practices

• review notes where the implementation misses part of the pattern's checklist

• the NestJS angle: interceptors as decorators, Passport strategies, CQRS commands and events, DI singletons

• a pattern it is often confused with, when that one also matched

• links to the full guide in the side panel, its implementation checklist, and the matching page on refactoring.guru

The review notes are the useful bit. A pattern hover that only says "this is a Strategy" is trivia. One that says the context class holds the strategy but never exposes a way to swap it is a code review.

Nestor: Browse Design Patterns opens any of the 22 guides or the design principles page. The guides are original writing, not copied from refactoring.guru; they link there for further reading.

The NestJS design patterns you will see most

If you are searching for NestJS design patterns because a course or interview mentioned them, these are the ones the framework itself is built on, and the ones Nestor's NestJS notes cover:

Nestor does not stop at these five. The static rules cover all 22 Gang of Four patterns; the NestJS notes are there because a JwtStrategy should be explained as a Passport strategy, not as an abstract textbook example.

How detection works: static rules first, Groq if you want it

Without any setup, patterns come from static rules that read the class's syntax: constructor visibility, fields, heritage (extends, implements), and which methods call what. It runs locally. Nothing leaves your machine.

If you want a second opinion on ambiguous classes, run Nestor: Set Groq API Key. Then:

• When you hover a class, Nestor sends one request to Groq and waits up to two seconds (nestor.patterns.ai.hoverWaitMs) for the verdict.

• If Groq is slower than that, the static result shows first and the AI verdict appears on the next hover. The editor never stalls on a network call.

• Verdicts are cached per workspace until the class changes.

• The default model is openai/gpt-oss-120b; any Groq model with structured outputs works via nestor.patterns.ai.model.

• Nestor: Analyse Class Under Cursor with Groq forces a fresh verdict when you want one.

The key is stored in VS Code's secret storage, not in settings. Nestor: Clear Groq API Key removes it. The "Nestor: Patterns" output channel logs each Groq outcome by class name, never the source.

What gets sent, and what never does

Sending a developer's source to a third-party API is a trust problem, so the rules are explicit:

• Nestor makes no network requests on its own. Groq is used only after you store a key.

• Each request contains the hovered class's source, the names of the other classes and interfaces declared in the same file, and the static hints. It goes only to api.groq.com.

• Classes longer than nestor.patterns.ai.maxClassChars (12,000 by default) are never sent.

• Files under node_modules and .d.ts declaration files are never sent.

• Set nestor.patterns.ai.enabled to false to keep the key but stop sending.

Nestor next to the other NestJS extensions

Nestor is not a replacement for the extensions you already have. It is the layer they are missing. My full list, with install counts and the ones to skip, is in best VS Code extensions for NestJS.

If you only want one extension, the honest answer depends on experience. A developer who knows NestJS well and wants speed should install snippets. A developer who wants to understand what they are writing, or who reviews other people's NestJS code, gets more from Nestor.

Settings worth changing

Nine settings, all under nestor.*. The defaults are sensible; these are the ones I actually touch.

Requirements and limitations

Requirements: VS Code 1.85 or later, and TypeScript files on disk (file: scheme), because hovers use VS Code's built-in TypeScript support. A Groq API key is only needed for the optional AI verdicts.

Limitations in 0.1.0, stated plainly:

• Pattern detection is syntactic. Nestor knows types by their written names, not by resolving them, so a strategy interface declared in another file is recognised by naming convention only.

• The side panel renders code blocks without syntax highlighting.

• The vendored documentation is a snapshot. It is refreshed with each release, so a doc change upstream lands in the next version of the extension, not the same day.

Install and first five minutes

1. Install from the Visual Studio Marketplace or run ext install devxmursalin.nestor from the command palette.

2. Open any NestJS project and hover @Injectable(), ValidationPipe, or a module import. You should see the docs excerpt.

3. Press Ctrl+Alt+N and type "guards". Pick a section heading and watch the panel scroll to it.

4. Hover one of your own interceptors, Passport strategies, or CQRS handlers. Read the review notes.

5. Optional: Nestor: Set Groq API Key if you want AI verdicts on the classes the static rules are unsure about.

The full case study, with the technical decisions behind the extension, is on the Nestor project page.

FAQ

Is there a NestJS extension for VS Code that shows documentation?

Yes. Nestor shows the official NestJS documentation on hover for about 800 @nestjs/* symbols, with a searchable side panel. The docs are bundled with the extension, so it works offline.

Can I read the NestJS documentation offline?

With Nestor, yes: 136 pages of docs.nestjs.com are vendored into the extension and searchable with Ctrl+Alt+N. The other route is cloning the docs.nestjs.com repository and running it locally, which works but is a separate app rather than something inside your editor.

What design patterns does NestJS use?

Singleton (providers), Decorator (interceptors and the decorator syntax), Strategy (Passport), Command and Observer (CQRS), and Factory (useFactory providers, dynamic modules) are the ones you meet first. Nestor recognises all 22 Gang of Four patterns in your own classes and explains the NestJS-specific ones in context.

Does Nestor send my code anywhere?

Not unless you store a Groq API key. With a key, it sends the hovered class's source and the names of sibling declarations to api.groq.com only, never files under node_modules, .d.ts files, or classes over the size cap. Without a key, it makes no network requests at all.

Is Nestor free?

Yes. The extension code and the pattern guides are MIT. The bundled documentation is the NestJS documentation, also MIT, with the upstream license preserved.

Does it work with JavaScript NestJS projects?

No. It activates on TypeScript and TypeScript React files and relies on VS Code's TypeScript server to resolve symbols.

Work with me

Nestor is a side project, but the reason it exists is the client work: NestJS backends for SaaS products, usually paired with Next.js and Prisma. If you need one built or reviewed, book a call or start a professional-tier build. The scope is on the web and SaaS platforms professional page, and my remote working setup from Bangladesh is on the remote developer page.