Decorator reference
Marks your model as an entity. Entity is a class which is transformed into a database table. You can specify the table name in the entity:
@Entity("users")
export class User {}
This code will create a database table named "users".
You can also specify some additional entity options:
name- table name. If not specified, then table name is generated from entity class name.database- database name in selected DB server.schema- schema name.engine- database engine to be set during table creation (works only in some databases).synchronize- entities marked withfalseare skipped from schema updates.orderBy- specifies default ordering for entities when usingfindoperations andQueryBuilder.
Example:
@Entity({
name: "users",
engine: "MyISAM",
database: "example_dev",
schema: "schema_with_best_tables",
synchronize: false,
orderBy: {
name: "ASC",
id: "DESC",
},
})
export class User {}
View entity is a class that maps to a database view.
@ViewEntity() accepts following options:name- view name. If not specified, then view name is generated from entity class name.database- database name in selected DB server.schema- schema name.expression- view definition. Required parameter.
expression can be string with properly escaped columns and tables, depend on database used (postgres in example):@ViewEntity({
expression: `
SELECT "post"."id" "id", "post"."name" AS "name", "category"."name" AS "categoryName"
FROM "post" "post"
LEFT JOIN "category" "category" ON "post"."categoryId" = "category"."id"
`,
})
export class PostCategory {}
or an instance of QueryBuilder
@ViewEntity({
expression: (dataSource: DataSource) =>
dataSource
.createQueryBuilder()
.select("post.id", "id")
.addSelect("post.name", "name")
.addSelect("category.name", "categoryName")
.from(Post, "post")
.leftJoin(Category, "category", "category.id = post.categoryId"),
})
export class PostCategory {}
Note: parameter binding is not supported due to drivers limitations. Use the literal parameters instead.
@ViewEntity({
expression: (dataSource: DataSource) =>
dataSource
.createQueryBuilder()
.select("post.id", "id")
.addSelect("post.name", "name")
.addSelect("category.name", "categoryName")
.from(Post, "post")
.leftJoin(Category, "category", "category.id = post.categoryId")
.where("category.name = :name", { name: "Cars" }) // <-- this is wrong
.where("category.name = 'Cars'"), // <-- and this is right
})
export class PostCategory {}
Marks a property in your entity as a table column. Example:
@Entity("users")
export class User {
@Column({ primary: true })
id: number
@Column({ type: "varchar", length: 200, unique: true })
firstName: string
@Column({ nullable: true })
lastName: string
@Column({ default: false })
isActive: boolean
}
@Column accept several options you can use:name: string- Column name in the database table. By default, the column name is generated from the name of the property. You can change it by specifying your own name.length: string|number- Column type's length. For example, if you want to createvarchar(150)type you specify column type and length options.nullable: boolean- determines whether the column can becomeNULLor always has to beNOT NULL. By default column isnullable: false.update: boolean- Indicates if column value is updated by "save" operation. If false, you'll be able to write this value only when you first time insert the object. Default value istrue.insert: boolean- Indicates if column value is set the first time you insert the object. Default value istrue.select: boolean- Defines whether or not to hide this column by default when making queries. When set tofalse, the column data will not show with a standard query. By default column isselect: truedefault: string- Adds database-level column'sDEFAULTvalue.primary: boolean- Marks column as primary. Same as using@PrimaryColumn.unique: boolean- Marks column as unique column (creates unique constraint). Default value is false.comment: string- Database's column comment. Not supported by all database types.precision: number- The precision for a decimal (exact numeric) column (applies only for decimal column), which is the maximum number of digits that are stored for the values. Used in some column types.scale: number- The scale for a decimal (exact numeric) column (applies only for decimal column), which represents the number of digits to the right of the decimal point and must not be greater than precision. Used in some column types.zerofill: boolean- PutsZEROFILLattribute on to a numeric column. Used only in MySQL. Iftrue, MySQL automatically adds theUNSIGNEDattribute to this column.unsigned: boolean- PutsUNSIGNEDattribute on to a numeric column. Used only in MySQL.charset: string- Defines a column character set. Not supported by all database types.collation: string- Defines a column collation.enum: string[]|AnyEnum- Used inenumcolumn type to specify list of allowed enum values. You can specify array of values or specify a enum class.enumName: string- A name for generated enum type. If not specified, TypeORM will generate a enum type from entity and column names - so it's necessary if you intend to use the same enum type in different tables.primaryKeyConstraintName: string- A name for the primary key constraint. If not specified, then constraint name is generated from the table name and the names of the involved columns.generatedType: "VIRTUAL"|"STORED"- Generated column type. Used only in MySQL and Postgres (Only "STORED").hstoreType: "object"|"string"- Return type ofHSTOREcolumn. Returns value as string or as object. Used only in Postgres.array: boolean- Used for postgres and cockroachdb column types which can be array (for example int[]).transformer: ValueTransformer|ValueTransformer[]- Specifies a value transformer (or array of value transformers) that is to be used to (un)marshal this column when reading or writing to the database. In case of an array, the value transformers will be applied in the natural order from entityValue to databaseValue, and in reverse order from databaseValue to entityValue.spatialFeatureType: string- Optional feature type (Point,Polygon,LineString,Geometry) used as a constraint on a spatial column. If not specified, it will behave as thoughGeometrywas provided. Used only in PostgreSQL and CockroachDB.srid: number- Optional Spatial Reference ID used as a constraint on a spatial column. If not specified, it will default to0. Standard geographic coordinates (latitude/longitude in the WGS84 datum) correspond to EPSG 4326. Used only in PostgreSQL and CockroachDB.
Marks a property in your entity as a table primary column. Same as
@Column decorator but sets its primary option to true.Example:
@Entity()
export class User {
@PrimaryColumn()
id: number
}
@PrimaryColumn() supports custom primary key constraint name:@Entity()
export class User {
@PrimaryColumn({ primaryKeyConstraintName: "pk_user_id" })
id: number
}
Note: when usingprimaryKeyConstraintNamewith multiple primary keys, the constraint name must be the same for all primary columns.
Marks a property in your entity as a table-generated primary column. Column it creates is primary and its value is auto-generated. Example:
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number
}
@PrimaryGeneratedColumn() supports custom primary key constraint name:@Entity()
export class User {
@PrimaryGeneratedColumn({ primaryKeyConstraintName: "pk_user_id" })
id: number
}
There are four generation strategies:
increment- uses AUTO_INCREMENT / SERIAL / SEQUENCE (depend on database type) to generate incremental number.identity- only for PostgreSQL 10+. Postgres versions above 10 support the SQL-Compliant IDENTITY column. When marking the generation strategy asidentitythe column will be produced usingGENERATED [ALWAYS|BY DEFAULT] AS IDENTITYuuid- generates uniqueuuidstring.rowid- only for CockroachDB. Value is automatically generated using theunique_rowid()function. This produces a 64-bit integer from the current timestamp and ID of the node executing theINSERTorUPSERToperation.Note: property with arowidgeneration strategy must be astringdata type
Default generation strategy is
increment, to change it to another strategy, simply pass it as the first argument to decorator:@Entity()
export class User {
@PrimaryGeneratedColumn("uuid")
id: string
}
Marks a property in your entity as ObjectId. This decorator is only used in MongoDB. Every entity in MongoDB must have a ObjectId column. Example:
@Entity()
export class User {
@ObjectIdColumn()
id: ObjectId
}
Special column that is automatically set to the entity's insertion time. You don't need to write a value into this column - it will be automatically set. Example:
@Entity()
export class User {
@CreateDateColumn()
createdDate: Date
}
Special column that is automatically set to the entity's update time each time you call
save from entity manager or repository. You don't need to write a value into this column - it will be automatically set.@Entity()
export class User {
@UpdateDateColumn()
updatedDate: Date
}
Special column that is automatically set to the entity's delete time each time you call soft-delete of entity manager or repository. You don't need to set this column - it will be automatically set.
TypeORM's own soft delete functionality utilizes global scopes to only pull "non-deleted" entities from the database.
If the @DeleteDateColumn is set, the default scope will be "non-deleted".
@Entity()
export class User {
@DeleteDateColumn()
deletedDate: Date
}
Special column that is automatically set to the entity's version (incremental number) each time you call
save from entity manager or repository. You don't need to write a value into this column - it will be automatically set.@Entity()
export class User {
@VersionColumn()
version: number
}
Marks column to be a generated value. For example:
@Entity()
export class User {
@Column()
@Generated("uuid")
uuid: string
}
Value will be generated only once, before inserting the entity into the database.
Special column that is never saved to the database and thus acts as a readonly property. Each time you call
find or findOne from the entity manager, the value is recalculated based on the query function that was provided in the VirtualColumn Decorator. The alias argument passed to the query references the exact entity alias of the generated query behind the scenes.@Entity({ name: "companies", alias: "COMP" })
export class Company extends BaseEntity {
@PrimaryColumn("varchar", { length: 50 })
name: string;
@VirtualColumn({ query: (alias) => `SELECT COUNT("name") FROM "employees" WHERE "companyName" = ${alias}.name` })
totalEmployeesCount: number;
@OneToMany((type) => Employee, (employee) => employee.company)
employees: Employee[];
}
@Entity({ name: "employees" })
export class Employee extends BaseEntity {
@PrimaryColumn("varchar", { length: 50 })
name: string;
@ManyToOne((type) => Company, (company) => company.employees)
company: Company;
}
One-to-one is a relation where A contains only one instance of B, and B contains only one instance of A. Let's take for example
User and Profile entities. User can have only a single profile, and a single profile is owned by only a single user. Example:import { Entity, OneToOne, JoinColumn } from "typeorm"
import { Profile } from "./Profile"
@Entity()
export class User {
@OneToOne((type) => Profile, (profile) => profile.user)
@JoinColumn()
profile: Profile
}
Many-to-one / one-to-many is a relation where A contains multiple instances of B, but B contains only one instance of A. Let's take for example
User and Photo entities. User can have multiple photos, but each photo is owned by only one single user. Example:import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from "typeorm"
import { User } from "./User"
@Entity()
export class Photo {
@PrimaryGeneratedColumn()
id: number
@Column()
url: string
@ManyToOne((type) => User, (user) => user.photos)
user: User
}
Many-to-one / one-to-many is a relation where A contains multiple instances of B, but B contains only one instance of A. Let's take for example
User and Photo entities. User can have multiple photos, but each photo is owned by only a single user. Example:import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from "typeorm"
import { Photo } from "./Photo"
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number
@Column()
name: string
@OneToMany((type) => Photo, (photo) => photo.user)
photos: Photo[]
}
Many-to-many is a relation where A contains multiple instances of B, and B contain multiple instances of A. Let's take for example
Question and Category entities. Question can have multiple categories, and each category can have multiple questions. Example:import {
Entity,
PrimaryGeneratedColumn,
Column,
ManyToMany,
JoinTable,
} from "typeorm"
import { Category } from "./Category"
@Entity()
export class Question {
@PrimaryGeneratedColumn()
id: number
@Column()
title: string
@Column()
text: string
@ManyToMany((type) => Category)
@JoinTable()
categories: Category[]
}
Defines which side of the relation contains the join column with a foreign key and allows you to customize the join column name, referenced column name and foreign key name. Example:
@Entity()
export class Post {
@ManyToOne((type) => Category)
@JoinColumn({
name: "cat_id",
referencedColumnName: "name",
foreignKeyConstraintName: "fk_cat_id"
})
category: Category
}
Used for
many-to-many relations and describes join columns of the "junction" table. Junction table is a special, separate table created automatically by TypeORM with columns referenced to the related entities. You can change the name of the generated "junction" table, the column names inside the junction table, their referenced columns with the joinColumn- and inverseJoinColumn attributes, and the created foreign keys names. You can also set parameter synchronize to false to skip schema update(same way as in @Entity)Example:
@Entity()
export class Post {
@ManyToMany((type) => Category)
@JoinTable({
name: "question_categories",
joinColumn: {
name: "question",
referencedColumnName: "id",
foreignKeyConstraintName: "fk_question_categories_questionId"
},
inverseJoinColumn: {
name: "category",
referencedColumnName: "id",
foreignKeyConstraintName: "fk_question_categories_categoryId"
},
synchronize: false,
})
categories: Category[]
}
If the destination table has composite primary keys, then an array of properties must be sent to the
@JoinTable decorator.Loads id (or ids) of specific relations into properties. For example, if you have a many-to-one
category in your Post entity, you can have a new category id by marking a new property with @RelationId. Example:@Entity()
export class Post {
@ManyToOne((type) => Category)
category: Category
@RelationId((post: Post) => post.category) // you need to specify target relation
categoryId: number
}
This functionality works for all kind of relations, including
many-to-many:@Entity()
export class Post {
@ManyToMany((type) => Category)
categories: Category[]
@RelationId((post: Post) => post.categories)
categoryIds: number[]
}
Relation id is used only for representation. The underlying relation is not added/removed/changed when chaining the value.
You can define a method with any name in entity and mark it with
@AfterLoad and TypeORM will call it each time the entity is loaded using QueryBuilder or repository/manager find methods. Example:@Entity()
export class Post {
@AfterLoad()
updateCounters() {
if (this.likesCount === undefined) this.likesCount = 0
}
}
You can define a method with any name in entity and mark it with
@BeforeInsert and TypeORM will call it before the entity is inserted using repository/manager save. Example:@Entity()
export class Post {
@BeforeInsert()
updateDates() {
this.createdDate = new Date()
}
}
You can define a method with any name in entity and mark it with
@AfterInsert and TypeORM will call it after the entity is inserted using repository/manager save. Example:@Entity()
export class Post {
@AfterInsert()
resetCounters() {
this.counters = 0
}
}
You can define a method with any name in the entity and mark it with
@BeforeUpdate and TypeORM will call it before an existing entity is updated using repository/manager save. Example:@Entity()
export class Post {
@BeforeUpdate()
updateDates() {
this.updatedDate = new Date()
}
}
You can define a method with any name in the entity and mark it with
@AfterUpdate and TypeORM will call it after an existing entity is updated using repository/manager save. Example:@Entity()
export class Post {
@AfterUpdate()
updateCounters() {
this.counter = 0
}
}
You can define a method with any name in the entity and mark it with
@BeforeRemove and TypeORM will call it before a entity is removed using repository/manager remove. Example:@Entity()
export class Post {
@BeforeRemove()
updateStatus() {
this.status = "removed"
}
}
You can define a method with any name in the entity and mark it with
@AfterRemove and TypeORM will call it after the entity is removed using repository/manager remove. Example:@Entity()
export class Post {
@AfterRemove()
updateStatus() {
this.status = "removed"
}
}
You can define a method with any name in the entity and mark it with
@BeforeSoftRemove and TypeORM will call it before a entity is soft removed using repository/manager softRemove. Example:@Entity()
export class Post {
@BeforeSoftRemove()
updateStatus() {
this.status = "soft-removed"
}
}
You can define a method with any name in the entity and mark it with
@AfterSoftRemove and TypeORM will call it after the entity is soft removed using repository/manager softRemove. Example:@Entity()
export class Post {
@AfterSoftRemove()
updateStatus() {
this.status = "soft-removed"
}
}
You can define a method with any name in the entity and mark it with
@BeforeRecover and TypeORM will call it before a entity is recovered using repository/manager recover. Example:@Entity()
export class Post {
@BeforeRecover()
updateStatus() {
this.status = "recovered"
}
}
You can define a method with any name in the entity and mark it with
@AfterRecover and TypeORM will call it after the entity is recovered using repository/manager recover. Example:@Entity()
export class Post {
@AfterRecover()
updateStatus() {
this.status = "recovered"
}
}
Marks a class as an event subscriber which can listen to specific entity events or any entity's events. Events are fired using
QueryBuilder and repository/manager methods. Example:@EventSubscriber()
export class PostSubscriber implements EntitySubscriberInterface<Post> {
/**
* Indicates that this subscriber only listen to Post events.
*/
listenTo() {
return Post
}
/**
* Called before post insertion.
*/
beforeInsert(event: InsertEvent<Post>) {
console.log(`BEFORE POST INSERTED: `, event.entity)
}
}
You can implement any method from
EntitySubscriberInterface. To listen to any entity, you just omit the listenTo method and use any:@EventSubscriber()
export class PostSubscriber implements EntitySubscriberInterface {
/**
* Called before entity insertion.
*/
beforeInsert(event: InsertEvent<any>) {
console.log(`BEFORE ENTITY INSERTED: `, event.entity)
}
}
This decorator allows you to create a database index for a specific column or columns. It also allows you to mark column or columns to be unique. This decorator can be applied to columns or an entity itself. Use it on a column when an index on a single column is needed and use it on the entity when a single index on multiple columns is required. Examples:
@Entity()
export class User {
@Index()
@Column()
firstName: string
@Index({ unique: true })
@Column()
lastName: string
}