Nous allons étudier comment mettre à jour un post existant en utilisant la route "UPDATE POST BY ID" dans le fichier postsRoutes.js. Cette route gère la mise à jour d'un post basé sur son ID unique.

Définition de la Route

Le code ci-dessous définit la route "UPDATE POST BY ID" en utilisant router.put():

router.put("/post/:id", validatePostData, async (req, res, next) => { ... }

• Cette route est configurée pour gérer les requêtes HTTP PUT, spécifiquement pour la mise à jour des posts;
• Elle inclut un :id paramétré dans le chemin de la route pour identifier le post à mettre à jour;
• Le middleware validatePostData est ajouté pour assurer la validation des données avant de procéder. La logique du middleware validatePostData reste la même que dans l'étape précédente.

Obtention des données de la requête

Ici, nous extrayons les données nécessaires de la requête, y compris l'ID du post et le contenu mis à jour du post :

const postId = req.params.id;
const updatedData = {
  username: req.body.username,
  postTitle: req.body.postTitle,
  postContent: req.body.postContent,
};

• L'ID du post est extrait des paramètres de la requête, le rendant disponible pour un traitement ultérieur. Le paramètre :id de l'URL de la route est capturé en utilisant req.params.id;
• Les username, postTitle et postContent sont extraits du corps de la requête.

Mettre à jour le post dans la base de données

La mise à jour d'un post existant implique plusieurs étapes, comme décrit ci-dessous :

const data = await readData();

const postIndex = data.findIndex((post) => post.id === postId);

if (postIndex === -1) {
  return res.status(404).json({ error: "Post not found" });
}

data[postIndex] = {
  ...data[postIndex],
  ...updatedData,
};

await fs.writeFile("./database/posts.json", JSON.stringify(data));

• Nous lisons les données existantes à partir du fichier JSON en utilisant la fonction asynchrone readData, comme expliqué précédemment;
• La variable postIndex stocke l'index du post à mettre à jour dans le tableau data en comparant les IDs des posts;
• Si le post n'est pas trouvé (c'est-à-dire postIndex === -1), une réponse 404 (Non trouvé) avec un message d'erreur est renvoyée au client;
• Pour mettre à jour les données du post, nous fusionnons les données existantes du post (...data[postIndex]) avec les données mises à jour (...updatedData). Cela garantit que seuls les champs spécifiés sont mis à jour et que les données existantes sont conservées;
• Enfin, le tableau data mis à jour est réécrit dans le fichier JSON pour enregistrer les modifications apportées au post.

Envoi d'une réponse

Après la mise à jour réussie du post, une réponse JSON est envoyée au client. La réponse inclut un code de statut 200 (OK), indiquant une mise à jour réussie et les données du post mis à jour.

res.status(200).json(data[postIndex]);

Gestion des erreurs

Nous enveloppons le code de la route dans un bloc try-catch pour gérer les erreurs potentielles lors de la récupération des données ou du traitement des requêtes. Toutes les erreurs qui se produisent sont enregistrées dans la console à des fins de débogage :

try {
  // ... (code for retrieving and processing data)
} catch (error) {
  console.error(error.message);
}

Code complet du fichier postsRoutes.js à cette étape

const express = require("express");
const fs = require("fs/promises");
const validatePostData = require("../middlewares/validateData");

const router = express.Router();

// Function to read data from the JSON file
async function readData() {
  try {
    // Read the contents of the `posts.json` file
    const data = await fs.readFile("./database/posts.json");
    // Parse the JSON data into a JavaScript object
    return JSON.parse(data);
  } catch (error) {
    // If an error occurs during reading or parsing, throw the error
    throw error;
  }
}

// GET ALL POSTS
router.get("/", async (req, res, next) => {
  try {
    // Call the `readData` function to retrieve the list of posts
    const data = await readData();
    // Send the retrieved data as the response
    res.status(200).send(data);
  } catch (error) {
    // If an error occurs during data retrieval or sending the response
    console.error(error.message); // Log the error to the console for debugging
  }
});

// GET POST BY ID
router.get("/post/:id", async (req, res, next) => {
  try {
    // Extract the post ID from the request parameters
    const postId = req.params.id;
    // Read data from the JSON file
    const data = await readData();

    // Find the post with the matching ID
    const post = data.find((post) => post.id === postId);

    // If the post is not found, send a 404 response
    if (!post) {
      res.status(404).json({ error: "Post not found" });
    } else {
      // If the post is found, send it as the response
      res.status(200).send(post);
    }
  } catch (error) {
    // Handle errors by logging them and sending an error response
    console.error(error.message);
  }
});

// CREATE POST
router.post("/", validatePostData, async (req, res, next) => {
  try {
    const newPost = {
      id: Date.now().toString(), // Generate a unique ID for the new post
      username: req.body.username,
      postTitle: req.body.postTitle,
      postContent: req.body.postContent,
    };

    // Read the existing data
    const data = await readData();

    // Add the new post to the data
    data.push(newPost);

    // Write the updated data back to the JSON file
    await fs.writeFile("./database/posts.json", JSON.stringify(data));

    // Send a success response with the new post
    res.status(201).json(newPost);
  } catch (error) {
    // Handle errors by logging them to the console
    console.error(error.message);
  }
});

// UPDATE POST BY ID
router.put("/post/:id", validatePostData, async (req, res, next) => {
  try {
    // Extract the post ID from the request parameters
    const postId = req.params.id;
    // Extract the updated data from the request body
    const updatedData = {
      username: req.body.username,
      postTitle: req.body.postTitle,
      postContent: req.body.postContent,
    };

    // Read the existing data
    const data = await readData();

    // Find the index of the post with the specified ID in the data array
    const postIndex = data.findIndex((post) => post.id === postId);

    // If the post with the specified ID doesn't exist, return a 404 error
    if (postIndex === -1) {
      return res.status(404).json({ error: "Post not found" });
    }

    // Update the post data with the new data using spread syntax
    data[postIndex] = {
      ...data[postIndex], // Keep existing data
      ...updatedData, // Apply updated data
    };

    // Write the updated data back
    await fs.writeFile("./database/posts.json", JSON.stringify(data));

    // Send a success response with the updated post
    res.status(200).json(data[postIndex]);
  } catch (error) {
    console.error(error.message);
    next(error);
  }
});