In this lesson, we will explore how to fetch and display todos from the backend for our Full-Stack Todo List Application. By the end of this lesson, you'll know how to retrieve data from a backend server and display it on your webpage, transforming your todo list from static placeholder data to dynamic, real-time information. This crucial step will ensure that your application remains up-to-date with any changes made on the server. It also lays the foundation for more complex interactions between the frontend and backend.

To achieve our goal, we will focus on two key functions: one for fetching todo items from the backend server, and another for creating HTML elements for these todos on the client side, complete with event listeners to handle user interactions. Mastering these functions will improve your ability to manage server-client data flow, simplifying debugging and future enhancements.

We have been using Axios for all our HTTP requests so far, but in this lesson, we will introduce a new API called fetch. Axios is a promise-based HTTP client with features like automatic JSON data transformation and easier handling of request and response interceptors. In contrast, the Fetch API is a built-in JavaScript function for requests that requires more manual handling of response data and lacks some of the advanced features offered by Axios. However, the Fetch API is widely supported and a good choice for simpler use cases. Mastering both Axios and Fetch will make you versatile in handling HTTP requests in any project.

We will be using the same GET, POST, PUT, DELETE, and PATCH requests, and as such here is an overview. Knowing when to use each request method is important for effective interaction with backend services. Misusing these methods can lead to unexpected behavior and potential errors.

A GET request retrieves data from a server endpoint. It's the simplest form of a fetch request. This method is typically used to request data from a given resource without altering it. Here's a basic example using the Fetch API:

A POST request sends data to the server, typically to create a new resource. This method changes the state of the server, hence it is used when submitting form data or uploading a file. Here's an example of how to use a POST request to add a new todo item:

Including the Content-Type: application/json header ensures that the server correctly interprets the JSON data format being sent in the request body. Without this header, the server may not correctly parse the JSON data, potentially leading to errors in processing the request.

A PUT request updates an existing resource entirely. This method will replace the current representation of the target resource with the provided data. Here is an example using the Fetch API to update an existing todo item:

A PATCH request updates an existing resource partially. This is commonly used for modifying specific fields without replacing the entire resource. Below is an example to update only the completed status of a todo item:

A DELETE request removes a resource from the server. This method is irreversible, so it should be used with caution. Here's a basic example to delete a specified todo item:

Each of these fetch functions involves making a request to a specific URL, potentially including headers and a body, and then handling the server's response. Understanding these methods will enable you to perform a wide range of CRUD operations with your backend server.

Now that we have gone over the new fetch API, it is time to practically implement it. The first step in our client-side part of the application is the retrieval of data from the backend database using an asynchronous function. This asynchronous function will incorporate error handling to ensure robustness in different network conditions. We will do this with the following function:

Here we use a GET request to fetch the todo items, loop through each item, and create a frontend element by calling the createTodoElement function, which will be explained in the next section. This method ensures that all fetched todos are displayed accurately and efficiently. By incorporating error handling, we can make the application more robust and user-friendly.

After successfully fetching the data, the next step is to dynamically create the todo items and display them. Generating HTML elements for each todo item ensures that they are interactive and responsive to user actions. Additionally, we need to ensure that the created elements can reflect the state changes in the backend, keeping the UI consistent. Below are the steps involved:

• Create the List Item (li) and Checkbox Elements:

• Add Event Listener to the Checkbox to Handle State Changes:

• Set attributes and Append Elements to the List Item:

• Complete Function Example:

The event listener attached to the checkbox listens for changes in the checkbox state, i.e., whether it is checked or unchecked. When the state changes, it triggers an asynchronous function to update the backend using a PATCH request. This PATCH request sends a fetch call to our backend server targeting the specific todo item by its unique identifier. The URL /api/todos/${todo._id} includes the todo's ID, and the request method PATCH is used to update only the completed field of the todo item. The request includes headers to specify that the content type is JSON and a body containing the updated completed status of the todo.

Using this approach, each todo item becomes an interactive part of the user interface. This approach improves the maintainability of our application and facilitates further enhancements in the future. This not only enhances user experience but also maintains synchronization with the backend database.

In this lesson, we explored how to fetch todos from a backend server and display them on the frontend using JavaScript. We explained the usage of the fetch API for making HTTP requests and how it differs from Axios. The core of our lesson focused on two key functions: one for fetching data and handling responses, and another for dynamically creating and updating todo list items in the DOM. By loading the fetched items and creating client-sided elements with proper event listeners, we ensured that the todo list is both interactive and responsive to user actions. This foundational knowledge will greatly aid in building more complex features in future lessons. Happy coding!