typeorm

What is typeorm?

TypeORM is an Object-Relational Mapper (ORM) for Node.js that can be used with TypeScript or JavaScript (ES5, ES6, ES7, ES8). It supports both Active Record and Data Mapper patterns, unlike other JavaScript ORMs. You can use it with TypeScript and JavaScript (ES5, ES6, ES7, ES8). It's highly influenced by other ORMs, such as Hibernate, Doctrine, and Entity Framework.

What are typeorm's main functionalities?

Entity Definition

This code sample demonstrates how to define an entity in TypeORM. Entities are the equivalent of tables in a database, and each instance of an entity represents a row in the table.

import {Entity, PrimaryGeneratedColumn, Column} from 'typeorm';

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

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    isActive: boolean;
}

CRUD Operations

This code sample shows how to perform CRUD (Create, Read, Update, Delete) operations using the repository API provided by TypeORM.

import {getRepository} from 'typeorm';
import {User} from './entity/User';

async function createUser() {
    const userRepository = getRepository(User);
    const user = new User();
    user.firstName = 'Timber';
    user.lastName = 'Saw';
    user.isActive = true;
    await userRepository.save(user);
}

async function findUserById(id) {
    const userRepository = getRepository(User);
    return await userRepository.findOne(id);
}

Data Querying

This code sample illustrates how to query data using the QueryBuilder API, which allows for building SQL queries in a programmatic and type-safe manner.

import {getConnection} from 'typeorm';

async function getUsersByName(firstName) {
    const users = await getConnection()
        .getRepository(User)
        .createQueryBuilder('user')
        .where('user.firstName = :firstName', { firstName })
        .getMany();
    return users;
}

Transactions

This code sample demonstrates how to perform transactions, ensuring that all operations within the transaction block either complete successfully together or are all rolled back.

import {getConnection} from 'typeorm';

async function updateUserLastName(id, lastName) {
    await getConnection().transaction(async transactionalEntityManager => {
        const user = await transactionalEntityManager.findOne(User, id);
        user.lastName = lastName;
        await transactionalEntityManager.save(user);
    });
}

Migrations

This code sample shows how to define a migration class in TypeORM. Migrations are a way to manage database schema changes and can be automatically generated or manually written.

import {MigrationInterface, QueryRunner} from 'typeorm';

export class CreateUserTable1588102412341 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`CREATE TABLE user (id int PRIMARY KEY, firstName varchar(255), lastName varchar(255))`);
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query('DROP TABLE user');
    }
}

Other packages similar to typeorm

sequelize

Sequelize is a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite, and Microsoft SQL Server. It features solid transaction support, relations, eager and lazy loading, read replication, and more. Compared to TypeORM, Sequelize has been around for longer and has a larger community, but it doesn't have as strong TypeScript support.

bookshelf

Bookshelf is a JavaScript ORM for Node.js, built on the Knex SQL query builder. It features a simple and intuitive API and supports transactions, eager/nested-eager relation loading, and plugins. Unlike TypeORM, Bookshelf follows a more traditional JavaScript style and doesn't emphasize TypeScript integration.

README

TypeORM is an ORM that can run in Node.js, Browser, Cordova, Ionic, React Native, NativeScript, Expo, and Electron platforms and can be used with TypeScript and JavaScript (ES2021). Its goal is to always support the latest JavaScript features and provide additional features that help you to develop any kind of application that uses databases - from small applications with a few tables to large-scale enterprise applications with multiple databases.

TypeORM supports more databases than any other JS/TS ORM: Google Spanner, Microsoft SqlServer, MySQL/MariaDB, MongoDB, Oracle, Postgres, SAP HANA and SQLite, as well we derived databases and different drivers.

TypeORM supports both Active Record and Data Mapper patterns, unlike all other JavaScript ORMs currently in existence, which means you can write high-quality, loosely coupled, scalable, maintainable applications in the most productive way.

TypeORM is highly influenced by other ORMs, such as Hibernate, Doctrine and Entity Framework.

Features

• Supports both DataMapper and ActiveRecord (your choice).
• Entities and columns.
• Database-specific column types.
• Entity manager.
• Repositories and custom repositories.
• Clean object-relational model.
• Associations (relations).
• Eager and lazy relations.
• Unidirectional, bidirectional, and self-referenced relations.
• Supports multiple inheritance patterns.
• Cascades.
• Indices.
• Transactions.
• Migrations and automatic migrations generation.
• Connection pooling.
• Replication.
• Using multiple database instances.
• Working with multiple database types.
• Cross-database and cross-schema queries.
• Elegant-syntax, flexible and powerful QueryBuilder.
• Left and inner joins.
• Proper pagination for queries using joins.
• Query caching.
• Streaming raw results.
• Logging.
• Listeners and subscribers (hooks).
• Supports closure table pattern.
• Schema declaration in models or separate configuration files.
• Supports MySQL / MariaDB / Postgres / CockroachDB / SQLite / Microsoft SQL Server / Oracle / SAP Hana / sql.js.
• Supports MongoDB NoSQL database.
• Works in Node.js / Browser / Ionic / Cordova / React Native / NativeScript / Expo / Electron platforms.
• TypeScript and JavaScript support.
• ESM and CommonJS support.
• Produced code is performant, flexible, clean, and maintainable.
• Follows all possible best practices.
• CLI.

