Learn the basics of setting up a web server with the Node.js framework Express. The course demonstrates how to create a simple RESTful API that serves JSON.

Getting Started with Express (Learn Nodejs Backend JSON REST API Web Development)

This course is also available on Simpliv: https://www.simpliv.com/webdevelopment/getting-started-with-express Are you a fan of Nodejs? Get a Tee: https://amz...

Getting Started with Express - Introduction (Bookstore)

# Course Summary: Building a JSON API with Express

## Overview
In this course, we will learn how to use the Express framework to build a JSON API that performs the basic operations known as CRUD (Create, Read, Update, Delete). Express is a web framework for Node.js, which allows JavaScript to run on the server side.

## Course Structure
1. **Introduction to Data Structure**
   - Understanding the basic data structure for our API.
   
2. **Project Setup**
   - Generating a project using Express.
   - Writing our first Express project and running the server.

3. **Creating Routes**
   - Setting up routes to:
     - Get all resources.
     - Retrieve a specific resource by ID.
     - Update a resource.
     - Delete a resource.

## Data Structure
- We will be simulating a bookstore API for this course, focusing on a resource called a "book."
- Each book will have an ID and a title (additional properties may be present but will be omitted for simplicity).
- The API will be able to return a list of all books, fetch a specific book by ID, update book details, and delete a book.

## Next Steps
- We will explore the data structure in more detail in the next lesson and begin generating our project.

Welcome everyone! In this course we're going to learn how to use the Express
framework to build a JSON API serving the most basic operations in every app.
Create, read, update and delete. For those of you who already know the acronym CRUD
that's what we're going to do. So Express is a web framework for Node.js.
Node.js simply means the JavaScript that is run on the server side, right? So this
is how this course is going to be laid out. First we're going to be introduced
to the data structure that we are going to be working with. We're going to then
generate our project with Express, learn how to write our first Express project,
we're going to learn how to run the server, then we're going to learn how to
create our routes. The routes to get all the resources, you got a specific
resource by ID to delete or update a resource. Okay, so let's first take a look
at the data structure. I'm going to the text editor here and I use Adam by the
way. This is what we are going to be working with. Since we don't have a we
want to focus on Express for this course, we don't want to have to deal with any
database configuration. Okay, so this is just a quick start course on the Express
framework. Let's assume the database is already set up somewhere. What we're going
to do is we're going to kind of make a fake API response using hard coded data,
hard coded array and objects in JavaScript. Okay, so we're going to be
imagine that you are working for a bookstore and then you have to build an
API that is going to serve basic operations around the resource called
the book. So a book has a 90 and a title. I could have many other properties. We're
just going to omit them for the sake of focusing on how to build the API. Okay,
but there sure are a lot of other properties around a book. So let's just
go with that. Then here we have a resource. Imagine this is the database and
each of this is a record. It's like a row in a SQL table. So we're going to be
able to get all the books with the API or get a specific book by ID. For example,
if I look for the book ID to I expect to get this object back. I can also update.
For example, I want to update this guy's name to Ron Quixote. For example, the
title of this book, or you could delete the record altogether. So those are
most basic operations that we're going to learn. Okay, so we learned the data
structure we'll be working with, what kind of data and in the next lesson we're
going to start generating our project. Until then.


01 Getting Started with Express - Introduction (Bookstore)

Generating the Project with NPM

# Node.js Project Setup for nvk Bookstore

Welcome back! In this lesson, we will generate a Node.js project called **nvk bookstore**. This session assumes you have Node.js installed.

## Steps to Create the Project

1. **Open Terminal**:
   - Navigate to your desired directory and create a new folder:
     ```bash
     mkdir nvk_bookstore
     cd nvk_bookstore
     ```

2. **Initialize the Project**:
   - Run the following command to create a new Node.js project:
     ```bash
     npm init
     ```
   - You will be prompted to answer a few questions for your `package.json`:
     - **Package name**: nvk_bookstore (default)
     - **Version**: 1 (default)
     - **Description**: (Optional, can skip)
     - **Entry point**: app.js
     - **Test command**: (Optional, can skip)
     - **Repository**: (Optional, can skip)
     - **Keywords**: (Optional, can skip)
     - **Author**: (Your name or username)
     - **License**: MIT (or choose your own)

3. **Install Express**:
   - Now, install Express by running:
     ```bash
     npm install express
     ```
   - Note: In older versions of Node.js, you might need to add `--save` to the install command.

4. **Check the `package.json`**:
   - After the installation, the `package.json` file will include Express as a dependency.

## Conclusion

Now that we have set up our project and installed Express version 4.16.3, we will start writing our first file in the next lesson. See you then!

Welcome back everyone. So let's start and generate a project. What we're going to do
we're going to go to the terminal. Okay so this course already assumes that you
have Node.js installed. Okay so to get started let's first generate a Node.js
project. I am going to make a directory here and call it nvk bookstore. So I'm
going to cd to nvk bookstore. This is where our project is going to be. You can
call it whatever you want. Okay just how I'm going to call this project. Now
there's nothing here yet. Let's do an npm init to create a project. But before I do
that I would like to point out that this video is being recorded using Node version
8.12.0. Okay so npm init will ask a few questions before I can create the
file package.json that's going to serve a project. So I'm just going to choose the
default package name and the case bookstore. Version I'm going to leave at
one. Description you can add whatever you want there. I'm just going to skip it.
For the entry point I'm just going to say app.js. That's a file we're going to
write with our server. Task command that we don't have it yet and we won't care
for this course. Get prepository if you have one. If we to add there. I don't care about
keyword author put your name. I can put mine username. Doesn't really matter.
License you can choose your own license. Let's use MIT for me. Is this okay? Yes. So
you see now if I open the text editor I use item by the way and go back there.
Here is the package.json that was created by the npm init command. Okay not much there.
Now let's finally get to install express. Let's get back to the terminal. Okay let me clear this.
We're going to do npm install express. Notice because in the previous versions of node npm it
used to be that you needed to say dash dash save if you want to add this dependency to the package
json. So it already does automatically for me but if you're using a version of node that does not
do that. Node the older version. You should put dash dash save there. In any case we now have if I go
back to the text editor to package.json we now have express here. We're using express version 4.16.3
in this video. Okay just so you know. Now that's all good. Great and now we have to start writing
a first file. So I'm going to leave that to the next lesson. I'll see you then. Okay.


02 Generating the Project with NPM

Setting Up and Running the Express Server

```markdown
## Creating a Basic Express Server

### Step 1: Create the Server File
1. Create a file named `app.js` in your project directory to hold the server's startup code.

### Step 2: Import Express
2. In `app.js`, import Express using the following code:
   ```javascript
   const express = require('express');
   ```

### Step 3: Initialize the Express Application
3. Call Express as a function to create an Express application:
   ```javascript
   const app = express();
   ```

### Step 4: Define Port
4. Create a variable to hold the port number where the app will run:
   ```javascript
   const port = 3000; // You can choose any port
   ```

### Step 5: Make the App Listen
5. Set the app to listen on the defined port and log a message to the console upon starting:
   ```javascript
   app.listen(port, () => {
       console.log(`Express server is now listening on port ${port}`);
   });
   ```

### Step 6: Run the Server
6. Open the terminal and navigate to where `app.js` is located. Run the following command:
   ```
   node app.js
   ```
   - You should see a message indicating the server is listening on port 3000.

### Step 7: Test the Server
7. Access the server in your browser at:
   ```
   http://localhost:3000
   ```
   - Note: Currently, there are no routes defined, so you won't see any specific response.

### Additional Notes
- To stop the server, press `Control + C` in the terminal.
- Ensure that you properly interpolate variables when logging messages for clarity.
```


