TP 3 : Conception d'une API calculatrice avec NestJS

export const OPERATIONS_V1 = ['addition', 'soustraction', 'multiplication', 'division'] as const;
export type OperationV1 = (typeof OPERATIONS_V1)[number];

export const OPERATIONS_V2 = ['somme', 'produit', 'moyenne', 'min', 'max'] as const;
export type OperationV2 = (typeof OPERATIONS_V2)[number];

export interface Calcul {
  id: number;
  version: 1 | 2;
  operation: string;
  operandes: number[];
  resultat: number;
  date: string;
}

export interface CalculV1Dto {
  operation: OperationV1;
  a: number;
  b: number;
}

export interface CalculV2Dto {
  operation: OperationV2;
  nombres: number[];
}

import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { Calcul, OPERATIONS_V1, OPERATIONS_V2, OperationV1, OperationV2 } from './calculs.types';

@Injectable()
export class CalculsService {
  private historique: Calcul[] = [];
  private prochainId = 1;

  // ----- Version 1 : deux opérandes -----
  calculer(operation: string, a: number, b: number): Calcul {
    if (!OPERATIONS_V1.includes(operation as OperationV1)) {
      throw new BadRequestException(`Opération inconnue : ${operation}. Opérations possibles : ${OPERATIONS_V1.join(', ')}`);
    }
    this.verifierNombres([a, b]);
    if (operation === 'division' && b === 0) {
      throw new BadRequestException('Division par zéro impossible');
    }
    const resultats: Record<OperationV1, number> = {
      addition: a + b,
      soustraction: a - b,
      multiplication: a * b,
      division: a / b,
    };
    return this.enregistrer(1, operation, [a, b], resultats[operation as OperationV1]);
  }

  // ----- Version 2 : une liste de nombres -----
  calculerListe(operation: string, nombres: number[]): Calcul {
    if (!OPERATIONS_V2.includes(operation as OperationV2)) {
      throw new BadRequestException(`Opération inconnue : ${operation}. Opérations possibles : ${OPERATIONS_V2.join(', ')}`);
    }
    if (!Array.isArray(nombres) || nombres.length === 0) {
      throw new BadRequestException('La propriété « nombres » doit être une liste non vide');
    }
    this.verifierNombres(nombres);
    const somme = nombres.reduce((s, n) => s + n, 0);
    const resultats: Record<OperationV2, number> = {
      somme,
      produit: nombres.reduce((p, n) => p * n, 1),
      moyenne: somme / nombres.length,
      min: Math.min(...nombres),
      max: Math.max(...nombres),
    };
    return this.enregistrer(2, operation, nombres, resultats[operation as OperationV2]);
  }

  // ----- Historique -----
  lister(operation?: string, limite = 10): Calcul[] {
    const liste = operation ? this.historique.filter((c) => c.operation === operation) : this.historique;
    return liste.slice(-limite).reverse();          // les plus récents d'abord
  }

  trouver(id: number): Calcul {
    const c = this.historique.find((x) => x.id === id);
    if (!c) throw new NotFoundException(`Calcul ${id} introuvable`);
    return c;
  }

  vider(): void {
    this.historique = [];
  }

  // ----- Outils privés -----
  private verifierNombres(nombres: unknown[]): void {
    if (nombres.some((n) => typeof n !== 'number' || !Number.isFinite(n))) {
      throw new BadRequestException('Les opérandes doivent être des nombres');
    }
  }

  private enregistrer(version: 1 | 2, operation: string, operandes: number[], resultat: number): Calcul {
    const calcul: Calcul = {
      id: this.prochainId++,
      version,
      operation,
      operandes,
      resultat: Math.round(resultat * 1e6) / 1e6,
      date: new Date().toISOString(),
    };
    this.historique.push(calcul);
    return calcul;
  }
}

import {
  Body, Controller, DefaultValuePipe, Delete, Get, HttpCode, HttpStatus, Param, ParseFloatPipe,
  ParseIntPipe, Post, Query, Redirect, Res,
} from '@nestjs/common';
import type { Response } from 'express';
import { CalculsService } from './calculs.service';
import { CalculV1Dto, OPERATIONS_V1 } from './calculs.types';

@Controller({ path: 'calculs', version: '1' })
export class CalculsV1Controller {
  constructor(private readonly calculsService: CalculsService) {}

  @Get('operations')                                   // routes statiques AVANT ':operation'
  operations() {
    return { version: 1, operations: OPERATIONS_V1 };
  }

  @Get('aide')
  @Redirect('https://github.com/VOTRE-COMPTE/api-calculatrice#readme', 302)
  aide() {}

  @Get('historique')
  historique(
    @Query('operation') operation?: string,
    @Query('limite', new DefaultValuePipe(10), ParseIntPipe) limite = 10,
  ) {
    return this.calculsService.lister(operation, limite);
  }

  @Get('historique/:id')
  unCalcul(@Param('id', ParseIntPipe) id: number) {
    return this.calculsService.trouver(id);
  }

  @Delete('historique')
  @HttpCode(HttpStatus.NO_CONTENT)
  viderHistorique() {
    this.calculsService.vider();
  }

  @Get(':operation')                                   // GET /api/v1/calculs/addition?a=2&b=3
  calculer(
    @Param('operation') operation: string,
    @Query('a', ParseFloatPipe) a: number,
    @Query('b', ParseFloatPipe) b: number,
  ) {
    return this.calculsService.calculer(operation, a, b);
  }

  @Post()                                              // POST /api/v1/calculs  { operation, a, b }
  creer(@Body() dto: CalculV1Dto, @Res({ passthrough: true }) res: Response) {
    const calcul = this.calculsService.calculer(dto.operation, dto.a, dto.b);
    res.location(`/api/v1/calculs/historique/${calcul.id}`);
    return calcul;
  }
}

import { Body, Controller, Get, Post } from '@nestjs/common';
import { CalculsService } from './calculs.service';
import { CalculV2Dto, OPERATIONS_V2 } from './calculs.types';

@Controller({ path: 'calculs', version: '2' })
export class CalculsV2Controller {
  constructor(private readonly calculsService: CalculsService) {}

  @Get('operations')
  operations() {
    return { version: 2, operations: OPERATIONS_V2 };
  }

  @Post()                                              // POST /api/v2/calculs  { operation, nombres }
  creer(@Body() dto: CalculV2Dto) {
    return this.calculsService.calculerListe(dto.operation, dto.nombres);
  }
}

import { Module } from '@nestjs/common';
import { CalculsV1Controller } from './calculs-v1.controller';
import { CalculsV2Controller } from './calculs-v2.controller';
import { CalculsService } from './calculs.service';

@Module({
  controllers: [CalculsV1Controller, CalculsV2Controller],
  providers: [CalculsService],
})
export class CalculsModule {}

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

@Controller({ path: 'sante', version: VERSION_NEUTRAL })
export class SanteController {
  @Get()
  etat() {
    return { statut: 'ok', application: 'api-calculatrice', dureeFonctionnement: Math.round(process.uptime()) };
  }
}

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

@Module({
  imports: [CalculsModule],
  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();

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