And more...

With TypeORM, your models look like this:

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"

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

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    age: number
}

And your domain logic looks like this:

const userRepository = MyDataSource.getRepository(User)

const user = new User()
user.firstName = "Timber"
user.lastName = "Saw"
user.age = 25
await userRepository.save(user)

const allUsers = await userRepository.find()
const firstUser = await userRepository.findOneBy({
    id: 1,
}) // find by id
const timber = await userRepository.findOneBy({
    firstName: "Timber",
    lastName: "Saw",
}) // find by firstName and lastName

await userRepository.remove(timber)

Alternatively, if you prefer to use the ActiveRecord implementation, you can use it as well:

import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm"

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

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    age: number
}

And your domain logic will look this way:

const user = new User()
user.firstName = "Timber"
user.lastName = "Saw"
user.age = 25
await user.save()

const allUsers = await User.find()
const firstUser = await User.findOneBy({
    id: 1,
})
const timber = await User.findOneBy({
    firstName: "Timber",
    lastName: "Saw",
})

await timber.remove()

Samples

Take a look at the samples in sample for examples of usage.

There are a few repositories that you can clone and start with:

• Example how to use TypeORM with TypeScript
• Example how to use TypeORM with JavaScript
• Example how to use TypeORM with JavaScript and Babel
• Example how to use TypeORM with TypeScript and SystemJS in Browser
• Example how to use TypeORM with TypeScript and React in Browser
• Example how to use Express and TypeORM
• Example how to use Koa and TypeORM
• Example how to use TypeORM with MongoDB
• Example how to use TypeORM in a Cordova app
• Example how to use TypeORM with an Ionic app
• Example how to use TypeORM with React Native
• Example how to use TypeORM with Nativescript-Vue
• Example how to use TypeORM with Nativescript-Angular
• Example how to use TypeORM with Electron using JavaScript
• Example how to use TypeORM with Electron using TypeScript

Extensions

There are several extensions that simplify working with TypeORM and integrating it with other modules:

• TypeORM integration with TypeDI
• TypeORM integration with routing-controllers
• Models generation from the existing database - typeorm-model-generator
• Fixtures loader - typeorm-fixtures-cli
• ER Diagram generator - typeorm-uml
• another ER Diagram generator - erdia
• Create, drop and seed database - typeorm-extension
• Automatically update data-source.ts after generating migrations/entities - typeorm-codebase-sync
• Easy manipulation of relations objects - typeorm-relations
• Automatically generate relations based on a GraphQL query - typeorm-relations-graphql
• Generate TypeORM entities from Valibot schemas - piying-orm

Contributing

Learn about contribution here and how to set up your development environment here.

This project exists thanks to all the people who contribute:

Sponsors

Open source is hard and time-consuming. If you want to invest in TypeORM's future, you can become a sponsor and allow our core team to spend more time on TypeORM's improvements and new features. Become a sponsor

Gold Sponsors

Become a gold sponsor and get premium technical support from our core contributors. Become a gold sponsor

Changelog

0.3.26 (2025-08-16)

Notes:

• When using MySQL, TypeORM now connects using stringifyObjects: true, in order to avoid a potential security vulnerability in the mysql/mysql2 client libraries. You can revert to the old behavior by setting connectionOptions.extra.stringifyObjects = false.
• When using SAP HANA, TypeORM now uses the built-in pool from the @sap/hana-client library. The deprecated hdb-pool is no longer necessary and can be removed. See https://typeorm.io/docs/drivers/sap/#data-source-options for the new pool options.

Bug Fixes

• add stricter type-checking and improve event loop handling (#11540) (01dddfe)
• do not create junction table metadata when it already exists (#11114) (3c26cf1)
• mysql: set stringifyObjects implicitly (#11574) (d57fe3b)
• mysql: support Alibaba AnalyticDB returning version() column name in getVersion() (#11555) (1737e97)
• oracle: pass duplicated parameters correctly to the client when executing a query (#11537) (f2d2236)
• platform[web worker]: improve globalThis variable retrieval for browser environment (#11495) (ec26eae)
• preserve useIndex when cloning a QueryExpressionMap (or a QueryBuilder) (#10679) (66ee307), closes #10678 #10678
• regtype is not supported in aurora serverless v2 (#11568) (6e9f20d)
• resolve array modification bug in QueryRunner drop methods (#11564) (f351757), closes #11563
• support for better-sqlite3 v12 (#11557) (1ea3a5e)

Features

• add Redis 5.x support with backward compatibility with peer dependency to allow (#11585) (17cf837), closes #11528
• sap: add support for REAL_VECTOR and HALF_VECTOR data types in SAP HANA Cloud (#11526) (abf8863)
• sap: use the native driver for connection pooling (#11520) (aebc7eb)
• support virtual columns in entity schema (#11597) (d1e3950)

Performance Improvements

• avoid unnecessary count on getManyAndCount (#11524) (5904ac3)