So let's continue. We're going to create a file called app.js. That's going to hold our startup code for the server.
So I'm going to go here under our projects directory. I am going to create the file app.js.
Okay, so let's get started writing our first Express server. First, you're going to need to import or require Express.
So let's do it. We're going to do a const variable. Let's call it express. And we're going to do a require with the express package name.
Okay, so after requiring Express, you got this guy right here. We're going to use this guy and call it as though it were a function.
So we're going to do the following like this. Okay, so when you call this guy, you're going to get an express application.
So we're going to start this in a variable called app. Okay, now our app needs to run on a specific port. Let's create a variable for the port.
We can use any port you want. Let's do 3000. Now, to make our app listen to the outside world, we have to tell it to listen.
So we're going to call app.listen. We need to give it a port. This gives 3000, but we have a variable. So we're going to say port.
And then you pass a callback that you want to be executed after it started listening.
In this case, we just want to display a message to the console saying that the server is now listening to any requests.
So we're going to do console log. Okay. Now we're going to say express server is now listening to incoming connections or whatever.
Let's say just listening. Let's also say the port, but that's useful for the person who starts up the server because you need to know what part to access the server at.
So we can use either string concatenation here or string interpolation. Let's have about leaves interpolation.
So since ES6, we can use interpolation if we substitute the quotes, single quotes here in my case, with a back tick.
Back tick is the key next to the latter one in the American keyboard. Next to the number one, sorry.
Okay. So express service now listening on. So I'm going to use a dollar sign with the curly braces to interpolate the value.
The variable port here has the value 3000 that we will be substituted here in this part. Okay. Think of it that way.
Anyway, so let me enable soft wrap so you can see the line breaks there. I can decrease the font size.
So let's review what we wrote. First, we have to require the express. Okay. Package module. Then you call on that module to get the application, the express application.
We define a port variable to hold just to hold the value of the part at which the server will be running. Then we tell our app to listen at the part 3000 in this case.
And after that we just say console log to tell the user who powered up the server that the server is now listening on the specified part. This case 3000.
Okay. Let's get this running. Let's go to the terminal. And we're going to, you can see the files are here. You have app.js. So you're just simply going to say node app.js.
Now it's at the message. Express servers allow listening on 3000. Oops. I should say the word to port by the way on port 3000. Let's try again. Just to make it nicer.
Oh, but before I try again, how do I get out of this? Right. So I can use control C to kill the server control C. Okay.
And that will send a signal to stop the server. I can try again. Now I added the word port there. Now it's nice. Now it's listening. Okay.
So express servers listening a port 3000. So you can access this guy at local host H2P colon slash slash local host colon 3000.
But right now we don't have any routes. So I don't know what we're going to get. Let's try it out.


03 Setting Up and Running the Express Server

Defining our First GET Route in Express

# Summary of Transcript

In this transcript, the speaker demonstrates how to set up and define routes in an Express server using Node.js. Here's a step-by-step overview:

1. **Starting the Server:**
   - The speaker navigates to `http://localhost:3000` in the browser and receives a "cannot get /" message, indicating that there are no routes defined yet.
   - Attempting to access `/books` also results in the same error.

2. **Defining a Route:**
   - The speaker edits `app.js` to define a simple route.
   - They explain how to use the `app.get()` method to set up a route, specifying:
     - The path `"/"` for the root route.
     - A callback function that takes in `request (req)` and `response (res)` objects to handle incoming requests.

3. **Sending a Response:**
   - Within the callback function, the speaker uses `res.send()` to send a response back to the client with a message: "Welcome to Express".

4. **Restarting the Server:**
   - After making code changes, the speaker restarts the server using `control + C` and then `node app.js`.

5. **Testing the Route:**
   - The speaker goes back to the browser and refreshes the page on the root route (`/`), which now correctly displays "Welcome to Express".

6. **Review and Conclusion:**
   - The speaker summarizes the key points:
     - How to call HTTP methods to define routes.
     - The importance of the request and response objects.
     - The use of `res.send()` to return a response.
   
The lesson concludes with the speaker indicating that this concludes the tutorial for defining a simple route in Express.

--- 

This Markdown summary captures the essential points from the transcript in a structured format.

So I'm going to go to the browser, let's go back to the browser, we're gonna go to
HTTP colon slash slash localhost add use the colon sorry, 3000, okay, localhost colon
3000. I'm going to try it out to try it out. So we got a message saying cannot
get slash. So that's the express server saying that he did not specify any route
at this point you can try slash books for example and it's going to say the
same thing. So we're trying to get slash books but the route is not defined so
that's what express gives us back okay. Great. Now we learn how to round the
server using node app.js and to kill the server control C. Let's go back to our
file here app.js. Now we are going to learn how to define a route in express
okay. So let's just define a simple route with just an arbitrary data so we can
get our get started. To define a route we're gonna do the following between the
listen and whatever you did we're gonna add the following. We're gonna call on our
app and we're gonna call the method called get okay and then we're gonna say
slash this is the path to our route this is going to be the route okay and then
you give it some callback or function here that's going to have at least like
two basic objects that's the request object and the response object okay. So
let's write it typically we write it those guys in express with the
abbreviations req and res they stand for request and response respectively. So
let's use our narrow function here to define the body of what we want to do
when we hit the route slash that's going to be just localhost 3000 slash right.
So let's send a response to send a response we're gonna use the res object
that's the response object and then just say dot send and whatever you want to
send let's just send a string okay welcome to express like so okay so when we
hit the route the route route we are going to send back a response with the
text welcome to express. Let's get back to the terminal now we have to restart the
terminal because we made a change to the code so we got to control C to kill it
and we're going to do node app.js to run it again okay now let's go to the
browser and try again with the slash route see we got a response welcome to
express
okay
so let's get back to the code and review so we're gonna call the app and we're
gonna call a method with the HTTP verb for your request in this case it's a get
request it could be post it could be put it could be delete right so and then
this is the path this case slash the route route you give the definition to
what do you want to do when the user hits this route you request what you're
gonna do and then we send a response with our yes object always request
response in the signature of this function right here and recall on the
send to send some string in this case all right so I think we're good with
this lesson and I'll see you on the next one


04 Defining our First GET Route in Express

Using Postman to Test the API

# Summary of API Endpoint Testing with Postman

## Overview
In this lesson, we start building our API endpoints and utilize Postman, a REST client, for testing and debugging.

## Steps Covered

1. **Downloading Postman**
   - The speaker downloads Postman on a Mac and moves it to the Applications folder.
   - The app is opened without signing in.

2. **Using Postman**
   - The interface of Postman is introduced, including the HTTP verbs (GET, POST, etc.) and the URL input.
   - The test URL `http://localhost:3000` is used, followed by sending a request.

3. **Understanding the Response**
   - The response body shows an HTML response with a 200 OK status code.
   - HTML content type is displayed alongside server headers.

4. **Sending JSON Data**
   - The speaker demonstrates sending JSON by changing the server code and resending the request in Postman.
   - JSON responses are displayed with options for raw and formatted ("pretty") views.

5. **Testing with Arrays of Objects**
   - The speaker prepares a response containing an array of objects, restarts the server, and tests again in Postman.
   - The response shows JSON format with a 200 OK status and relevant content type.

## Key Takeaways
- The `send` method can return objects or arrays as JSON.
- Postman allows easy visualization of raw and formatted API responses.
- Content types and HTTP status codes are important indicators of server responses.
- Express automatically adds the `X-Powered-By` header indicating it's powered by Express.

## Conclusion
This lesson focused on using Postman to test APIs and understand JSON responses from an Express server. The next steps will build on this foundation.

