TP 4 : Réaliser une API TodoList (CRUD en mémoire) avec NestJS

export const STATUTS = ['a-faire', 'en-cours', 'terminee'] as const;
export type Statut = (typeof STATUTS)[number];

export const PRIORITES = ['basse', 'normale', 'haute'] as const;
export type Priorite = (typeof PRIORITES)[number];

export interface Tache {
  id: string;
  titre: string;
  description?: string;
  statut: Statut;
  priorite: Priorite;
  echeance?: string;          // AAAA-MM-JJ
  creePar: string;
  creeLe: string;
  modifieLe: string;
}

export class CreerTacheDto {
  titre: string;
  description?: string;
  priorite?: Priorite;
  echeance?: string;
}

export class ModifierTacheDto {
  titre?: string;
  description?: string;
  statut?: Statut;
  priorite?: Priorite;
  echeance?: string;
}

export interface TodoConfig {
  maxTaches: number;
  prioriteParDefaut: Priorite;
}

export const TODO_CONFIG = 'TODO_CONFIG';

import { Injectable } from '@nestjs/common';

export const HORLOGE = Symbol('HORLOGE');

export interface Horloge {
  maintenant(): Date;
}

@Injectable()
export class HorlogeSysteme implements Horloge {
  maintenant(): Date {
    return new Date();
  }
}

import { Injectable } from '@nestjs/common';
import { randomUUID } from 'node:crypto';

export abstract class GenerateurId {
  abstract suivant(): string;
}

@Injectable()
export class GenerateurSequentiel extends GenerateurId {
  private compteur = 0;
  suivant(): string {
    return `T-${String(++this.compteur).padStart(4, '0')}`;    // T-0001, T-0002…
  }
}

@Injectable()
export class GenerateurUuid extends GenerateurId {
  suivant(): string {
    return randomUUID();
  }
}

import { Inject, Injectable, Scope } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import type { Request } from 'express';

@Injectable({ scope: Scope.REQUEST })
export class ContexteUtilisateur {
  readonly nom: string;

  constructor(@Inject(REQUEST) requete: Request) {
    const entete = requete.headers['x-utilisateur'];
    this.nom = typeof entete === 'string' && entete.trim() ? entete.trim() : 'anonyme';
  }
}

import { BadRequestException, ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
import { GenerateurId } from '../common/generateur-id';
import { HORLOGE, Horloge } from '../common/horloge';
import {
  CreerTacheDto, ModifierTacheDto, Priorite, PRIORITES, Statut, STATUTS, Tache, TODO_CONFIG, TodoConfig,
} from './tache.model';

export interface FiltreTaches {
  statut?: string;
  priorite?: string;
  q?: string;
}

@Injectable()
export class TachesService {
  private taches: Tache[] = [];

  constructor(
    private readonly generateurId: GenerateurId,
    @Inject(HORLOGE) private readonly horloge: Horloge,
    @Inject(TODO_CONFIG) private readonly config: TodoConfig,
  ) {}

  findAll(filtre: FiltreTaches = {}): Tache[] {
    if (filtre.statut) this.verifierStatut(filtre.statut);
    if (filtre.priorite) this.verifierPriorite(filtre.priorite);
    const q = filtre.q?.toLowerCase();
    return this.taches
      .filter((t) => !filtre.statut || t.statut === filtre.statut)
      .filter((t) => !filtre.priorite || t.priorite === filtre.priorite)
      .filter((t) => !q || `${t.titre} ${t.description ?? ''}`.toLowerCase().includes(q))
      .toSorted((a, b) => (a.echeance ?? '9999').localeCompare(b.echeance ?? '9999'));   // échéance la plus proche d'abord
  }

  findOne(id: string): Tache {
    const t = this.taches.find((x) => x.id === id);
    if (!t) throw new NotFoundException(`Tâche ${id} introuvable`);
    return t;
  }

  create(dto: CreerTacheDto, utilisateur: string): Tache {
    if (!dto?.titre?.trim()) throw new BadRequestException('Le titre est obligatoire');
    if (this.taches.length >= this.config.maxTaches) {
      throw new ConflictException(`Nombre maximal de tâches atteint (${this.config.maxTaches})`);
    }
    if (dto.priorite) this.verifierPriorite(dto.priorite);
    if (dto.echeance) this.verifierDate(dto.echeance);
    const maintenant = this.horloge.maintenant().toISOString();
    const tache: Tache = {
      id: this.generateurId.suivant(),
      titre: dto.titre.trim(),
      description: dto.description,
      statut: 'a-faire',
      priorite: dto.priorite ?? this.config.prioriteParDefaut,
      echeance: dto.echeance,
      creePar: utilisateur,
      creeLe: maintenant,
      modifieLe: maintenant,
    };
    this.taches.push(tache);
    return tache;
  }

  update(id: string, dto: ModifierTacheDto): Tache {
    const t = this.findOne(id);
    if (dto.statut) this.verifierStatut(dto.statut);
    if (dto.priorite) this.verifierPriorite(dto.priorite);
    if (dto.echeance) this.verifierDate(dto.echeance);
    if (dto.titre !== undefined && !dto.titre.trim()) throw new BadRequestException('Le titre ne peut pas être vide');
    const { titre, description, statut, priorite, echeance } = dto;   // seuls les champs autorisés
    Object.assign(t, Object.fromEntries(
      Object.entries({ titre, description, statut, priorite, echeance }).filter(([, v]) => v !== undefined),
    ));
    t.modifieLe = this.horloge.maintenant().toISOString();
    return t;
  }

  terminer(id: string): Tache {
    const t = this.findOne(id);
    if (t.statut === 'terminee') throw new ConflictException(`La tâche ${id} est déjà terminée`);
    return this.update(id, { statut: 'terminee' });
  }

  remove(id: string): void {
    this.findOne(id);
    this.taches = this.taches.filter((t) => t.id !== id);
  }

  supprimerTerminees(): number {
    const avant = this.taches.length;
    this.taches = this.taches.filter((t) => t.statut !== 'terminee');
    return avant - this.taches.length;
  }

  statistiques() {
    const aujourdHui = this.horloge.maintenant().toISOString().slice(0, 10);
    const parStatut = Object.fromEntries(STATUTS.map((s) => [s, this.taches.filter((t) => t.statut === s).length]));
    const enRetard = this.taches.filter((t) => t.statut !== 'terminee' && t.echeance && t.echeance < aujourdHui).length;
    const avancement = this.taches.length ? Math.round((parStatut['terminee'] / this.taches.length) * 100) : 0;
    return { total: this.taches.length, parStatut, enRetard, avancement };
  }

  private verifierStatut(s: string): asserts s is Statut {
    if (!STATUTS.includes(s as Statut)) throw new BadRequestException(`Statut invalide : ${s} (${STATUTS.join(', ')})`);
  }

  private verifierPriorite(p: string): asserts p is Priorite {
    if (!PRIORITES.includes(p as Priorite)) throw new BadRequestException(`Priorité invalide : ${p} (${PRIORITES.join(', ')})`);
  }

  private verifierDate(d: string): void {
    if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || Number.isNaN(Date.parse(d))) {
      throw new BadRequestException(`Échéance invalide : ${d} (format AAAA-MM-JJ)`);
    }
  }
}

