Referencia de Decoradores

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Decoradores de Entidad

@Entity

Marca tu modelo como una entidad. Una entidad es una clase que se transforma en una tabla de base de datos. Puedes especificar el nombre de la tabla en la entidad:

@Entity("users")
export class User {}

Este código creará una tabla de base de datos llamada "users".

También puedes especificar opciones adicionales para la entidad:

• name - nombre de la tabla. Si no se especifica, el nombre se genera a partir del nombre de la clase de la entidad.

• database - nombre de la base de datos en el servidor de BD seleccionado.

• schema - nombre del esquema.

• engine - motor de base de datos a establecer durante la creación de la tabla (funciona solo en algunas bases).

• synchronize - las entidades marcadas con false se omiten en actualizaciones de esquema.

• orderBy - especifica el orden predeterminado para entidades en operaciones find y QueryBuilder.

Métodos Útiles de QueryRunner

@Entity({
    name: "users",
    engine: "MyISAM",
    database: "example_dev",
    schema: "schema_with_best_tables",
    synchronize: false,
    orderBy: {
        name: "ASC",
        id: "DESC",
    },
})
export class User {}

Más información sobre Entidades.

@ViewEntity

Una entidad vista es una clase que se mapea a una vista de base de datos.

@ViewEntity() acepta las siguientes opciones:

• name - nombre de la vista. Si no se especifica, el nombre se genera automáticamente a partir del nombre de la clase de la entidad.

• database - nombre de la base de datos en el servidor de BD seleccionado.

• schema - nombre del esquema.

• expression - definición de la vista. Parámetro obligatorio.

expression puede ser una cadena con columnas y tablas escapadas correctamente, dependiendo de la base de datos utilizada (postgres en el ejemplo):

@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 {}

o una instancia de 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 {}

Nota: el binding de parámetros no es compatible debido a limitaciones de los drivers. Utiliza parámetros literales en su lugar.

@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 {}

Más información sobre Entidades Vista.

Decoradores de Columna

@Column

Marca una propiedad en tu entidad como columna de tabla. Ejemplo:

@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 acepta varias opciones:

• type: ColumnType - Tipo de columna. Uno de los tipos de columna soportados.

• name: string - Nombre de la columna en la tabla de base de datos. Por defecto, se genera a partir del nombre de la propiedad. Puedes cambiarlo especificando tu propio nombre.

• length: string|number - Longitud del tipo de columna. Ejemplo: para crear tipo varchar(150) se especifica el tipo de columna y esta opción.

• width: number - Ancho de visualización del tipo de columna. Solo para tipos enteros de MySQL. Obsoleto en versiones recientes de MySQL, se eliminará de TypeORM en futuras versiones.

• onUpdate: string - Disparador ON UPDATE. Solo se usa en MySQL.

• nullable: boolean - Determina si la columna puede ser NULL o siempre debe ser NOT NULL. Por defecto es nullable: false.

• update: boolean - Indica si el valor de la columna se actualiza con la operación "save". Si es false, solo podrás escribir este valor durante la primera inserción. Valor predeterminado: true.

• insert: boolean - Indica si el valor de la columna se establece al insertar el objeto por primera vez. Valor predeterminado: true.

• select: boolean - Define si esta columna se oculta por defecto en las consultas. Cuando es false, los datos no aparecerán en consultas estándar. Por defecto es select: true.

• default: string - Establece un valor DEFAULT a nivel de base de datos para la columna.

• primary: boolean - Marca la columna como primaria. Equivalente a usar @PrimaryColumn.

• unique: boolean - Marca la columna como única (crea una restricción unique). Valor predeterminado: false.

• comment: string - Comentario de la columna en la base de datos. No compatible con todos los tipos de bases.

• precision: number - Precisión para columnas decimales (numéricas exactas), que define la cantidad máxima de dígitos almacenados. Aplica solo para ciertos tipos de columna.

• scale: number - Escala para columnas decimales (numéricas exactas), que representa los dígitos a la derecha del punto decimal y no debe ser mayor que la precisión. Aplica solo para ciertos tipos de columna.

• zerofill: boolean - Añade atributo ZEROFILL a columnas numéricas. Solo para MySQL. Si es true, MySQL añade automáticamente el atributo UNSIGNED. Obsoleto en versiones recientes de MySQL, se eliminará de TypeORM en futuras versiones. Usa columnas de caracteres con función LPAD como sugiere MySQL.

• unsigned: boolean - Añade el atributo UNSIGNED a columnas numéricas. Solo para MySQL.

• charset: string - Define el charset de la columna. No compatible con todos los tipos de bases.