Welcome back. So since we'll be starting on actually building our API endpoints,
I would like us to use a REST client to facilitate our debugging of the API or testing.
I am going to use postman.com. You can download this app to test out the API.
This is a REST client that I am going to use. If you already know how to use a REST client
and you have a favorite one, you might want to skip this video.
Anyway, I am using a Mac so I download the app and after doing that, I just move the application file to the applications folder.
Then I open it. It asks, are you sure? I just click open and then it goes like this.
So I am using postman. I am just going to go here and skip signing in and take me straight to the app.
So I got all this guy right here. I don't want to show this on launch anymore.
Close this. Let me make this smaller so you can see.
Okay, so this is postman so we can test out our API endpoints.
So here we have the HTTP verb. You can choose get, post, and so on.
And you enter the URL where you want to hit.
We are going to use HTTP colon slash slash localhost 3000.
I am going to click send and right here, down here, we get the body of the response.
And right here, it says HTML. You can see the headers here.
The content type is text, HTML, care set, UTF-8, powered by express, header, and so on.
Okay, so we got a 200 okay for the response.
That's usually the default for express. We will use this HTTP status code of 200 okay if you do not specify it.
Okay, now going back to the code.
We send this guy out, but we can also send JSON if you simply send an array or an object.
For example, you send an object with some property name and some value. Let's see what we get.
I am going back to the terminal because we changed the server code, control C to kill the server,
and do node app.js again to restart it.
Now let's go back to our REST client and we're going to resend those.
Request, if you look at the body again, now we get some JSON okay.
If you see the raw one is like this, and if you want to see the pretty version, so it's formatted with spaces and annotation, click pretty right here.
Alright, so you can see the headers of the response, content type application JSON in this case, powered by express.
Anyway, going back to the body.
So it automatically does JSON there for us, so that's nice.
Going back to the atom, add text editor. You can also do an array.
Let's do an array right here, send back an array of objects.
I'm just going to duplicate this line with some other name.
I can put an ID to just to see you can have multiple properties.
Okay, so I'm going to send back, I forgot to close the array, an array of objects.
Let's restart the server again.
Go back to the REST client, postman, resend, and now look at the results.
Let's see if we can bring this up.
Click header just so we can get more space.
So we got an array of objects. This is JSON format 200k status quote.
Look at the headers, application slash JSON.
Okay, so we got our first steps in sending back JSON from the express server.
All right, so that's what we're going to do from now on.
Just send back some data using the send method.
Okay, so let's review what we did in this lesson.
This lesson we learned that the send can be used also to send an object or an array.
And they turned out to be JSON when we tested out in our postman.
That's the REST client that we downloaded to test out the API.
You can choose the H3 verb right here on the left-hand side, the URL, the endpoint of the API.
Then you click send. You're going to be able to see the body of the response.
This is the raw one, but if you want to make it better for you to see is the pretty tab.
You can see the headers in the header tab. Notice the content type application JSON.
So it's interesting to note that the express adds an X power by header with the express text.
Okay, and we got a 200k status code by default from express.
That's it for this lesson until the next one.


05 Using Postman to Test the API

Writing the Route to Get All Books

# Summary of "Building a Get Books Endpoint"

In this lesson, we begin creating the `GET /books` endpoint which retrieves all books from a fake database. Instead of setting up a real database, we utilize a hard-coded array of book objects to serve as our data source.

## Key Steps

1. **Setup Fake Database**:
   - Create an array of book objects each containing an `ID` and `title`. This array will act as our fake database.
  
2. **Create a Module**:
   - In the project folder (`NBK Books`), we create a module named `book.js`.
   - This module uses `module.exports` to define the `findAll` method, which returns the array of books synchronously.

3. **Integrate with Express**:
   - In the `app.js` file, require the `book` module.
   - Implement the `GET /books` endpoint to call `findAll` from the `book` module and send the resulting array as a response.

4. **Test the Endpoint**:
   - Use Postman or a similar REST client to make a `GET` request to `/books`.
   - Ensure that the server is restarted after any code changes to view the updated output.

5. **Response Handling**:
   - The endpoint responds with a status code of 200, and if there are no books, it returns an empty array instead of a 404 error.

## Conclusion
This lesson sets the foundation for the next part, where we will learn to create an endpoint for retrieving a specific book by its ID.

In this lesson, we're going to get started into building our get slash books endpoint.
This is the endpoint to get all the books in our fake database.
If we go back all the way to the data structure we had before, we had a list of book objects.
This is going to be our fake database.
This course is focused on Express, so we're not going to deal with setting up and configuring
the database.
We just want to focus on the basics of Express.
Let's make a fake database with hard coded objects, array of objects in the server side
code.
For the response for the get slash books, we're going to get this guy, 200k status code
with this response right here.
It's an array of objects with ID and title for each book.
To do that, we have to build a fake API.
We could directly send this from the send method and that's okay.
But if you want something more elegant, let's create a module for our resource.
Right here at NBK Books are the project folder.
Let's create a book.js module.
Let's do a module.expart, an object.
And then let's define some methods.
Let's define the method findAll that will be used to get all the books.
So first let's do a hard coded data here.
Let's copy that code.
Assume this is our database, so we're going to copy this guy, an array of objects with
each object have an ID and title property.
If you want to take a moment to copy that.
Going back to book.js, I'm going to make a cost variable here with the hard coded data
right here.
I'm going to say books.
Like so.
Actually, I'm going to make a let and I'm going to put lowercase in case we want to
change it to make it permanently changed.
Anyway, so we have this variable, leave it there.
I'm going to fold it.
And then we have in the module the findAll method that's going to return all the books.
I'm going to assume it's not going to be asynchronous.
So let's just do it synchronously without any kind of promise.
So if you say findAll, we just want to return all the books.
So that's just fine.
So just return all the books as is.
Now let's go back to, let's save this file and then go back to app.
And then when you send this guy, we're going to do the following.
We're going to call in the book module, findAll and this guy is going to return what?
An array of objects.
And that's going to be used for the send method.
Now let's require a book right here.
I'm going to go here, costBook is require dot slash book.
You can put a .js, but I think you don't need it.
So let's omit that.
Save it.
Now let's test it out.
Go to your postman or whatever REST client you're using.
One detail, if you forgot to change the route, it's a get slash books, right?
So get slash books right here.
Save it.
Let's go back.
Oops, postman.
Let's say get slash books, the endpoint and let's send.
So we got four and four not found.
Oh, because we forgot to restart the server.
So every time you make a change to the code, you have to go to the terminal, control C,
and then the app.js.
Now let's go to our postman, send.
And then we got a response with all the books.
Okay?
200 okay.
So in this case, even if there were not any books, you would get an empty array.
So we don't have to deal with four or four not found or any kind of error.
Okay?
Now going back to our code, that's the slash books route.
We send some output from this module called books that we defined to be a fake database.
We just hard coded the books, an array of objects, and we just returned those books
and find all.
Mind you that we're not using any kind of promises here.
All right?
Okay, that's great.
So the next endpoint would be to get a specific boot by ID.
We'll see you in the next lesson where we will learn just that.
Okay?


06 Writing the Route to Get All Books

Writing the GET Route to Get a Specific Book By Id

# Summary of Transcript

In this session, we discuss creating an Express route to retrieve a specific book by its ID. The key points are outlined below:

## Route Creation
- **Endpoint Structure:** We define our endpoint as `/book/:bookID`, where `:bookID` is a route parameter that represents the ID of the book.
- **Accessing Route Parameters:** Express populates this parameter in the request object (`req.params`) as `req.params.bookID`.

## Implementation Steps
1. **Setup in `app.js`:**
   - Create a new route using `app.get('/book/:bookID', (req, res) => {...})`.
   - Initially, send back the `req.params` object to test if the route is working.

2. **Installation of Nodemon:**
   - To avoid manually restarting the server on code changes, install Nodemon using `npm install --save-dev nodemon`, which helps in automatically restarting the server.

3. **Parameter Parsing:**
   - Convert `req.params.bookID` from a string to an integer with `parseInt(req.params.bookID, 10)` to ensure it matches the expected datatype.

4. **Finding a Book:**
   - Implement a `findOne` function in `book.js` that searches an array of books for the book with the provided ID using the `find` method.

5. **Handling Not Found Cases:**
   - If no book is found, return a `404 Not Found` status and an appropriate error message in JSON format.
   - Use `res.status(404).send({ message: 'Could not find the book' })` to send the response.

