NestJS Project Enforcer

A comprehensive skill that enforces NestJS best practices, project structure, code quality standards, and database patterns using Prisma ORM.

What This Skill Does

This skill ensures your NestJS project follows a strict, scalable architecture with:

Instructions

1. Project Structure Enforcement

**Required Directory Structure:**

**Required Root Files:**

**Validate** that these paths and files exist before any code generation or modification.

2. Module Structure Rules

Every module under `src/modules/` **MUST** include:

**Additional patterns to recognize:**

When creating or modifying modules, ensure all required files are present or generated.

3. Testing Requirements

**Test Patterns:**

**Test Configuration:**

**Coverage Requirement:**

**When generating code:**

4. Database & Prisma

**Schema Location:** `prisma/schema.prisma`

**Migrations:** `prisma/migrations/`

**Seed Script:** `prisma/seed.ts`

**Validation Rules:**

When modifying database models:

1. Update `prisma/schema.prisma`

2. Prompt user to run `npx prisma migrate dev --name <migration_name>`

3. Update corresponding `*.entity.ts` files

4. Regenerate Prisma client types (`npx prisma generate`)

5. API Documentation

**Swagger Configuration:** `src/swagger/`

**OpenAPI Output:** `openapi.json`

**Automation:**

When creating or updating API routes:

1. Add Swagger decorators to controllers and DTOs

2. Regenerate `openapi.json`

3. Verify documentation accuracy

6. Code Quality Standards

**File Size Limits:**

**Naming Convention:**

**TypeScript Standards:**

**Enforcement:**

7. Validation Rules

Before accepting any code changes, validate:

1. **Environment Variables** (`validateEnv: true`)

- All required env vars in `.env` and `.env.test`

- No hardcoded secrets in source code

2. **Prisma Schema** (`validatePrisma: true`)

- Schema syntax is valid

- All entities have corresponding Prisma models

3. **Controllers** (`validateControllers: true`)

- Proper route decorators (`@Get()`, `@Post()`, etc.)

- DTOs used for request validation

- Swagger decorators present

4. **Services** (`validateServices: true`)

- Business logic separated from controllers

- Proper dependency injection

- Error handling implemented

5. **DTOs** (`validateDtos: true`)

- Use `class-validator` decorators

- Match API contracts

- Documented with `@ApiProperty()`

8. Type Generation

**Auto-generate types** from Prisma schema:

Usage Examples

Example 1: Creating a New Module

User: "Create a `posts` module"

**Steps:**

1. Create `src/modules/posts/` directory

2. Generate required files:

- `posts.controller.ts` (with Swagger decorators)

- `posts.service.ts` (with business logic)

- `posts.module.ts` (NestJS module)

- `dto/create-post.dto.ts` (validation)

- `dto/update-post.dto.ts` (validation)

- `posts.entity.ts` (matches Prisma schema)

3. Generate test files:

- `posts.controller.spec.ts`

- `posts.service.spec.ts`

4. Prompt user to update Prisma schema and migrate

5. Update `openapi.json`

Example 2: Refactoring Oversized File

User: "Fix code quality issues in user.service.ts"

**Steps:**

1. Check file length — if >500 lines, suggest splitting

2. Check function lengths — extract functions >50 lines

3. Verify strict typing — add missing types

4. Ensure kebab-case naming

5. Run tests to ensure no regressions

Example 3: Adding API Endpoint

User: "Add GET /users/:id endpoint"

**Steps:**

1. Add method to `users.controller.ts`:

- `@Get(':id')` decorator

- `@ApiOperation()` description

- DTO for path params

2. Implement logic in `users.service.ts`

3. Add test cases in `users.controller.spec.ts` and `users.service.spec.ts`

4. Regenerate Swagger docs

5. Verify 80% coverage maintained

Important Notes