Riferimento ai decoratori

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

Decoratori per entità

`@Entity`

Contrassegna la tua classe come entità. Un'entità è una classe che viene trasformata in una tabella del database. Puoi specificare il nome della tabella nell'entità:

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

Questo codice creerà una tabella nel database chiamata "users".

Puoi anche specificare opzioni aggiuntive per l'entità:

name - nome della tabella. Se non specificato, il nome viene generato dal nome della classe dell'entità.
database - nome del database nel server DB selezionato.
schema - nome dello schema.
engine - motore del database da impostare durante la creazione della tabella (funziona solo in alcuni database).
synchronize - le entità contrassegnate con false vengono escluse dagli aggiornamenti dello schema.
orderBy - specifica l'ordinamento predefinito per le entità nelle operazioni find e QueryBuilder.

Esempio:

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

Maggiori informazioni sulle Entità.

`@ViewEntity`

Un'entità vista è una classe che mappa una vista del database.

@ViewEntity() accetta le seguenti opzioni:

name - nome della vista. Se non specificato, il nome viene generato dal nome della classe dell'entità.
database - nome del database nel server DB selezionato.
schema - nome dello schema.
expression - definizione della vista. Parametro obbligatorio.

expression può essere una stringa con colonne e tabelle correttamente escape, a seconda del database utilizzato (esempio PostgreSQL):

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

oppure un'istanza di 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: il binding dei parametri non è supportato a causa di limitazioni dei driver. Utilizza invece parametri letterali.

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

Maggiori informazioni sulle Entità Vista.

Decoratori per colonne

`@Column`

Contrassegna una proprietà della tua entità come colonna della tabella. Esempio:

@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 accetta diverse opzioni configurabili:

type: ColumnType - Tipo di colonna. Uno dei tipi di colonna supportati.
name: string - Nome della colonna nella tabella del database. Per impostazione predefinita, il nome della colonna è generato dal nome della proprietà. Puoi modificarlo specificando un nome personalizzato.
length: string|number - Lunghezza del tipo di colonna. Ad esempio, per creare un tipo varchar(150) è necessario specificare tipo di colonna e opzione length.
width: number - larghezza di visualizzazione del tipo di colonna. Utilizzato solo per tipi interi MySQL. Deprecato nelle versioni più recenti di MySQL, verrà rimosso da TypeORM nelle prossime versioni.
onUpdate: string - Trigger ON UPDATE. Utilizzato solo in MySQL.
nullable: boolean - determina se la colonna può essere NULL o deve essere sempre NOT NULL. Per impostazione predefinita è nullable: false.
update: boolean - Indica se il valore della colonna viene aggiornato dall'operazione "save". Se false, potrai scrivere questo valore solo durante il primo inserimento dell'oggetto. Valore predefinito: true.
insert: boolean - Indica se il valore della colonna viene impostato durante il primo inserimento dell'oggetto. Valore predefinito: true.
select: boolean - Definisce se nascondere questa colonna per impostazione predefinita nelle query. Se impostato su false, i dati della colonna non verranno mostrati in una query standard. Per impostazione predefinita è select: true.
default: string - Aggiunge il valore DEFAULT a livello di database per la colonna.
primary: boolean - Contrassegna la colonna come primaria. Equivalente all'uso di @PrimaryColumn.
unique: boolean - Contrassegna la colonna come univoca (crea un vincolo unique). Valore predefinito: false.
comment: string - Commento della colonna nel database. Non supportato da tutti i tipi di database.
precision: number - Precisione per colonne decimali (numeriche esatte), rappresenta il numero massimo di cifre memorizzate. Si applica solo a colonne decimali. Utilizzato in alcuni tipi di colonna.
scale: number - Scala per colonne decimali (numeriche esatte), rappresenta il numero di cifre dopo la virgola e non può superare la precisione. Utilizzato in alcuni tipi di colonna.
zerofill: boolean - Applica l'attributo ZEROFILL alle colonne numeriche. Utilizzato solo in MySQL. Se true, MySQL aggiunge automaticamente l'attributo UNSIGNED. Deprecato nelle versioni più recenti di MySQL, verrà rimosso da TypeORM nelle prossime versioni. Utilizzare una colonna carattere e la funzione LPAD come suggerito da MySQL.
unsigned: boolean - Applica l'attributo UNSIGNED alle colonne numeriche. Utilizzato solo in MySQL.
charset: string - Definisce il set di caratteri di una colonna. Non supportato da tutti i tipi di database.
collation: string - Definisce la collation di una colonna.
enum: string[]|AnyEnum - Utilizzato nei tipi di colonna enum per specificare l'elenco dei valori consentiti. Puoi specificare un array di valori o una classe enum.
enumName: string - Nome per il tipo enum generato. Se non specificato, TypeORM genera un tipo enum da nomi di entità e colonne - necessario se intendi usare lo stesso tipo enum in tabelle diverse.
primaryKeyConstraintName: string - Nome per il vincolo di chiave primaria. Se non specificato, il nome viene generato da tabella e colonne coinvolte.
asExpression: string - Espressione per colonne generate. Utilizzato solo in MySQL e Postgres.
generatedType: "VIRTUAL"|"STORED" - Tipo di colonna generata. Utilizzato solo in MySQL e Postgres (solo "STORED").
hstoreType: "object"|"string" - Tipo di ritorno per colonne HSTORE. Restituisce il valore come stringa o oggetto. Utilizzato solo in Postgres.
array: boolean - Utilizzato per tipi di colonna PostgreSQL e CockroachDB che supportano array (ad esempio int[]).
transformer: ValueTransformer|ValueTransformer[] - Specifica un value transformer (o array di value transformer) da utilizzare per effettuare il (un)marshalling di questa colonna durante letture/scritture nel database. In caso di array, i value transformer verranno applicati in ordine naturale da entityValue a databaseValue, e in ordine inverso da databaseValue a entityValue.
spatialFeatureType: string - Tipo di feature opzionale (Point, Polygon, LineString, Geometry) utilizzato come vincolo per colonne spaziali. Se non specificato, si comporterà come se fosse fornito Geometry. Utilizzato solo in PostgreSQL e CockroachDB.
srid: number - Spatial Reference ID opzionale utilizzato come vincolo per colonne spaziali. Se non specificato, il valore predefinito è 0. Le coordinate geografiche standard (latitudine/longitudine nel datum WGS84) corrispondono a EPSG 4326. Utilizzato solo in PostgreSQL e CockroachDB.