• collation: string - Define la collation de la columna.

• enum: string[]|AnyEnum - Usado en tipo de columna enum para especificar valores permitidos. Puede ser un array de valores o una clase enum.

• enumName: string - Nombre para el tipo enum generado. Si no se especifica, TypeORM generará el tipo a partir del nombre de entidad y columna. Necesario si planeas usar el mismo enum en múltiples tablas.

• primaryKeyConstraintName: string - Nombre para la restricción de clave primaria. Si no se especifica, se genera automáticamente a partir de la tabla y columnas involucradas.

• asExpression: string - Expresión para columnas generadas. Solo para MySQL y Postgres.

• generatedType: "VIRTUAL"|"STORED" - Tipo de columna generada. Solo para MySQL y Postgres (solo "STORED").

• hstoreType: "object"|"string" - Tipo de retorno para columnas HSTORE. Devuelve el valor como string u objeto. Solo para Postgres.

• array: boolean - Usado para tipos de columna que pueden ser arrays en Postgres y CockroachDB (ej. int[]).

• transformer: ValueTransformer|ValueTransformer[] - Especifica un transformador de valor (o array de transformadores) para (des)serializar esta columna durante operaciones de lectura/escritura en la base de datos. En arrays, los transformadores se aplican en orden natural (entityValue → databaseValue) y en orden inverso (databaseValue → entityValue).

• spatialFeatureType: string - Tipo de geometría opcional (Point, Polygon, LineString, Geometry) como restricción en columnas espaciales. Si no se especifica, se comportará como Geometry. Solo para PostgreSQL y CockroachDB.

• srid: number - ID de Referencia Espacial opcional como restricción en columnas espaciales. Valor predeterminado: 0. Coordenadas geográficas estándar (latitud/longitud en datum WGS84) corresponden a EPSG 4326. Solo para PostgreSQL y CockroachDB.

Más información sobre columnas de entidad.

@PrimaryColumn

Marca una propiedad en tu entidad como columna primaria de la tabla. Equivalente a @Column con la opción primary establecida en true.

Métodos Útiles de QueryRunner

@Entity()
export class User {
    @PrimaryColumn()
    id: number
}

@PrimaryColumn() soporta nombres personalizados para restricciones de clave primaria:

@Entity()
export class User {
    @PrimaryColumn({ primaryKeyConstraintName: "pk_user_id" })
    id: number
}

Nota: al usar primaryKeyConstraintName con múltiples claves primarias, el nombre de la restricción debe ser el mismo para todas las columnas primarias.

Más información sobre columnas de entidad.

@PrimaryGeneratedColumn

Marca una propiedad en tu entidad como columna primaria generada por la tabla. La columna creada es primaria y su valor se genera automáticamente. Ejemplo:

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

@PrimaryGeneratedColumn() soporta nombres personalizados para restricciones de clave primaria:

@Entity()
export class User {
    @PrimaryGeneratedColumn({ primaryKeyConstraintName: "pk_user_id" })
    id: number
}

Existen cuatro estrategias de generación:

• increment - Usa AUTO_INCREMENT / SERIAL / SEQUENCE (según tipo de base) para generar números incrementales.

• identity - Exclusivo para PostgreSQL 10+. Las versiones de Postgres superiores a 10 admiten la columna IDENTITY compatible con SQL. Al marcar la estrategia de generación como identity, la columna se producirá usando GENERATED [ALWAYS|BY DEFAULT] AS IDENTITY.

• uuid - Genera strings únicos uuid.

• rowid - Exclusivo para CockroachDB. Genera valores automáticos mediante unique_rowid(), produciendo enteros de 64 bits combinando timestamp e ID del nodo ejecutor de INSERT/UPSERT.

  Nota: las propiedades con estrategia rowid deben ser de tipo string.

La estrategia de generación predeterminada es increment. Para cambiarla, simplemente pásela como primer argumento al decorador:

@Entity()
export class User {
    @PrimaryGeneratedColumn("uuid")
    id: string
}

Más información sobre columnas de entidad.

@ObjectIdColumn

Marca una propiedad en tu entidad como ObjectId. Este decorador solo se usa en MongoDB. Cada entidad en MongoDB debe tener una columna ObjectId. Ejemplo:

@Entity()
export class User {
    @ObjectIdColumn()
    id: ObjectId
}

Más información sobre MongoDB.

@CreateDateColumn

Columna especial que se establece automáticamente con la hora de inserción de la entidad. No necesitas escribir un valor: se establecerá automáticamente. Ejemplo:

@Entity()
export class User {
    @CreateDateColumn()
    createdDate: Date
}

@UpdateDateColumn