## Conclusion
- In this lesson, we learned how to:
  - Create a route for fetching a book by ID.
  - Use route parameters and convert them to the correct datatype.
  - Implement basic error handling for cases where a book is not found, returning appropriate HTTP status codes and messages.

The session concludes with a reminder to always handle edge cases and validate inputs effectively.

## Next Steps
The next lesson will likely build upon this foundation, enhancing the functionalities related to books or error handling.

Now you're back. So let's write the get slash book slash book ID route. So this
route is to get a specific book by ID. So our endpoint is going to have slash
book slash the ID of the book. Could be one two three four whatever. So for that
we're going to use route parameters. In Express route parameters are represented
with a colon followed by the name you want to call the parameter. This case I
just call book ID. So these guys colon book ID is going to appear in the rec
object as a property of the rec dot prams object. Okay. So if you go here our app.js
we already have the slash books. Let's make another route app.get route. What's
the path slash book slash what colon book ID. This is a route parameter because
there's a colon. This variable name will be will appear in the rec dot prams
object. Load to find a rec. R-E-S arrow function. So I'm just gonna do a rest
dot send. I'm gonna send back rec dot prams. So you can see it's actually what's
inside this object right here. I'm gonna send back rec dot prams. That's where the
route prams are. Let's save it. Go to postman. Oh mind you that we have to
restart the server. You can kill this guy. Notice we keep restarting the server
and that's very annoying. So there's actually a tool to not have to restart it
and have it do automatically. It's called Noledmon. If you want to do it I'll
teach you right now quickly. You can do npm install dash dash save dev. By the way
I is if you say I that's like a shorthand for install and Noledmon is the
module. This is gonna use save dev because this is just a tool for development. We
don't want to have this package in the production. Build for the app okay. You
don't need that. So it's gonna take some time. Great. Now to run Noledmon instead
of running the app node app.js you're gonna use Noledmon. You're gonna Noledmon
app.js. But if I do it like this it's gonna call upon the globally installed
Noledmon. We don't have it. I don't have it so I'm gonna use the Noledmon that
was installed as a dependency for our current project with npx prefix. Just
before doing that go to the atom text editor package.json. You can see
dev dependencies now has Noledmon version 1.18.4. So this is just for
development. So we are node modules right here. If you notice there are many files.
So we want to use the Noledmon from this node modules directory. To do that we
use npx prefix with the Noledmon app.js. With that Noledmon is gonna be
start watching the file app.js. And if you make any change for example if I go
here I change the book. I add a comma or something. And I go back. You're gonna see
it restarts the server after making a change. That's great. So now we don't
have to restart the server every time we make a change. So that's Noledmon. Okay
so let's keep going now. Back to where we were before. We wrote the endpoint
slash books slash book ID. So let me try it out. I'm gonna put slash one for the
ID. Send. And we got a 4.4 and a found. What's going on? Let's go back to our
code. Save this app.js. We got app.get slash book. Oh it's forgot it. S right.
The s right here. Save it. Go back to Noledmon. We are sorry go back postman. We
already have Noledmon taking care of restarting the server. Try again. Now we
got an object on the JSON right here with book ID one. So this guy this route
parameter that we call book ID appears in the rack dot parameters object. That's
how we get the route parameters. Okay so let's go back. So we know that rack
parameters has dot book ID. So we're gonna use that to search for a book. But
now we're gonna use our book module find one. Let's call a new function find one
where you give the ID. Okay right here. And then it's gonna find by the ID. Mind you
one thing before we continue. Rack dot parameters dot book ID is a string. Look
at a postman response. This is not a number. It's a has quotes. So it's a string.
So all route parameters are a string. If you need the number actual number type you
need to parse it. But remember that always parse your parameters. So instead of doing
this guy let's parse it. So I'm gonna say book ID is going to be parsed int with
the rack parameters book ID and 10. We're gonna parse this into an integer because we
assume the ID is an integer in our case. Okay so remember data structure uses an
integer for the ID. So with that we're gonna use book ID right here already
parsed as an integer. Mind you we're doing very simple things here. So I'm not
assuming this might not give out an error in parsing it or the argument is
given not as a number as a string. So there are all these special cases you
have to handle. Let's ignore that just for the sake of focusing on learning
express. Okay so be aware that book ID somebody might not write a number there
or something else and then you have to handle that. Anyway so we assume you're
gonna create the find one function that when you call it with the ID of the book
it's gonna return the object the book object whose ID is book ID and whatever
name it is. Okay but if you just send it like this right what if it doesn't find
it it's gonna return no right. We'll get to that later so let's focus on
writing find one. So I'm gonna save this and go to the book.js I'm gonna write
find one right now and the the parameter for this method is going to be the
ID the book ID. So to find a book by ID in this list is very simple you can use
the find method of the array type right. So let's do that. So we're gonna return
books.find and we're gonna find a book whose ID okay so we're gonna find a
book whose ID is the ID given. We assume this is an integer okay must be a
lumber type of integer to match these guys we're doing strict equality. So
that's it if it doesn't find it it's gonna return no. So let's try it out save
this go back to the app just see if things are okay great let's try it out
in postman. Let's we know the book by ID one exists so we let's try it send it so
we got it back right ID one title picture of door ingrate great that's awesome
let's try number two. I booked two and book three and book four there's no book
four so we got nothing because we return no so that's not very good to get a
200 okay of no so you want to usually if you don't find a record you want to say
to the user 404 status code okay and usually some error message if you want.
So going back to our route definition we got to think through this and we don't
want to return no so let's do something else right here so let's put this guy in
a variable called book let's say const book is book find one book now we have
one condition here this guy sends the book assuming it exists but if the book
does not exist what do you do if book if it's no this is going to be true so we
execute something so we want to return a response with a status of 404 so we're
going to send status 404 in this case let's see what we get by the way we
should return right away otherwise it's going to call our yes again and that's
not good so make sure to return after this early our yes send okay we don't
want to send a book that's no so let's try this out since status is going to
send a response back of status 404 usually used for not found things are not
found so let's try it out going back to postman send again look we have a
status not found now that's great now we didn't have any specific error message
in JSON format if you want to add that let's try it go back to the text editor
and you can concatenate here with a send an object I can put I don't know a
message for example error message or description you can say could not find
the book something like that let's try
seems like it did not work let's think through this send status 404 send let me
look just the moment I'm try something I put the 404 before the message I think
this is already deprecated so but I want to see the error message in a console
let me try to postman now we got to could not find a book but this is
deprecated use our yes dot status status dot send okay so we should actually use
so this is a good practice for us to deal with deprecated things so you read the
express deprecated message so you should not do that don't use the rest send with
the status quote on the body anymore should use separate things like our yes
dot status with the status quote and send with the body okay so I just missed
that I put send status here instead of just status going back to what we had
before this should be just status okay our yes dot status 404 and then you send
something save it try it again there you go 404 and the message could not find a
book great nice so let's review what we did in this lesson we learned how to make
the slash book slash book ID route we learned about route parameters if you
put a call and follow some name it's gonna appear in the rack dot per am's
object with that same property name notice that this is always a string so
if you have a number there you have to parse it for example in our case parse the
book ID into an it then we built a fine one fake database response which is if
you give a book ID you get the it searches for that book ID if it doesn't
find it make sure to return a response with status 404 and some message and
make sure to return early from the route otherwise you're gonna go on and try to
send something again that's not good I always remember the return and then if
it finds the book this condition we follow so it's not gonna execute anything
here but it's gonna send the actual book object as found okay so that's it for
this lesson and I see you on the next one


07 Writing the GET Route to Get a Specific Book By Id

Parsing Incoming Request Body in Express using Middleware

# Lesson Summary: Creating a Book with Express.js

In this lesson, we covered how to create a new book object using Express.js. The following points summarize the key steps and concepts discussed:

