Restful : C’est quoi une méthode safe ou idempotent ?

Safe

Les méthodes safe, sécurisées en français, sont toutes les méthodes HTTP qui ne modifient aucune ressource.

Par exemple, une requête GET sur une ressource ne devrait jamais modifier de données.

Ainsi, la requête suivant n’est pas correcte si son but est réellement de supprimer un utilisateur :

GET /user/delete/1234

L’avantage des méthodes safe c’est qu’elles peuvent être mise en cache ou en prefetch sans crainte, a condition de respecter cette règle.

Idempotent

Une méthode idempotente est une méthode qui peut être appelée autant de fois que l’on souhaite et qui retournera toujours le même résultat.

Par exemple, une méthode qui affecte une valeur à une ressource est idempotente :

username = mike

Peut être appelée un million de fois, le résultat sera toujours le même. Par conttre, la méthode qui ferait l’action suivante n’est pas idempotente :

user_age = user_age +1

On remarquera aussi que ces deux méthodes ne sont pas safe, elles modifient toutes les deux des données.

L’idempotence est importante quand on veut réaliser une API robuste. Par exemple si on permet d’effectuer une mise a jour via un POST ça peut poser un problème, imaginons que la requête de ce POST n’aboutisse pas (timeout par exemple) on peut alors se retrouver avec des données corrompues : faut-il recommencer ? La données a-elle été mise à jour ?

Si on utilise les méthodes idempotents à bons escient on n’a pas besoin de se poser ces questions et on peut renvoyer ces requêtes tant qu’elles ne passent pas correctement.

Un petit récapitulatif

METHODE HTTP Idempotent Safe
OPTIONS Oui Oui
GET Oui Oui
HEAD Oui Oui
PUT Oui Non
POST Non Non
DELETE Oui Non
PATCH Non Non

Pour avoir plus d’informations vous pouvez aller voir ce site référence: restcookbook.com

 

Une courte introduction aux Promises

La programmation synchrone comme en PHP ou en Python est simple à appréhender, une étape à la fois, chaque instruction est exécutée l’une après l’autre. Mais lorsque vous regardez un peu ce qu’il se passe du coté de nodejs et du javascript, vous vous rendez vite compte que la programmation asynchrone omniprésente. C’est un gain de performances, pouvoir lancer plusieurs requêtes en même temps et recevoir (et traiter) les réponses à mesure qu’elle arrivent, c’est plutôt efficace.

Par contre ça peut vite devenir très difficile à gérer lorsque l’application grandit, c’est là que les objets Promise entrent en jeu

Utiliser les objets Promises

Un petit exemple


function parse(json) {
  return new Promise( (resolve, reject) => {
    try {
      resolve(JSON.parse(json));
    } catch (e) {
      reject(e);
    }
  });
}

parse(process.argv[2]).then( result => {
    // On traite le résultat
}).catch( reject => {
    // On traite l'erreur
    console.log(reject);
});

Un objet Promise ne devrait être utilisé qu’avec des fonction asynchrones, setTimeOut par exemple.

Lorsqu’on crée une Promise il peut y avoir deux retours soit tout c’est bien passé et on retourne le résultat avec resolve() ou alors il y a eu une erreur et alors on utilise reject()

On voit bien l’intérêt d’utiliser les objets Promise dans un environnement asynchrone le fait de pouvoir chaîner les then() entre-eux allège énormément le code.

Par exemple, lancer plusieurs fonctions les unes à la suite des autres devient alors bien plus simple , plus la peine de les imbriquer entre elles à l’intérieur des callbacks


promise()
    .then(...)
    .then(...)
    .then(...)
    .then(...)
    .catch(...)

Pour aller plus loin : Les promises sur MDN