Exemple des opérations NESTJS CRUD

NESTJS CRUD Operations Exemple

Cet exemple démontre une opération CRUD (créer, lire, mettre à jour, supprimer) pour une entité Cat à l'aide de NESTJS. Nous utiliserons Typeorm pour l'interaction de la base de données. Supposons que vous ayez une entité Cat définie comme suit:

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

@Entity()
export class Cat {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  age: number;
}

Maintenant, créons un fichier cats.controller.ts:

import { Controller, Get, Post, Body, Param, Delete, Put } from '@nestjs/common';
import { CreateCatDto } from './create-cat.dto';
import { Cat } from './cat.entity';
import { CatsService } from './cats.service';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Post()
  async create(@Body() createCatDto: CreateCatDto): Promise<Cat> {
    return this.catsService.create(createCatDto);
  }

  @Get()
  async findAll(): Promise<Cat[]> {
    return this.catsService.findAll();
  }

  @Get(':id')
  async findOne(@Param('id') id: string): Promise<Cat> {
    return this.catsService.findOne(+id);
  }

  @Put(':id')
  async update(@Param('id') id: string, @Body() updateCatDto: CreateCatDto): Promise<Cat> {
    return this.catsService.update(+id, updateCatDto);
  }

  @Delete(':id')
  async remove(@Param('id') id: string): Promise<void> {
    return this.catsService.remove(+id);
  }
}

et un cats.service.ts:

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Cat } from './cat.entity';
import { CreateCatDto } from './create-cat.dto';

@Injectable()
export class CatsService {
  constructor(
    @InjectRepository(Cat)
    private catsRepository: Repository<Cat>,
  ) {}

  async create(cat: CreateCatDto): Promise<Cat> {
    const newCat = this.catsRepository.create(cat);
    return this.catsRepository.save(newCat);
  }

  async findAll(): Promise<Cat[]> {
    return this.catsRepository.find();
  }

  async findOne(id: number): Promise<Cat> {
    return this.catsRepository.findOneBy({ id });
  }

  async update(id: number, cat: CreateCatDto): Promise<Cat> {
    await this.catsRepository.update(id, cat);
    return this.catsRepository.findOneBy({ id });
  }

  async remove(id: number): Promise<void> {
    await this.catsRepository.delete(id);
  }
}

correspondant à installer les packages nécessaires: npm install @nestjs/typeorm typeorm et configurer votre connexion de base dans votre ormconfig.json. Cela fournit un exemple complet, bien que basique,

comment puis-je implémenter les opérations de crud de base à l'aide de NESTJS?

Implémentation des opérations CRUD de base dans les NESTJ implique généralement ces étapes:

1. Définir votre entité: Création d'une classe de type représentant votre modèle de données en utilisant des décorateurs de types (@Entity, @PriMaryGeneratedColumn, @Column, etc.). Cela définit la structure de vos données dans la base de données.
2. Créer un service: Cette couche gère la logique métier pour interagir avec vos données. Il utilise un référentiel (généralement fourni par Typeorm) pour effectuer des opérations de base de données. Le service résume la logique d'accès aux données, permettant au contrôleur de rester propre et de se concentrer sur la manipulation des demandes.
3. Créer un contrôleur: Cette couche gère les demandes HTTP entrantes (publier, obtenir, mettre, supprimer) et déléguer la manipulation réelle des données au service. Les décorateurs de NESTJS (@Controller, @get, @post, @put, @delete, @body, @param) sont utilisés pour cartographier les demandes HTTP aux méthodes de contrôleur.
4. Utiliser une référentiel (par exemple, Typeorm): Un référentiel fournit une couche d'abstraction pour l'interaction de données. Il gère les opérations spécifiques à la base de données, permettant à votre service de rester indépendant de la technologie de base de données sous-jacente. Typeorm est un choix populaire, offrant des fonctionnalités telles que la génération automatique de schéma et les migrations.
5. Objets de transfert de données (DTOS): Créer des DTO pour valider et structurer les données reçues des demandes HTTP. Cela améliore la sécurité et améliore la lisibilité du code.

Quelles sont les meilleures pratiques pour structurer une application NESTJS avec des fonctionnalités crud?

Plusieurs meilleures pratiques améliorent la maintenabilité et l'évolutivité de votre application NESTJS:

• Conception modulaire: Organisez votre code en modules en fonction des fonctionnalités (par exemple, module utilisateur, module de produit). Cela améliore l'organisation et la réutilisabilité du code.
• Séparation des préoccupations: Séparent strictement les préoccupations entre les contrôleurs (demandes de traitement), les services (logique métier) et les référentiels (accès aux données).
• Utiliser des DTO: Utilisez toujours des DTO pour valider et former l'observation et les données existantes. Cela améliore la sécurité et la cohérence des données.
• Validation des entrées: Valider les entrées utilisateur à l'aide de la classe-validatrice ou des bibliothèques similaires pour empêcher les données non valides d'atteindre votre base de données.
• Gestion des erreurs: Implémentez les mécanismes de gestion des erreurs robustes pour gérer gracieusement les exceptions et le rendement de l'état HTTP approprié HTTP. codes.
• Tests: Écrivez des tests d'unité et d'intégration pour assurer l'exactitude et la fiabilité de votre code.
• Versioning: Envisagez d'implémenter les versions de l'API pour gérer les modifications de votre API au fil du temps.

Les pièges à éviter comprennent:

Validation d'entrée insuffisante:
• Ne pas valider les entrées des utilisateurs peut entraîner des vulnérabilités de sécurité (par exemple, l'injection de SQL) et les incohérences de données.
Ignorer la gestion des erreurs:
• Le manque de traitement des erreurs approprié peut entraîner des accidents des applications ou des comportements inattendus. Gérez toujours les exceptions potentielles et renvoyez des messages d'erreur significatifs.
Mélange de logique métier dans les contrôleurs:
• Les contrôleurs doivent principalement se concentrer sur les demandes de routage. La logique métier complexe doit résider dans les services.
L'accès direct à la base de données dans les contrôleurs:
• Les contrôleurs ne doivent jamais interagir directement avec la base de données. Utilisez toujours une couche de service et de référentiel.
Contrôleurs trop complexes:
• Gardez les contrôleurs maigres et concentrés. Les grands contrôleurs complexes sont difficiles à entretenir et à tester.
Le manque de tests:
• Les tests insuffisants peuvent entraîner des bogues et des régressions. Écrivez des tests unitaires pour les services et les tests d'intégration pour les contrôleurs et les référentiels.
Ignorer la pagination et le filtrage:
• pour les grands ensembles de données, implémentez la pagination et le filtrage pour améliorer les performances et l'expérience utilisateur. Ne récupérez pas l'intégralité de l'ensemble de données pour chaque demande.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!