Nous allons examiner 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 en fonction de son identifiant unique.

Définition de la route

Le code ci-dessous définit la route « UPDATE POST BY ID » à l’aide de router.put() :

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

• Cette route est configurée pour traiter les requêtes HTTP PUT, spécifiquement pour la mise à jour des posts ;
• Elle inclut un paramètre :id dans le chemin de la route pour identifier le post à mettre à jour ;
• Le middleware validatePostData est ajouté afin d’assurer la validation des données avant de poursuivre. La logique du middleware validatePostData reste identique à celle de l’étape précédente.

Obtention des données depuis la requête

Ici, nous extrayons les données nécessaires de la requête, y compris l'identifiant 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'identifiant du post est extrait des paramètres de la requête, ce qui le rend disponible pour un traitement ultérieur. Le paramètre :id de l'URL de la route est capturé à l'aide de req.params.id ;
• Les champs username, postTitle et postContent sont extraits du corps de la requête.

Mise à jour du post dans la base de données

La mise à jour d'un post existant implique plusieurs étapes, décrites 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));

• Les données existantes sont lues depuis le fichier JSON à l'aide de 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 identifiants 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 afin d'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 ainsi que les données du post mises à jour.

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

Gestion des erreurs

Le code de la route est encapsulé dans un bloc try-catch afin de gérer les erreurs potentielles lors de la récupération des données ou du traitement de la requête. Toute erreur survenant est enregistrée 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);
  }
});