Nestjs performance

Skill ComeOnOliver/skillshub/skills/HoangNguyen0403/agent-skills-standard/nestjs-performance

🧠 The right skill, one API call. AI agent skills registry with token-efficient skill resolution. 5,000+ skills from 500+ top repos.

Install

npx -y skills add ComeOnOliver/skillshub --skill nestjs-performance

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

What its author says it does

Copied from the file, not written here

Fastify adapter, Scope management, and Compression. Use when optimizing NestJS performance with Fastify, request-scoped providers, or compression. (triggers: main.ts, FastifyAdapter, compression, SINGLETON, REQUEST scope)

SKILL.md

3.4 KB, 789 tokens by cl100k_base, as published. Nobody here has run it

Performance Tuning

Priority: P1 (OPERATIONAL)

High-performance patterns and optimization techniques for NestJS applications.

Adapter: Use FastifyAdapter instead of Express (2x throughput).
Compression: Enable Gzip/Brotli compression.
```
// main.ts
app.use(compression());
```
Keep-Alive: Configure http.Agent keep-alive settings to reuse TCP connections for upstream services.

Scope & Dependency Injection

Default Scope: Adhere to SINGLETON scope (default).
Request Scope: AVOID REQUEST scope unless absolutely necessary.
- Pro Tip: A single request-scoped service makes its entire injection chain request-scoped.
- Solution: Use Durable Providers (durable: true) for multi-tenancy.
Lazy Loading: Use LazyModuleLoader for heavyweight modules (e.g., Admin panels).

Caching Strategy

Application Cache: Use @nestjs/cache-manager for computation results.
- Deep Dive: See Caching & Redis for L1/L2 strategies and Invalidation patterns.
HTTP Cache: Set Cache-Control headers for client-side caching (CDN/Browser).
Distributed: In microservices, use Redis store, not memory store.

Queues & Async Processing

Offloading: Never block the HTTP request for long-running tasks (Emails, Reports, webhooks).
Tool: Use @nestjs/bull (BullMQ) or RabbitMQ (@nestjs/microservices).
- Pattern: Producer (Controller) -> Queue -> Consumer (Processor).

Serialization

Warning: class-transformer is CPU expensive.
Optimization: For high-throughput READ endpoints, consider manual mapping or using fast-json-stringify (built-in fastify serialization) instead of interceptors.

Database Tuning

Projections: Always use select: [] to fetch only needed columns.
N+1: Prevent N+1 queries by using relations carefully or DataLoader for Graph/Field resolvers.
Connection Pooling: Configure pool size (e.g., pool: { min: 2, max: 10 }) in config to match DB limits.

Profiling & Scaling

API Overhead vs DB Execution: Use an "Execution Bucket" strategy to continuously benchmark Total Duration, DB Execution Time, and API Overhead.
- Total Baseline: Excellent (< 50ms), Acceptable (< 200ms), Poor (> 500ms). Exception: Authentication routes (e.g. bcrypt/argon2) should take 300-500ms intentionally.
- DB Execution Baseline: Excellent (< 5ms), Acceptable (< 30ms), Poor (> 100ms - implies missing index or N+1 problem).
- API Overhead Baseline: Excellent (< 20ms), Poor (> 100ms - implies heavy synchronous processing or serialization blocking Node's event loop).
Offloading: Move CPU-heavy tasks (Image processing, Crypto) to worker_threads.
Clustering: For non-containerized environments, use ClusterModule to utilize all CPU cores. In K8s, prefer ReplicaSets.

Anti-Patterns

No REQUEST scope without evaluation: One REQUEST-scoped provider makes the entire chain request-scoped.
No CPU tasks in HTTP handler: Offload image/crypto work to worker_threads or BullMQ.
No unprojected queries: Always select: [] the needed columns to avoid serializing unused data.