Awesome-jetbrains-claude nest-dev

Professional NestJS backend development. Covers module creation, controllers, services, Mongoose schemas, DTOs with class-validator, guards, interceptors, caching with Redis, cursor-based pagination, JWT authentication decorators, and TypeScript patterns. Use this skill when working on any backend code - creating or editing modules, adding endpoints, writing services, defining schemas/DTOs, configuring guards/interceptors, or following project conventions. Triggers on any NestJS, Mongoose, MongoDB, backend API, DTO, guard, interceptor, or server architecture task within this project.

install

source · Clone the upstream repo

git clone https://github.com/IliyaBrook/awesome-jetbrains-claude

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/IliyaBrook/awesome-jetbrains-claude "$T" && mkdir -p ~/.claude/skills && cp -r "$T/.claude/skills/nest-dev" ~/.claude/skills/iliyabrook-awesome-jetbrains-claude-nest-dev && rm -rf "$T"

manifest: .claude/skills/nest-dev/SKILL.md

source content

Project Stack

NestJS 11 + TypeScript 5.7 (target ES2023, nodenext modules)
MongoDB + Mongoose 9 (
```
@nestjs/mongoose
```
)
JWT auth via
```
@nestjs/jwt
```
+
```
@nestjs/passport
```
(Google OAuth)
Redis caching via
```
cache-manager
```
+
```
@keyv/redis
```
(in-memory fallback)
```
class-validator
```
+
```
class-transformer
```
for DTO validation
```
@nestjs/swagger
```
for OpenAPI docs
```
@nestjs/throttler
```
for rate limiting (3 tiers)
```
@nestjs/terminus
```
for health checks
Helmet + compression + CORS middleware
Jest 30 + supertest for testing

Critical Rules

Barrel exports — every new file MUST be exported from its
```
index.ts
```
Named exports only — no
```
export default
```
DRY — extract shared logic into services/utils, never copy-paste
Types co-located — export interfaces from the file that defines them (schema, service, DTO)
Path aliases with
.js
extension —
```
import { X } from '#modules/auth/index.js'
```
(nodenext resolution)

Aliases:

#modules/*

#shared/*

#common/*

#config/*

#email-templates/*

Swagger decorators — every controller endpoint MUST have
```
@ApiTags
```
,
```
@ApiOperation
```
,
```
@ApiResponse
```
Auth by default — all routes require JWT; use
```
@Public()
```
to opt out
Ownership checks — services must verify
```
userId
```
matches the document owner

Workflow: New Module

Create directory
```
src/modules/feature-name/
```
Create schema:
```
feature-name.schema.ts
```
(Mongoose
```
@Schema
```
+
```
@Prop
```
)

Create DTOs:

dto/create-feature.dto.ts

dto/update-feature.dto.ts

dto/index.ts

Create service:
```
feature-name.service.ts
```
(
```
@Injectable()
```
, inject model)
Create controller:
```
feature-name.controller.ts
```
(REST endpoints + Swagger)
Create module:
```
feature-name.module.ts
```
(register schema, providers, exports)
Create barrel:
```
index.ts
```
(export everything)
Register module in
```
src/app.module.ts
```

See references/modules.md for complete templates.

Workflow: New Endpoint

Add method to controller with HTTP decorator (
```
@Get
```
,
```
@Post
```
,
```
@Patch
```
,
```
@Delete
```
)

Add Swagger decorators:

@ApiBearerAuth()

@ApiOperation

@ApiResponse

Use
```
@CurrentUser('sub')
```
for authenticated user ID
Use
```
@Body()
```
,
```
@Param()
```
,
```
@Query()
```
for input extraction
Create/update DTO if new input is needed
Implement business logic in service (not controller)
Controllers are thin — delegate to service, return result

See references/modules.md for controller and service patterns.

Workflow: New Schema

Create
```
feature-name.schema.ts
```

Define

FeatureDocument = HydratedDocument<Feature>

Use

@Schema({ timestamps: true, collection: 'features' })

Use

@Prop()

with options:

required

unique

default

enum

ref

select

index

For refs:

@Prop({ type: Types.ObjectId, ref: 'OtherModel' })

Export

FeatureSchema = SchemaFactory.createForClass(Feature)

Add compound indexes after schema creation

See references/database.md for schema and DTO templates.

Workflow: New DTO

Create
```
dto/create-feature.dto.ts
```

Use

class-validator

decorators:

@IsString

@IsNotEmpty

@IsOptional

@IsMongoId

, etc.

Add
```
@ApiProperty
```
/
```
@ApiPropertyOptional
```
with
```
example
```
values

For updates:

export class UpdateFeatureDto extends PartialType(CreateFeatureDto) {}

Export from
```
dto/index.ts
```

See references/database.md for DTO patterns and validation decorators.

Workflow: Cursor-Based Pagination

PaginationDto

(

{ limit?, cursor? }

) from

#shared/index.js

Return

PaginatedResponse<T>

(

{ data, nextCursor, hasMore }

)

Query with
```
limit + 1
```
to detect
```
hasMore
```
Build compound cursor from last item (e.g.,
```
date_id
```
)
Use
```
$or
```
with cursor for consistent sort order

See references/database.md for pagination implementation.

Workflow: Guard / Interceptor / Pipe

Create in

src/common/guards/

src/common/interceptors/

, or

src/common/pipes/

Implement
```
CanActivate
```
,
```
NestInterceptor
```
, or
```
PipeTransform
```
Export from directory
```
index.ts
```
and
```
src/common/index.ts
```
Register globally in
```
main.ts
```
or per-route with decorator

See references/infrastructure.md for guard, interceptor, and caching patterns.

Workflow: Caching

Inject
```
CacheService
```
from
```
#shared/index.js
```
Use
```
getOrSet(key, factory, ttl?)
```
for read-through cache
Use
```
del(key)
```
to invalidate on mutations
```
@CacheTTL()
```
and
```
@CacheKey()
```
decorators for HTTP cache interceptor
```
@NoCache()
```
to skip caching on specific routes

See references/infrastructure.md for cache service API and patterns.

Reference Files

references/modules.md — module template, controller template, service template, barrel exports
references/database.md — schema template, DTO template, validation decorators, pagination pattern
references/infrastructure.md — guards, interceptors, caching, rate limiting, config patterns