NestJS开发
Universal
nestjs
by giuseppe-trisciuoglio
聚焦 NestJS 与 Drizzle ORM 开发实践，覆盖模块、控制器、认证授权、数据库建模、GraphQL、微服务与测试，适合快速搭建 API 服务并规范项目架构。
安装
claude skill add --url github.com/giuseppe-trisciuoglio/developer-kit/tree/main/plugins/developer-kit-typescript/skills/nestjs文档
NestJS Framework with Drizzle ORM
Overview
This skill provides comprehensive guidance for building NestJS applications with TypeScript, including integration with Drizzle ORM for database operations. It covers all major aspects of NestJS development from basic module structure to advanced patterns like microservices and GraphQL.
When to Use
- Building REST APIs or GraphQL servers with NestJS
- Setting up authentication and authorization
- Implementing middleware, guards, or interceptors
- Working with databases (TypeORM, Drizzle ORM)
- Creating microservices architecture
- Writing unit and integration tests
- Setting up OpenAPI/Swagger documentation
Instructions
- Start with Module Structure: Define your feature modules with clear boundaries
- Implement Controllers: Create controllers to handle HTTP requests and define routes
- Create Services: Build business logic in injectable service classes
- Configure Database: Set up Drizzle ORM with proper schema definitions
- Add Validation: Implement DTOs with class-validator for input validation
- Implement Guards: Add authentication and authorization guards as needed
- Write Tests: Create unit and e2e tests for all components
- Configure OpenAPI: Add Swagger decorators for API documentation
Examples
Creating a Complete CRUD Module
typescript
// 1. Define the entity schema (with Drizzle)
export const products = pgTable('products', {
id: serial('id').primaryKey(),
name: text('name').notNull(),
price: real('price').notNull(),
createdAt: timestamp('created_at').defaultNow(),
});
// 2. Create the DTO
export class CreateProductDto {
@IsString()
@IsNotEmpty()
name: string;
@IsNumber()
@Min(0)
price: number;
}
// 3. Implement the service
@Injectable()
export class ProductsService {
constructor(private db: DatabaseService) {}
async create(dto: CreateProductDto) {
return this.db.database.insert(products).values(dto).returning();
}
}
// 4. Create the controller
@Controller('products')
export class ProductsController {
constructor(private service: ProductsService) {}
@Post()
create(@Body() dto: CreateProductDto) {
return this.service.create(dto);
}
}
Constraints and Warnings
- Database Connections: Always use connection pooling for production
- Async Operations: All database operations are async; handle errors properly
- DTOs Required: Never accept raw objects in controllers; always use DTOs
- Module Imports: Be careful with circular dependencies between modules
- Guards Order: Auth guards should run before role guards
- Transaction Scope: Keep transactions as short as possible to avoid deadlocks
- Environment Variables: Never hardcode database credentials or secrets
Core Architecture
Module Structure
typescript
import { Module } from '@nestjs/common';
@Module({
imports: [/* other modules */],
controllers: [/* controllers */],
providers: [/* providers */],
exports: [/* exported providers */],
})
export class FeatureModule {}
Controller Pattern
typescript
import { Controller, Get, Post, Body, Param, Query } from '@nestjs/common';
@Controller('users')
export class UsersController {
@Get()
findAll(@Query() query: any) {
return 'This returns all users';
}
@Get(':id')
findOne(@Param('id') id: string) {
return `This returns user #${id}`;
}
@Post()
create(@Body() createUserDto: any) {
return 'This creates a user';
}
}
Service with Dependency Injection
typescript
import { Injectable } from '@nestjs/common';
@Injectable()
export class UsersService {
constructor(/* inject dependencies */) {}
findAll() {
return 'Users service logic';
}
}
Database Integration with Drizzle
Setup with Drizzle ORM
Installation
bash
# Using npm
npm install drizzle-orm pg
npm install -D drizzle-kit tsx @types/pg
# Using yarn
yarn add drizzle-orm pg
yarn add -D drizzle-kit tsx @types/pg
Configuration
typescript
// drizzle.config.ts
import 'dotenv/config';
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
out: './drizzle',
schema: './src/db/schema.ts',
dialect: 'postgresql',
dbCredentials: {
url: process.env.DATABASE_URL!,
},
});
Database Schema
typescript
// src/db/schema.ts
import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
export const users = pgTable('users', {
id: serial('id').primaryKey(),
name: text('name').notNull(),
email: text('email').notNull().unique(),
createdAt: timestamp('created_at').defaultNow(),
});
Database Service
typescript
// src/db/database.service.ts
import { Injectable } from '@nestjs/common';
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import * as schema from './schema';
@Injectable()
export class DatabaseService {
private db: ReturnType<typeof drizzle>;
constructor() {
const pool = new Pool({
connectionString: process.env.DATABASE_URL,
});
this.db = drizzle(pool, { schema });
}
get database() {
return this.db;
}
}
User Repository with Drizzle
typescript
// src/users/user.repository.ts
import { Injectable } from '@nestjs/common';
import { DatabaseService } from '../db/database.service';
import { users } from '../db/schema';
import { eq } from 'drizzle-orm';
@Injectable()
export class UserRepository {
constructor(private db: DatabaseService) {}
async findAll() {
return this.db.database.select().from(users);
}
async findOne(id: number) {
const result = await this.db.database
.select()
.from(users)
.where(eq(users.id, id))
.limit(1);
return result[0];
}
async create(data: typeof users.$inferInsert) {
const result = await this.db.database
.insert(users)
.values(data)
.returning();
return result[0];
}
async update(id: number, data: Partial<typeof users.$inferInsert>) {
const result = await this.db.database
.update(users)
.set(data)
.where(eq(users.id, id))
.returning();
return result[0];
}
async remove(id: number) {
const result = await this.db.database
.delete(users)
.where(eq(users.id, id))
.returning();
return result[0];
}
}
Complete User Module
typescript
// src/users/users.module.ts
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { UserRepository } from './user.repository';
import { DatabaseService } from '../db/database.service';
@Module({
controllers: [UsersController],
providers: [UsersService, UserRepository, DatabaseService],
exports: [UsersService],
})
export class UsersModule {}
User Service Implementation
typescript
// src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { UserRepository } from './user.repository';
import { User } from './interfaces/user.interface';
@Injectable()
export class UsersService {
constructor(private userRepository: UserRepository) {}
async findAll(): Promise<User[]> {
return this.userRepository.findAll();
}
async findOne(id: number): Promise<User> {
const user = await this.userRepository.findOne(id);
if (!user) {
throw new Error('User not found');
}
return user;
}
async create(userData: Partial<User>): Promise<User> {
return this.userRepository.create(userData);
}
async update(id: number, userData: Partial<User>): Promise<User> {
await this.findOne(id); // Verify user exists
return this.userRepository.update(id, userData);
}
async remove(id: number): Promise<User> {
await this.findOne(id); // Verify user exists
return this.userRepository.remove(id);
}
}
Authentication & Authorization
JWT Authentication Guard
typescript
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
@Injectable()
export class JwtAuthGuard implements CanActivate {
constructor(private jwtService: JwtService) {}
canActivate(context: ExecutionContext) {
const request = context.switchToHttp().getRequest();
const token = request.headers.authorization?.split(' ')[1];
if (!token) {
return false;
}
try {
const decoded = this.jwtService.verify(token);
request.user = decoded;
return true;
} catch {
return false;
}
}
}
Roles-Based Guard
typescript
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
@Injectable()
export class RolesGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(context: ExecutionContext): boolean {
const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler());
if (!requiredRoles) {
return true;
}
const { user } = context.switchToHttp().getRequest();
return requiredRoles.some((role) => user.roles?.includes(role));
}
}
Validation with Pipes
Validation Pipe
typescript
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';
@Injectable()
export class ValidationPipe implements PipeTransform {
async transform(value: any, { metatype }: ArgumentMetadata) {
if (!metatype || !this.toValidate(metatype)) {
return value;
}
const object = plainToClass(metatype, value);
const errors = await validate(object);
if (errors.length > 0) {
throw new BadRequestException(errors);
}
return value;
}
private toValidate(metatype: Function): boolean {
const types: Function[] = [String, Boolean, Number, Array, Object];
return !types.includes(metatype);
}
}
Exception Handling
Global Exception Filter
typescript
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';
@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
catch(exception: HttpException, host: ArgumentsHost) {
const ctx = host.switchToHttp();
const response = ctx.getResponse<Response>();
const request = ctx.getRequest<Request>();
const status = exception.getStatus();
response.status(status).json({
statusCode: status,
timestamp: new Date().toISOString(),
path: request.url,
message: exception.message,
});
}
}
Testing Patterns
Unit Testing Services
typescript
import { Test, TestingModule } from '@nestjs/testing';
import { UsersService } from './users.service';
import { UserRepository } from './user.repository';
describe('UsersService', () => {
let service: UsersService;
let repository: jest.Mocked<UserRepository>;
beforeEach(async () => {
const mockRepository = {
findAll: jest.fn(),
findOne: jest.fn(),
create: jest.fn(),
update: jest.fn(),
remove: jest.fn(),
} as any;
const module: TestingModule = await Test.createTestingModule({
providers: [
UsersService,
{
provide: UserRepository,
useValue: mockRepository,
},
],
}).compile();
service = module.get<UsersService>(UsersService);
repository = module.get(UserRepository);
});
it('should return all users', async () => {
const expectedUsers = [{ id: 1, name: 'John', email: 'john@example.com' }];
repository.findAll.mockResolvedValue(expectedUsers);
const result = await service.findAll();
expect(result).toEqual(expectedUsers);
expect(repository.findAll).toHaveBeenCalled();
});
});
E2E Testing with Drizzle
typescript
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';
import { DatabaseService } from '../src/db/database.service';
import { drizzle } from 'drizzle-orm/node-postgres';
import { migrate } from 'drizzle-node-postgres/migrator';
import { migrate as drizzleMigrate } from 'drizzle-orm/node-postgres/migrator';
describe('UsersController (e2e)', () => {
let app: INestApplication;
let db: DatabaseService;
beforeAll(async () => {
const moduleFixture: TestingModule = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = moduleFixture.createNestApplication();
db = moduleFixture.get<DatabaseService>(DatabaseService);
// Run migrations
await drizzleMigrate(db.database, { migrationsFolder: './drizzle' });
await app.init();
});
afterAll(async () => {
await app.close();
});
beforeEach(async () => {
// Clean database
await db.database.delete(users).execute();
});
it('/users (POST)', () => {
const createUserDto = {
name: 'Test User',
email: 'test@example.com',
};
return request(app.getHttpServer())
.post('/users')
.send(createUserDto)
.expect(201)
.expect((res) => {
expect(res.body).toMatchObject(createUserDto);
expect(res.body).toHaveProperty('id');
});
});
it('/users (GET)', async () => {
// First create a user
await db.database.insert(users).values({
name: 'Test User',
email: 'test@example.com',
});
return request(app.getHttpServer())
.get('/users')
.expect(200)
.expect((res) => {
expect(Array.isArray(res.body)).toBe(true);
expect(res.body).toHaveLength(1);
});
});
});
Migrations with Drizzle
Generating Migrations
bash
npx drizzle-kit generate
Running Migrations
typescript
// src/migrations/migration.service.ts
import { Injectable } from '@nestjs/common';
import { migrate } from 'drizzle-orm/node-postgres/migrator';
import { DatabaseService } from '../db/database.service';
@Injectable()
export class MigrationService {
constructor(private db: DatabaseService) {}
async runMigrations() {
try {
await migrate(this.db.database, { migrationsFolder: './drizzle' });
console.log('Migrations completed successfully');
} catch (error) {
console.error('Migration failed:', error);
throw error;
}
}
}
Configuration Management
Environment Configuration
typescript
// src/config/configuration.ts
export default () => ({
database: {
url: process.env.DATABASE_URL,
},
jwt: {
secret: process.env.JWT_SECRET || 'default-secret',
expiresIn: process.env.JWT_EXPIRES_IN || '24h',
},
app: {
port: parseInt(process.env.PORT, 10) || 3000,
},
});
Advanced Patterns
Custom Decorators
typescript
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
export const User = createParamDecorator(
(data: string, ctx: ExecutionContext) => {
const request = ctx.switchToHttp().getRequest();
const user = request.user;
return data ? user?.[data] : user;
},
);
Interceptors for Logging
typescript
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
const request = context.switchToHttp().getRequest();
const { method, url } = request;
const now = Date.now();
console.log(`[${method}] ${url} - Start`);
return next
.handle()
.pipe(
tap(() => console.log(`[${method}] ${url} - End ${Date.now() - now}ms`)),
);
}
}
Microservices
TCP Microservice
typescript
// main.ts
import { NestFactory } from '@nestjs/core';
import { Transport, MicroserviceOptions } from '@nestjs/microservices';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.createMicroservice<MicroserviceOptions>(
AppModule,
{
transport: Transport.TCP,
options: {
host: 'localhost',
port: 8877,
},
},
);
await app.listen();
}
bootstrap();
GraphQL Integration
GraphQL Resolver with Drizzle
typescript
import { Resolver, Query, Mutation, Args } from '@nestjs/graphql';
import { UserRepository } from './user.repository';
@Resolver(() => User)
export class UsersResolver {
constructor(private userRepository: UserRepository) {}
@Query(() => [User])
async users() {
return this.userRepository.findAll();
}
@Mutation(() => User)
async createUser(@Args('input') input: CreateUserInput) {
return this.userRepository.create(input);
}
}
Best Practices
- Always use constructor injection - Never use property injection
- Use DTOs for data transfer - Define interfaces for request/response
- Implement proper error handling - Use exception filters
- Validate all inputs - Use validation pipes
- Keep modules focused - Single responsibility principle
- Use environment variables - Never hardcode credentials
- Write comprehensive tests - Unit and integration tests
- Use transactions for complex operations - Maintain data consistency
- Implement proper logging - Use interceptors for cross-cutting concerns
- Use type safety - Leverage TypeScript features
Common Patterns with Drizzle
Transactions
typescript
async transferFunds(fromId: number, toId: number, amount: number) {
return this.db.database.transaction(async (tx) => {
// Debit from account
await tx
.update(accounts)
.set({ balance: sql`${accounts.balance} - ${amount}` })
.where(eq(accounts.id, fromId));
// Credit to account
await tx
.update(accounts)
.set({ balance: sql`${accounts.balance} + ${amount}` })
.where(eq(accounts.id, toId));
});
}
Soft Deletes
typescript
export const users = pgTable('users', {
id: serial('id').primaryKey(),
name: text('name').notNull(),
email: text('email').notNull().unique(),
deletedAt: timestamp('deleted_at'),
});
async softDelete(id: number) {
return this.db.database
.update(users)
.set({ deletedAt: new Date() })
.where(eq(users.id, id));
}
Complex Queries with Relations
typescript
async getUsersWithPosts() {
return this.db.database
.select()
.from(users)
.leftJoin(posts, eq(posts.userId, users.id));
}
相关 Skills
资深数据工程师
by alirezarezvani
Universal
热门
聚焦生产级数据工程，覆盖 ETL/ELT、批处理与流式管道、数据建模、Airflow/dbt/Spark 优化和数据质量治理，适合设计数据架构、搭建现代数据栈与排查性能问题。
✎ 复杂数据管道、ETL/ELT 和治理难题交给它，凭 Spark、Airflow、dbt 等现代数据栈经验，能更稳地搭起可扩展的数据基础设施。
数据与存储
未扫描12.1k
技术栈评估
by alirezarezvani
Universal
热门
对比框架、数据库和云服务，结合 5 年 TCO、安全风险、生态活力与迁移复杂度做量化评估，适合技术选型、栈升级和替换路线决策。
✎ 帮你系统比较技术栈优劣，不只看功能，还把TCO、安全性和生态健康度一起量化，选型和迁移决策更稳。
数据与存储
未扫描12.1k
迁移架构师
by alirezarezvani
Universal
热门
为数据库、API 与基础设施迁移制定分阶段零停机方案，提前校验兼容性与风险，生成回滚策略、验证关卡和时间线，适合复杂系统平滑切换。
✎ 做数据库与存储迁移时，用它统一梳理表结构和数据搬迁流程，架构视角更完整，复杂迁移也更稳。
数据与存储
未扫描12.1k
相关 MCP 服务
SQLite 数据库
编辑精选by Anthropic
SQLite 是让 AI 直接查询本地数据库进行数据分析的 MCP 服务器。
✎ 这个服务器解决了 AI 无法直接访问 SQLite 数据库的问题，适合需要快速分析本地数据集的开发者。不过，作为参考实现，它可能缺乏生产级的安全特性，建议在受控环境中使用。
数据与存储
84.2kPostgreSQL 数据库
编辑精选by Anthropic
PostgreSQL 是让 Claude 直接查询和管理你的数据库的 MCP 服务器。
✎ 这个服务器解决了开发者需要手动编写 SQL 查询的痛点，特别适合数据分析师或后端开发者快速探索数据库结构。不过，由于是参考实现，生产环境使用前务必评估安全风险，别指望它能处理复杂事务。
数据与存储
84.1kFirecrawl 智能爬虫
编辑精选by Firecrawl
Firecrawl 是让 AI 直接抓取网页并提取结构化数据的 MCP 服务器。
✎ 它解决了手动写爬虫的麻烦，让 Claude 能直接访问动态网页内容。最适合需要实时数据的研究者或开发者，比如监控竞品价格或抓取新闻。但要注意，它依赖第三方 API，可能涉及隐私和成本问题。
数据与存储
6.1k