import {
  Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Patch, Post, Query, Res,
} from '@nestjs/common';
import type { Response } from 'express';
import { ContexteUtilisateur } from '../common/contexte-utilisateur';
import { CreerTacheDto, ModifierTacheDto } from './tache.model';
import { TachesService } from './taches.service';

@Controller({ path: 'taches', version: '1' })
export class TachesController {
  constructor(
    private readonly tachesService: TachesService,
    private readonly contexte: ContexteUtilisateur,       // portée requête
  ) {}

  @Get()
  findAll(
    @Query('statut') statut?: string,
    @Query('priorite') priorite?: string,
    @Query('q') q?: string,
    @Res({ passthrough: true }) res?: Response,
  ) {
    const liste = this.tachesService.findAll({ statut, priorite, q });
    res?.setHeader('X-Total-Count', String(liste.length));
    return liste;
  }

  @Get('statistiques')                                   // avant ':id'
  statistiques() {
    return this.tachesService.statistiques();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.tachesService.findOne(id);
  }

  @Post()
  create(@Body() dto: CreerTacheDto, @Res({ passthrough: true }) res: Response) {
    const tache = this.tachesService.create(dto, this.contexte.nom);
    res.location(`/api/v1/taches/${tache.id}`);
    return tache;
  }

  @Patch(':id/terminer')
  terminer(@Param('id') id: string) {
    return this.tachesService.terminer(id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() dto: ModifierTacheDto) {
    return this.tachesService.update(id, dto);
  }

  @Delete('terminees')                                   // avant ':id'
  supprimerTerminees() {
    return { supprimees: this.tachesService.supprimerTerminees() };
  }

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT)
  remove(@Param('id') id: string) {
    this.tachesService.remove(id);
  }
}

import { Module } from '@nestjs/common';
import { ContexteUtilisateur } from '../common/contexte-utilisateur';
import { GenerateurId, GenerateurSequentiel, GenerateurUuid } from '../common/generateur-id';
import { HORLOGE, HorlogeSysteme } from '../common/horloge';
import { TODO_CONFIG, TodoConfig } from './tache.model';
import { TachesController } from './taches.controller';
import { TachesService } from './taches.service';

@Module({
  controllers: [TachesController],
  providers: [
    TachesService,
    ContexteUtilisateur,
    { provide: HORLOGE, useClass: HorlogeSysteme },
    {
      provide: GenerateurId,
      useClass: process.env.ID_MODE === 'uuid' ? GenerateurUuid : GenerateurSequentiel,
    },
    {
      provide: TODO_CONFIG,
      useFactory: (): TodoConfig => ({
        maxTaches: Number(process.env.MAX_TACHES ?? 100),
        prioriteParDefaut: 'normale',
      }),
    },
  ],
})
export class TachesModule {}

import { Controller, Get, VERSION_NEUTRAL } from '@nestjs/common';

@Controller({ path: 'sante', version: VERSION_NEUTRAL })
export class SanteController {
  @Get()
  etat() {
    return { statut: 'ok', application: 'api-todolist' };
  }
}

import { Module } from '@nestjs/common';
import { SanteController } from './sante.controller';
import { TachesModule } from './taches/taches.module';

@Module({
  imports: [TachesModule],
  controllers: [SanteController],
})
export class AppModule {}

import { Logger, VersioningType } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api', { exclude: ['sante'] });
  app.enableVersioning({ type: VersioningType.URI, defaultVersion: '1' });
  app.enableCors({ exposedHeaders: ['Location', 'X-Total-Count'] });

  const port = process.env.PORT ?? 3000;
  await app.listen(port);
  Logger.log(`API TodoList : http://localhost:${port}/api/v1/taches`, 'Bootstrap');
}
bootstrap();