TypeORM is an MIT-licensed object-relational mapper for TypeScript and JavaScript that runs on Node.js, in the browser, and across mobile and desktop platforms, and it is aimed at developers who want to model, query, and migrate SQL and NoSQL databases from one decorator-driven codebase.

What it is

TypeORM is an ORM that runs on Node.js, Browser, Cordova, Ionic, React Native, NativeScript, Expo, and Electron, and it works with TypeScript and JavaScript (ES2023). Its stated goal is to support the latest JavaScript features and to add the features needed by any application that uses databases, from small applications with a few tables to large-scale enterprise applications with multiple databases. The project is heavily influenced by Hibernate, Doctrine, and Entity Framework, and it lives in the Infrastructure & Operations / Databases category with the active-record, data-mapper, database, orm, postgresql, mysql, mariadb, sqlite, sqlserver, and cockroachdb topics.

The concrete problem it solves is the gap between an application's object model and the many databases it may need to talk to. TypeORM replaces hand-written SQL and single-dialect query layers: entities and columns carry database-specific column types, repositories and an entity manager replace ad-hoc queries, an elegant-syntax QueryBuilder replaces string-concatenated SQL, and migrations with automatic migrations generation replace manually maintained schema scripts. Under this sits a driver matrix covering PostgreSQL, MySQL/MariaDB, CockroachDB, SQLite, SQL Server, Oracle, SAP HANA, MongoDB, Google Spanner, and sql.js, so the same domain logic can run against several database types, support cross-database and cross-schema queries, and address multiple database instances from one application.

Key capabilities

• Supports both the Active Record pattern (BaseEntity) and the Data Mapper pattern (repositories), which the README describes as unlike all other JavaScript ORMs currently in existence.
• Decorator-based entities and columns, for example @Entity(), @PrimaryGeneratedColumn(), and @Column(), with database-specific column types.
• An elegant-syntax, flexible and powerful QueryBuilder with left and inner joins and proper pagination for queries using joins.
• Migrations and automatic migrations generation.
• Broad database coverage: PostgreSQL, MySQL/MariaDB, CockroachDB, SQLite, Microsoft SQL Server, Oracle, SAP HANA, MongoDB, Google Spanner, and sql.js.
• Transactions, connection pooling, replication, and use of multiple database instances.
• A CLI plus listeners and subscribers (hooks), query caching, logging, streaming raw results, indices, cascades, and eager and lazy relations.

Who uses it and how

• Teams building anything from small applications with a few tables to large-scale enterprise applications with multiple databases.
• Applications that need several database types at once, using cross-database and cross-schema queries and multiple database instances.
• Projects that ship across Node.js, Ionic, Cordova, React Native, NativeScript, Expo, Electron, and the browser from shared TypeScript or JavaScript.
• Codebases that require both ESM and CommonJS output.
• Developers who need unidirectional, bidirectional, and self-referenced relations, multiple inheritance patterns, and the closure table pattern without hand-writing joins.

Getting started

TypeORM is distributed as the typeorm package; the README imports entities and decorators from it, for example import { Entity, PrimaryGeneratedColumn, Column } from "typeorm", then wires a DataSource before calling MyDataSource.getRepository(User) and repository methods such as save, find, findOneBy, and remove. A CLI is listed among the features, and the project's homepage is at typeorm.io.

How it compares

TypeORM is heavily influenced by Hibernate, Doctrine, and Entity Framework, but it targets TypeScript and JavaScript rather than Java, PHP, or .NET. Its distinguishing position within that lineage is dual support for both the Active Record and Data Mapper patterns, which the README claims no other current JavaScript ORM offers.

When to use it — and when not to

Adopting TypeORM means operating the underlying database yourself: the project connects to PostgreSQL, MySQL, MariaDB, CockroachDB, SQLite, SQL Server, Oracle, SAP HANA, or MongoDB, but it does not run those servers or any other infrastructure for you. Teams that want only a thin query wrapper over a single database, or that want no decorator and entity-metadata layer at all, are likely better served by a smaller tool. The repository currently carries 646 open issues, so a sizeable backlog is the honest trade-off against the 36,651 stars, 6,671 forks, and clear MIT licence.

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

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

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    age: number
}

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)

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
}

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()