We gaan dieper in op de implementatie van de "DELETE POST BY ID"-route binnen het bestand postsRoutes.js. Deze route stelt clients in staat om een specifiek bericht te verwijderen door het unieke ID op te geven.

Routedefinitie

De onderstaande code definieert de "DELETE POST BY ID"-route met behulp van router.delete():

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

Deze route verwerkt HTTP DELETE-verzoeken met een geparameteriseerde :id in het routepad. De parameter :id wordt gebruikt om het te verwijderen bericht te identificeren. Extra middleware zoals dataValidation is niet nodig, omdat alle benodigde informatie uit de URL-parameter wordt gehaald.

Het post-ID extraheren

We halen het post-ID uit de requestparameters met req.params.id:

const postId = req.params.id;

Deze regel haalt de waarde van :id uit de URL, zodat we hiermee verder kunnen werken in de volgende code.

Verwijderen van de Post

Hier volgt hoe de post wordt verwijderd:

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.splice(postIndex, 1);

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

• Start met het uitlezen van de bestaande gegevens uit het JSON-bestand via de asynchrone functie readData, zoals eerder uitgelegd.
• Zoek de index van de te verwijderen post in de array data door post-ID's te vergelijken.
• Indien de post niet wordt gevonden (postIndex === -1), retourneer een 404 (Niet Gevonden) response met een foutmelding.
• Verwijder de post uit de array splice met de data-methode. De variabele postIndex bepaalt de positie van de te verwijderen post.
• Schrijf de bijgewerkte array data, zonder de verwijderde post, terug naar het JSON-bestand om de wijzigingen op te slaan.

Verzenden van een Response

Een JSON-response met statuscode 200 (OK) wordt naar de client gestuurd, wat aangeeft dat het verwijderen is geslaagd. De response bevat een bericht ter bevestiging dat de post succesvol is verwijderd:

res.status(200).json({ message: "Post deleted successfully" });

Foutafhandeling

De routecode wordt omgeven door een try-catch-blok om mogelijke fouten tijdens het ophalen van gegevens of het verwerken van het verzoek af te handelen. Eventuele fouten worden gelogd naar de console voor foutopsporing:

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

Volledige code van het postsRoutes.js-bestand in deze stap

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);
  }
});

// DELETE POST BY ID
router.delete("/post/:id", async (req, res, next) => {
  try {
    // Extract the post ID from the request parameters
    const postId = req.params.id;

    // 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" });
    }

    // Remove the post from the data array using `splice`
    data.splice(postIndex, 1);

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

    // Send a success response with the JSON response indicating successful deletion
    res.status(200).json({ message: "Post deleted successfully" });
  } catch (error) {
    console.error(error.message);
    next(error);
  }
});

module.exports = router;