nestjs

Q: How do I install nestjs?

Run npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill nestjs in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/nestjs/ (personal) or .claude/skills/nestjs/ (project).

by giuseppe-trisciuoglioBackend & APIs

Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applications. Generates REST/GraphQL APIs, implements authentication guards, creates database schemas, and sets up microservices. Use when building NestJS applications, setting up APIs, implementing authentication, working with databases, or integrating Drizzle ORM.

Installs: 4.3K
Last 24h: +9
Trending rank: #9314
Security: Warn

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill nestjs

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads nestjs automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·This skill provides standard NestJS framework patterns and Drizzle ORM integration. It follows industry security best practices, such as recommending environment variables for secrets, using DTOs for input validation, and leveraging parameterized queries. All identified dependencies are well-known, legitimate database drivers and development tools.

Socket PassNo alerts

Snyk PassLOW ·Risk: LOW · No issues

Runlayer WarnMEDIUM ·4/4 files flagged

ZeroLeaks PassNONE ·Score: 93/100 · 2 sections analyzed

SKILL.md

The instructions your agent reads when the skill is triggered.

NestJS Framework with Drizzle ORM

Overview

Provides NestJS patterns with Drizzle ORM for building production-ready server-side applications. Covers CRUD modules, JWT authentication, database operations, migrations, testing, microservices, and GraphQL integration.

When to Use

Building REST APIs or GraphQL servers with NestJS
Setting up authentication and authorization with JWT
Implementing database operations with Drizzle ORM
Creating microservices with TCP/Redis transport
Writing unit and integration tests
Running database migrations with drizzle-kit

Instructions

Install dependencies: npm i drizzle-orm pg && npm i -D drizzle-kit tsx
Define schema: Create src/db/schema.ts with Drizzle table definitions
Create DatabaseService: Inject Drizzle client as a NestJS provider
Build CRUD module: Controller → Service → Repository pattern
Add validation: Use class-validator DTOs with ValidationPipe
Implement guards: Create JWT/Roles guards for route protection
Write tests: Use @nestjs/testing with mocked repositories
Run migrations: npx drizzle-kit generate → Verify SQL → npx drizzle-kit migrate

Examples

Complete CRUD Module with Drizzle

// src/db/schema.ts
export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  createdAt: timestamp('created_at').defaultNow(),
});

// src/users/dto/create-user.dto.ts
export class CreateUserDto {
  @IsString() @IsNotEmpty() name: string;
  @IsEmail() email: string;
}

// src/users/user.repository.ts
@Injectable()
export class UserRepository {
  constructor(private db: DatabaseService) {}

  async findAll() {
    return this.db.database.select().from(users);
  }

  async create(data: typeof users.$inferInsert) {
    return this.db.database.insert(users).values(data).returning();
  }
}

// src/users/users.service.ts
@Injectable()
export class UsersService {
  constructor(private repo: UserRepository) {}

  async create(dto: CreateUserDto) {
    return this.repo.create(dto);
  }
}

// src/users/users.controller.ts
@Controller('users')
export class UsersController {
  constructor(private service: UsersService) {}

  @Post()
  create(@Body() dto: CreateUserDto) {
    return this.service.create(dto);
  }
}

// src/users/users.module.ts
@Module({
  controllers: [UsersController],
  providers: [UsersService, UserRepository, DatabaseService],
  exports: [UsersService],
})
export class UsersModule {}

JWT Authentication Guard

@Injectable()
export class JwtAuthGuard implements CanActivate {
  constructor(private jwtService: JwtService) {}

  canActivate(context: ExecutionContext) {
    const token = context.switchToHttp().getRequest()
      .headers.authorization?.split(' ')[1];
    if (!token) return false;
    try {
      const decoded = this.jwtService.verify(token);
      context.switchToHttp().getRequest().user = decoded;
      return true;
    } catch {
      return false;
    }
  }
}

Database Transactions

async transferFunds(fromId: number, toId: number, amount: number) {
  return this.db.database.transaction(async (tx) => {
    await tx.update(accounts)
      .set({ balance: sql`${accounts.balance} - ${amount}` })
      .where(eq(accounts.id, fromId));
    await tx.update(accounts)
      .set({ balance: sql`${accounts.balance} + ${amount}` })
      .where(eq(accounts.id, toId));
  });
}

Unit Testing with Mocks

describe('UsersService', () => {
  let service: UsersService;
  let repo: jest.Mocked<UserRepository>;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        UsersService,
        { provide: UserRepository, useValue: { findAll: jest.fn(), create: jest.fn() } },
      ],
    }).compile();
    service = module.get(UsersService);
    repo = module.get(UserRepository);
  });

  it('should create user', async () => {
    const dto = { name: 'John', email: 'john@example.com' };
    repo.create.mockResolvedValue({ id: 1, ...dto, createdAt: new Date() });
    expect(await service.create(dto)).toMatchObject(dto);
  });
});

Constraints and Warnings

DTOs required: Always use DTOs with class-validator, never accept raw objects
Transactions: Keep transactions short; avoid nested transactions
Guards order: JWT guard must run before Roles guard
Environment variables: Never hardcode DATABASE_URL or JWT_SECRET
Migrations: Run drizzle-kit generate after schema changes before deploying
Circular dependencies: Use forwardRef() carefully; prefer module restructuring

Best Practices

Validate all inputs with global ValidationPipe
Use transactions for multi-table operations
Document APIs with OpenAPI/Swagger decorators

References

Advanced patterns and detailed examples available in:

references/reference.md - Core patterns, guards, interceptors, microservices, GraphQL
references/drizzle-reference.md - Drizzle ORM installation, configuration, queries
references/workflow-optimization.md - Development workflows, parallel execution strategies

FAQ

What does the nestjs skill do?

How do I install nestjs?

Run npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill nestjs in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/nestjs/ (personal) or .claude/skills/nestjs/ (project).

Which AI agents can use nestjs?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is nestjs safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed; Runlayer flagged items to review; ZeroLeaks passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains nestjs?

It is published by giuseppe-trisciuoglio in giuseppe-trisciuoglio/developer-kit. It has 4,257 recorded installs.