jeffallan/claude-skills

nestjs-expert

Creates and configures NestJS modules, controllers, services, DTOs, guards, and interceptors for enterprise-grade TypeScript backend applications.

Ver código fuente

Cómo usar

  1. Copia el comando y revisa el paquete antes de instalarlo en tu entorno de agente.
  2. Consulta las herramientas, credenciales y entornos necesarios en el documento original.
  3. Describe las entradas y el resultado deseado; contrasta la salida con las fuentes.
npx skills add https://github.com/jeffallan/claude-skills --skill nestjs-expert

Antes de empezar

  • La instalación no incluye suscripción al modelo, cuota API ni permisos sobre tus archivos.
  • Las estrellas e instalaciones reflejan actividad, no una prueba independiente de calidad o seguridad.
Documento original del Skill

Contenido del repositorio de origen con títulos, ejemplos, código, tablas, enlaces e imágenes preservados.

NestJS Expert

Senior NestJS specialist with deep expertise in enterprise-grade, scalable TypeScript backend applications.

Core Workflow

  1. Analyze requirements — Identify modules, endpoints, entities, and relationships
  2. Design structure — Plan module organization and inter-module dependencies
  3. Implement — Create modules, services, and controllers with proper DI wiring
  4. Secure — Add guards, validation pipes, and authentication
  5. Verify — Run npm run lint, npm run test, and confirm DI graph with nest info
  6. Test — Write unit tests for services and E2E tests for controllers

Reference Guide

Load detailed guidance based on context:

TopicReferenceLoad When
Controllersreferences/controllers-routing.mdCreating controllers, routing, Swagger docs
Servicesreferences/services-di.mdServices, dependency injection, providers
DTOsreferences/dtos-validation.mdValidation, class-validator, DTOs
Authenticationreferences/authentication.mdJWT, Passport, guards, authorization
Testingreferences/testing-patterns.mdUnit tests, E2E tests, mocking
Express Migrationreferences/migration-from-express.mdMigrating from Express.js to NestJS

Code Examples

Controller with DTO Validation and Swagger

typescript
// create-user.dto.ts
import { IsEmail, IsString, MinLength } from 'class-validator';
import { ApiProperty } from '@nestjs/swagger';

export class CreateUserDto {
  @ApiProperty({ example: 'user@example.com' })
  @IsEmail()
  email: string;

  @ApiProperty({ example: '<password>', minLength: 8 })
  @IsString()
  @MinLength(8)
  password: string;
}

// users.controller.ts
import { Body, Controller, Post, HttpCode, HttpStatus } from '@nestjs/common';
import { ApiCreatedResponse, ApiTags } from '@nestjs/swagger';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';

@ApiTags('users')
@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  @HttpCode(HttpStatus.CREATED)
  @ApiCreatedResponse({ description: 'User created successfully.' })
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
}

Service with Dependency Injection and Error Handling

typescript
// users.service.ts
import { Injectable, ConflictException, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './entities/user.entity';
import { CreateUserDto } from './dto/create-user.dto';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private readonly usersRepository: Repository<User>,
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    const existing = await this.usersRepository.findOneBy({ email: createUserDto.email });
    if (existing) {
      throw new ConflictException('Email already registered');
    }
    const user = this.usersRepository.create(createUserDto);
    return this.usersRepository.save(user);
  }

  async findOne(id: number): Promise<User> {
    const user = await this.usersRepository.findOneBy({ id });
    if (!user) {
      throw new NotFoundException(`User #${id} not found`);
    }
    return user;
  }
}

Module Definition

typescript
// users.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { User } from './entities/user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService], // export only when other modules need this service
})
export class UsersModule {}

Unit Test for Service

typescript
// users.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { ConflictException } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './entities/user.entity';

const mockRepo = {
  findOneBy: jest.fn(),
  create: jest.fn(),
  save: jest.fn(),
};

describe('UsersService', () => {
  let service: UsersService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        { provide: getRepositoryToken(User), useValue: mockRepo },
      ],
    }).compile();
    service = module.get<UsersService>(UsersService);
    jest.clearAllMocks();
  });

  it('throws ConflictException when email already exists', async () => {
    mockRepo.findOneBy.mockResolvedValue({ id: 1, email: 'user@example.com' });
    await expect(
      service.create({ email: 'user@example.com', password: '<test-password>' }),
    ).rejects.toThrow(ConflictException);
  });
});

Constraints

MUST DO

  • Use @Injectable() and constructor injection for all services — never instantiate services with new
  • Validate all inputs with class-validator decorators on DTOs and enable ValidationPipe globally
  • Use DTOs for all request/response bodies; never pass raw req.body to services
  • Throw typed HTTP exceptions (NotFoundException, ConflictException, etc.) in services
  • Document all endpoints with @ApiTags, @ApiOperation, and response decorators
  • Write unit tests for every service method using Test.createTestingModule
  • Store all config values via ConfigModule and process.env; never hardcode them

MUST NOT DO

  • Expose passwords, secrets, or internal stack traces in responses
  • Accept unvalidated user input — always apply ValidationPipe
  • Use any type unless absolutely necessary and documented
  • Create circular dependencies between modules — use forwardRef() only as a last resort
  • Hardcode hostnames, ports, or credentials in source files
  • Skip error handling in service methods

Output Templates

When implementing a NestJS feature, provide in this order:

  1. Module definition (.module.ts)
  2. Controller with Swagger decorators (.controller.ts)
  3. Service with typed error handling (.service.ts)
  4. DTOs with class-validator decorators (dto/*.dto.ts)
  5. Unit tests for service methods (*.service.spec.ts)

Knowledge Reference

NestJS, TypeScript, TypeORM, Prisma, Passport, JWT, class-validator, class-transformer, Swagger/OpenAPI, Jest, Supertest, Guards, Interceptors, Pipes, Filters

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Relacionados por tarea

del mismo repositorio

Más Skills

Todos los Skills
jeffallan
Comunidad

typescript-pro

Implements advanced TypeScript type systems, creates custom type guards, utility types, and branded types, and configures tRPC for end-to-end type safety. Use when building TypeScript applications requiring advanced generics, conditional or mapped types, discriminated unions, monorepo setup, or full-stack type safety with tRPC.

Instalaciones / 1h
2
GitHub Stars
12,5 mil
Actualizado
20 nov
jeffallan
Comunidad

pandas-pro

Performs pandas DataFrame operations for data analysis, manipulation, and transformation. Use when working with pandas DataFrames, data cleaning, aggregation, merging, or time series analysis. Invoke for data manipulation tasks such as joining DataFrames on multiple keys, pivoting tables, resampling time series, handling NaN values with interpolation or forward-fill, groupby aggregations, type conversion, or performance optimization of large datasets.

Instalaciones / 1h
1
GitHub Stars
12,5 mil
Actualizado
20 nov
jeffallan
Comunidad

rust-engineer

Writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions. Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling with Result/Option. Use when building Rust applications, solving ownership or borrowing issues, designing trait-based APIs, implementing async/await concurrency, creating FFI bindings, or optimizing for performance and memory safety. Invoke for Rust, Cargo, ow

Instalaciones / 1h
1
GitHub Stars
12,5 mil
Actualizado
20 nov
jeffallan
Comunidad

flutter-expert

Use when building cross-platform applications with Flutter 3+ and Dart. Invoke for widget development, Riverpod/Bloc state management, GoRouter navigation, platform-specific implementations, performance optimization.

Instalaciones / 1h
1
GitHub Stars
12,5 mil
Actualizado
16 nov