Scopri di più sulle colonne delle entità.

`@PrimaryColumn`

Contrassegna una proprietà della tua entità come colonna primaria della tabella. Equivalente al decoratore @Column ma imposta l'opzione primary su true.

Esempio:

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

@PrimaryColumn() supporta un nome personalizzato per il vincolo di chiave primaria:

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

Nota: quando si utilizza primaryKeyConstraintName con più chiavi primarie, il nome del vincolo deve essere identico per tutte le colonne primarie.

Scopri di più sulle colonne delle entità.

`@PrimaryGeneratedColumn`

Contrassegna una proprietà nella tua entità come colonna primaria generata dalla tabella. La colonna creata è primaria e il suo valore viene generato automaticamente. Esempio:

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

@PrimaryGeneratedColumn() supporta un nome personalizzato per il vincolo di chiave primaria:

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

Esistono quattro strategie di generazione:

increment - utilizza AUTO_INCREMENT / SERIAL / SEQUENCE (dipende dal tipo di database) per generare numeri incrementali.
identity - solo per PostgreSQL 10+. Le versioni di Postgres superiori alla 10 supportano la colonna IDENTITY conforme allo standard SQL. Quando si imposta la strategia di generazione su identity, la colonna verrà prodotta usando GENERATED [ALWAYS|BY DEFAULT] AS IDENTITY.
uuid - genera stringhe uuid univoche.
rowid - solo per CockroachDB. Il valore viene generato automaticamente usando la funzione unique_rowid(), producendo un intero a 64 bit dal timestamp corrente e dall'ID del nodo che esegue l'operazione INSERT o UPSERT.

Nota: le proprietà con strategia di generazione rowid devono essere di tipo string

La strategia di generazione predefinita è increment. Per cambiarla in un'altra strategia, passala semplicemente come primo argomento al decoratore:

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

Scopri di più sulle colonne delle entità.

`@ObjectIdColumn`

Contrassegna una proprietà nella tua entità come ObjectId. Questo decoratore è utilizzato esclusivamente in MongoDB. Ogni entità in MongoDB deve avere una colonna ObjectId. Esempio:

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

Scopri di più su MongoDB.

`@CreateDateColumn`

Colonna speciale impostata automaticamente al momento dell'inserimento dell'entità. Non è necessario assegnare un valore manualmente - verrà impostato automaticamente. Esempio:

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

`@UpdateDateColumn`

Colonna speciale impostata automaticamente all'ora di aggiornamento dell'entità ogni volta che chiami save tramite entity manager o repository. Non è necessario assegnare un valore manualmente - verrà impostato automaticamente.

