
Nestjs
- 2k installs
- 311 repo stars
- Updated June 22, 2026
- giuseppe-trisciuoglio/developer-kit
nestjs is an agent skill that Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applicat.
About
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 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 1 Install dependencies npm i drizzle orm pg npm i D drizzle kit tsx 2 Define schema Create src db schema ts with Drizzle table definitions 3 Create DatabaseService Inject Drizzle client as a NestJS provider 4 Build CRUD module Controller Service Repository pattern 5 Add validation Use class validator DTOs with ValidationPipe 6 Implement guards Create JWT Roles guards for route protection 7 Write tests Use nestjs testing with mocked repositories 8 Run migrations npx drizzle kit generate Verify SQL npx drizzle kit migrate typescript src db schema ts export const users pgTable users id serial id primaryKey name text name notNull email text email
- description: Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-
- allowed-tools: Read, Write, Edit, Glob, Grep, Bash
- Provides NestJS patterns with Drizzle ORM for building production-ready server-side applications. Covers CRUD modules, J
- Follow nestjs SKILL.md steps and documented constraints.
- Follow nestjs SKILL.md steps and documented constraints.
Nestjs by the numbers
- 2,035 all-time installs (skills.sh)
- +58 installs in the week ending Jul 28, 2026 (Skillselion tracking)
- Ranked #566 of 16,659 AI & Agent Building skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
nestjs capabilities & compatibility
- Capabilities
- description: provides comprehensive nestjs frame · allowed tools: read, write, edit, glob, grep, ba · provides nestjs patterns with drizzle orm for bu · follow nestjs skill.md steps and documented cons
- Use cases
- orchestration
What nestjs says it does
description: Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applications. Generates REST/GraphQL APIs, implements authentication guards
allowed-tools: Read, Write, Edit, Glob, Grep, Bash
Provides NestJS patterns with Drizzle ORM for building production-ready server-side applications. Covers CRUD modules, JWT authentication, database operations, migrations, testing, microservices, and
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill nestjsAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 2k |
|---|---|
| repo stars | ★ 311 |
| Security audit | 3 / 3 scanners passed |
| Last updated | June 22, 2026 |
| Repository | giuseppe-trisciuoglio/developer-kit ↗ |
When should an agent use nestjs and what problem does it solve?
Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applications. Generates REST/GraphQL APIs, implements authentication guards, creates dat
Who is it for?
Developers invoking nestjs as documented in the skill source.
Skip if: Skip when requirements fall outside nestjs documented scope.
When should I use this skill?
Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applications. Generates REST/GraphQL APIs, implements authentication guards, creates dat
What you get
Outputs aligned with the nestjs SKILL.md workflow and stated deliverables.
- Validated DTOs
- Exception filter setup
- Focused NestJS modules with tests
By the numbers
- Documents 10 core NestJS best-practice principles in the README
Files
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
1. Install dependencies: npm i drizzle-orm pg && npm i -D drizzle-kit tsx 2. Define schema: Create src/db/schema.ts with Drizzle table definitions 3. Create DatabaseService: Inject Drizzle client as a NestJS provider 4. Build CRUD module: Controller → Service → Repository pattern 5. Add validation: Use class-validator DTOs with ValidationPipe 6. Implement guards: Create JWT/Roles guards for route protection 7. Write tests: Use @nestjs/testing with mocked repositories 8. 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 generateafter 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, GraphQLreferences/drizzle-reference.md- Drizzle ORM installation, configuration, queriesreferences/workflow-optimization.md- Development workflows, parallel execution strategies
NestJS Best Practices
Comprehensive best practices for NestJS development.
Core Principles
1. Always use constructor injection - Never use property injection 2. Use DTOs for data transfer - Define interfaces for request/response 3. Implement proper error handling - Use exception filters 4. Validate all inputs - Use validation pipes 5. Keep modules focused - Single responsibility principle 6. Use environment variables - Never hardcode credentials 7. Write comprehensive tests - Unit and integration tests 8. Use transactions for complex operations - Maintain data consistency 9. Implement proper logging - Use interceptors for cross-cutting concerns 10. Use type safety - Leverage TypeScript features
Database Best Practices
- Connection pooling - Always use pooling for production workloads
- Index frequently queried columns - Improve query performance
- Use migrations for schema changes - Never modify schema manually
- Implement soft deletes - Preserve data history
- Use transactions - Ensure data consistency
Security Best Practices
- Never expose stack traces - In production error responses
- Validate all inputs - Prevent injection attacks
- Use parameterized queries - Drizzle does this automatically
- Implement rate limiting - Prevent abuse
- Use HTTPS - Encrypt data in transit
Install Drizzle and Gel Packages
Source: https://orm.drizzle.team/docs/get-started/gel-new
Installs the necessary Drizzle ORM and Gel packages, along with development dependencies like Drizzle Kit and tsx.
npm i drizzle-orm gel
npm i -D drizzle-kit tsxyarn add drizzle-orm gel
yarn add -D drizzle-kit tsxpnpm add drizzle-orm gel
pnpm add -D drizzle-kit tsxbun add drizzle-orm gel
bun add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Drizzle Kit with bun
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Installs Drizzle ORM and Drizzle Kit using the Bun runtime's package manager, including types for Bun.
bun add drizzle-orm
bun add -D drizzle-kit @types/bun--------------------------------
Install Drizzle ORM and Drizzle Kit with npm
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Installs the necessary Drizzle ORM package for database operations and Drizzle Kit for schema management and migrations using npm.
npm i drizzle-orm
npm i -D drizzle-kit @types/bun--------------------------------
Install Drizzle ORM and Drizzle Kit with yarn
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Installs the Drizzle ORM and Drizzle Kit packages using yarn, including the types for Bun.
yarn add drizzle-orm
yarn add -D drizzle-kit @types/bun--------------------------------
Install Drizzle Packages with bun
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Installs the necessary Drizzle ORM packages, the PlanetScale database driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
bun add drizzle-orm @planetscale/database dotenv
bun add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Drizzle Kit with pnpm
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Installs Drizzle ORM and Drizzle Kit, along with Bun types, using the pnpm package manager.
pnpm add drizzle-orm
pnpm add -D drizzle-kit @types/bun--------------------------------
Install Drizzle Packages with pnpm
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Installs the necessary Drizzle ORM packages, the PlanetScale database driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
pnpm add drizzle-orm @planetscale/database dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Install Drizzle Packages with npm
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Installs the necessary Drizzle ORM packages, the PlanetScale database driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
npm i drizzle-orm @planetscale/database dotenv
npm i -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and SQLite Cloud Driver (bun)
Source: https://orm.drizzle.team/docs/get-started/sqlite-cloud-new
Installs the necessary Drizzle ORM beta package, the SQLite Cloud driver, dotenv for environment variables, and Drizzle Kit with tsx for development using bun.
bun add drizzle-orm@beta @sqlitecloud/drivers dotenv
bun add -D drizzle-kit@beta tsx--------------------------------
Install Drizzle ORM and Supabase Dependencies (bun)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Installs the necessary Drizzle ORM, postgres driver, dotenv for environment variables, and development tools like drizzle-kit and tsx using bun.
bun add drizzle-orm postgres dotenv
bun add -D drizzle-kit tsx--------------------------------
Install Drizzle Packages with yarn
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Installs the necessary Drizzle ORM packages, the PlanetScale database driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
yarn add drizzle-orm @planetscale/database dotenv
yarn add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and SQLite Cloud Driver (npm)
Source: https://orm.drizzle.team/docs/get-started/sqlite-cloud-new
Installs the necessary Drizzle ORM beta package, the SQLite Cloud driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
npm i drizzle-orm@beta @sqlitecloud/drivers dotenv
npm i -D drizzle-kit@beta tsx--------------------------------
Database Connection Setup (Basic)
Source: https://orm.drizzle.team/docs/get-started/postgresql-new
Initializes Drizzle ORM with a PostgreSQL connection using the DATABASE_URL from environment variables and the node-postgres driver.
import 'dotenv/config';
import { drizzle } from 'drizzle-orm/node-postgres';
const db = drizzle(process.env.DATABASE_URL!);--------------------------------
Install Drizzle ORM and Supabase Dependencies (pnpm)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Installs the necessary Drizzle ORM, postgres driver, dotenv for environment variables, and development tools like drizzle-kit and tsx using pnpm.
pnpm add drizzle-orm postgres dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Supabase Dependencies (npm)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Installs the necessary Drizzle ORM, postgres driver, dotenv for environment variables, and development tools like drizzle-kit and tsx using npm.
npm i drizzle-orm postgres dotenv
npm i -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and SQLite Cloud Driver (pnpm)
Source: https://orm.drizzle.team/docs/get-started/sqlite-cloud-new
Installs the necessary Drizzle ORM beta package, the SQLite Cloud driver, dotenv for environment variables, and Drizzle Kit with tsx for development using pnpm.
pnpm add drizzle-orm@beta @sqlitecloud/drivers dotenv
pnpm add -D drizzle-kit@beta tsx--------------------------------
Install Drizzle ORM and SQLite Cloud Driver (yarn)
Source: https://orm.drizzle.team/docs/get-started/sqlite-cloud-new
Installs the necessary Drizzle ORM beta package, the SQLite Cloud driver, dotenv for environment variables, and Drizzle Kit with tsx for development using yarn.
yarn add drizzle-orm@beta @sqlitecloud/drivers dotenv
yarn add -D drizzle-kit@beta tsx--------------------------------
Install Drizzle Packages (bun)
Source: https://orm.drizzle.team/docs/get-started/vercel-new
Installs the necessary Drizzle ORM packages and development tools using bun. This includes the core Drizzle ORM library, the Vercel Postgres driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
bun add drizzle-orm @vercel/postgres dotenv
bun add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Supabase Dependencies (yarn)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Installs the necessary Drizzle ORM, postgres driver, dotenv for environment variables, and development tools like drizzle-kit and tsx using yarn.
yarn add drizzle-orm postgres dotenv
yarn add -D drizzle-kit tsx--------------------------------
Initialize Gel Project
Source: https://orm.drizzle.team/docs/get-started/gel-new
Initializes a new Gel project. This command is used to set up the basic structure for a Gel database project.
npx gel project inityarn gel project initpnpm gel project initbunx gel project init--------------------------------
Install Drizzle ORM and TiDB Serverless Packages (bun)
Source: https://orm.drizzle.team/docs/connect-tidb
Installs the necessary Drizzle ORM and TiDB Serverless packages using bun. It also installs drizzle-kit as a development dependency for schema management and migrations.
bun add drizzle-orm @tidbcloud/serverless
bun add -D drizzle-kit--------------------------------
PostgreSQL Connection URL Example
Source: https://orm.drizzle.team/docs/guides/postgresql-local-setup
This is the standard format for a PostgreSQL database connection URL. Replace the placeholders with your specific credentials and host information.
postgres://:@:/postgres://postgres:mypassword@localhost:5432/postgres--------------------------------
Drizzle Kit Configuration for PostgreSQL
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Configuration file for Drizzle Kit, specifying the output directory for migrations, the schema file location, the database dialect (PostgreSQL), and database credentials.
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!,
},
});--------------------------------
Install Drizzle ORM and Drizzle Kit Packages
Source: https://orm.drizzle.team/docs/connect-cloudflare-d1
Installs the necessary Drizzle ORM and Drizzle Kit packages for project setup. Drizzle ORM is used for database interactions, while Drizzle Kit provides tooling for schema management and migrations.
npm i drizzle-orm
npm i -D drizzle-kityarn add drizzle-orm
yarn add -D drizzle-kitpnpm add drizzle-orm
pnpm add -D drizzle-kitbun add drizzle-orm
bun add -D drizzle-kit--------------------------------
Configure MySQL Database URL
Source: https://orm.drizzle.team/docs/guides/mysql-local-setup
This is the standard format for a MySQL connection URL. Replace the placeholders with your specific credentials and host information. The example provided shows how to construct the URL for the previously started Docker container.
mysql://:@:/mysql://root:mypassword@localhost:3306/mysql--------------------------------
Database Connection Setup (with Config)
Source: https://orm.drizzle.team/docs/get-started/postgresql-new
Initializes Drizzle ORM with a PostgreSQL connection, passing specific node-postgres connection options like SSL configuration.
import 'dotenv/config';
import { drizzle } from 'drizzle-orm/node-postgres';
// You can specify any property from the node-postgres connection options
const db = drizzle({
connection: {
connectionString: process.env.DATABASE_URL!,
ssl: true
}
});--------------------------------
Install Drizzle ORM and Drizzle Kit with npm/yarn/pnpm/bun
Source: https://orm.drizzle.team/docs/get-started/bun-sqlite-new
Commands to install Drizzle ORM and Drizzle Kit, essential for ORM functionality and schema management. Drizzle Kit requires @types/bun for TypeScript projects.
npm i drizzle-orm
npm i -D drizzle-kit @types/bunyarn add drizzle-orm
yarn add -D drizzle-kit @types/bunpnpm add drizzle-orm
pnpm add -D drizzle-kit @types/bunbun add drizzle-orm
bun add -D drizzle-kit @types/bun--------------------------------
Run Docker Container with User and Database
Source: https://orm.drizzle.team/docs/guides/postgresql-local-setup
This shows how to start a PostgreSQL container with a specific user and database name. If not provided, default values are used.
docker run --name drizzle-postgres -e POSTGRES_USER=myuser -e POSTGRES_PASSWORD=mypassword -e POSTGRES_DB=mydatabase -d -p 5432:5432 postgres--------------------------------
Install Drizzle Packages (npm)
Source: https://orm.drizzle.team/docs/get-started/vercel-new
Installs the necessary Drizzle ORM packages and development tools using npm. This includes the core Drizzle ORM library, the Vercel Postgres driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
npm i drizzle-orm @vercel/postgres dotenv
npm i -D drizzle-kit tsx--------------------------------
Project File Structure for Drizzle ORM
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Basic file structure for a Drizzle ORM project using Bun SQL. It shows the location of schema definitions, migration files, configuration files, and environment variables.
📦
├ 📂 drizzle
├ 📂 src
│ ├ 📂 db
│ │ └ 📜 schema.ts
│ └ 📜 index.ts
├ 📜 .env
├ 📜 drizzle.config.ts
├ 📜 package.json
└ 📜 tsconfig.json--------------------------------
Install Drizzle ORM and MySQL2 Dependencies (npm)
Source: https://orm.drizzle.team/docs/get-started/mysql-new
Installs the necessary Drizzle ORM packages, the mysql2 driver, dotenv for environment variables, and drizzle-kit and tsx for development.
npm i drizzle-orm mysql2 dotenv
npm i -D drizzle-kit tsx--------------------------------
Configure Drizzle Kit
Source: https://orm.drizzle.team/docs/get-started/gel-new
Sets up the Drizzle Kit configuration file. This TypeScript file specifies the database dialect and other project-specific settings for Drizzle Kit.
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
dialect: 'gel',
});--------------------------------
Install Drizzle ORM and MySQL2 Dependencies (bun)
Source: https://orm.drizzle.team/docs/get-started/mysql-new
Installs the necessary Drizzle ORM packages, the mysql2 driver, dotenv for environment variables, and drizzle-kit and tsx for development using Bun.
bun add drizzle-orm mysql2 dotenv
bun add -D drizzle-kit tsx--------------------------------
Install Drizzle Packages (pnpm)
Source: https://orm.drizzle.team/docs/get-started/vercel-new
Installs the necessary Drizzle ORM packages and development tools using pnpm. This includes the core Drizzle ORM library, the Vercel Postgres driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
pnpm add drizzle-orm @vercel/postgres dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Setup SQLite Cloud Connection String
Source: https://orm.drizzle.team/docs/get-started/sqlite-cloud-new
Defines the environment variable for the SQLite Cloud database connection string in the .env file.
SQLITE_CLOUD_CONNECTION_STRING=--------------------------------
Install Drizzle ORM and Dependencies (bun)
Source: https://orm.drizzle.team/docs/get-started/turso-database-new
Installs the essential Drizzle ORM packages and development tools using bun. This command includes the beta versions of drizzle-orm and drizzle-kit, as well as @tursodatabase/database, dotenv, and tsx for the project.
bun add drizzle-orm@beta @tursodatabase/database dotenv
bun add -D drizzle-kit@beta tsx--------------------------------
Install Drizzle ORM and Dependencies (bun)
Source: https://orm.drizzle.team/docs/get-started/d1-new
Installs the necessary Drizzle ORM packages and development tools using bun. drizzle-orm and dotenv are for runtime, while drizzle-kit and tsx are for development.
bun add drizzle-orm dotenv
bun add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Neon Packages (bun)
Source: https://orm.drizzle.team/docs/get-started/neon-new
Installs the core Drizzle ORM package, the Neon serverless driver, dotenv for environment variables, and development tools like Drizzle Kit and tsx using bun.
bun add drizzle-orm @neondatabase/serverless dotenv
bun add -D drizzle-kit tsx--------------------------------
Configure Drizzle Kit
Source: https://orm.drizzle.team/docs/get-started/sqlite-cloud-new
Sets up the Drizzle Kit configuration file, specifying the migration output directory, schema file location, dialect, and database credentials.
import 'dotenv/config';
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
out: './drizzle',
schema: './src/db/schema.ts',
dialect: 'sqlite',
dbCredentials: {
url: process.env.SQLITE_CLOUD_CONNECTION_STRING!,
},
});--------------------------------
Database Connection Setup (using Pool)
Source: https://orm.drizzle.team/docs/get-started/postgresql-new
Initializes Drizzle ORM with a PostgreSQL connection managed by a node-postgres Pool, allowing for connection pooling.
import 'dotenv/config';
import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";
const pool = new Pool({
connectionString: process.env.DATABASE_URL!,
});
const db = drizzle({ client: pool });--------------------------------
Install Drizzle ORM and Neon Serverless Driver (bun)
Source: https://orm.drizzle.team/docs/connect-neon
Installs the Drizzle ORM and the Neon serverless driver using bun. Also installs drizzle-kit as a development dependency.
bun add drizzle-orm @neondatabase/serverless
bun add -D drizzle-kit--------------------------------
Install Drizzle Packages (yarn)
Source: https://orm.drizzle.team/docs/get-started/vercel-new
Installs the necessary Drizzle ORM packages and development tools using yarn. This includes the core Drizzle ORM library, the Vercel Postgres driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
yarn add drizzle-orm @vercel/postgres dotenv
yarn add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Neon Serverless Driver (npm)
Source: https://orm.drizzle.team/docs/connect-neon
Installs the Drizzle ORM and the Neon serverless driver using npm. Also installs drizzle-kit as a development dependency.
npm i drizzle-orm @neondatabase/serverless
npm i -D drizzle-kit--------------------------------
Install Drizzle ORM and MySQL2 Dependencies (pnpm)
Source: https://orm.drizzle.team/docs/get-started/mysql-new
Installs the necessary Drizzle ORM packages, the mysql2 driver, dotenv for environment variables, and drizzle-kit and tsx for development using pnpm.
pnpm add drizzle-orm mysql2 dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Dependencies (npm)
Source: https://orm.drizzle.team/docs/get-started/turso-database-new
Installs the necessary Drizzle ORM packages and development tools using npm. It includes the beta versions of drizzle-orm and drizzle-kit, along with @tursodatabase/database, dotenv, and tsx for development.
npm i drizzle-orm@beta @tursodatabase/database dotenv
npm i -D drizzle-kit@beta tsx--------------------------------
Install Drizzle ORM and TiDB Serverless Packages (npm)
Source: https://orm.drizzle.team/docs/connect-tidb
Installs the necessary Drizzle ORM and TiDB Serverless packages using npm. It also installs drizzle-kit as a development dependency for schema management and migrations.
npm i drizzle-orm @tidbcloud/serverless
npm i -D drizzle-kit--------------------------------
Seeding and Querying Database with Drizzle ORM (TypeScript)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Demonstrates how to interact with a PostgreSQL database using Drizzle ORM in TypeScript. It includes operations for inserting a new user, selecting all users, updating a user's age, and deleting a user. This example assumes a usersTable schema and uses environment variables for database connection.
import 'dotenv/config';
import { drizzle } from 'drizzle-orm/postgres-js';
import { eq } from 'drizzle-orm';
import { usersTable } from './db/schema';
const db = drizzle(process.env.DATABASE_URL!);
async function main() {
const user: typeof usersTable.$inferInsert = {
name: 'John',
age: 30,
email: 'john@example.com',
};
await db.insert(usersTable).values(user);
console.log('New user created!')
const users = await db.select().from(usersTable);
console.log('Getting all users from the database: ', users)
/*
const users: {
id: number;
name: string;
age: number;
email: string;
}[]
*/
await db
.update(usersTable)
.set({
age: 31,
})
.where(eq(usersTable.email, user.email));
console.log('User info updated!')
await db.delete(usersTable).where(eq(usersTable.email, user.email));
console.log('User deleted!')
}
main();--------------------------------
Install Drizzle ORM and SQLite Packages (bun)
Source: https://orm.drizzle.team/docs/get-started/sqlite-new
Installs the necessary Drizzle ORM, libsql client, dotenv, and development packages using bun. This command is for setting up a new project or adding dependencies to an existing one.
bun add drizzle-orm @libsql/client dotenv
bun add -D drizzle-kit tsx--------------------------------
Manage Gel Migrations
Source: https://orm.drizzle.team/docs/get-started/gel-new
Commands to manage Gel database migrations. 'migration create' generates a migration file, and 'migration apply' applies pending migrations to the database.
gel migration creategel migration apply--------------------------------
Initialize Drizzle ORM with Bun SQL
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Initializes the Drizzle ORM instance using the connection URL from the environment variables for Bun SQL.
import 'dotenv/config';
import { drizzle } from 'drizzle-orm/bun-sql';
const db = drizzle(process.env.DATABASE_URL!);--------------------------------
Install Drizzle ORM and TiDB Serverless Packages (pnpm)
Source: https://orm.drizzle.team/docs/connect-tidb
Installs the necessary Drizzle ORM and TiDB Serverless packages using pnpm. It also installs drizzle-kit as a development dependency for schema management and migrations.
pnpm add drizzle-orm @tidbcloud/serverless
pnpm add -D drizzle-kit--------------------------------
Install Drizzle and PGlite Packages (npm, yarn, pnpm, bun)
Source: https://orm.drizzle.team/docs/get-started/pglite-new
Provides commands to install the necessary Drizzle ORM packages, the PGlite driver, dotenv for environment variables, and Drizzle Kit with tsx for development.
npm i drizzle-orm @electric-sql/pglite dotenv
npm i -D drizzle-kit tsxyarn add drizzle-orm @electric-sql/pglite dotenv
yarn add -D drizzle-kit tsxpnpm add drizzle-orm @electric-sql/pglite dotenv
pnpm add -D drizzle-kit tsxbun add drizzle-orm @electric-sql/pglite dotenv
bun add -D drizzle-kit tsx--------------------------------
Initialize Drizzle ORM Connection (Async)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Initializes an asynchronous Drizzle ORM connection using the 'postgres-js' driver and the DATABASE_URL from environment variables.
import { drizzle } from 'drizzle-orm'
async function main() {
const db = drizzle('postgres-js', process.env.DATABASE_URL);
}
main();--------------------------------
Generate and Apply Database Migrations with drizzle-kit
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Generates SQL migration files based on schema changes and then applies these migrations to the database. This process is managed via separate commands.
npx drizzle-kit generatenpx drizzle-kit migrate--------------------------------
Install Drizzle ORM and MySQL2 Dependencies (yarn)
Source: https://orm.drizzle.team/docs/get-started/mysql-new
Installs the necessary Drizzle ORM packages, the mysql2 driver, dotenv for environment variables, and drizzle-kit and tsx for development using Yarn.
yarn add drizzle-orm mysql2 dotenv
yarn add -D drizzle-kit tsx--------------------------------
List Docker Images
Source: https://orm.drizzle.team/docs/guides/postgresql-local-setup
After pulling an image, this command lists all downloaded Docker images on your system, allowing you to verify the PostgreSQL image and its details.
docker images--------------------------------
Turso CLI: Authenticate and Create Database
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-turso
Commands to authenticate with the Turso service and create a new database. Requires Turso CLI installation. The database name 'drizzle-turso-db' is used as an example.
turso auth signup
turso auth login
turso db create drizzle-turso-db
turso db show drizzle-turso-db
turso db tokens create drizzle-turso-db--------------------------------
Install Drizzle ORM and Neon Packages (npm)
Source: https://orm.drizzle.team/docs/get-started/neon-new
Installs the core Drizzle ORM package, the Neon serverless driver, dotenv for environment variables, and development tools like Drizzle Kit and tsx using npm.
npm i drizzle-orm @neondatabase/serverless dotenv
npm i -D drizzle-kit tsx--------------------------------
Start Netlify Development Server
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-netlify-edge-functions-neon
Launches the Netlify dev server for local testing of edge functions and site deployment. This command allows for simulating the Netlify environment locally.
netlify dev--------------------------------
Install Drizzle ORM and Neon Serverless Driver (pnpm)
Source: https://orm.drizzle.team/docs/connect-neon
Installs the Drizzle ORM and the Neon serverless driver using pnpm. Also installs drizzle-kit as a development dependency.
pnpm add drizzle-orm @neondatabase/serverless
pnpm add -D drizzle-kit--------------------------------
SQL Generated Migration File Example
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-turso
An example of a SQL file generated by Drizzle Kit for database migrations. It includes CREATE TABLE statements for 'posts' and 'users', defining their columns, constraints, foreign keys, and unique indexes.
CREATE TABLE `posts` (
`id` integer PRIMARY KEY NOT NULL,
`title` text NOT NULL,
`content` text NOT NULL,
`user_id` integer NOT NULL,
`created_at` text DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
`updated_at` integer,
FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE cascade
);
--> statement-breakpoint
CREATE TABLE `users` (
`id` integer PRIMARY KEY NOT NULL,
`name` text NOT NULL,
`age` integer NOT NULL,
`email` text NOT NULL
);
--> statement-breakpoint
CREATE UNIQUE INDEX `users_email_unique` ON `users` (`email`);--------------------------------
Run TypeScript Script with Bun
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Executes a TypeScript file using the Bun runtime environment. This command is used to run the main application script after setting up database operations.
bun src/index.ts--------------------------------
Initialize New Netlify Project
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-netlify-edge-functions-neon
Initializes a new Netlify project using the Netlify CLI. This command guides the user through setting up a new site and choosing deployment options.
netlify init--------------------------------
Install Drizzle ORM and Neon Packages (pnpm)
Source: https://orm.drizzle.team/docs/get-started/neon-new
Installs the core Drizzle ORM package, the Neon serverless driver, dotenv for environment variables, and development tools like Drizzle Kit and tsx using pnpm.
pnpm add drizzle-orm @neondatabase/serverless dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Generated Drizzle Schema for Gel
Source: https://orm.drizzle.team/docs/get-started/gel-new
Example of a schema file generated by Drizzle Kit after pulling from a Gel database. It defines a 'users' table with UUID, smallint, and text fields.
import { gelTable, uniqueIndex, uuid, smallint, text } from "drizzle-orm/gel-core"
import { sql } from "drizzle-orm"
export const users = gelTable("users", {
id: uuid().default(sql`uuid_generate_v4()`).primaryKey().notNull(),
age: smallint(),
email: text().notNull(),
name: text(),
}, (table) => [
uniqueIndex("a8c6061c-f37f-11ef-9249-0d78f6c1807b;schemaconstr").using("btree", table.id.asc().nullsLast().op("uuid_ops")),
]);--------------------------------
Install Drizzle ORM and SQLite Packages (pnpm)
Source: https://orm.drizzle.team/docs/get-started/sqlite-new
Installs the necessary Drizzle ORM, libsql client, dotenv, and development packages using pnpm. This command is for setting up a new project or adding dependencies to an existing one.
pnpm add drizzle-orm @libsql/client dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and TiDB Serverless Packages (yarn)
Source: https://orm.drizzle.team/docs/connect-tidb
Installs the necessary Drizzle ORM and TiDB Serverless packages using yarn. It also installs drizzle-kit as a development dependency for schema management and migrations.
yarn add drizzle-orm @tidbcloud/serverless
yarn add -D drizzle-kit--------------------------------
Install Drizzle ORM and Vercel Postgres Packages
Source: https://orm.drizzle.team/docs/connect-vercel-postgres
Installs the Drizzle ORM and the Vercel Postgres driver using npm, yarn, pnpm, or bun. Also installs drizzle-kit as a development dependency.
npm i drizzle-orm @vercel/postgres
npm i -D drizzle-kityarn add drizzle-orm @vercel/postgres
yarn add -D drizzle-kitpnpm add drizzle-orm @vercel/postgres
pnpm add -D drizzle-kitbun add drizzle-orm @vercel/postgres
bun add -D drizzle-kit--------------------------------
Initialize Drizzle ORM with Bun SQL Connection Options
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Initializes Drizzle ORM with specific connection options for Bun SQL, allowing configuration of the connection object.
import 'dotenv/config';
import { drizzle } from 'drizzle-orm/bun-sql';
// You can specify any property from the bun sql connection options
const db = drizzle({ connection: { url: process.env.DATABASE_URL! }});--------------------------------
Install Drizzle ORM and Dependencies (pnpm)
Source: https://orm.drizzle.team/docs/get-started/d1-new
Installs the necessary Drizzle ORM packages and development tools using pnpm. drizzle-orm and dotenv are for runtime, while drizzle-kit and tsx are for development.
pnpm add drizzle-orm dotenv
pnpm add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Neon Serverless Driver (yarn)
Source: https://orm.drizzle.team/docs/connect-neon
Installs the Drizzle ORM and the Neon serverless driver using yarn. Also installs drizzle-kit as a development dependency.
yarn add drizzle-orm @neondatabase/serverless
yarn add -D drizzle-kit--------------------------------
Install Drizzle ORM and SQLite Packages (npm)
Source: https://orm.drizzle.team/docs/get-started/sqlite-new
Installs the necessary Drizzle ORM, libsql client, dotenv, and development packages using npm. This command is for setting up a new project or adding dependencies to an existing one.
npm i drizzle-orm @libsql/client dotenv
npm i -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and libSQL Client Packages
Source: https://orm.drizzle.team/docs/connect-turso
Installs the necessary Drizzle ORM and libSQL client packages for different package managers. This is the first step to connect Drizzle to Turso Cloud.
npm i drizzle-orm @libsql/client
npm i -D drizzle-kityarn add drizzle-orm @libsql/client
yarn add -D drizzle-kitpnpm add drizzle-orm @libsql/client
pnpm add -D drizzle-kitbun add drizzle-orm @libsql/client
bun add -D drizzle-kit--------------------------------
Initialize Drizzle ORM Connection (Sync)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Initializes a synchronous Drizzle ORM connection by explicitly creating a postgres client and passing it to the Drizzle instance.
import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'
async function main() {
const client = postgres(process.env.DATABASE_URL)
const db = drizzle({ client });
}
main();--------------------------------
Install Drizzle ORM and Dependencies (npm)
Source: https://orm.drizzle.team/docs/get-started/d1-new
Installs the necessary Drizzle ORM packages and development tools using npm. drizzle-orm and dotenv are for runtime, while drizzle-kit and tsx are for development.
npm i drizzle-orm dotenv
npm i -D drizzle-kit tsx--------------------------------
Initialize Drizzle with SingleStore (Basic)
Source: https://orm.drizzle.team/docs/get-started/singlestore-new
Initializes Drizzle ORM with a SingleStore database connection using the DATABASE_URL from environment variables.
import 'dotenv/config';
import { drizzle } from "drizzle-orm/singlestore";
const db = drizzle(process.env.DATABASE_URL);--------------------------------
Environment Variable Setup
Source: https://orm.drizzle.team/docs/get-started/vercel-new
Defines the database connection URL in a .env file. For Vercel Postgres, it's crucial to name the variable POSTGRES_URL. The value can be obtained from the Vercel Postgres storage tab.
POSTGRES_URL=--------------------------------
Database Connection URL in .env
Source: https://orm.drizzle.team/docs/get-started/bun-sql-new
Specifies the database connection string in the .env file, which Drizzle ORM will use to connect to the database.
DATABASE_URL=--------------------------------
Install Drizzle ORM and Dependencies (yarn)
Source: https://orm.drizzle.team/docs/get-started/d1-new
Installs the necessary Drizzle ORM packages and development tools using yarn. drizzle-orm and dotenv are for runtime, while drizzle-kit and tsx are for development.
yarn add drizzle-orm dotenv
yarn add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Neon Packages (yarn)
Source: https://orm.drizzle.team/docs/get-started/neon-new
Installs the core Drizzle ORM package, the Neon serverless driver, dotenv for environment variables, and development tools like Drizzle Kit and tsx using yarn.
yarn add drizzle-orm @neondatabase/serverless dotenv
yarn add -D drizzle-kit tsx--------------------------------
Start PostgreSQL Docker Container
Source: https://orm.drizzle.team/docs/guides/postgresql-local-setup
This command starts a new PostgreSQL container named 'drizzle-postgres'. It sets the password, runs in detached mode, and maps port 5432 from the container to the host.
docker run --name drizzle-postgres -e POSTGRES_PASSWORD=mypassword -d -p 5432:5432 postgres--------------------------------
Run TypeScript Files using tsx Command
Source: https://orm.drizzle.team/docs/get-started/gel-new
This section provides commands to execute TypeScript files using the 'tsx' tool across different package managers (npm, yarn, pnpm, bun). It's a convenient way to run scripts without a full TypeScript compilation step. Ensure 'tsx' is installed in your project.
npx tsx src/index.tsyarn tsx src/index.tspnpm tsx src/index.tsbunx tsx src/index.ts--------------------------------
Install Drizzle ORM and AWS SDK for PostgreSQL (bun)
Source: https://orm.drizzle.team/docs/connect-aws-data-api-pg
Installs the Drizzle ORM package and the AWS SDK client for RDS Data using bun. Also installs drizzle-kit as a development dependency for schema management.
bun add drizzle-orm @aws-sdk/client-rds-data
bun add -D drizzle-kit--------------------------------
Initialize Drizzle ORM with Existing PlanetScale Client
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Initializes the Drizzle ORM instance by providing an existing PlanetScale client instance. This allows for more control over the client configuration.
import { drizzle } from "drizzle-orm/planetscale-serverless";
import { Client } from "@planetscale/database";
const client = new Client({
host: process.env.DATABASE_HOST!,
username: process.env.DATABASE_USERNAME!,
password: process.env.DATABASE_PASSWORD!,
});
const db = drizzle({ client: client });--------------------------------
Configure Drizzle Kit for SQLite
Source: https://orm.drizzle.team/docs/get-started/bun-sqlite-new
Sets up the drizzle.config.ts file for Drizzle Kit. Specifies the output directory for migrations, schema file location, dialect (sqlite), and database credentials.
import 'dotenv/config';
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
out: './drizzle',
schema: './src/db/schema.ts',
dialect: 'sqlite',
dbCredentials: {
url: process.env.DB_FILE_NAME!,
},
});--------------------------------
Install Drizzle ORM and SQLite Packages (yarn)
Source: https://orm.drizzle.team/docs/get-started/sqlite-new
Installs the necessary Drizzle ORM, libsql client, dotenv, and development packages using yarn. This command is for setting up a new project or adding dependencies to an existing one.
yarn add drizzle-orm @libsql/client dotenv
yarn add -D drizzle-kit tsx--------------------------------
Install Drizzle ORM and Dependencies (pnpm)
Source: https://orm.drizzle.team/docs/get-started/turso-database-new
Installs the necessary Drizzle ORM packages and development tools using pnpm. This command adds the beta versions of drizzle-orm and drizzle-kit, along with @tursodatabase/database, dotenv, and tsx to the project's dependencies.
pnpm add drizzle-orm@beta @tursodatabase/database dotenv
pnpm add -D drizzle-kit@beta tsx--------------------------------
Install Drizzle ORM and AWS SDK for PostgreSQL (npm)
Source: https://orm.drizzle.team/docs/connect-aws-data-api-pg
Installs the Drizzle ORM package and the AWS SDK client for RDS Data using npm. Also installs drizzle-kit as a development dependency for schema management.
npm i drizzle-orm @aws-sdk/client-rds-data
npm i -D drizzle-kit--------------------------------
Initialize Drizzle ORM with PlanetScale Serverless Driver
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Initializes the Drizzle ORM instance using the PlanetScale serverless driver. It reads connection details from environment variables.
import { drizzle } from "drizzle-orm/planetscale-serverless";
const db = drizzle({ connection: {
host: process.env.DATABASE_HOST!,
username: process.env.DATABASE_USERNAME!,
password: process.env.DATABASE_PASSWORD!,
}});--------------------------------
Running the Application
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-nile
This command starts the Node.js web application using tsx, allowing you to test the implemented API endpoints.
npx tsx src/app.ts--------------------------------
Install Drizzle ORM and PostgreSQL Dependencies (bun)
Source: https://orm.drizzle.team/docs/get-started/nile-new
Installs the core Drizzle ORM package, the 'pg' driver for PostgreSQL, 'dotenv' for environment variables, and development dependencies like 'drizzle-kit', 'tsx', and '@types/pg' using bun.
bun add drizzle-orm pg dotenv
bun add -D drizzle-kit tsx @types/pg--------------------------------
Push Migrations with Multiple Config Files (bun)
Source: https://orm.drizzle.team/docs/drizzle-kit-push
Provides examples of pushing database migrations using multiple Drizzle Kit configuration files with bun.
bunx drizzle-kit push --config=drizzle-dev.config.ts
bunx drizzle-kit push --config=drizzle-prod.config.ts--------------------------------
PlanetScale Database Connection Variables
Source: https://orm.drizzle.team/docs/get-started/planetscale-new
Defines the environment variables required to connect to the PlanetScale database. These include the host, username, and password.
DATABASE_HOST=
DATABASE_USERNAME=
DATABASE_PASSWORD=--------------------------------
Drizzle ORM Configuration Example (TypeScript)
Source: https://orm.drizzle.team/docs/drizzle-kit-migrate
Provides an example TypeScript configuration file for Drizzle ORM. It specifies the database dialect, schema location, credentials, and migration table/schema settings. This file is essential for defining your database connection and migration strategy.
import { defineConfig } from "drizzle-kit";
export default defineConfig({
dialect: "postgresql",
schema: "./src/schema.ts",
dbCredentials: {
url: "postgresql://user:password@host:port/dbname"
},
migrations: {
table: 'journal',
schema: 'drizzle',
},
});--------------------------------
Install Drizzle ORM and Dependencies (yarn)
Source: https://orm.drizzle.team/docs/get-started/turso-database-new
Installs the required Drizzle ORM packages and development tools using yarn. This command ensures that the beta versions of drizzle-orm and drizzle-kit, along with @tursodatabase/database, dotenv, and tsx, are included in the project dependencies.
yarn add drizzle-orm@beta @tursodatabase/database dotenv
yarn add -D drizzle-kit@beta tsx--------------------------------
Example SQL Migration File for Drizzle ORM
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-neon
Illustrates the structure of a SQL migration file generated by Drizzle Kit. This example shows the creation of two tables, 'posts_table' and 'users_table', including primary keys, constraints, and foreign key relationships.
CREATE TABLE IF NOT EXISTS "posts_table" (
"id" serial PRIMARY KEY NOT NULL,
"title" text NOT NULL,
"content" text NOT NULL,
"user_id" integer NOT NULL,
"created_at" timestamp DEFAULT now() NOT NULL,
"updated_at" timestamp NOT NULL
);
--> statement-breakpoint
CREATE TABLE IF NOT EXISTS "users_table" (
"id" serial PRIMARY KEY NOT NULL,
"name" text NOT NULL,
"age" integer NOT NULL,
"email" text NOT NULL,
CONSTRAINT "users_table_email_unique" UNIQUE("email")
);
--> statement-breakpoint
DO $$ BEGIN
ALTER TABLE "posts_table" ADD CONSTRAINT "posts_table_user_id_users_table_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users_table"("id") ON DELETE cascade ON UPDATE no action;
EXCEPTION
WHEN duplicate_object THEN null;
END $$;--------------------------------
Install postgres package (bun)
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-supabase
Installs the postgres package using bun, a Node.js driver for PostgreSQL that Drizzle ORM can use.
bun add postgres--------------------------------
Install @libsql/client Package
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-turso
Installs the '@libsql/client' package, which is the official driver for interacting with libSQL-compatible databases like Turso. This client enables Drizzle ORM to communicate with the database.
npm i @libsql/clientyarn add @libsql/clientpnpm add @libsql/clientbun add @libsql/client--------------------------------
Initialize Drizzle Connection with Existing Driver
Source: https://orm.drizzle.team/docs/get-started/turso-database-new
Demonstrates how to initialize Drizzle ORM when you already have an existing database client instance. This is useful for integrating Drizzle with pre-configured database connections or custom driver setups.
import 'dotenv/config';
import { Database } from '@tursodatabase/database';
import { drizzle } from 'drizzle-orm/tursodatabase/database';
const client = new Database(process.env.DB_FILE_NAME!);
const db = drizzle({ client });--------------------------------
Install Drizzle and Gel Packages (bun)
Source: https://orm.drizzle.team/docs/get-started-gel
Installs the necessary Drizzle ORM and Gel packages for bun projects. Includes the development dependency for Drizzle Kit.
bun add drizzle-orm gel
bun add -D drizzle-kit--------------------------------
Install Drizzle ORM and PostgreSQL Dependencies (npm)
Source: https://orm.drizzle.team/docs/get-started/nile-new
Installs the core Drizzle ORM package, the 'pg' driver for PostgreSQL, 'dotenv' for environment variables, and development dependencies like 'drizzle-kit', 'tsx', and '@types/pg'.
npm i drizzle-orm pg dotenv
npm i -D drizzle-kit tsx @types/pg--------------------------------
Drizzle Kit Generate Migration Process
Source: https://orm.drizzle.team/docs/drizzle-kit-generate
Visual representation of the drizzle-kit generate process, outlining steps from reading migration folders to generating SQL files.
┌────────────────────────┐
│ $ drizzle-kit generate │
└─┬──────────────────────┘
│
└ 1. read previous migration folders
2. find diff between current and previous scheama
3. prompt developer for renames if necessary
┌ 4. generate SQL migration and persist to file
│ ┌─┴───────────────────────────────────────┐
│ 📂 drizzle
│ ├ 📂 _meta
│ └ 📜 0000_premium_mister_fear.sql
v--------------------------------
Install Drizzle ORM and mysql2 driver
Source: https://orm.drizzle.team/docs/get-started-singlestore
Installs the necessary Drizzle ORM packages and the mysql2 driver for SingleStore integration using npm, yarn, pnpm, or bun.
npm i drizzle-orm mysql2
npm i -D drizzle-kityarn add drizzle-orm mysql2
yarn add -D drizzle-kitpnpm add drizzle-orm mysql2
pnpm add -D drizzle-kitbun add drizzle-orm mysql2
bun add -D drizzle-kit--------------------------------
Start MySQL Docker Container
Source: https://orm.drizzle.team/docs/guides/mysql-local-setup
This command starts a MySQL container named 'drizzle-mysql' in detached mode. It sets the root password, maps port 3306 on the host to the container's port 3306 for external access, and uses the 'mysql' image. Optional environment variables can create databases and users upon container creation.
docker run --name drizzle-mysql -e MYSQL_ROOT_PASSWORD=mypassword -d -p 3306:3306 mysqldocker ps--------------------------------
Initialize Supabase Project
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-supabase-edge-functions
Initializes a new Supabase project locally. This command creates a 'supabase' folder containing configuration files for your Supabase project.
supabase init--------------------------------
Install Drizzle ORM and PostgreSQL Dependencies (pnpm)
Source: https://orm.drizzle.team/docs/get-started/nile-new
Installs the core Drizzle ORM package, the 'pg' driver for PostgreSQL, 'dotenv' for environment variables, and development dependencies like 'drizzle-kit', 'tsx', and '@types/pg' using pnpm.
pnpm add drizzle-orm pg dotenv
pnpm add -D drizzle-kit tsx @types/pg--------------------------------
Set up Bun:SQLite Database Connection Variable
Source: https://orm.drizzle.team/docs/get-started/bun-sqlite-new
Defines the database file name for Bun:SQLite in the .env file. This variable is used to configure the database connection string for Drizzle ORM.
DB_FILE_NAME=mydb.sqlite--------------------------------
Install Neon Serverless Driver
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-neon
Installs the Neon serverless driver, which is required for connecting Drizzle ORM to a Neon Postgres database. Supports multiple package managers.
npm i @neondatabase/serverlessyarn add @neondatabase/serverlesspnpm add @neondatabase/serverlessbun add @neondatabase/serverless--------------------------------
Install Express Package
Source: https://orm.drizzle.team/docs/tutorials/drizzle-with-nile
Installs the 'express' package, a minimal and flexible Node.js web application framework, using common package managers.
npm i expressyarn add expresspnpm add expressbun add express--------------------------------
Drizzle Configuration File
Source: https://orm.drizzle.team/docs/get-started/vercel-new
Sets up the drizzle.config.ts file, which Drizzle Kit uses for database operations. It specifies the migration output directory (out), schema file location (schema), database dialect (dialect), and credentials (including the POSTGRES_URL from environment variables).
import 'dotenv/config';
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
out: './drizzle',
schema: './src/db/schema.ts',
dialect: 'postgresql',
dbCredentials: {
url: process.env.POSTGRES_URL!,
},
});--------------------------------
Initialize Drizzle ORM Database Connection in TypeScript
Source: https://orm.drizzle.team/docs/get-started/gel-new
This snippet demonstrates how to initialize a connection to your database using Drizzle ORM and a 'gel' client. It requires the 'drizzle-orm/gel' and 'gel' packages. The output is a configured Drizzle database instance.
import { drizzle } from "drizzle-orm/gel";
import { createClient } from "gel";
const gelClient = createClient();
const db = drizzle({ client: gelClient });--------------------------------
Install Drizzle ORM and Drizzle Kit with bun
Source: https://orm.drizzle.team/docs/connect-bun-sqlite
Installs Drizzle ORM and Drizzle Kit using the Bun runtime. Bun provides a fast alternative for package installation and JavaScript execution.
bun add drizzle-orm
bun add -D drizzle-kit--------------------------------
Initialize SingleStore driver with connection options
Source: https://orm.drizzle.team/docs/get-started-singlestore
Initializes the Drizzle ORM driver for SingleStore by providing connection options, including the database URI, and shows a sample query.
import { drizzle } from "drizzle-orm/singlestore";
// You can specify any property from the mysql2 connection options
const db = drizzle({ connection:{ uri: process.env.DATABASE_URL }});
const response = await db.select().from(...)--------------------------------
Initialize Drizzle ORM Connection (Supabase Pool Mode)
Source: https://orm.drizzle.team/docs/get-started/supabase-new
Initializes a Drizzle ORM connection for Supabase with 'Transaction' pool mode enabled, disabling 'prepare' as it's not supported in this configuration.
import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'
async function main() {
// Disable prefetch as it is not supported for "Transaction" pool mode
const client = postgres(process.env.DATABASE_URL, { prepare: false })
const db = drizzle({ client });
}
main();--------------------------------
Pull PostgreSQL Docker Image
Source: https://orm.drizzle.team/docs/guides/postgresql-local-setup
This command fetches the latest PostgreSQL Docker image from Docker Hub. You can also specify a particular version using tags, for example, postgres:15.
docker pull postgresdocker pull postgres:15--------------------------------
Install Drizzle ORM and PostgreSQL Dependencies (yarn)
Source: https://orm.drizzle.team/docs/get-started/nile-new
Installs the core Drizzle ORM package, the 'pg' driver for PostgreSQL, 'dotenv' for environment variables, and development dependencies like 'drizzle-kit', 'tsx', and '@types/pg' using yarn.
yarn add drizzle-orm pg dotenv
yarn add -D drizzle-kit tsx @types/pgDrizzle Migrations
Database migration patterns for NestJS with Drizzle ORM.
Generating Migrations
npx drizzle-kit generateRunning Migrations
// 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;
}
}
}Migration Best Practices
1. Always backup before migrating - Protect production data 2. Test migrations locally first - Catch issues early 3. Make migrations reversible - Use down migrations when possible 4. Keep migrations small - Easier to debug and rollback 5. Version control migrations - Track schema changes in git
NestJS Patterns
Detailed code patterns for NestJS development with Drizzle ORM.
Core Architecture
Module Structure
import { Module } from '@nestjs/common';
@Module({
imports: [/* other modules */],
controllers: [/* controllers */],
providers: [/* providers */],
exports: [/* exported providers */],
})
export class FeatureModule {}Controller Pattern
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
import { Injectable } from '@nestjs/common';
@Injectable()
export class UsersService {
constructor(/* inject dependencies */) {}
findAll() {
return 'Users service logic';
}
}Database Integration with Drizzle
Installation
# 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/pgConfiguration
// 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
// 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
// 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
// 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
// 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
// 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
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
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
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
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,
});
}
}Configuration Management
Environment Configuration
// 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
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
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
// 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
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);
}
}Common Patterns with Drizzle
Transactions
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
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
async getUsersWithPosts() {
return this.db.database
.select()
.from(users)
.leftJoin(posts, eq(posts.userId, users.id));
}NestJS Framework Documentation
NestJS is a progressive Node.js framework for building efficient, reliable and scalable server-side applications. Built with TypeScript and fully supporting both TypeScript and JavaScript, it combines elements of Object Oriented Programming (OOP), Functional Programming (FP), and Functional Reactive Programming (FRP). Under the hood, NestJS uses robust HTTP server frameworks like Express (default) or Fastify, providing a level of abstraction while exposing their APIs directly to developers.
The framework provides an out-of-the-box application architecture inspired by Angular, enabling developers to create highly testable, scalable, loosely coupled, and maintainable applications. NestJS leverages dependency injection, decorators, modules, guards, interceptors, and pipes to organize code effectively. It supports multiple transport layers for microservices, integrates seamlessly with databases through TypeORM and Sequelize, and provides first-class support for GraphQL and OpenAPI documentation.
Core Building Blocks
Creating a Basic Application
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(process.env.PORT ?? 3000);
}
bootstrap();Controllers - HTTP Request Handling
import { Controller, Get, Post, Put, Delete, Body, Param, Query } from '@nestjs/common';
import { CreateCatDto, UpdateCatDto } from './dto';
import { CatsService } from './cats.service';
@Controller('cats')
export class CatsController {
constructor(private catsService: CatsService) {}
@Post()
async create(@Body() createCatDto: CreateCatDto) {
this.catsService.create(createCatDto);
return { message: 'Cat created successfully' };
}
@Get()
async findAll(@Query('age') age?: number, @Query('breed') breed?: string) {
return this.catsService.findAll({ age, breed });
}
@Get(':id')
async findOne(@Param('id') id: string) {
return this.catsService.findOne(id);
}
@Put(':id')
async update(@Param('id') id: string, @Body() updateCatDto: UpdateCatDto) {
return this.catsService.update(id, updateCatDto);
}
@Delete(':id')
async remove(@Param('id') id: string) {
await this.catsService.remove(id);
return { message: 'Cat removed successfully' };
}
}Providers - Business Logic and Services
import { Injectable } from '@nestjs/common';
import { Cat } from './interfaces/cat.interface';
@Injectable()
export class CatsService {
private readonly cats: Cat[] = [];
create(cat: Cat): void {
this.cats.push(cat);
}
findAll(filter?: { age?: number; breed?: string }): Cat[] {
if (!filter) return this.cats;
return this.cats.filter(cat => {
if (filter.age && cat.age !== filter.age) return false;
if (filter.breed && cat.breed !== filter.breed) return false;
return true;
});
}
findOne(id: string): Cat | undefined {
return this.cats.find(cat => cat.id === id);
}
update(id: string, updateData: Partial): Cat {
const catIndex = this.cats.findIndex(cat => cat.id === id);
if (catIndex === -1) throw new Error('Cat not found');
this.cats[catIndex] = { ...this.cats[catIndex], ...updateData };
return this.cats[catIndex];
}
remove(id: string): void {
const catIndex = this.cats.findIndex(cat => cat.id === id);
if (catIndex === -1) throw new Error('Cat not found');
this.cats.splice(catIndex, 1);
}
}Modules - Application Organization
import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
@Module({
controllers: [CatsController],
providers: [CatsService],
exports: [CatsService], // Make service available to other modules
})
export class CatsModule {}
// Root module
import { Module } from '@nestjs/common';
import { CatsModule } from './cats/cats.module';
import { DogsModule } from './dogs/dogs.module';
@Module({
imports: [CatsModule, DogsModule],
})
export class AppModule {}Middleware
Class-Based Middleware
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
use(req: Request, res: Response, next: NextFunction) {
console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
next();
}
}
// Apply in module
import { Module, NestModule, MiddlewareConsumer, RequestMethod } from '@nestjs/common';
@Module({
imports: [CatsModule],
})
export class AppModule implements NestModule {
configure(consumer: MiddlewareConsumer) {
consumer
.apply(LoggerMiddleware)
.exclude(
{ path: 'cats', method: RequestMethod.GET },
'cats/{*splat}',
)
.forRoutes(CatsController);
}
}Functional Middleware
import { Request, Response, NextFunction } from 'express';
export function logger(req: Request, res: Response, next: NextFunction) {
console.log(`Request...`);
next();
}
// Apply in module
consumer.apply(logger).forRoutes(CatsController);
// Global middleware
const app = await NestFactory.create(AppModule);
app.use(logger);
await app.listen(3000);Exception Filters
Built-in Exception Handling
import { Controller, Get, Post, Body, HttpException, HttpStatus } from '@nestjs/common';
@Controller('cats')
export class CatsController {
@Get()
async findAll() {
throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
}
@Post()
async create(@Body() createCatDto: CreateCatDto) {
throw new HttpException({
status: HttpStatus.FORBIDDEN,
error: 'This is a custom message',
}, HttpStatus.FORBIDDEN);
}
}Custom Exception Filter
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();
const request = ctx.getRequest();
const status = exception.getStatus();
response.status(status).json({
statusCode: status,
timestamp: new Date().toISOString(),
path: request.url,
message: exception.message,
});
}
}
// Apply to controller or method
import { UseFilters } from '@nestjs/common';
@Post()
@UseFilters(new HttpExceptionFilter())
async create(@Body() createCatDto: CreateCatDto) {
throw new ForbiddenException();
}
// Global exception filter
const app = await NestFactory.create(AppModule);
app.useGlobalFilters(new HttpExceptionFilter());
// Global with dependency injection
@Module({
providers: [
{
provide: APP_FILTER,
useClass: HttpExceptionFilter,
},
],
})
export class AppModule {}Catch-All Exception Filter
import { Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common';
import { HttpAdapterHost } from '@nestjs/core';
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
constructor(private readonly httpAdapterHost: HttpAdapterHost) {}
catch(exception: unknown, host: ArgumentsHost): void {
const { httpAdapter } = this.httpAdapterHost;
const ctx = host.switchToHttp();
const httpStatus = exception instanceof HttpException
? exception.getStatus()
: HttpStatus.INTERNAL_SERVER_ERROR;
const responseBody = {
statusCode: httpStatus,
timestamp: new Date().toISOString(),
path: httpAdapter.getRequestUrl(ctx.getRequest()),
message: exception instanceof Error ? exception.message : 'Internal server error',
};
httpAdapter.reply(ctx.getResponse(), responseBody, httpStatus);
}
}Pipes
Built-in Transformation Pipes
import { Controller, Get, Param, Query, ParseIntPipe, ParseUUIDPipe } from '@nestjs/common';
@Controller('cats')
export class CatsController {
@Get(':id')
async findOne(@Param('id', ParseIntPipe) id: number) {
return this.catsService.findOne(id);
}
@Get('user/:uuid')
async findByUser(@Param('uuid', ParseUUIDPipe) uuid: string) {
return this.catsService.findByUser(uuid);
}
@Get()
async findAll(@Query('page', ParseIntPipe) page: number) {
return this.catsService.findAll(page);
}
}Validation Pipe with class-validator
import { IsString, IsInt, Min, Max } from 'class-validator';
export class CreateCatDto {
@IsString()
name: string;
@IsInt()
@Min(0)
@Max(30)
age: number;
@IsString()
breed: string;
}
// Apply validation pipe
import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';
@Controller('cats')
export class CatsController {
@Post()
@UsePipes(new ValidationPipe())
async create(@Body() createCatDto: CreateCatDto) {
return this.catsService.create(createCatDto);
}
}
// Global validation pipe
async function bootstrap() {
const app = await NestFactory.create(AppModule);
app.useGlobalPipes(new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
}));
await app.listen(3000);
}
// With dependency injection
@Module({
providers: [
{
provide: APP_PIPE,
useClass: ValidationPipe,
},
],
})
export class AppModule {}Custom Transformation Pipe
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';
@Injectable()
export class ParseIntPipe implements PipeTransform {
transform(value: string, metadata: ArgumentMetadata): number {
const val = parseInt(value, 10);
if (isNaN(val)) {
throw new BadRequestException('Validation failed (numeric string is expected)');
}
return val;
}
}
@Get(':id')
async findOne(@Param('id', new ParseIntPipe()) id: number) {
return this.catsService.findOne(id);
}Schema Validation with Zod
import { PipeTransform, ArgumentMetadata, BadRequestException } from '@nestjs/common';
import { ZodSchema } from 'zod';
export class ZodValidationPipe implements PipeTransform {
constructor(private schema: ZodSchema) {}
transform(value: unknown, metadata: ArgumentMetadata) {
try {
const parsedValue = this.schema.parse(value);
return parsedValue;
} catch (error) {
throw new BadRequestException('Validation failed');
}
}
}
// Define schema
import { z } from 'zod';
export const createCatSchema = z.object({
name: z.string(),
age: z.number().min(0).max(30),
breed: z.string(),
}).required();
export type CreateCatDto = z.infer;
// Use in controller
@Post()
@UsePipes(new ZodValidationPipe(createCatSchema))
async create(@Body() createCatDto: CreateCatDto) {
return this.catsService.create(createCatDto);
}Guards
Authentication Guard
import { Injectable, CanActivate, ExecutionContext, UnauthorizedException } from '@nestjs/common';
import { Observable } from 'rxjs';
@Injectable()
export class AuthGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean | Promise | Observable {
const request = context.switchToHttp().getRequest();
const token = request.headers.authorization;
if (!token) {
throw new UnauthorizedException('No token provided');
}
try {
// Validate token logic here
const user = this.validateToken(token);
request.user = user;
return true;
} catch (error) {
throw new UnauthorizedException('Invalid token');
}
}
private validateToken(token: string) {
// Token validation logic
return { id: '123', username: 'john' };
}
}
// Apply guard
import { Controller, Get, UseGuards } from '@nestjs/common';
@Controller('cats')
@UseGuards(AuthGuard)
export class CatsController {
@Get()
findAll() {
return this.catsService.findAll();
}
}Role-Based Authorization Guard
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
// Custom decorator
export const Roles = Reflector.createDecorator();
@Injectable()
export class RolesGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(context: ExecutionContext): boolean {
const roles = this.reflector.get(Roles, context.getHandler());
if (!roles) {
return true;
}
const request = context.switchToHttp().getRequest();
const user = request.user;
return this.matchRoles(roles, user.roles);
}
private matchRoles(requiredRoles: string[], userRoles: string[]): boolean {
return requiredRoles.some(role => userRoles.includes(role));
}
}
// Use in controller
@Post()
@Roles(['admin'])
@UseGuards(RolesGuard)
async create(@Body() createCatDto: CreateCatDto) {
return this.catsService.create(createCatDto);
}
// Global guard with DI
@Module({
providers: [
{
provide: APP_GUARD,
useClass: RolesGuard,
},
],
})
export class AppModule {}Interceptors
Logging Interceptor
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 {
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} - Completed in ${Date.now() - now}ms`);
}),
);
}
}
@UseInterceptors(LoggingInterceptor)
@Controller('cats')
export class CatsController {}Response Transformation Interceptor
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
export interface Response {
data: T;
timestamp: string;
path: string;
}
@Injectable()
export class TransformInterceptor implements NestInterceptor> {
intercept(context: ExecutionContext, next: CallHandler): Observable> {
const request = context.switchToHttp().getRequest();
return next.handle().pipe(
map(data => ({
data,
timestamp: new Date().toISOString(),
path: request.url,
})),
);
}
}
// Result: GET /cats returns { data: [...], timestamp: "...", path: "/cats" }Cache Interceptor
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable, of } from 'rxjs';
@Injectable()
export class CacheInterceptor implements NestInterceptor {
private cache = new Map();
intercept(context: ExecutionContext, next: CallHandler): Observable {
const request = context.switchToHttp().getRequest();
const cacheKey = `${request.method}:${request.url}`;
if (this.cache.has(cacheKey)) {
console.log('Returning cached response');
return of(this.cache.get(cacheKey));
}
return next.handle().pipe(
tap(response => {
this.cache.set(cacheKey, response);
}),
);
}
}Timeout Interceptor
import { Injectable, NestInterceptor, ExecutionContext, CallHandler, RequestTimeoutException } from '@nestjs/common';
import { Observable, throwError, TimeoutError } from 'rxjs';
import { catchError, timeout } from 'rxjs/operators';
@Injectable()
export class TimeoutInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable {
return next.handle().pipe(
timeout(5000),
catchError(err => {
if (err instanceof TimeoutError) {
return throwError(() => new RequestTimeoutException('Request timeout'));
}
return throwError(() => err);
}),
);
}
}Dependency Injection
Constructor Injection
@Injectable()
export class CatsService {
constructor(
private readonly dogsService: DogsService,
private readonly configService: ConfigService,
) {}
async findAll() {
const config = this.configService.get('database');
return this.catsRepository.find();
}
}Custom Provider with Token
const CONNECTION = 'DATABASE_CONNECTION';
@Module({
providers: [
{
provide: CONNECTION,
useValue: {
host: 'localhost',
port: 5432,
database: 'test',
},
},
],
})
export class DatabaseModule {}
// Inject custom provider
@Injectable()
export class CatsRepository {
constructor(@Inject(CONNECTION) private connection: any) {}
}Factory Provider
@Module({
providers: [
{
provide: 'DATABASE_CONNECTION',
useFactory: async (configService: ConfigService) => {
const config = configService.get('database');
const connection = await createConnection(config);
return connection;
},
inject: [ConfigService],
},
],
})
export class DatabaseModule {}Async Provider
@Module({
providers: [
{
provide: 'ASYNC_CONNECTION',
useFactory: async () => {
const connection = await createAsyncConnection();
return connection;
},
},
],
})
export class AppModule {}Class Provider with Conditional Logic
const configServiceProvider = {
provide: ConfigService,
useClass: process.env.NODE_ENV === 'development'
? DevelopmentConfigService
: ProductionConfigService,
};
@Module({
providers: [configServiceProvider],
})
export class AppModule {}Database Integration
TypeORM Setup
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
@Module({
imports: [
TypeOrmModule.forRoot({
type: 'postgres',
host: 'localhost',
port: 5432,
username: 'postgres',
password: 'password',
database: 'nest_db',
entities: [__dirname + '/**/*.entity{.ts,.js}'],
synchronize: true, // Don't use in production
logging: true,
}),
],
})
export class AppModule {}Entity Definition
import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToMany } from 'typeorm';
import { Photo } from '../photos/photo.entity';
@Entity('users')
export class User {
@PrimaryGeneratedColumn('uuid')
id: string;
@Column({ unique: true })
email: string;
@Column()
firstName: string;
@Column()
lastName: string;
@Column({ default: true })
isActive: boolean;
@CreateDateColumn()
createdAt: Date;
@UpdateDateColumn()
updatedAt: Date;
@OneToMany(() => Photo, photo => photo.user)
photos: Photo[];
}Repository Pattern
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';
@Injectable()
export class UsersService {
constructor(
@InjectRepository(User)
private usersRepository: Repository,
) {}
async findAll(): Promise {
return this.usersRepository.find({ relations: ['photos'] });
}
async findOne(id: string): Promise {
const user = await this.usersRepository.findOne({
where: { id },
relations: ['photos'],
});
if (!user) throw new NotFoundException('User not found');
return user;
}
async create(userData: CreateUserDto): Promise {
const user = this.usersRepository.create(userData);
return this.usersRepository.save(user);
}
async update(id: string, updateData: UpdateUserDto): Promise {
await this.usersRepository.update(id, updateData);
return this.findOne(id);
}
async remove(id: string): Promise {
const result = await this.usersRepository.delete(id);
if (result.affected === 0) {
throw new NotFoundException('User not found');
}
}
}
@Module({
imports: [TypeOrmModule.forFeature([User])],
providers: [UsersService],
controllers: [UsersController],
exports: [UsersService],
})
export class UsersModule {}Database Transactions
import { DataSource } from 'typeorm';
@Injectable()
export class UsersService {
constructor(
@InjectRepository(User) private usersRepository: Repository,
private dataSource: DataSource,
) {}
async createUserWithPhotos(userData: CreateUserDto, photos: CreatePhotoDto[]) {
const queryRunner = this.dataSource.createQueryRunner();
await queryRunner.connect();
await queryRunner.startTransaction();
try {
const user = await queryRunner.manager.save(User, userData);
for (const photoData of photos) {
await queryRunner.manager.save(Photo, { ...photoData, user });
}
await queryRunner.commitTransaction();
return user;
} catch (err) {
await queryRunner.rollbackTransaction();
throw err;
} finally {
await queryRunner.release();
}
}
}Async Configuration
TypeOrmModule.forRootAsync({
imports: [ConfigModule],
useFactory: (configService: ConfigService) => ({
type: 'postgres',
host: configService.get('DB_HOST'),
port: configService.get('DB_PORT'),
username: configService.get('DB_USERNAME'),
password: configService.get('DB_PASSWORD'),
database: configService.get('DB_NAME'),
entities: [__dirname + '/**/*.entity{.ts,.js}'],
synchronize: configService.get('DB_SYNC') === 'true',
}),
inject: [ConfigService],
})Testing
Unit Testing with Mocks
import { Test, TestingModule } from '@nestjs/testing';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
describe('CatsController', () => {
let catsController: CatsController;
let catsService: CatsService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
controllers: [CatsController],
providers: [CatsService],
}).compile();
catsService = module.get(CatsService);
catsController = module.get(CatsController);
});
describe('findAll', () => {
it('should return an array of cats', async () => {
const result = [{ name: 'Test Cat', age: 2, breed: 'Persian' }];
jest.spyOn(catsService, 'findAll').mockImplementation(() => Promise.resolve(result));
expect(await catsController.findAll()).toBe(result);
});
});
describe('create', () => {
it('should create a cat', async () => {
const catDto = { name: 'New Cat', age: 1, breed: 'Siamese' };
jest.spyOn(catsService, 'create').mockImplementation(() => Promise.resolve(catDto));
expect(await catsController.create(catDto)).toEqual(catDto);
});
});
});Testing with Provider Override
describe('CatsController', () => {
let controller: CatsController;
const mockCatsService = {
findAll: jest.fn(() => [{ name: 'Test', age: 2, breed: 'Persian' }]),
findOne: jest.fn((id) => ({ id, name: 'Test', age: 2, breed: 'Persian' })),
create: jest.fn((dto) => ({ id: '123', ...dto })),
};
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
controllers: [CatsController],
providers: [CatsService],
})
.overrideProvider(CatsService)
.useValue(mockCatsService)
.compile();
controller = module.get(CatsController);
});
it('should be defined', () => {
expect(controller).toBeDefined();
});
});End-to-End Testing
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';
describe('CatsController (e2e)', () => {
let app: INestApplication;
beforeAll(async () => {
const moduleFixture: TestingModule = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = moduleFixture.createNestApplication();
await app.init();
});
afterAll(async () => {
await app.close();
});
it('/cats (GET)', () => {
return request(app.getHttpServer())
.get('/cats')
.expect(200)
.expect((res) => {
expect(Array.isArray(res.body)).toBe(true);
});
});
it('/cats (POST)', () => {
return request(app.getHttpServer())
.post('/cats')
.send({ name: 'Test Cat', age: 2, breed: 'Persian' })
.expect(201)
.expect((res) => {
expect(res.body).toHaveProperty('id');
expect(res.body.name).toBe('Test Cat');
});
});
it('/cats/:id (GET)', () => {
return request(app.getHttpServer())
.get('/cats/123')
.expect(200)
.expect((res) => {
expect(res.body).toHaveProperty('id', '123');
});
});
});Testing with Repository Mocks
describe('UsersService', () => {
let service: UsersService;
let repository: Repository;
const mockRepository = {
find: jest.fn(),
findOne: jest.fn(),
create: jest.fn(),
save: jest.fn(),
update: jest.fn(),
delete: jest.fn(),
};
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
UsersService,
{
provide: getRepositoryToken(User),
useValue: mockRepository,
},
],
}).compile();
service = module.get(UsersService);
repository = module.get>(getRepositoryToken(User));
});
it('should find all users', async () => {
const users = [{ id: '1', email: 'test@example.com' }];
mockRepository.find.mockResolvedValue(users);
expect(await service.findAll()).toEqual(users);
expect(repository.find).toHaveBeenCalled();
});
});Microservices
TCP Microservice Setup
import { NestFactory } from '@nestjs/core';
import { Transport, MicroserviceOptions } from '@nestjs/microservices';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.createMicroservice(
AppModule,
{
transport: Transport.TCP,
options: {
host: '127.0.0.1',
port: 8877,
},
},
);
await app.listen();
}
bootstrap();Message Pattern Handler
import { Controller } from '@nestjs/common';
import { MessagePattern, Payload, Ctx, NatsContext } from '@nestjs/microservices';
@Controller()
export class MathController {
@MessagePattern({ cmd: 'sum' })
accumulate(@Payload() data: number[]): number {
return (data || []).reduce((a, b) => a + b, 0);
}
@MessagePattern({ cmd: 'multiply' })
multiply(@Payload() data: { a: number; b: number }): number {
return data.a * data.b;
}
}Event Pattern Handler
@Controller()
export class NotificationsController {
@EventPattern('user_created')
async handleUserCreated(@Payload() data: CreateUserEvent) {
console.log('New user created:', data);
// Send welcome email
await this.emailService.sendWelcome(data.email);
}
@EventPattern('order_placed')
async handleOrderPlaced(@Payload() data: OrderPlacedEvent) {
console.log('Order placed:', data);
// Process order
await this.orderService.process(data);
}
}Microservice Client
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
@Module({
imports: [
ClientsModule.register([
{
name: 'MATH_SERVICE',
transport: Transport.TCP,
options: {
host: '127.0.0.1',
port: 8877,
},
},
]),
],
controllers: [AppController],
})
export class AppModule {}
// Use in controller
import { Controller, Get, Inject } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
import { Observable } from 'rxjs';
@Controller()
export class AppController {
constructor(@Inject('MATH_SERVICE') private client: ClientProxy) {}
@Get('sum')
accumulate(): Observable {
const pattern = { cmd: 'sum' };
const payload = [1, 2, 3, 4, 5];
return this.client.send(pattern, payload);
}
@Get('notify')
async notify() {
this.client.emit('user_created', { id: '123', email: 'user@example.com' });
return { message: 'Notification sent' };
}
}Redis Transport
// Microservice
const app = await NestFactory.createMicroservice(
AppModule,
{
transport: Transport.REDIS,
options: {
host: 'localhost',
port: 6379,
},
},
);
// Client
ClientsModule.register([
{
name: 'REDIS_SERVICE',
transport: Transport.REDIS,
options: {
host: 'localhost',
port: 6379,
},
},
])GraphQL
Apollo GraphQL Setup
import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { join } from 'path';
@Module({
imports: [
GraphQLModule.forRoot({
driver: ApolloDriver,
autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
sortSchema: true,
playground: true,
}),
],
})
export class AppModule {}GraphQL Resolvers (Code First)
import { Resolver, Query, Mutation, Args, ID } from '@nestjs/graphql';
import { ObjectType, Field, Int } from '@nestjs/graphql';
@ObjectType()
export class Cat {
@Field(() => ID)
id: string;
@Field()
name: string;
@Field(() => Int)
age: number;
@Field()
breed: string;
}
@Resolver(() => Cat)
export class CatsResolver {
constructor(private catsService: CatsService) {}
@Query(() => [Cat], { name: 'cats' })
async findAll() {
return this.catsService.findAll();
}
@Query(() => Cat, { name: 'cat' })
async findOne(@Args('id', { type: () => ID }) id: string) {
return this.catsService.findOne(id);
}
@Mutation(() => Cat)
async createCat(
@Args('name') name: string,
@Args('age', { type: () => Int }) age: number,
@Args('breed') breed: string,
) {
return this.catsService.create({ name, age, breed });
}
@Mutation(() => Boolean)
async removeCat(@Args('id', { type: () => ID }) id: string) {
await this.catsService.remove(id);
return true;
}
}GraphQL Input Types
import { InputType, Field, Int } from '@nestjs/graphql';
@InputType()
export class CreateCatInput {
@Field()
name: string;
@Field(() => Int)
age: number;
@Field()
breed: string;
}
@Mutation(() => Cat)
async createCat(@Args('input') input: CreateCatInput) {
return this.catsService.create(input);
}OpenAPI/Swagger Documentation
Basic Swagger Setup
import { NestFactory } from '@nestjs/core';
import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
const config = new DocumentBuilder()
.setTitle('Cats API')
.setDescription('The cats API documentation')
.setVersion('1.0')
.addTag('cats')
.addBearerAuth()
.build();
const documentFactory = () => SwaggerModule.createDocument(app, config);
SwaggerModule.setup('api', app, documentFactory);
await app.listen(3000);
}
bootstrap();
// Access at http://localhost:3000/apiAPI Decorators
import { ApiTags, ApiOperation, ApiResponse, ApiProperty, ApiBearerAuth } from '@nestjs/swagger';
export class CreateCatDto {
@ApiProperty({ example: 'Fluffy', description: 'The name of the cat' })
name: string;
@ApiProperty({ example: 3, description: 'The age of the cat' })
age: number;
@ApiProperty({ example: 'Persian', description: 'The breed of the cat' })
breed: string;
}
@ApiTags('cats')
@Controller('cats')
export class CatsController {
@Post()
@ApiOperation({ summary: 'Create a new cat' })
@ApiResponse({ status: 201, description: 'The cat has been successfully created.', type: Cat })
@ApiResponse({ status: 400, description: 'Bad Request.' })
@ApiBearerAuth()
async create(@Body() createCatDto: CreateCatDto) {
return this.catsService.create(createCatDto);
}
@Get()
@ApiOperation({ summary: 'Get all cats' })
@ApiResponse({ status: 200, description: 'Return all cats.', type: [Cat] })
async findAll() {
return this.catsService.findAll();
}
}Configuration
Environment Configuration
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true,
envFilePath: ['.env.local', '.env'],
ignoreEnvFile: process.env.NODE_ENV === 'production',
}),
],
})
export class AppModule {}
// Use in service
@Injectable()
export class AppService {
constructor(private configService: ConfigService) {}
getDatabaseConfig() {
return {
host: this.configService.get('DB_HOST'),
port: this.configService.get('DB_PORT'),
};
}
}Custom Configuration Files
export default () => ({
port: parseInt(process.env.PORT, 10) || 3000,
database: {
host: process.env.DATABASE_HOST || 'localhost',
port: parseInt(process.env.DATABASE_PORT, 10) || 5432,
username: process.env.DATABASE_USERNAME,
password: process.env.DATABASE_PASSWORD,
},
jwt: {
secret: process.env.JWT_SECRET,
expiresIn: '7d',
},
});
// Import in module
import configuration from './config/configuration';
@Module({
imports: [
ConfigModule.forRoot({
load: [configuration],
}),
],
})
export class AppModule {}
// Access nested config
const dbHost = this.configService.get('database.host');Summary
NestJS provides a comprehensive framework for building scalable server-side applications with a focus on maintainability and testability. The framework's modular architecture, combined with dependency injection and decorators, enables developers to structure applications effectively. Core building blocks include controllers for handling HTTP requests, providers for business logic, modules for organization, and middleware for request processing. Advanced features like guards, interceptors, and pipes enable cross-cutting concerns such as authentication, logging, validation, and transformation.
The framework excels in enterprise applications through its support for microservices architecture with multiple transport layers, database integration via TypeORM and Sequelize, GraphQL API development, and comprehensive testing utilities. NestJS's decorator-based approach and TypeScript support provide excellent developer experience with type safety and IDE integration. The framework's extensibility allows integration with various libraries and tools while maintaining clean architecture principles. Whether building REST APIs, GraphQL servers, microservices, or WebSocket applications, NestJS provides the tools and patterns needed for production-ready applications with proper error handling, validation, logging, and documentation through OpenAPI/Swagger integration.
NestJS Testing Patterns
Unit and E2E testing patterns for NestJS applications with Drizzle ORM.
Unit Testing Services
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
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-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 migrate(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);
});
});
});Testing Best Practices
1. Mock external dependencies - Use Jest mocks for repositories and services 2. Clean database between tests - Use beforeEach to reset state 3. Run migrations in E2E tests - Ensures schema is up to date 4. Test edge cases - Error scenarios and validation failures 5. Use supertest for HTTP assertions - Clean API for testing endpoints
NestJS Skill Workflow Optimization Guide
Overview
This document outlines optimized workflows for building NestJS applications with Drizzle ORM by leveraging parallel execution, subagent delegation, and dependency management strategies.
Key Optimization Principles
1. Parallel Execution Strategy
Tasks that can be executed simultaneously:
- Package Installation: Install NestJS, Drizzle, testing, and development dependencies in parallel
- Module Scaffolding: Create folder structures for multiple modules concurrently
- Interface/Type Definition: Define DTOs and interfaces while setting up database schemas
- Test Preparation: Set up test configuration while writing implementation code
2. Sequential Dependencies
Tasks that must follow a specific order: 1. Project Setup: npm install → nest new → cd project → install additional packages 2. Database Setup: .env → drizzle.config.ts → schema → migrations → database service → repositories 3. Feature Development: DTOs → Repository → Service → Controller → Module → Guards 4. Testing: Unit tests → Integration tests → E2E tests
Optimized Workflow Examples
Workflow 1: New NestJS Project with Drizzle ORM
Phase 1: Parallel Setup (Agents: 2-3)
Agent 1: Project Initialization
- Create NestJS project
- Install core dependencies
- Configure TypeScript
- Set up basic folder structure
Agent 2: Database Preparation
- Install Drizzle packages
- Configure environment files
- Set up drizzle.config.ts
- Prepare database connection
Phase 2: Core Configuration (Sequential)
- Database schema definition
- Migration generation
- Database service setup
Phase 3: Parallel Feature Development (Agents: 2-4)
Agent 1: Data Layer
- Repository implementation
- Service layer logic
- Unit tests for data layer
Agent 2: API Layer
- Controller implementation
- DTOs and validation
- Route protection
Agent 3: Security
- Authentication setup
- Guards implementation
- Security middleware
Agent 4: Documentation
- OpenAPI decorators
- API documentation
- README generation
Phase 4: Integration & Testing (Parallel)
- Integration tests
- E2E test scenarios
- Performance optimizationWorkflow 2: Adding New Feature Module
Step 1: Parallel Preparation
- Define feature requirements
- Create module folder structure
- Prepare DTOs and interfaces
- Set up test files
Step 2: Data Layer (Database Agent)
- Create/update schema
- Generate migrations
- Implement repository
- Write repository tests
Step 3: Business Logic (Service Agent)
- Implement service methods
- Add business validation
- Handle transactions
- Write unit tests
Step 4: API Layer (Controller Agent)
- Create controller endpoints
- Add validation pipes
- Implement guards
- Write integration tests
Step 5: Security Integration (Security Agent)
- Add route protection
- Implement role-based access
- Add audit logging
- Security tests
Step 6: Documentation (Documentation Agent)
- Add OpenAPI decorators
- Update API docs
- Create examples
- Review documentationSubagent Delegation Patterns
When to Delegate to Database Agent
- Setting up new database connections
- Complex schema migrations
- Query optimization
- Transaction management
- Database testing setup
When to Delegate to Security Agent
- Implementing authentication
- Setting up authorization
- Security audit requirements
- OAuth integration
- Vulnerability fixes
When to Delegate to Testing Agent
- Comprehensive test suite creation
- Test infrastructure setup
- CI/CD test integration
- Performance testing
- Test data management
Best Practices for Optimization
1. Dependency Management
// Use async configuration for parallel setup
@Module({
imports: [
ConfigModule.forRoot({ isGlobal: true }),
DatabaseModule,
AuthModule,
],
})
export class AppModule {}2. Modular Architecture
// Keep modules independent for parallel development
@Module({
imports: [DatabaseModule],
controllers: [UsersController],
providers: [UsersService, UsersRepository],
exports: [UsersService],
})
export class UsersModule {}3. Configuration-Driven Development
// Enable environment-specific parallel development
export default () => ({
database: {
url: process.env.DATABASE_URL,
poolSize: parseInt(process.env.DB_POOL_SIZE) || 10,
},
features: {
auth: process.env.ENABLE_AUTH === 'true',
caching: process.env.ENABLE_CACHE === 'true',
},
});4. Test-Driven Parallel Development
// Write tests alongside implementation
describe('UsersService', () => {
// Test setup can run in parallel with service implementation
beforeEach(async () => {
const module = await Test.createTestingModule({
providers: [UsersService, MockRepository],
}).compile();
});
});Performance Optimization Techniques
1. Database Optimizations
- Use connection pooling
- Implement query batching
- Add proper indexes
- Use database transactions wisely
2. API Optimizations
- Implement caching strategies
- Use pagination
- Add compression middleware
- Optimize serialization
3. Testing Optimizations
- Parallel test execution
- Test database reuse
- Mock external services
- Selective test runs
Monitoring and Feedback
1. Workflow Metrics
- Track time spent in each phase
- Measure parallel execution efficiency
- Monitor bottlenecks
- Collect agent performance data
2. Quality Gates
- Code reviews before merging
- Automated testing
- Security scans
- Performance benchmarks
Conclusion
By following these optimized workflows and leveraging specialized subagents, NestJS development with Drizzle ORM can be significantly accelerated while maintaining high code quality and architectural integrity. The key is understanding task dependencies, maximizing parallel execution, and delegating specialized work to expert subagents.
Related skills
Forks & variants (1)
Nestjs has 1 known copy in the catalog totaling 26 installs. They canonicalize to this original listing.
- giuseppe-trisciuoglio - 26 installs
How it compares
Use nestjs for opinionated NestJS module and security conventions rather than generic TypeScript style guides.
FAQ
What is nestjs?
Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applications. Generates REST/GraphQL APIs, implements authentication
When should I use nestjs?
Provides comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable server-side applications. Generates REST/GraphQL APIs, implements authentication
Is nestjs safe to install?
Review the Security Audits panel on this page before production use.