## Overview
- We previously learned how to retrieve all books and get a specific book by its ID.
- Now, we focus on creating a new book using a POST request to the `/books` endpoint.

## Data Structure
- Our data consists of a list of book objects in a fake database.
- Each book has an automatically assigned `ID` and a `title`, which the user must provide.

## Implementation Steps

1. **POST Request Setup**:
   - We set up an endpoint `app.post('/books')`.
   - The request body needs to contain the `title` of the book.

2. **Middleware for Parsing JSON**:
   - In order to handle the request body, we need to parse JSON data.
   - Express version 4.16 introduced built-in middleware for JSON parsing (`express.json()`).
   - Optionally, we can use the `body-parser` middleware (install via npm) for older versions.

3. **Using Middleware**:
   - Require `body-parser` at the top of your file (if using it).
   - Apply it using `app.use(bodyParser.json())` or `app.use(express.json())`.

4. **Accessing the Request Body**:
   - Once the middleware is in place, the body of the request can be accessed via `req.body`.
   - We illustrated the capability by sending a JSON object through Postman.

## Testing the Endpoint
- We used Postman to send a POST request to `/books` with a JSON body containing the title.
- Verified that the server response contains the sent title, demonstrating that the body was correctly parsed.

## Creating a New Book
- We discussed the need to implement a method to create a new book. This involves:
  - Pushing the new book object (with ID and title) into our books array.
  - Incrementing the ID based on the last book’s ID to ensure uniqueness.

By following these steps, you should be able to set up an endpoint to create books in your Express.js application.

In this lesson, we're going to learn how to make a book.
So we already learned how to get all the books, how to get a specific book by ID.
Now it's time for us to create a new book object.
We're going to do the post slash book, books, endpoint, and for that, if you look at our
data structure, we have a list of book objects in our fake database, hard-coded data.
So each book has an ID and a title.
So when you want to create a new book, all you have to do is provide a title.
The ID will be set automatically and given back to whoever creates the book.
So in this case, this request has the body.
And this body here is going to have the title of the book.
And our back-end or server is going to take this, insert into our list of books, and generate
a new ID for that book.
We're going to return back the book with an ID assigned to it.
So let's get back to our code.
We're at the JSN.
Let me just fold this guy.
So we did the get slash books.
We did the get slash book, slash book ID.
Now it's time for us to do the app.post.
So if you call post on the app, that's going to give you a poster out.
The path is slash books.
We're going to have our usual rec and rest parameters for the arrow function here.
Now we have a problem.
How do we get the request body into our application here?
To do that, we're going to have to use a express middleware.
A middleware is like a middleman between the incoming request and your defined route.
So it's going to be intercepted.
And we're going to get that request body and parse it into a JSON object in JavaScript
because the incoming data is in JSON format.
It's just a string, right?
So we have to JSON parse it into an actual JavaScript object so we can work with it.
So to do that, typically before express 4.16, you would use a body parse a middleware.
Now we can actually just do express as a built in JSON middleware.
But just in case you want to use body parse, I'm just going to tell you how to do it quickly.
So all you have to do is go to the terminal.
Let me kill the server here.
And you're going to have to install the package called body parse it like so.
And then this is going to automatically save to my package JSON because node 8 or that
it does that.
If I look at package.json, we now have the body parse a middleware 118.13 for express.
So the way to apply middleware in express is before all the routes here right after we
do our express app, we're going to use the use method on the app.
That's going to allow you to use a middleware.
So all you have to do is you're going to have to use the body parse a middleware.
So first let's let's require the middleware right at the top.
Let's call it body parser and require body dash parser.
And then finally here you just call body parser dot JSON and you call it the method.
This will apply the middleware.
So every time it goes to your server is going to go through body parser to see if it has
to parse anything from JSON to an actual JavaScript object or list.
And that's going to create a property called body in the rack object.
So you're going to have this rack dot body property.
So to illustrate it we're going to do a rest in the rack dot body.
Okay, just send it back when you go do a post slash books.
So this is where the body of the request is going to be because we're using body parser.
So let's save it.
If you don't use body parser by the way, you're going to get this guy.
You're going to get undefined.
Let's go to the postman application here.
So let's change the verb to post and slash books.
Now to send a body in this request to include a body you click on body here instead of form
there let's use the raw option with the JSON instead of text.
So we have application slash JSON.
So create a JSON.
So what do we need to create a new book and need a title.
So create a new property called title.
Let's call it the awesome book like so and then you click send.
Now I forgot to start my server.
I'm sorry.
Let's use npx no known app.js again.
Going back to the postman application send.
So we got back the same thing we sent.
So that's good.
So rect.body actually contains the body of the request.
So that's what we learned.
And just so you can actually see that body parser is needed I am going to comment this
line and see what we get.
Back to postman send nothing comes as a response because the rect.body is undefined.
Okay.
So that's all now in Express 4.16 there's a new built in middle air to parse the JSON.
So I'm going to comment it out.
Comment out body parser and instead here I'm going to duplicate this line and we're going
to just use the built in in case you don't want to include an external library external
third party app module that is body parser.
So you can just say express remember we required express dot JSON here like so and it's going
to do pretty much the same thing for us.
Let's try it.
Go to postman send it and there you go.
You got back the awesome book.
Great.
Now now that we learned how to parse the request body it's time for us to.
Implement our actual creation of the data.
So if you let's go to book.js and let's create a new method.
So this new math is going to be called create and what creates going to do is simply create
a new book and insert it into this this existing list of books.
Mind you that we have to figure out the last ID so we can increment it so the next guy is
going to have ID for right.
So the create method needs to take what take the actual book object with the title.
So let's add the book parameter.
So books are going to contain something like this.
So first what we have to do is simply push to this array but we have to add an ID to
the new record.
So let's just do a simple books dot push with an object.
We're going to push an object that has ID and a title.
A title is going to come from the actual parameter right now what's the ID we need
to.


08 Parsing Incoming Request Body in Express using Middleware

Defining the POST Route to Create a Book

# Summary of Transcript

In this transcript, the speaker discusses how to manage unique IDs for records in a relational database. Here's a breakdown of the main points:

1. **Understanding ID Management**:
   - Simply taking the last record's ID and adding one can lead to issues if records are deleted.
   - The last used ID will be tracked—if the ID of the last record is 3 and one record is deleted, the next ID will be 4.

2. **Updating the Last ID**:
   - The last ID is incremented before assigning it to a new record.
   - The code uses `const ID` to define a new ID by incrementing `lastID`.

3. **Response Preparation**:
   - Typically, the server responds with the object of the newly created record, including its ID.
   - The new book is created and stored in a variable named `newBook`, which is then sent back to the client.

4. **Route Handling**:
   - Before creating a book, JSON data is parsed and passed to the `book.create` method.
   - The speaker mentions the importance of filtering out unwanted properties from the request body, although it’s not implemented in this example.

5. **Testing the Implementation**:
   - The speaker uses Postman to test the creation of new books.
   - After implementing the POST route, they verify that the record is created correctly, displaying the updated list of books.

6. **Final Thoughts**:
   - The lesson concludes with a reminder about the importance of filtering request properties in a real project.

Overall, the session provides insights into handling IDs in databases and the process of creating new records within a web application.

