TypeORM — Object-Relational Mapper for TypeScript & Node.js

What is TypeORM?

TypeORM was the dominant TypeScript ORM for several years and remains widely used in enterprise Node.js applications, particularly those built with NestJS. It supports both Active Record (model-centric) and Data Mapper (repository-centric) patterns, giving flexibility in architecture.

Quick Start

npm install typeorm reflect-metadata
npm install pg  # Or mysql2, sqlite3, etc.

// Require reflect-metadata at app entry point
import "reflect-metadata";
import { DataSource } from "typeorm";

export const AppDataSource = new DataSource({
  type: "postgres",
  host: "localhost",
  port: 5432,
  username: "postgres",
  password: "password",
  database: "myapp",
  synchronize: false,  // Never true in production
  logging: true,
  entities: ["src/entities/**/*.ts"],
  migrations: ["src/migrations/**/*.ts"],
});

Entity Definition (Data Mapper)

// src/entities/User.ts
import {
  Entity, Column, PrimaryGeneratedColumn,
  CreateDateColumn, UpdateDateColumn,
  OneToMany, ManyToOne
} from "typeorm";

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

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

  @Column({ nullable: true })
  name: string;

  @Column({ default: true })
  active: boolean;

  @OneToMany(() => Post, post => post.author)
  posts: Post[];

  @CreateDateColumn()
  createdAt: Date;

  @UpdateDateColumn()
  updatedAt: Date;
}

@Entity("posts")
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column("text", { nullable: true })
  content: string;

  @Column({ default: false })
  published: boolean;

  @ManyToOne(() => User, user => user.posts)
  author: User;

  @Column()
  authorId: number;

  @CreateDateColumn()
  createdAt: Date;
}

Repository Pattern (Data Mapper)

import { AppDataSource } from "./data-source";
import { User } from "./entities/User";

const userRepository = AppDataSource.getRepository(User);

// CREATE
const user = userRepository.create({ email: "[email protected]", name: "Alice" });
await userRepository.save(user);

// READ
const users = await userRepository.find({
  where: { active: true },
  relations: ["posts"],
  order: { createdAt: "DESC" },
  take: 10,
  skip: 0,
});

// FIND ONE
const user = await userRepository.findOne({
  where: { email: "[email protected]" },
  relations: ["posts"],
});

// UPDATE
await userRepository.update({ id: 1 }, { name: "Alice Smith" });

// DELETE
await userRepository.delete({ id: 1 });

Query Builder

const posts = await AppDataSource
  .createQueryBuilder(Post, "post")
  .leftJoinAndSelect("post.author", "user")
  .where("post.published = :published", { published: true })
  .andWhere("user.email LIKE :domain", { domain: "%@company.com" })
  .orderBy("post.createdAt", "DESC")
  .limit(20)
  .getMany();

// With subqueries
const activeUsers = await AppDataSource
  .createQueryBuilder(User, "user")
  .where(qb => {
    const subQuery = qb.subQuery()
      .select("post.authorId")
      .from(Post, "post")
      .where("post.published = true")
      .getQuery();
    return "user.id IN " + subQuery;
  })
  .getMany();

NestJS Integration

TypeORM is the default ORM for NestJS:

// app.module.ts
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      url: process.env.DATABASE_URL,
      entities: [User, Post],
      migrations: ['dist/migrations/**/*.js'],
      migrationsRun: true,
    }),
    TypeOrmModule.forFeature([User, Post]),
  ],
})
export class AppModule {}

// users.service.ts
@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async findAll() {
    return this.userRepository.find({ relations: ['posts'] });
  }
}

TypeORM remains the go-to ORM for NestJS applications and enterprise systems that benefit from its mature feature set, despite newer alternatives offering better performance.

Best For

• NestJS applications — TypeORM is the most common ORM in NestJS and is deeply integrated into NestJS modules and dependency injection
• Enterprise TypeScript projects needing Active Record or Data Mapper patterns with full decorator support
• Legacy MySQL/PostgreSQL projects migrating from plain SQL queries to an ORM while needing a migration system
• Teams comfortable with a large, mature ecosystem with 30k+ GitHub stars and extensive documentation

TypeORM vs. Alternatives

	TypeORM	Prisma	Drizzle ORM	MikroORM
Type safety	Good	Excellent	Excellent	Good
Performance	Medium	Medium	Fast	Medium
Migration	✅ Built-in	✅	✅	✅
Bundle size	Large	Medium	Small	Medium
Active Record	✅	✗	✗	✗
NestJS	First-class	Good	Growing	Good
Best for	NestJS, enterprise	Type-safe queries, Next.js	Raw SQL feel + types	Domain-driven design

Prisma and Drizzle offer better type safety and developer experience for new projects. TypeORM remains the right choice when NestJS integration depth or Active Record pattern is needed.