Relaciones Ansiosas y Perezosas

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 →

Relaciones ansiosas

Las relaciones ansiosas se cargan automáticamente cada vez que recuperas entidades desde la base de datos. Por ejemplo:

import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm"
import { Question } from "./Question"

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

    @Column()
    name: string

    @ManyToMany((type) => Question, (question) => question.categories)
    questions: Question[]
}

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, (category) => category.questions, {
        eager: true,
    })
    @JoinTable()
    categories: Category[]
}

Ahora, cuando cargas preguntas no necesitas hacer JOIN ni especificar qué relaciones quieres cargar. Se cargarán automáticamente:

const questionRepository = dataSource.getRepository(Question)

// questions will be loaded with its categories
const questions = await questionRepository.find()

Las relaciones ansiosas solo funcionan con métodos find*. Si usas QueryBuilder, las relaciones ansiosas se desactivan y debes usar leftJoinAndSelect para cargar la relación. Las relaciones ansiosas solo pueden usarse en un lado de la relación: activar eager: true en ambos lados no está permitido.

Relaciones perezosas

Las entidades en relaciones perezosas se cargan cuando las accedes. Estas relaciones deben tener tipo Promise: almacenas el valor en una promesa y al cargarlas también obtienes una promesa. Ejemplo:

import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm"
import { Question } from "./Question"

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

    @Column()
    name: string

    @ManyToMany((type) => Question, (question) => question.categories)
    questions: Promise<Question[]>
}

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, (category) => category.questions)
    @JoinTable()
    categories: Promise<Category[]>
}

categories es una Promise. Significa que es perezosa y solo puede almacenar una promesa con un valor interno. Ejemplo de cómo guardar esta relación:

const category1 = new Category()
category1.name = "animals"
await dataSource.manager.save(category1)

const category2 = new Category()
category2.name = "zoo"
await dataSource.manager.save(category2)

const question = new Question()
question.categories = Promise.resolve([category1, category2])
await dataSource.manager.save(question)

Ejemplo de cómo cargar objetos en relaciones perezosas:

const [question] = await dataSource.getRepository(Question).find()
const categories = await question.categories
// you'll have all question's categories inside "categories" variable now

Nota: si vienes de otros lenguajes (Java, PHP, etc.) y estás acostumbrado a usar relaciones perezosas en todos lados - ten cuidado. Esos lenguajes no son asíncronos, y la carga perezosa se implementa diferente, sin usar promesas. En JavaScript y Node.JS, debes usar promesas para tener relaciones de carga perezosa. Esta es una técnica no estándar y se considera experimental en TypeORM.