Columna especial que se actualiza automáticamente con la hora de modificación cada vez que llamas a save desde el entity manager o repositorio. No necesitas escribir un valor: se establecerá automáticamente.

Esta columna también se actualiza automáticamente durante operaciones upsert cuando ocurre una actualización por conflicto.

@Entity()
export class User {
    @UpdateDateColumn()
    updatedDate: Date
}

@DeleteDateColumn

Columna especial que se establece automáticamente con la hora de eliminación cada vez que usas soft-delete desde entity manager o repositorio. No necesitas establecer este valor: se asignará automáticamente.

La funcionalidad de borrado suave de TypeORM utiliza scopes globales para recuperar solo entidades "no eliminadas" de la base de datos.

Si @DeleteDateColumn está establecido, el scope predeterminado será "no eliminado".

@Entity()
export class User {
    @DeleteDateColumn()
    deletedDate: Date
}

@VersionColumn

Columna especial que se actualiza automáticamente con el número de versión de la entidad (incremental) cada vez que llamas a save desde entity manager o repositorio. No necesitas escribir un valor: se establecerá automáticamente.

Esta columna también se actualiza automáticamente durante operaciones upsert cuando ocurre una actualización por conflicto.

@Entity()
export class User {
    @VersionColumn()
    version: number
}

@Generated

Marca una columna como valor generado. Por ejemplo:

@Entity()
export class User {
    @Column()
    @Generated("uuid")
    uuid: string
}

El valor se generará solo una vez, antes de insertar la entidad en la base de datos.

@VirtualColumn

Columna especial que nunca se guarda en la base de datos y actúa como una propiedad de solo lectura. Cada vez que llamas a find o findOne desde el administrador de entidades, el valor se recalcula según la función de consulta proporcionada en el decorador VirtualColumn. El alias pasado a la consulta hace referencia exacta al alias de entidad de la consulta generada subyacente.

@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
}

Decoradores de relaciones

@OneToOne

Uno a uno es una relación donde A contiene solo una instancia de B, y B contiene solo una instancia de A. Tomemos como ejemplo las entidades User y Profile. Un usuario puede tener solo un perfil, y un perfil pertenece solo a un usuario. Ejemplo:

import { Entity, OneToOne, JoinColumn } from "typeorm"
import { Profile } from "./Profile"

@Entity()
export class User {
    @OneToOne((type) => Profile, (profile) => profile.user)
    @JoinColumn()
    profile: Profile
}

Aprende más sobre relaciones uno a uno.

@ManyToOne

Muchos a uno / uno a muchos es una relación donde A contiene múltiples instancias de B, pero B contiene solo una instancia de A. Tomemos como ejemplo las entidades User y Photo. Un usuario puede tener múltiples fotos, pero cada foto pertenece solo a un usuario. Ejemplo:

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
}

Aprende más sobre relaciones muchos a uno / uno a muchos.

@OneToMany

Muchos a uno / uno a muchos es una relación donde A contiene múltiples instancias de B, pero B contiene solo una instancia de A. Tomemos como ejemplo las entidades User y Photo. Un usuario puede tener múltiples fotos, pero cada foto pertenece solo a un usuario. Ejemplo:

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[]
}

Aprende más sobre relaciones muchos a uno / uno a muchos.

@ManyToMany

Muchos a muchos es una relación donde A contiene múltiples instancias de B, y B contiene múltiples instancias de A. Tomemos como ejemplo las entidades Question y Category. Una pregunta puede tener múltiples categorías, y cada categoría puede tener múltiples preguntas. Ejemplo:

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[]
}

Aprende más sobre relaciones muchos a muchos.

@JoinColumn

Define qué lado de la relación contiene la columna de unión con una clave externa y permite personalizar el nombre de la columna de unión, el nombre de la columna referenciada y el nombre de la clave externa. Ejemplo:

@Entity()
export class Post {
    @ManyToOne((type) => Category)
    @JoinColumn({
        name: "cat_id",
        referencedColumnName: "name",
        foreignKeyConstraintName: "fk_cat_id",
    })
    category: Category
}

@JoinTable

Se usa para relaciones many-to-many y describe las columnas de unión de la tabla "de unión". La tabla de unión es una tabla especial separada creada automáticamente por TypeORM con columnas que referencian a las entidades relacionadas. Puedes cambiar el nombre de la tabla de unión generada, los nombres de columna dentro de esta tabla, sus columnas referenciadas con los atributos joinColumn e inverseJoinColumn, y los nombres de las claves externas creadas. También puedes establecer el parámetro synchronize en false para omitir la actualización del esquema (igual que en @Entity).

