# Review a Pull Request in NestJS with Atlas in 2026 > Atlas empowers NestJS developers to review pull requests thoroughly, identifying hidden bugs by analyzing full file context and verifying signature changes across modules and providers. Atlas helps NestJS developers in 2026 review pull requests by going beyond simple diffs, leveraging tools like `jest` for testing, `pnpm` for package management, and `prettier` for formatting to ensure comprehensive code quality and catch bugs that a line-by-line review might miss. It integrates directly with your `nest-cli.json` and `app.module.ts` to understand your project's structure. ## Key takeaways - Atlas reviews NestJS pull requests by analyzing full file context, not just line-by-line diffs, to catch subtle bugs. - Atlas integrates directly with NestJS tools like `jest` for testing and `prettier` for formatting, executing them via `bash`. - The `lsp` tool's `findReferences` operation helps Atlas identify all callers of changed NestJS function signatures, preventing hidden breakage. - Atlas uses `grep` to find missed updates to NestJS constants or feature flags across the codebase, including `nest-cli.json`. - Every Atlas action in a NestJS project is permission-gated, with plans drafted in a read-only agent and unified diffs for approval. - Atlas understands NestJS structures like `@Module` imports, provider scopes, and DTOs, leveraging AST indexing for deep analysis. ## How Atlas Reviews NestJS Pull Requests Beyond the Diff In 2026, Atlas reviews NestJS pull requests by first fetching the raw diff, then immediately moving beyond it to analyze the full context of changed files. This approach helps catch subtle bugs that a line-by-line diff, which only shows hunks, would inevitably miss. Atlas initiates a NestJS pull request review by using its VCS layer to fetch the specific branch and generate the raw patch. However, a crucial step for NestJS code quality is to then use the `read` tool to pull the full content of all changed files, not just the diff hunks. This allows Atlas to understand the surrounding logic, `@Module` imports, provider scopes, and DTO definitions that might be affected by a change, even if they are outside the immediate diff. For instance, if a developer modifies a DTO wired to a `ValidationPipe`, Atlas can see the full DTO definition and its context within the module, providing a more complete picture than a simple line-by-line comparison. This comprehensive view is essential for identifying architectural issues or unintended side effects in a highly modular NestJS application. ## Verifying NestJS Code Changes with `jest` and `prettier` Atlas rigorously verifies NestJS code changes by executing the project's `jest` tests and applying `prettier` formatting, ensuring both functional correctness and adherence to coding standards. This process, critical in 2026, helps maintain high code quality across all modules and providers. After analyzing the code context, Atlas leverages the `bash` tool to run the project's `jest` test suite. This is not a superficial check; Atlas can build a `Test.createTestingModule` harness, mimicking how a human developer would set up isolated tests for NestJS components. Before executing, Atlas presents a permission prompt, ensuring transparency and user control over potentially destructive actions. The findings from the `jest` run are then reported as a `todowrite` list, ordered by severity, highlighting any regressions or new failures. Furthermore, to maintain consistent code style across the NestJS codebase, Atlas can be instructed to run `prettier` across all touched providers and files. This ensures that the pull request adheres to the project's formatting guidelines, which are often defined in a `.prettierrc` file, preventing style-related conflicts and improving readability for other developers working with `app.module.ts` or other NestJS files. ## Catching Hidden NestJS Bugs with Contextual Grep and LSP Atlas employs advanced contextual analysis, including `grep` for pattern matching and `lsp` for `findReferences`, to uncover hidden bugs in NestJS code that a standard diff would miss. This proactive approach, vital in 2026, ensures robust changes across controllers and services. A key part of Atlas's NestJS review workflow involves using the `grep` tool to search for specific patterns that should have been updated but were overlooked. This includes old constant names, stale copies of code, or feature flags that might have been missed in a large refactor. For example, if a constant defined in a shared utility file is changed, `grep` can identify all instances across various NestJS modules, providers, or even `nest-cli.json` configurations that still reference the old value. Simultaneously, Atlas utilizes the `lsp` tool's `findReferences` operation, especially crucial for NestJS's decorator-driven dependency injection. If a function signature in a service or controller changes, `lsp` can identify every caller, even if those callers are in files not included in the initial diff. This prevents runtime errors caused by mismatched method calls or broken dependency injections, ensuring that changes to a guard or interceptor, for instance, do not inadvertently break other parts of the application. ## Atlas's Safety and Transparency in NestJS Code Reviews Atlas prioritizes safety and transparency in every NestJS code review, ensuring that all tool calls are permission-gated and every proposed change is presented as a unified diff for explicit approval. This robust process, standard in 2026, protects your codebase from unintended modifications. Atlas is designed with multiple layers of safety and transparency, crucial when making changes to a complex NestJS application. Every Atlas tool call, whether it's `bash` for running `pnpm install` or `lsp` for refactoring, is permission-gated against allow, ask, and deny rules. Before any modification, Atlas drafts a plan in a read-only plan agent and asks for explicit approval before switching to a build agent that can make changes. When Atlas proposes an edit, it computes a unified diff for every file, such as `app.module.ts` or a new DTO, and surfaces it for approval. This allows the NestJS developer to review the exact changes before they are written to disk. Furthermore, Atlas snapshots file changes as git patches, meaning any edits can be easily diffed and rolled back if necessary. This comprehensive safety framework ensures that even when Atlas suggests adding a guard or interceptor and registering it, the developer retains full control and visibility over the process. ## Steps 1. Fetch the NestJS branch and produce the diff using Atlas's VCS layer, exposing `status`, `diff`, `diffRaw`, and `commits`. 2. Read the full changed NestJS files with Atlas's `read` tool, not just the hunks, to gain context outside the immediate diff. 3. For every changed NestJS function signature or DTO wired to a `ValidationPipe`, run Atlas's `lsp` tool's `findReferences` operation to check all callers. 4. Use Atlas's `grep` tool to search for old NestJS constant names, stale copies, or feature flags that should have been updated but were not. 5. Execute NestJS `jest` tests via Atlas's `bash` tool, potentially building a `Test.createTestingModule` harness, and report findings as a `todowrite` list. 6. Review the unified diff for Atlas's proposed changes, then let Atlas run `prettier` across the touched NestJS providers and files to ensure formatting consistency. ## FAQ ### How does Atlas review NestJS pull requests? Atlas reviews NestJS pull requests by fetching the diff, reading full changed files with its `read` tool, checking signature references with `lsp`, grepping for patterns, and running `jest` tests via `bash`. It focuses on providing context beyond simple line changes. ### Can Atlas run `jest` tests for my NestJS project? Yes, Atlas can run `jest` tests for your NestJS project using its `bash` tool. It can even build a `Test.createTestingModule` harness, similar to how a human developer would, behind a permission prompt to ensure safety. ### How does Atlas ensure safety when modifying NestJS code? Atlas ensures safety by using permission-gated tool calls, drafting a read-only plan in a plan agent, asking for explicit approval before switching to a build agent, and surfacing a unified diff for every file edit before writing to your NestJS project. ### Does Atlas understand NestJS-specific structures like modules and DTOs? Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand NestJS `@Module` imports and exports, provider scopes, and DTOs wired to your `ValidationPipe`. This enables more intelligent code analysis and suggestions. ### What NestJS tools does Atlas integrate with? Atlas integrates directly with standard NestJS development tools such as `jest` for testing, `pnpm` for package management, and `prettier` for code formatting. It executes these tools via its `bash` tool, respecting your project's `nest-cli.json` configuration. ### How does Atlas find references for changed NestJS function signatures? Atlas uses its `lsp` tool's `findReferences` operation to check all callers of a changed NestJS function signature, even those not visible in the initial diff. This is crucial for catching breaking changes in services, controllers, or providers across your application. ### Can Atlas help with NestJS code formatting? Yes, Atlas can help with NestJS code formatting. After reviewing changes, you can instruct Atlas to run `prettier` across the touched providers and files using its `bash` tool, ensuring your codebase adheres to consistent style guidelines. --- Canonical HTML: https://runatlas.sh/resources/stacks/review-a-pull-request-in-nestjs Source of truth: aeo_pages row `/resources/stacks/review-a-pull-request-in-nestjs` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.