We need to find out what the last ID is.
We do not necessarily want to just take the last one in this list and add one because
usually in databases, relational databases, if for example I delete this guy
and you add a new record, the ID would actually be 4, not 3 because we deleted 3
and that's already used in the past.
So we're going to keep track of the last ID like so.
So the last ID is going to be 3 in this case because we have 3 records
and the last ID that was used was 3, okay?
And we're going to update this as we add or remove new records.
Sorry, as we add.
Anyway, so going back to what we have here, we're going to use 1, 2, 3.
Last ID was 3 so we need to use 4.
So we're going to first increment last ID then use it for the new ID.
Okay?
So let's make a variable here, const ID.
First you're going to do last ID plus plus and then we do ID as last ID.
There are many ways you could do this.
You could even do like this, for example, this will first increment last ID then use its value.
So that's going to make last ID 3, 4, 3 plus 1, 4 and then use 4 as the value for this ID.
Okay?
So we can use ID here because we can also use this shortcut if the property has the same name
as the variable here, you can do this, okay?
So we increment the last ID, got all that, sounds good.
Now this looks good, we push but then what about the response?
What are we going to respond with?
Well, typically we would just reply with the actual object including the ID.
So let's do that, let's extract this new book into a variable called new book.
New book is just this object here, okay?
And then we send the new book back to the client.
Let's try it out, save this.
Oops, actually we're not in the controller in the route yet, right?
So I'm sorry, I went too far ahead.
We're actually still inside books.
So actually we want to return just the new book back to whoever called this, alright?
Now this was called on the route, post route here.
So we would have to send a new book like so, okay?
So I got it later ahead of myself.
This would be book.create with whatever and this would return the new book, right?
So let's backtrack a little bit.
We first need to get to call the book.create.
We need to first parse the JSON, we already have that done using the middle error.
Now we got to take that and pass it to book.create.
So you can do just rec.body right here.
And you're going to pass the whole body to the book.create method.
And that's going to go there, going to increment the ID, generate the new book, push to the books list and return the new book.
Go back here, take the new book and then we send.
And that's it.
Mind you that we did it very quick and in a simple line, typically you would have to fit like,
what if the client tries to send more properties than you need in the rec.body?
And that's not really nice.
So typically you would pick the properties you want and it filter out all the unwanted ones.
So you could do that here if you made a new object like,
JSON book is a new object with the title being rec.body.
You could use low dash with the pick method, you know, like so.
This kind of thing.
All right.
So I'm just going to leave as is, because I don't really mind at this point we're just learning about keeping mind you should definitely do that in a real project.
Okay, let's test it out.
Go here to postman.
Let me first get all the books so you can see what the list looks like.
Oops, the server is not running because I crashed.
Did I miss something?
Unexpected identifier 31.
Line 31 of book.
Okay, I forgot the comma right here.
So there's a comma.
Sorry about that.
Let's go on.
So it was now running again.
So postman, let's go back at a list of other books.
One, two, and three.
Now let's create a new book with post slash books.
Let's go here to the body.
We have a application JSON.
Let's give it a title.
The awesome book.
Let's click send.
So we got back the awesome book with an ID for great.
Now let's get all the books again.
I'm going to open a new tab and I'm just going to say this local is 3000 books.
Just want to see if the actual list has been updated.
So as you can see, it's now there.
The fourth record, the awesome book.
Let's create another one.
Another awesome book.
There you go.
So we finished our post slash books route.
So first we have to make sure to create the book in the database.
We're using a fake one, by the way.
You got the racked out body to get all the properties that you need to create the book.
This case was just that.
We just put that all in.
I didn't filter out unwanted properties, but you should definitely do that.
And we send it back to the user.
Very simple.
Okay.
So for this lesson, that's it.
And I'll see you next time.
Bye.


09 Defining the POST Route to Create a Book

Defining the PUT Route to Update a Book

```markdown
# Summary of the Transcript

In this lesson, we learned how to update an existing book in our application. Here are the key points:

## Overview of Updating a Book
- We already learned how to create and retrieve books. Now, we focus on updating them.
- The update process involves:
  1. Retrieving the existing book by its ID.
  2. Modifying its properties (like the title).
  3. Saving the updated book back into our fake database.

## API Route
- The route for updating a book is: `PUT /books/:bookId`
- The `bookId` is a route parameter, and the new book properties are included in the request body.

## Implementation Steps
1. **Retrieve the Book**:
   - Use the ID from the route to find the book.
   - If the book exists, proceed; if not, return a 404 error.

2. **Updating Properties**:
   - If changing a single property (e.g., title), create a new object with the updated title.
   - For multiple properties, merge properties from the existing book with the new properties using the spread operator (`...`).

3. **Persist Changes**:
   - Use the `map()` function to create a new array with the updated book. Reassign this to the books list to maintain immutability.

4. **Returning Response**:
   - Send back the updated book details in the response.

## Testing
- We used Postman to test our implementation.
- Initially, if we tried to update a book that didn't exist, we received a 200 OK response, which was incorrect.
- After adding error handling, attempting to update a non-existent book now correctly results in a 404 Not Found response.

## Key Learnings
- **HTTP Method**: We learned about using the `PUT` method for updates.
- **Error Handling**: Implementing proper error handling is essential for robust applications.

With these concepts, you should be able to update any existing book in your application. 
```


Welcome back. So we learned how to get all the books, how to get a specific book
by ID, how to create a book. Now let's learn how to update an existing book.
Looking back at our data structure here in book.js. Let's say I want to change
the title of Donkey Holiday book from to something else. Now we need a way to
first get this guy, then we change the title, then we update this guy. Now for
the route itself, it's going to be a foot slash book slash the book ID. So we give
the book ID as a route parameter so we can first find what book we want to
update. And then for the foot request, we're gonna give it a request body with
the actual title we want to modify. From Donkey Holiday, let's say, I don't know,
Mr. Kihote. Let's change the title to that. So we're gonna have a body in the
request. We're gonna have a request parameter. So to get these guys remember
we use rack.body for the request body and rack.params for the request the
route parameter. Okay, it's gonna be a foot verb. Let's get started. After post,
we're gonna use app. You guessed it. Put slash book slash book ID with a colon
prefix. The usual rack and rest parameters for the function right here.
Then so we need a method in the book module to update the book, right? So let's
first do that. Going back to the MOOC module. We have to do this because we
don't have an ORM nor a database setup. So we're faking it with this module. Okay.
Now let's create a new one here update. It's gonna be somewhat similar to what we
didn't create and find one combined kind of. Anyway, so update needs first you
need the ID of the book to update. So let's give an ID and then we need the
actual new properties for the book. So let's just call it book. Now first
you want to find the book. So we're going to use the same logic right here. So
existing book is going to be books dot fine. Book is the parameter where the
book ID is going to be the ID fast as an argument that enable soft wrap so you
can see. Now we have that or we don't have it because what if the book doesn't
exist? Well if it does not exist we should definitely return no or something.
Anyway, but if it does exist we are going to go here after we find the guy we
need to update the title. So if it's just one property you can just make a very
easy for example you're gonna create the updated book. It's just the existing
book of an object whose ID is the existing book ID but the title is going
to be what? This argument book dot title because it's the new title. That's one
way but if you have so many properties what are you gonna do? Type one by
one? Yeah you could do that. There's another way if you want to include all
the properties from the book into the existing one in a new object and you
can do like that as so. Just do a three dots existing book then you say whatever
from the book here. So this is what this is doing is it copies all the
properties from the existing book then copies all the properties from book and
if book does happen to have the same properties already defined here previously
it's going to overwrite them. Okay anyway with that we can just return. Oops we
cannot because we need to actually update our fake database. So what I'm
going to do is I'm going to use a map method of the array type because if
you look at it an update is actually just you're gonna go and find the one you
want to update. Just change one thing. The length of the array is going to stay
the same so we're gonna map through this guy. If it's not the book we want to
update we don't do anything just return the object as is. Otherwise if this is
the book we want to update we return a new object to this list with this title
replaced. Okay so let's do it. So let's get to books.map and let's do
something here. So if the book.id is the same as the id we want to change right
we are going to return that updated book. Now if it is not we just return the
book itself unchanged. So this map is going through each book in the list. If
the book.id matches the id of the book we want to update we return updated book.
That means the map is going to include in the new array the updated book. Otherwise
it's going to include the book as is without any changes. Mind you that the
map function it creates a whole new list so we have to reassign it to books like
so because this is not going to mutate the original books. Okay now after we do
that we finally update the list and we can return the updated book to the
client who called it because maybe we want to return the updated book back to
the client. Okay so let's say this go back to our route. Now how we're gonna do
this we're going to do book.update what's the id of the book we want to update. The
id comes from the request parameter so we can say rack.what.params.book.id but
remember this is a string because it's in params so we need to parse it into an
integer otherwise this strict equality right here is not going to work because
we have an actual number versus a string if we don't parse it. So let's remove
this guy. Extract it and make a variable book id parse int parse it as an integer.
I'll just put the 10 there just to make sure it's a base then and then we have
the idea of just use it in update and finally we need to pass it the updated
properties. Okay so you could just pick take all of them if you want or you can
filter out the unwanted ones I'll leave it to you to filter out as an exercise.
I'm just going to include request.body like so and then this is going to update
our fake database our coded data and then we just return this guy back to
actually we send the response right send this guy back to the user so the
client gets a copy of the updated book. Okay let's test it out. So we have three
books again notice there's no more four and five because we restarted the server
our hard-coded data is in memory and will be wiped out as and reset to its
original state every time we restart the server. So we got these guys going let's
change the name of Donkey Hoodie to something else. So let me change the
verb here to actually let me go to the another tab so we can reuse the other
one we got to use put HTTP localhost slash books slash to to is the Donkey
Hoodie books id we need a body remember let's use raw not text but
JSON application slash JSON we need want to change the title of the book to Mr.
Kihote for example now let's try it. Did we get any response yes we did it's just
down here I would like to drag it up so you can see better. So this is our
request body this is our response body so we got a title not changed to Mr.
Kihote to confirm that our database or fake database actually actually
changed we have to do a get slash books to see that the index the second
element is Mr. has now title Mr. Kihote and all the other records are
unchanged okay so that's a 200 okay everything went well. So let's just
review what we did in this lesson we learned how to use the HTTP app.put to
make a put request to update a book the endpoint is slash books slash colon
book id book id comes from the request parameters which is always a string so
you need to parse it into an actual number to make sure of things match
correctly inside our fake database search. Then we after we pass it to our
fake database to update the book using the id and the rack body with the
updated properties we send it back to the user of the 200 okay all right. Now
what if it doesn't exist oh that's something we didn't talk about right
let's go back here to our postman and try to update a book that does not exist
like book number four right now does not exist we are getting 200 okay that's not
good we should get at least a 404 right so we got no here so let's get back to her
to our route so this guy actually could be no so we should extract this guy into
updated book it's going to be equal that then if there is no updated book if
that is no right we are just going to return right away with a response send
what remember the status code let's put a status of 404 beforehand so we're
going to send a response with the status 404 and we're going to send a
message saying that the book you want to update is not does not exist how about
that okay so that's our error kind of handling here so let's try again oh
actually I forgot to place the updated book right here let's go to postman so
do what we started the service so it don't change that but we don't care
anymore anyway so we're going to do a put on book slash port which does not
exist and now we get 404 and add pound the book you want to update does not
exist okay so I just wanted to finish with that doing the 404 if the actual
book you're trying to update does not exist so I'll see you in the next lesson