Métodos Útiles de QueryRunner

@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[]
}

Si la tabla de destino tiene claves primarias compuestas, debes enviar un array de propiedades al decorador @JoinTable.

@RelationId

Carga el id (o ids) de relaciones específicas en propiedades. Por ejemplo, si tienes una relación muchos a uno category en tu entidad Post, puedes obtener un nuevo id de categoría marcando una nueva propiedad con @RelationId. Ejemplo:

@Entity()
export class Post {
    @ManyToOne((type) => Category)
    category: Category

    @RelationId((post: Post) => post.category) // you need to specify target relation
    categoryId: number
}

Esta funcionalidad funciona para todo tipo de relaciones, incluyendo many-to-many:

@Entity()
export class Post {
    @ManyToMany((type) => Category)
    categories: Category[]

    @RelationId((post: Post) => post.categories)
    categoryIds: number[]
}

El id de relación se usa solo para representación. La relación subyacente no se añade/elimina/modifica al cambiar el valor.

Decoradores de suscriptores y listeners

@AfterLoad

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @AfterLoad. TypeORM lo llamará cada vez que la entidad se cargue usando QueryBuilder o métodos de búsqueda del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @AfterLoad()
    updateCounters() {
        if (this.likesCount === undefined) this.likesCount = 0
    }
}

Aprende más sobre oyentes.

@BeforeInsert

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @BeforeInsert. TypeORM lo llamará antes de insertar la entidad usando save del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @BeforeInsert()
    updateDates() {
        this.createdDate = new Date()
    }
}

Aprende más sobre oyentes.

@AfterInsert

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @AfterInsert. TypeORM lo llamará después de insertar la entidad usando save del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @AfterInsert()
    resetCounters() {
        this.counters = 0
    }
}

Aprende más sobre oyentes.

@BeforeUpdate

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @BeforeUpdate. TypeORM lo llamará antes de actualizar una entidad existente usando save del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @BeforeUpdate()
    updateDates() {
        this.updatedDate = new Date()
    }
}

Aprende más sobre oyentes.

@AfterUpdate

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @AfterUpdate. TypeORM lo llamará después de actualizar una entidad existente usando save del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @AfterUpdate()
    updateCounters() {
        this.counter = 0
    }
}

Aprende más sobre oyentes.

@BeforeRemove

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @BeforeRemove y TypeORM lo llamará antes de que una entidad sea eliminada usando el remove del repositorio o manager. Ejemplo:

@Entity()
export class Post {
    @BeforeRemove()
    updateStatus() {
        this.status = "removed"
    }
}

Aprende más sobre oyentes.

@AfterRemove

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @AfterRemove. TypeORM lo llamará después de eliminar la entidad usando remove del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @AfterRemove()
    updateStatus() {
        this.status = "removed"
    }
}

Aprende más sobre oyentes.

@BeforeSoftRemove

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @BeforeSoftRemove y TypeORM lo llamará antes de que una entidad sea eliminada de forma suave (soft removed) usando el softRemove del repositorio o manager. Ejemplo:

@Entity()
export class Post {
    @BeforeSoftRemove()
    updateStatus() {
        this.status = "soft-removed"
    }
}

Aprende más sobre oyentes.

@AfterSoftRemove

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @AfterSoftRemove. TypeORM lo llamará después de eliminar suavemente la entidad usando softRemove del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @AfterSoftRemove()
    updateStatus() {
        this.status = "soft-removed"
    }
}

Aprende más sobre oyentes.

@BeforeRecover

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @BeforeRecover y TypeORM lo llamará antes de que una entidad sea recuperada usando el recover del repositorio o manager. Ejemplo:

@Entity()
export class Post {
    @BeforeRecover()
    updateStatus() {
        this.status = "recovered"
    }
}

Aprende más sobre oyentes.

@AfterRecover

Puedes definir un método con cualquier nombre en la entidad y marcarlo con @AfterRecover. TypeORM lo llamará después de recuperar la entidad usando recover del repositorio/manager. Ejemplo:

@Entity()
export class Post {
    @AfterRecover()
    updateStatus() {
        this.status = "recovered"
    }
}

Aprende más sobre oyentes.

@EventSubscriber

Marca una clase como suscriptor de eventos que puede escuchar eventos de entidades específicas o de cualquier entidad. Los eventos se disparan usando QueryBuilder y métodos del repositorio/manager. Ejemplo:

@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)
    }
}

Puedes implementar cualquier método de EntitySubscriberInterface. Para escuchar cualquier entidad, simplemente omite el método listenTo y usa any:

