TypeORM is an ORMthat can run in NodeJS, Browser, Cordova, PhoneGap, Ionic, React Native, NativeScript, Expo, and Electron platformsand can be used with TypeScript and JavaScript (ES5, ES6, ES7, ES8).Its goal is to always support the latest JavaScript features and provide additional featuresthat help you to develop any kind of application that uses databases - fromsmall applications with a few tables to large scale enterprise applicationswith multiple databases.

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 the most productive way.

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

Some TypeORM 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
• uni-directional, bi-directional and self-referenced relations
• supports multiple inheritance patterns
• cascades
• indices
• transactions
• migrations and automatic migrations generation
• connection pooling
• replication
• using multiple database connections
• working with multiple databases 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
• connection configuration in json / xml / yml / env formats
• supports MySQL / MariaDB / Postgres / CockroachDB / SQLite / Microsoft SQL Server / Oracle / sql.js
• supports MongoDB NoSQL database
• works in NodeJS / Browser / Ionic / Cordova / React Native / NativeScript / Expo / Electron platforms
• TypeScript and JavaScript 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 user = new User();
user.firstName = "Timber";
user.lastName = "Saw";
user.age = 25;
await repository.save(user);
const allUsers = await repository.find();
const firstUser = await repository.findOne(1); // find by id
const timber = await repository.findOne({ firstName: "Timber", lastName: "Saw" });
await repository.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.findOne(1);
const timber = await User.findOne({ firstName: "Timber", lastName: "Saw" });
await timber.remove();