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