nodejs-best-practices

Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.

Aller à l'installation

Dépôt: BEKO2210/Firstbrain
Dernière activité de la source: 17 mai 2026 à 12:40
Langue détectée de SKILL.md: anglais
Étoiles: 15
Forks: 2

Options d'installation

Le prompt qui vérifie d'abord la source est sélectionné par défaut. Vous pouvez passer à une commande directe ou télécharger une copie locale.

Vérifiez les fichiers source

Lisez SKILL.md et les fichiers associés affichés par SkillsMP avant de décider de l'installer.

Retour à la recherche Retour à l’installation

name	nodejs-best-practices
description	Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
type	skill
created	2026-02-27T00:00:00.000Z
domain	software-development
category	architecture
risk	unknown
source	community
tags	["skill","software-development","architecture","nodejs"]

Node.js Best Practices

Principles and decision-making for Node.js development in 2025. Learn to THINK, not memorize code patterns.

When to Use

Use this skill when making Node.js architecture decisions, choosing frameworks, designing async patterns, or applying security and deployment best practices.

⚠️ How to Use This Skill

This skill teaches decision-making principles, not fixed code to copy.

ASK user for preferences when unclear
Choose framework/pattern based on CONTEXT
Don't default to same solution every time

1. Framework Selection (2025)

Decision Tree

What are you building?
│
├── Edge/Serverless (Cloudflare, Vercel)
│   └── Hono (zero-dependency, ultra-fast cold starts)
│
├── High Performance API
│   └── Fastify (2-3x faster than Express)
│
├── Enterprise/Team familiarity
│   └── NestJS (structured, DI, decorators)
│
├── Legacy/Stable/Maximum ecosystem
│   └── Express (mature, most middleware)
│
└── Full-stack with frontend
    └── Next.js API Routes or tRPC

Comparison Principles

Factor	Hono	Fastify	Express
Best for	Edge, serverless	Performance	Legacy, learning
Cold start	Fastest	Fast	Moderate
Ecosystem	Growing	Good	Largest
TypeScript	Native	Excellent	Good
Learning curve	Low	Medium	Low

Selection Questions to Ask:

What's the deployment target?
Is cold start time critical?
Does team have existing experience?
Is there legacy code to maintain?

2. Runtime Considerations (2025)

Native TypeScript

Node.js 22+: --experimental-strip-types
├── Run .ts files directly
├── No build step needed for simple projects
└── Consider for: scripts, simple APIs

Module System Decision

ESM (import/export)
├── Modern standard
├── Better tree-shaking
├── Async module loading
└── Use for: new projects

CommonJS (require)
├── Legacy compatibility
├── More npm packages support
└── Use for: existing codebases, some edge cases

Request Flow:
│
├── Controller/Route Layer
│   ├── Handles HTTP specifics
│   ├── Input validation at boundary
│   └── Calls service layer
│
├── Service Layer
│   ├── Business logic
│   ├── Framework-agnostic
│   └── Calls repository layer
│
└── Repository Layer
    ├── Data access only
    ├── Database queries
    └── ORM interactions

Pattern:
├── Create custom error classes
├── Throw from any layer
├── Catch at top level (middleware)
└── Format consistent response

Client gets:
├── Appropriate HTTP status
├── Error code for programmatic handling
├── User-friendly message
└── NO internal details (security!)

Logs get:
├── Full stack trace
├── Request context
├── User ID (if applicable)
└── Timestamp

Situation	Status	When
Bad input	400	Client sent invalid data
No auth	401	Missing or invalid credentials
No permission	403	Valid auth, but not allowed
Not found	404	Resource doesn't exist
Conflict	409	Duplicate or state conflict
Validation	422	Schema valid but business rules fail
Server error	500	Our fault, log everything

I/O-bound (async helps):
├── Database queries
├── HTTP requests
├── File system
└── Network operations

CPU-bound (async doesn't help):
├── Crypto operations
├── Image processing
├── Complex calculations
└── → Use worker threads or offload

Where to validate:
├── API entry point (request body/params)
├── Before database operations
├── External data (API responses, file uploads)
└── Environment variables (startup)

Trust nothing:
├── Query params → validate
├── Request body → validate
├── Headers → verify
├── Cookies → validate
├── File uploads → scan
└── External APIs → validate response

node --test src/**/*.test.ts
├── No external dependency
├── Good coverage reporting
└── Watch mode available