10 Defining the PUT Route to Update a Book

Defining the DELETE Route to Destroy a Book

# Summary of Getting Started with Express: Deleting a Book

In this lesson of "Getting Started with Express," the focus is on implementing the delete functionality for a book resource in the Express application. 

## Key Concepts Covered

1. **HTTP DELETE Method**:
   - The DELETE method is used to remove a book by its ID.
   - Endpoint format: `/books/:bookID`

2. **Implementation Steps**:
   - Use `app.delete()` to create the delete endpoint.
   - Parse the book ID from `req.params.bookID`.
   - Check if the book exists by using `Book.findOne()`:
     - If the book does not exist, return a 404 status with an appropriate message.
   - If the book exists, call `Book.destroy(bookID)`:
     - If deletion is successful, respond with a 204 No Content status.
     - If deletion fails, return a 500 Internal Server Error.

3. **Code Details**:
   - Error handling for client errors (404) and server errors (500) is emphasized.
   - The delete logic involves filtering the book list to remove the target book based on its ID.

## Summary of Code Implementation
- The app structure accommodates the delete method.
- Test cases show successful deletion and error handling:
  - Attempting to delete a non-existent book returns a 404 error.
  - Deleting an existing book returns a 204 status, confirming the deletion.

In conclusion, the lesson reinforces the importance of managing different scenarios and responses in a web application, particularly in RESTful APIs. The instructor encourages practicing these error handling concepts as they are foundational for building robust applications.

---

This concludes the summarized lesson on deleting a book in Express. Looking forward to the next lesson!

Welcome back to Getting Started with Express. So we did get all the books, a
book by ID, create a book, update a book. Now the only thing remaining is
deleting a book. That's what we're going to do in this lesson. So let's get
started. The HP verb is going to be delete. And then we're going to do slash
books slash book ID for the endpoint. Now delete is pretty easy because all you
need is the book ID and don't need a body. You're just going to find a book and
delete it. Okay, so let's go back to our app. And right after let's see food, right
after put right here, let's do app dot delete. Okay, and we're just going to
follow the same pattern as we did before. So I want to challenge you to try to do
the delete by yourself before we can move on. So how did it go? So let's try it.
We're gonna do slash books slash colon book ID, rec rest. And then we need to go
color book dot what we don't have it yet. So let's call it this try. So we need the
ID of the book to destroy and that's in rec dot programs dot book ID, but we need
to parse it. So let's do it. book ID. Let's parse int the rec dot per oops, rec dot
programs dot book ID. And use base 10. After that, we pass it to the destroy method that
so you have to be defined, that guy's going to remove it and that's pretty much it. Just
it should return actually, what should it return, maybe just the ID of the book that
was returned, something like that, because we what if we try to destroy something that
does not exist? Should this guy return no, I guess so. Actually, we should just first
find the book and to see if it exists. And then after that, we try to destroy it. So
destroy is just going to return the ID of the book that was destroyed if it succeeds,
otherwise it should do no. So let's just find the book first. We're going to do book dot
find one. The ID is book ID, constant book, like so remember, the fine one. Now, if I
want to find one and then I want to check if the book does not exist, then we don't need
to delete it, right? We should do a 404. How about that? We're going to say rest dot
send status 404. And just that same message we had before, let me copy it. Exactly, except
it's the book you want to delete does not exist. Okay, so do a return right here so
it does not go on to the next things we want to do. So we look for the book first, if it
does not exist return 404 otherwise we can proceed to destroy it because it exists, right?
And then after destroying it, we just want to check if destroyed book ID is that. So if
the book ID matched the destroyed book ID, something like this, so we can have a, we can
know it actually destroyed it, or you could just check if this guy is no actually. Yeah,
let's try that if destroyed book ID
is not no. And that means it actually destroyed it that we have defined yet,
we should raise rest dot send. We just send nothing actually, we can just the status 201
meaning empty, like success. And that's pretty much it. Let's do a send status.
We don't have to return anything if we delete it successfully just 201. Now what happens if you
forget to return here if the destroyed book fails, right? We don't have any
mechanism to check for errors right now because we're just doing the hard-booted
ORM like thing. So I would say just return some kind of error right here at the end in case
this does not match. So I know it's getting a little bit complicated and even though it's
supposed to be easy. Anyway, there's so error handle you have to think about it. I just want
you to get get started to thinking about how to handle these special cases. It makes a little bit
more complicated in any case. So if it happens so that the destroyed book ID, you didn't get
anything you got null because the operation to destroy failed, then you should definitely send
back a rest dot status or I don't know specific error you should be able to do right here. Maybe
let's do a 500 and you a general internal server error. And just like that,
a message could not destroy, oops, could not delete the book. I've liked that. Anyway, our case,
this is not not going to fail I hope because we're already checked the book exists and everything,
but it's just in case. Anyway, so let's define this book that destroyed right here. So down there
destroy in the book.js file, we need the ID of the book to destroy. All we have to do is go
through the list and eliminate the ones we find right. So we can go and use filter. It's a method
of the array prototype. So we filter out the guys that do not match the ID of the item we want to
delete. So we're going to do the following books, it's going to be equals to books about filter
book. So we're going to allow all the book whose IDs are is not the ID of the book to be destroyed.
This is going to filter allow every book to be in the new list except for the one
that matches the desired ID. Okay, so you're telling it please include the book as long as its ID is
not the one that I'm looking for. To do that or database is updated and we don't have to do anything,
we just return the ID back. Now if there somehow if we're working with an ORM or whatever,
in a given error, you would have to handle it here and return no sum to indicate there was a
problem or something anyway, we're not dealing with that. So going back to our app.js,
let's see what we have here. Let's test it out. Save this postman. Let's change the delete. Let's
delete book four. Well, the book you want to delete does not exist because we implemented that,
right? Now let's delete book number one. Created. Oops, 201 created. I think I've got the wrong code.
I think it should be 204, I'm sorry. Let me just do a quick search right here.
204 code. Yeah, that's it. I'm sorry. That was not 201. It was supposed to be 204, no content.
Okay, so let me fix that. I meant to be 204 if you successfully destroy a book because there's no
content, we just send the status code. In any case, let's get back to what we were doing.
Let's do a get all books. We have one, two and three. Remember the server restarted. So that's
why we have them. Let's delete the first one. I'm going to delete books one. I don't need a body
data right now. So don't need you ignore that. So delete the first one.
We got a 204 no content with nothing. Let's check the database. Okay, one is gone.
Let's do three.
Delete three, no content. Three is gone. Let's do want to to remove the last one.
Delete book slash two. Oops, what happened here? Oh, maybe there was a problem in your database
or not. Could not get any response. Oh, I don't know what I have. Anyway, let's check the
database. There's nothing now. Okay, so that's it. No problems here. We're all good.
Let's review what we did. This lesson we learned how to destroy or delete an existing resource,
or if it does not exist, we do 404. So first we have to parse the book ID from the rack
parameters, the route parameters. First we look, then we looked for the book to see if it actually
exists. If it does not exist, return a 404 status with a message error as the error,
error message. We all then we call booked up destroy of the book ID and everything goes well.
We know it's going to go well in our case because it was hard coded data without any promises or
async, async operations. And we if we got the ID, which we probably we're always going to get in
this case, if there's no error, we return a make a response with a 204 no content status.
Okay, and then we just return. And then we added just a 500 right here, in case an error would
occur after trying to destroy the book. In this case, it's not going to occur, because we're not
dealing with actual database, we're not doing async stuff and all that stuff. Okay, so it's
just hard coded. So I just wanted you to practice thinking about different cases where
you would have to return a different response, handle the errors, be it client errors or
the actual server side errors, that kind of stuff. Okay, so
I think we're good. And until the next lesson, bye.