@EventSubscriber()
export class PostSubscriber implements EntitySubscriberInterface {
    /**
     * Called before entity insertion.
     */
    beforeInsert(event: InsertEvent<any>) {
        console.log(`BEFORE ENTITY INSERTED: `, event.entity)
    }
}

Aprende más sobre suscriptores.

Otros decoradores

@Index

Este decorador te permite crear un índice de base de datos para una columna específica o varias columnas. También te permite marcar una columna o columnas como únicas. Este decorador se puede aplicar a columnas o a la entidad misma. Úsalo en una columna cuando se necesite un índice en una sola columna y úsalo en la entidad cuando se requiera un único índice en múltiples columnas. Ejemplos:

@Entity()
export class User {
    @Index()
    @Column()
    firstName: string

    @Index({ unique: true })
    @Column()
    lastName: string
}

@Entity()
@Index(["firstName", "lastName"])
@Index(["lastName", "middleName"])
@Index(["firstName", "lastName", "middleName"], { unique: true })
export class User {
    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    middleName: string
}

Aprende más sobre índices.

@Unique

Este decorador te permite crear una restricción única de base de datos para una columna específica o varias columnas. Este decorador solo se puede aplicar a la entidad misma. Debes especificar los nombres de los campos de la entidad (no los nombres de las columnas de la base de datos) como argumentos.

Ejemplos:

@Entity()
@Unique(["firstName"])
@Unique(["lastName", "middleName"])
@Unique("UQ_NAMES", ["firstName", "lastName", "middleName"])
export class User {
    @Column({ name: "first_name" })
    firstName: string

    @Column({ name: "last_name" })
    lastName: string

    @Column({ name: "middle_name" })
    middleName: string
}

Nota: MySQL almacena las restricciones únicas como índices únicos

@Check

Este decorador te permite crear una restricción de verificación (check) de base de datos para una columna específica o varias columnas. Este decorador solo se puede aplicar a la entidad misma.

Ejemplos:

@Entity()
@Check(`"firstName" <> 'John' AND "lastName" <> 'Doe'`)
@Check(`"age" > 18`)
export class User {
    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    age: number
}

Nota: MySQL no admite restricciones de verificación.

@Exclusion

Este decorador te permite crear una restricción de exclusión de base de datos para una columna específica o varias columnas. Este decorador solo se puede aplicar a la entidad misma.

Ejemplos:

@Entity()
@Exclusion(`USING gist ("room" WITH =, tsrange("from", "to") WITH &&)`)
export class RoomBooking {
    @Column()
    room: string

    @Column()
    from: Date

    @Column()
    to: Date
}

Nota: Solo PostgreSQL admite restricciones de exclusión.

@ForeignKey

Este decorador te permite crear una clave foránea de base de datos para una columna específica o varias columnas. Este decorador se puede aplicar a columnas o a la entidad misma. Úsalo en una columna cuando se necesite una clave foránea en una sola columna y úsalo en la entidad cuando se requiera una única clave foránea en múltiples columnas.

Nota: No utilices este decorador con relaciones. Las claves foráneas se crean automáticamente para las relaciones que defines usando decoradores de relación (@ManyToOne, @OneToOne, etc). El decorador @ForeignKey debe usarse únicamente para crear claves foráneas en la base de datos cuando no quieras definir una relación de entidad equivalente.

Ejemplos:

@Entity("orders")
@ForeignKey(() => City, ["cityId", "countryCode"], ["id", "countryCode"])
export class Order {
    @PrimaryColumn()
    id: number

    @Column("uuid", { name: "user_uuid" })
    @ForeignKey<User>("User", "uuid", { name: "FK_user_uuid" })
    userUuid: string

    @Column({ length: 2 })
    @ForeignKey(() => Country, "code")
    countryCode: string

    @Column()
    @ForeignKey("cities")
    cityId: number

    @Column()
    dispatchCountryCode: string

    @ManyToOne(() => Country)
    dispatchCountry: Country

    @Column()
    dispatchCityId: number

    @ManyToOne(() => City)
    dispatchCity: City
}

@Entity("cities")
@Unique(["id", "countryCode"])
export class City {
    @PrimaryColumn()
    id: number

    @Column({ length: 2 })
    @ForeignKey("countries", { onDelete: "CASCADE", onUpdate: "CASCADE" })
    countryCode: string

    @Column()
    name: string
}

@Entity("countries")
export class Country {
    @PrimaryColumn({ length: 2 })
    code: string

    @Column()
    name: string
}

@Entity("users")
export class User {
    @PrimaryColumn({ name: "ref" })
    id: number

    @Column("uuid", { unique: true })
    uuid: string
}