Les APIs

Introduction aux API, JSON, JWT, OAuth et API Keys

NPM

Node Package Manager

Qu’est-ce qu’une API ?

  • Interface entre applications
  • Exposition des fonctionnalités via des endpoints
  • Méthodes : GET, POST, PUT, DELETE

JSON

JavaScript Object Notation


{
  "personne": {
    "nom": "Alice",
    "age": 25,
    "adresse": {
      "rue": "12 rue des Lilas",
      "ville": "Paris",
      "codePostal": "75001"
    },
    "contacts": [
      { "type": "email", "valeur": "alice@mail.com" },
      { "type": "téléphone", "valeur": "0601020304" }
    ]
  }
}
    

XML

eXtensible Markup Language



    Alice
    25
    
        12 rue des Lilas
        Paris
        75001
    
    
        alice@mail.com
        0601020304
    

    

Authentification

  • JWT - Token sécurisé
  • OAuth 2.0 - Accès via Google, GitHub...
  • API Keys - Clé unique par utilisateur

JWT - JSON Web Token

  1. L’utilisateur se connecte
  2. Le serveur génère un JWT
  3. Le JWT est stocké et envoyé dans chaque requête
  4. Le serveur API vérifie le JWT avant d’autoriser l’accès

OAuth 2.0

  1. L’utilisateur demande l’accès
  2. Redirection vers le fournisseur OAuth
  3. Connexion et validation
  4. Récupération du token d’accès
  5. Accès aux ressources sécurisées

API Keys

  1. Le client obtient une clé unique
  2. Il envoie cette clé dans chaque requête
  3. L’API vérifie et accorde/refuse l’accès

Utilisation de Fetch

Les Promises

Une Promise est un objet qui représente une opération asynchrone.

Elle peut être :

Pending (en attente) / Fulfilled (réussie) / Rejected (échouée)

then, catch, finally


// Exemple basique de Promise
const maPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
        if (Math.random() > 0.5) {
            resolve("✅ Succès !");
        } else {
            reject("❌ Erreur !");
        }
    }, 1000);
});

// Utilisation de then/catch/finally
maPromise
    .then(result => console.log(result))  // Si réussite
    .catch(error => console.error(error)) // Si échec
    .finally(() => console.log("🔄 Opération terminée"));
    

Chaînage de Promises


fetch("https://jsonplaceholder.typicode.com/users/1")
	// Convertit la réponse en JSON
    .then(response => response.json())

	// Récupère les posts de l'utilisateur
    .then(user => fetch(`https://jsonplaceholder.typicode.com/posts?userId=${user.id}`))
    .then(response => response.json())

	// Affiche le résultat
    .then(posts => console.log("📝 Articles :", posts))
    .catch(error => console.error("🚨 Erreur :", error));
    

async/await


// Fonction asynchrone
async function getUserData() {
    try {
        const response = await fetch("https://jsonplaceholder.typicode.com/users/1");
        const user = await response.json();
        console.log("👤 Utilisateur :", user);
    } catch (error) {
        console.error("❌ Erreur :", error);
    } finally {
        console.log("🔄 Requête terminée");
    }
}

getUserData();
    

Gestion des erreurs


async function getData(url) {
    try {
        let response = await fetch(url);
        if (!response.ok) {
            throw new Error(
				`Erreur ${response.status} : ${response.statusText}`
			);
        }
        return await response.json();
    } catch (error) {
        console.error("🚨 Erreur détectée :", error);
        return null;
    }
}

// Exemple d'utilisation
getData("https://jsonplaceholder.typicode.com/users/1")
    .then(data => console.log("✅ Données reçues :", data));
    

Le Back du Tierlist Maker

Express / TS / MongoDB

  • TypeScript : Typage statique
  • Express.js : Framework minimaliste pour APIs
  • MongoDB : Base de données NoSQL

TypeScript : Pourquoi ?


// Exemple : Déclaration typée
interface User {
    id: string;
    name: string;
    email: string;
}
const user: User = { id: "1", name: "Alice", email: "alice@email.com" };
    

Express.js


import express from "express";
const app = express();

// Middleware JSON
app.use(express.json());

// Route de test
app.get("/", (req, res) => {
    res.send("🚀 Serveur Express en TypeScript !");
});

app.listen(3000, () => console.log("✅ Serveur lancé !"));
    

Architecture du projet


/src
│── controllers/    # Gère la logique métier des routes
│── middlewares/    # Intercepte et modifie les requêtes/réponses
│── models/         # Définition des schémas Mongoose
│── routes/         # Définition des endpoints Express
│── services/       # Gestion des données (ex: MongoDB, cache)
│── utils/          # Fonctions utilitaires globales
│── app.ts          # Point d’entrée de l’application
└── server.ts       # Configuration du serveur
    

Le Not Only SQL

Le Not Only SQL

  • Base de données NoSQL
    • Stocke les données sous forme de documents JSON
  • Flexible
    • Pas de schéma fixe (contrairement aux bases SQL)
  • Scalabilité horizontale
    • Gestion facile de grandes quantités de données

Documents et Collections

Contrairement aux bases SQL, MongoDB stocke des documents JSON au lieu de tables.

{
    "_id": "650f2a91f0c3e454c1d8eabc",
    "nom": "Alice",
    "email": "alice@email.com",
    "age": 25,
    "adresse": {
        "ville": "Paris",
        "codePostal": "75000"
    }
}

Les documents sont regroupés dans des collections, équivalent aux tables SQL.

SQL vs NoSQL

Caractéristique SQL NoSQL (MongoDB)
Schéma Fixe (colonnes définies) Flexible (JSON dynamique)
Structure Tables & Relations Documents & Collections
Scalabilité Verticale (serveurs plus puissants) Horizontale (plusieurs serveurs)
Requêtes SQL (SELECT, JOIN...) JSON (find, aggregate...)

Requêtes MongoDB (CRUD)

Les opérations courantes sur MongoDB


// CREATE : Ajouter un utilisateur
db.users.insertOne({ name: "Alice", age: 25 });

// READ : Trouver un utilisateur
db.users.findOne({ name: "Alice" });

// UPDATE : Modifier un utilisateur
db.users.updateOne({ name: "Alice" }, { $set: { age: 26 } });

// DELETE : Supprimer un utilisateur
db.users.deleteOne({ name: "Alice" });
    

MongoDB et Express

Utilisation avec Mongoose pour simplifier les interactions :


import mongoose from "mongoose";

const UserSchema = new mongoose.Schema({
    name: String,
    email: String,
    age: Number
});

export default mongoose.model("User", UserSchema);
    

Connexion à MongoDB

Connexion via Mongoose :


import mongoose from "mongoose";

const connectDB = async () => {
    try {
        await mongoose.connect("mongodb://localhost:27017/monapp");
        console.log("✅ Connecté à MongoDB");
    } catch (error) {
        console.error("❌ Erreur de connexion :", error);
    }
};

export default connectDB;