Active Record vs Data Mapper

Traduzione Beta Non Ufficiale

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

Cos'è il pattern Active Record?

In TypeORM puoi utilizzare sia il pattern Active Record che Data Mapper.

Con l'approccio Active Record, definisci tutti i metodi di query all'interno del modello stesso, e salvi, rimuovi e carichi oggetti utilizzando i metodi del modello.

In parole semplici, il pattern Active Record è un approccio per accedere al database direttamente dai tuoi modelli. Puoi approfondire il pattern Active Record su Wikipedia.

Esempio:

import { BaseEntity, Entity, PrimaryGeneratedColumn, Column } from "typeorm"

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

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    isActive: boolean
}

Tutte le entità active-record devono estendere la classe BaseEntity, che fornisce metodi per lavorare con l'entità. Esempio di utilizzo:

// example how to save AR entity
const user = new User()
user.firstName = "Timber"
user.lastName = "Saw"
user.isActive = true
await user.save()

// example how to remove AR entity
await user.remove()

// example how to load AR entities
const users = await User.find({ skip: 2, take: 5 })
const newUsers = await User.findBy({ isActive: true })
const timber = await User.findOneBy({ firstName: "Timber", lastName: "Saw" })

BaseEntity contiene la maggior parte dei metodi del Repository standard. Generalmente non è necessario utilizzare Repository o EntityManager con entità active record.

Supponiamo di voler creare una funzione che restituisca utenti per nome e cognome. Possiamo crearla come metodo statico nella classe User:

import { BaseEntity, Entity, PrimaryGeneratedColumn, Column } from "typeorm"

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

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    isActive: boolean

    static findByName(firstName: string, lastName: string) {
        return this.createQueryBuilder("user")
            .where("user.firstName = :firstName", { firstName })
            .andWhere("user.lastName = :lastName", { lastName })
            .getMany()
    }
}

E utilizzarla come qualsiasi altro metodo:

const timber = await User.findByName("Timber", "Saw")

Cos'è il pattern Data Mapper?

In TypeORM puoi utilizzare sia il pattern Active Record che Data Mapper.

Con l'approccio Data Mapper, definisci tutti i metodi di query in classi separate chiamate "repository", e salvi, rimuovi e carichi oggetti utilizzando i repository. Nel data mapper le tue entità sono molto semplici - definiscono solo le proprietà e possono avere qualche metodo "base".

In sintesi, il data mapper è un approccio per accedere al database tramite repository invece che dai modelli. Puoi approfondire il data mapper su Wikipedia.

Esempio:

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"

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

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column()
    isActive: boolean
}

Esempio di utilizzo:

const userRepository = dataSource.getRepository(User)

// example how to save DM entity
const user = new User()
user.firstName = "Timber"
user.lastName = "Saw"
user.isActive = true
await userRepository.save(user)

// example how to remove DM entity
await userRepository.remove(user)

// example how to load DM entities
const users = await userRepository.find({ skip: 2, take: 5 })
const newUsers = await userRepository.findBy({ isActive: true })
const timber = await userRepository.findOneBy({
    firstName: "Timber",
    lastName: "Saw",
})

Per estendere un repository standard con metodi personalizzati, utilizza il custom repository pattern.

Quale scegliere?

La decisione spetta a te. Entrambe le strategie hanno pro e contro.

Un aspetto da considerare nello sviluppo software è la manutenibilità delle applicazioni. L'approccio Data Mapper favorisce la manutenibilità, risultando più efficace in applicazioni complesse. L'approccio Active Record mantiene le cose semplici, funzionando bene in applicazioni più piccole.