Questa colonna viene aggiornata automaticamente anche durante le operazioni upsert quando un aggiornamento avviene a causa di un conflitto.

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

`@DeleteDateColumn`

Colonna speciale impostata automaticamente all'ora di eliminazione dell'entità ogni volta che chiami il soft-delete tramite entity manager o repository. Non è necessario impostare manualmente questa colonna - verrà impostata automaticamente.

La funzionalità di soft delete integrata in TypeORM utilizza scope globali per recuperare dal database solo entità "non eliminate".

Se @DeleteDateColumn è impostata, lo scope predefinito sarà "non eliminato".

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

`@VersionColumn`

Colonna speciale impostata automaticamente alla versione dell'entità (numero incrementale) ogni volta che chiami save tramite entity manager o repository. Non è necessario assegnare un valore manualmente - verrà impostato automaticamente.

Questa colonna viene aggiornata automaticamente anche durante le operazioni upsert quando un aggiornamento avviene a causa di un conflitto.

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

`@Generated`

Contrassegna una colonna come valore generato. Ad esempio:

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

Il valore viene generato una sola volta, prima dell'inserimento dell'entità nel database.

`@VirtualColumn`

Colonna speciale che non viene mai salvata nel database, fungendo quindi da proprietà di sola lettura. Ogni volta che si richiama find o findOne dall'entity manager, il valore viene ricalcolato in base alla funzione di query fornita nel decoratore VirtualColumn. L'argomento alias passato alla query fa riferimento all'esatto alias dell'entità nella query generata internamente.

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

Decoratori per le relazioni

`@OneToOne`

Relazione uno-a-uno in cui A contiene una sola istanza di B, e B contiene una sola istanza di A. Consideriamo ad esempio le entità User e Profile. Un utente può avere un solo profilo, e ogni profilo appartiene a un solo utente. Esempio:

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

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

Maggiori informazioni sulle relazioni uno-a-uno.

`@ManyToOne`

Relazione molti-a-uno / uno-a-molti in cui A contiene multiple istanze di B, ma B contiene una sola istanza di A. Consideriamo ad esempio le entità User e Photo. Un utente può avere molte foto, ma ogni foto appartiene a un solo utente. Esempio:

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
}

Maggiori informazioni sulle relazioni molti-a-uno / uno-a-molti.

`@OneToMany`

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

Maggiori informazioni sulle relazioni molti-a-uno / uno-a-molti.

`@ManyToMany`

Relazione molti-a-molti in cui A contiene multiple istanze di B, e B contiene multiple istanze di A. Consideriamo ad esempio le entità Question e Category. Una domanda può appartenere a più categorie, e ogni categoria può contenere più domande. Esempio:

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

Maggiori informazioni sulle relazioni molti-a-molti.

`@JoinColumn`

Definisce quale lato della relazione contiene la colonna di join con foreign key, consentendo di personalizzare: nome colonna di join, nome colonna referenziata e nome foreign key. Esempio:

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

`@JoinTable`

Utilizzato per relazioni many-to-many, descrive le colonne di join della tabella "junction". Questa tabella speciale viene creata automaticamente da TypeORM con colonne collegate alle entità correlate. È possibile personalizzare: nome tabella junction, nomi colonne al suo interno, colonne referenziate tramite attributi joinColumn/inverseJoinColumn, e nomi foreign key. Il parametro synchronize può essere impostato su false per saltare gli aggiornamenti dello schema (analogamente a @Entity).

Esempio:

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

Se la tabella di destinazione ha chiavi primarie composite, è necessario passare un array di proprietà al decoratore @JoinTable.

`@RelationId`

Carica l'ID (o gli ID) di relazioni specifiche in proprietà. Ad esempio, con una relazione many-to-one category nell'entità Post, è possibile ottenere un nuovo category ID contrassegnando una proprietà con @RelationId. Esempio:

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

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

Questa funzionalità supporta tutti i tipi di relazioni, incluse many-to-many:

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

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

L'ID di relazione è utilizzato solo per rappresentazione. La relazione sottostante non viene aggiunta/rimossa/modificata quando si cambia il valore.

Decoratori per subscriber e listener

`@AfterLoad`

Puoi definire un metodo con nome arbitrario nell'entità e contrassegnarlo con @AfterLoad e TypeORM lo richiamerà ogni volta che l'entità viene caricata tramite QueryBuilder o metodi find di repository/manager. Esempio:

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