Validation, Configuration and Databases

Connecting a database with TypeORM

Nest provides an official TypeORM integration, @nestjs/typeorm. For PostgreSQL, install it with the driver.

npm i @nestjs/typeorm typeorm pg

Define tables as entity classes, configure the connection in the root module, and register entities in feature modules.

// src/users/entities/user.entity.ts
import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column({ unique: true })
  email: string;
}

// src/app.module.ts
import { Module } from "@nestjs/common";
import { ConfigModule, ConfigService } from "@nestjs/config";
import { TypeOrmModule } from "@nestjs/typeorm";
import { UsersModule } from "./users/users.module";

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: "postgres",
        url: config.get<string>("DATABASE_URL"),
        autoLoadEntities: true,
        synchronize: false, // use migrations in production
      }),
    }),
    UsersModule,
  ],
})
export class AppModule {}

Add TypeOrmModule.forFeature([User]) to the imports of UsersModule, then inject the repository with @InjectRepository.

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { CreateUserDto } from "./dto/create-user.dto";
import { User } from "./entities/user.entity";

@Injectable()
export class UsersService {
  constructor(@InjectRepository(User) private readonly users: Repository<User>) {}

  findAll() {
    return this.users.find();
  }

  create(dto: CreateUserDto) {
    return this.users.save(this.users.create(dto));
  }
}

synchronize: true alters the schema to match your entities. It is handy early on but can drop data, so turn it off in production and manage the schema with TypeORM migrations.

Using Prisma instead

Prisma is an ORM where you describe models in schema.prisma and generate a typed client from it. Start with npm i -D prisma and npx prisma init, and create and apply migrations with npx prisma migrate dev. There is no official Nest module; the usual pattern is a PrismaService provider wrapping the generated PrismaClient, connecting in onModuleInit, and injected into other services. Client output location and setup differ between Prisma releases, so follow the NestJS guide in Prisma's docs.

In plain Express

Express ships no validation or data layer. Parse bodies with express.json(), validate with a library such as Zod or Joi, and expose your ORM or driver from a module your routers import. You design yourself what Nest organizes with modules and dependency injection.

Summary

• Providers are shared, so keep per-request state out of fields and store durable state externally.
• Define rules on DTOs with class-validator and validate automatically with a global ValidationPipe.
• Read environment variables through ConfigModule and ConfigService.
• Connect TypeORM through @nestjs/typeorm and inject repositories; wire Prisma through your own PrismaService.