j4flmao/agent_skills_nodejs_nestjs

conventions

Defines the rule base every skill in this pack obeys: file layout, frontmatter, vocabulary, OOP/typing/decoupling axioms, and anti-patterns. Load FIRST before authoring or applying any other skill in this pack.

architecting-nestjs-modules

Designs NestJS feature modules with clean dependency boundaries, provider scopes, and dynamic modules. Use when adding a new feature module, splitting a monolithic AppModule, or fixing tangled imports between modules.

building-nestjs-controllers

Builds thin NestJS controllers that parse input, invoke a single use case, and map the Result to ApiResponse<T>. Use when adding HTTP endpoints, refactoring fat controllers, or applying API versioning.

deploying-nestjs-production

Prepares a NestJS service for production: graceful shutdown, health/readiness, structured logs, config, Dockerfile, CI gates, and rollout safety. Use when promoting a service to staging/production or auditing readiness.

designing-nestjs-services

Designs NestJS application services as use-case classes that orchestrate domain logic and ports without leaking the framework. Use when creating new use cases, refactoring services that mix HTTP/DB/domain, or moving from anemic services to OOP.

handling-nestjs-exceptions

Maps internal AppError hierarchy to HTTP responses through a single global exception filter and a Result-to-HttpException helper. Use when adding new error types, fixing inconsistent error responses, or removing scattered try/catch in controllers.

persisting-data-with-typeorm

Implements the Repository pattern with TypeORM in NestJS so domain entities stay framework-free, ORM models live in infrastructure, and transactions are explicit. Use when adding persistence, refactoring leaky ORM usage, or handling transactions across…

testing-nestjs-applications

Tests NestJS applications at unit, integration, and e2e levels using Test.createTestingModule and Supertest with hand-rolled fakes. Use when writing tests for use cases, controllers, or full HTTP flows.

using-nestjs-pipes-guards-interceptors

Applies pipes, guards, and interceptors for cross-cutting concerns in NestJS — validation, auth, transformation, logging, caching. Use when implementing auth, response shaping, observability, or any concern that should not live in controllers.

validating-nestjs-dtos

Validates NestJS request payloads with class-validator and class-transformer using a global ValidationPipe. Use when adding/refactoring DTOs, hardening boundary input, or removing manual validation from controllers.

applying-design-patterns

Applies GoF and DDD design patterns in TypeScript: Factory, Repository, Strategy, Adapter, Decorator, Facade, Observer, Command, Specification. Use when picking the right structure for a feature or refactoring duplicated logic.

decoupling-with-di

Decouples modules using ports, adapters, and a DI container (tsyringe / inversify / NestJS). Use when wiring services, removing direct imports of concrete classes, or breaking circular dependencies.

designing-oop-typescript

Designs classes and class hierarchies in TypeScript using SOLID, encapsulation, and immutability. Use when creating new domain entities, application services, or refactoring procedural code into OOP.

handling-errors-typescript

Defines a typed error hierarchy, distinguishes expected business failures from unexpected programmer errors, and forbids swallowing errors. Use when creating new error types, mapping errors to HTTP, or reviewing try/catch usage.

logging-and-observability

Adds structured JSON logging, correlation/trace IDs, metrics, and health endpoints. Use when wiring observability for a new service, debugging cross-service requests, or removing console.log.

managing-configuration

Loads and validates configuration once at boot through a typed schema (Zod / class-validator), preventing scattered process.env access and runtime surprises. Use when adding env vars, debugging config-related crashes, or onboarding a new environment.

nodejs-typescript-foundation

Sets the baseline tooling and tsconfig for any Node.js TypeScript project: strict compiler flags, ESLint, Prettier, package layout, npm scripts. Use when bootstrapping a new project or auditing an existing one for foundational quality.

securing-nodejs-apps

Hardens Node.js HTTP services: input validation, secure headers, authentication/authorization basics, secret handling, and dependency hygiene. Use when shipping to production or reviewing a service for security gaps.

separating-business-logic

Separates code into domain, application, and infrastructure layers so business rules stay framework-free and testable. Use when designing a new feature, splitting a god service, or moving rules out of controllers.

structuring-project-layout

Specifies folder structure, module boundaries, barrels, and path aliases for a Node.js TypeScript project. Use when starting a new repo, adding a new feature module, or refactoring tangled imports.

testing-typescript-services

Writes unit, integration, and contract tests for TypeScript services using Vitest/Jest with hand-rolled fakes. Use when adding tests, refactoring untestable code, or designing the test strategy for a feature.

typing-generic-responses

Defines generic types for cross-boundary data: ApiResponse<T>, Paginated<T>, Result<T,E>, Repository<T,ID>. Use when designing HTTP responses, use-case return types, or persistence ports.