9.2-entities-et-repository.md

Entities et repository

Créer une entity

Une entity c'est une classe exporté sur laquelle on applique le décorateur @Entity() importé depuis le package typeorm.

On appliquera sur les propriétés de la classe des décorateurs afin de les transformer en colonne avec des propriété spécifique dans le RDBMS (Relational Database Management System).

• @PrimaryGeneratedColumn(): Définit la clé primaire de la table. Par défaut, il s'agit d'un nombre auto-incrémenté. Il est possible d'utliser une stratégie de génération différente en la passant en paramètre (tout les RDBMS ne supporte pas toutes les stratégies de génération). ex: @PrimaryGeneratedColumn('uuid')
• @Column(): Définit une colonnes de la table. Le type sera inférer du typage typescript. Il est toutefois possible de le spécifier en paramétre du décorateur référence par RDBMS

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

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

  @Column({
    type: "varchar",
  })
  firstName: string;

  @Column()
  lastName: string;
}

Options de colonnes:

En plus du type de données, est possible de specifier un certain nombre d'option. référence des options

import { Entity, Column } from "typeorm";

@Entity()
export class User {
  @Column({
    type: "varchar",
    length: 150,
    unique: true,
  })
  name: string;
}

Ceci n'est pas une list exhaustive, mais une présentation des plus utiles:

• type: type de la colonne dans la base de données
• length: taille maximale de la donnée
• default: valeur par défaut
• unique: marque la colonne comme unique (crée un index)
• enum: string[]|AnyEnum: Définit une liste de valeur autorisée
• nullable

Colonnes spéciales:

• @CreateDateColumn(): insère automatiquement la date de création de la ligne
• @UpdateDateColumn(): insère automatiquement la date de la dernière mise à jour de la ligne
• @DeleteDateColumn(): insère automatiquement la date de suppression de la ligne. Active l'option de soft-delete sur l'entity
• @VersionColumn(): insère automatiquement le nombre de modification réalisé sur la ligne.

Injecter un repository

Aprés avoir déclarer les entités d'un module dans la configuration par fonctionnalité de typeORM.

import { TypeOrmModule } from "@nestjs/typeorm";

@Module({
  imports: [
    TypeOrmModule.forFeature([
      /* entité utilisé par le module */
    ]),
  ],
})
export class FeatureModule {}

il est possible d'injecter les repository correspondant à ces entités.

Repository: c'est une classe générique qui prendra une entité en spécialisation Reposiorty<Entity>. Elle offrira un certain nombre de méthode afin de manipuler les données en base: create, save, remove, update, upsert, delete, softDelete/restore, count, find, findById, ... Liste exhaustive en anglais

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { User } from "./user.entity";

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User) private readonly userRepository: Repository<User>,
  ) {}
}

Utilisation d'un repository

import { Injectable } from "@nestjs/common";
import { getRepositoryToken, InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { User } from "./user.entity";

export class UserService {
  constructor(@InjectRepository(User) userRepository: Repository<User>) {}

  list(): Promise<User[]> {
    // liste tout les utilisateur en base
    // il est possible de spécifier via un objet d'option les détails de la requêtes
    return this.userRepository.find();
  }

  get(id: string): Promise<User> {
    // trouve un utilisateur en base avec l'id passé en paramétre ou renvoi une erreur
    return this.userRepository.findOne(id);
  }

  async create(createUserDto: CreateUserDto): Promise<User> {
    // crée une entité
    const user = this.userRepository.create(createUserDto);
    // persiste l'entité en base
    await this.userRepository.save(user);

    // il est possible d'utiliser this.userRepository.insert(createUserDto) mais cela ne retourne pas l'entité persisté.

    return user;
  }

  async update(id: string, updateUserDto: UpdateUserDto): Promise<User> {
    // ceci n'est qu'une méthode pour le faire
    await this.userRepository.update(id, updateUserDto);
    return this.get(id);
  }

  // le typage de retour n'est pas le bon mais il est tard et je le changerai...
  delete(id: string): Promise<void> {
    // il est possible de passer un objet d'option à la place de l'id pour supprimer une ou plusieurs entités en fonction de critéres arbitraire.
    return this.userRepository.delete(id);
  }
}