11 Defining the DELETE Route to Destroy a Book

End of the Express Course Review

# Course Summary

## Introduction
- Congratulations on completing the course!
- We reviewed everything learned during the course.

## Key Topics Covered
1. **Project Setup**
   - Generated a new project using NPM.
   - Installed **Express**, a Node.js web framework, used to build a RESTful JSON API.

2. **Bookstore Example**
   - Built an example API for a bookstore, focusing on managing books with properties like title.

3. **Express Basics**
   - Set up an Express application.
   - Used `app.use` for middleware application.
   - Learned about **body parser** and **Express JSON middleware** to access request body data.

4. **HTTP Methods**
   - Implemented **GET**, **POST**, **PUT**, and **DELETE** routes.
   - Defined routes using HTTP verbs and endpoints.
   - Processed requests and sent responses using `res.send`.

5. **Routing and Parameters**
   - Handled route parameters with `req.params` and recommended parsing those values.
   - Managed status codes, including:
     - Return **404** for not found errors.
     - **204 No Content** for successful deletions.
     - **500 Internal Server Error** for general errors.

6. **Validation and Error Handling**
   - Emphasized the importance of validation for request bodies.
   - Encouraged filtering out unwanted request properties.

7. **Server Setup**
   - Used `app.listen()` to run the server on **localhost:3000**.

## Further Recommendations
- Explore more middleware, such as **passport.js** for authentication.
- Improve the code by organizing it into a scalable structure, possibly following the MVC (Model-View-Controller) pattern.
- Conduct further research into advanced Express topics and best practices.

## Conclusion
- Thank you for participating in the course!
- You're encouraged to continue learning and building upon this foundation.

Hello everybody, we have reached the end of the course.
So congratulations on getting here.
So let's review everything we did in this course.
So we learned how to generate a new project using NPM.
We installed Express.
Express is a Node.js web framework.
We use it in our case to build a RESTful JSON API.
We use an example of a bookstore where you have many books and those books each have
a title.
They could have many more properties where we focus on just learning the Express and
how to do the routing and all that kind of stuff, how to handle the data and call a fake
ORM-like module.
That's the book module we made to do operations on the hard code, the data that we thought
of it as our database.
So we learned to use Express.
Set it up with a basic Express.
You have to call Express to make the app.
Then the app is pretty much where everything is going to be acted upon.
You call app.use to apply any middle errors.
You learn about the body parser and the Express JSON middle errors to allow us to get a rack.body
available inside a route so we can see the contents of the request body formatted from
JSON to the actual JavaScript object or list.
We learned about how to do a get, a post, a put and delete routes using the Express.
Usually the usual way to define a route is you do the verb.
HTTP verb is going to be the method you call.
First argument is the path, the endpoint to this API resource.
Then the second is always going to be what you're going to do when this request comes.
It's where you define typically your response.
You do some processing and then you respond to the request.
It's always with the rack as its first parameter and the rest as the second parameter.
Those correspond to request and response respectively.
We learned about res.send to send any kind of response back to the client.
Alert various ways of parsing the request route parameters.
Rack.params, remember it's a string so if you have numbers in there you should definitely
parse them.
Then we learned about how to change the status code.
In this case if we could not find the record we should always make sure to return a response
with the status code 404 and with some friendly message for the client.
Otherwise everything goes well just send the actual book object in this case in JSON format.
Then we learned how to create a book.
Very simple.
We didn't do any validation in this course but you should definitely validate all these
request body parameters that come in.
You should also filter out the unwanted ones in case some guy is trying to mess with your
system and try to add new stuff that could have some bad consequences.
I don't know.
Anyway.
We did update, same thing 404 and all that stuff.
Then finally we did the delete.
We went a little bit overboard in the delete because we wanted to start thinking about
special cases and error handling.
Since we are using a card coded database like structure it's not really a database and it's
not a sync asynchronous.
We don't have any issues but you would probably have some issues to solve if you were an actual
database.
Learn to send the status tool for no content in case we destroy something and it succeeds
and there's no content to be returned.
Learn about 500 internal server error just in case something general error would happen.
This is not recommended to be used anyway.
You would use something like 422 bad request.
I don't remember the name of 422.
It's either bad request or something else.
Anyway 400 type, 4XX type errors is when the actual server side, the client sends something
that the server does not think it was not in the right format.
You should read more about status code on your own.
Anyway.
Yeah.
So we learned around and everything.
Make sure to call the app.list so you are actually running the server and put a friendly
messaging to the server so he can know what part is running.
In all cases we define the part 3000 so we go to localhost 3000 every time we want to
access our API.
So this course was just an introduction to express.
There's a lot more you can build upon.
You should definitely look into the more middlewares for authentication, that kind of stuff.
I recommend passport.js and that kind of stuff.
Also you should definitely look into improving the code base.
In our case we put everything in one file but that's not really good in the long term
for scale as your app grows and grows and grows.
So you define, you could follow the kind of MVC model view controller like directory
structure where each of the routes go under a, we call it controller.
And we can separate all the routes depending on for each resource and the kind of stuff.
So you can do your own research and learn about that as you go on advanced topics of
the express framework.
Okay that is all for the course and thank you so much.
Congratulations.
