In this lesson we'll learn how to integrate our newly learned Sequelize skills with Express to build a RESTful API. We'll perform full CRUD
functionality on our Twert
model.
"Yes, I know totally not a tweet or twitter..."
Fork
andClone
npm install
sequelize db:create
sequelize db:migrate
sequelize db:seed:all
npm run dev
Make a GET
request to http:localhost:3001/
using your REST client (Insomnia, Or Postman), and confirm that your server is working. You should see the following message:
{
"message": "Server Works"
}
Some routes have been set up for you already. Test the following routes and ensure that you are receiving a JSON response:
GET
:http://localhost:3001/api/feed/trending
GET
:http://localhost:3001/api/feed/recents
GET
:http://localhost:3001/api/users
GET
:http://localhost:3001/api/users/:user_id
, Get a user id from the above response!
We'll be building basic CRUD functionality for our twerts. Endpoints have already been set up for you in the TwertRouter.js
file.
Let's start with the first one:
Router.get('/view/:twert_id')
Open the TwertController.js
file and find the function called GetTwertDetails
. I should be able to find a twert by it's primary key. Query for a twert by id:
Let's link this function to our TwertRouter
:
Router.get('/view/:twert_id', controller.GetTwertDetails)
Test this endpoint by finding a random twert id in your database, you can also use any number between 1-400. Make a GET
request to the following endpoint:
GET
:http://localhost:3001/api/feed/view/<Some Twert Id>
You should a valid JSON response, here's an example:
{
"updatedAt": "2020-12-01T03:54:06.668Z",
"ownerId": 89,
"owner_id": 89,
"likes": 23589,
"id": 3,
"createdAt": "2020-12-01T03:54:06.668Z",
"content": "Quo praesentium ex. Dolor molestiae velit ut tempora error voluptate voluptatem aut. Ea repellendus neque eveniet aut velit ea. Voluptates ad aperiam in. Voluptatem quo est aut assumenda sit."
}
Let's create a twert. Our Twerts
model has the following fields:
The ownerId
being a foreign key is not something we provide through the request body, typically you'll see this in a request query or request params. For our example we'll use the request params.
In the TwertRouter.js
file find the endpoint for post:
Router.post('/:user_id')
In your TwertController.js
file, find the function called CreateTwert
.
Let's use the create
method attached to our model to create a new twert:
Let's break this down:
- We're getting the user id from the request params, by default the params are a string so we parse that value to an integer.
- We create a new object containing everything from the request body and add in the
ownerId
, remember the object keys provided must match what's in our model. - Utilizing the
create
method for our model, we create a new twert and send it back in the response.
Navigate back to your TwertRouter.js
and link that method to it's appropriate endpoint:
Router.post('/:user_id', controller.CreateTwert)
Test the endpoint in your REST client:
POST
:http://localhost:3001/api/feed/<Some User Id>
, again pick a random user id between 1-100.
Here's an example of the request body as JSON:
{
"content": "A non controversial twert...."
}
You should see a new twert come back as a reponse:
{
"updatedAt": "2020-12-01T07:32:50.688Z",
"ownerId": 3,
"likes": 0,
"id": 401,
"createdAt": "2020-12-01T07:32:50.688Z",
"content": "A non controversial twert...."
}
You'll notice we never sent a likes
field in the original POST
request, that field is set be defaulted to 0
on creation. It would be nice to post a new twert with a billion likes I suppose...
Not really feeling that last twert? No problem, we can fix that.
Find the put
route in your TwertRouter.js
:
Router.put('/:twert_id')
You'll see it accepts a twert_id
as a parameter. That's the identifier we'll use to perform our update operation.
Find the UpdateTwert
function in the TwertController.js
. We'll use the update
method from sequelize to perform our operation:
Breakdown:
- Again parsing the param to an integer
- Providing the request body to the update
- Finding the record where the id is a match
- Using the
returning:true
option to return the count of the records updated along with the updated records.
Link this method to the PUT
route:
Router.put('/:twert_id', controller.UpdateTwert)
Test this in your REST client by sending a PUT
request:
PUT
:http://localhost:3001/api/feed/<Use the id from the recently created twert>
Here's an example request body:
{
"content": "A little less controversial twert...."
}
Here's an example response:
[
1,
[
{
"updatedAt": "2020-12-01T07:44:52.579Z",
"owner_id": 3,
"likes": 0,
"id": 401,
"createdAt": "2020-12-01T07:32:50.688Z",
"content": "A little less controversial twert...."
}
]
]
Time to delete some twerts. Find the delete
endpoint in TwertRouter.js
:
Router.delete('/:twert_id')
Find the DeleteTwert
function.
Let's destroy
some bad twerts:
Link this function to the delete
endpoint:
Router.delete('/:twert_id', controller.DeleteTwert)
Test this in your REST client by sending a delete
request:
DELETE
:http://localhost:3001/api/feed/<Some Twert Id>
You should see the following message:
{
"message": "Deleted twert with an id of 401"
}
You can confirm the deletion by making a GET request to the /view/
endpoint with the id you just used to make the deletion.
You've been tasked with building out CRUD functionality for comments. Work in the CommentController
and CommentRouter
files. Test your endpoints as you move along. You'll use the /comments
endpoint to start your requests, example:
http://localhost:3001/api/comments
-
Add a followers feature using a many-many-self relationship with the ability to follow other users
-
Build an endpoint that allows liking a twert or comment, you should only be allowed to increment the likes by 1 each time.
-
If you created the followers feature, build in functionality to view the amount of followers and following for a user when visiting their profile, you can use the
GetUserProfile
function in the user controller for this. An example of this is in theTwertController
.
In this lab, we learned how to integrate our Sequelize models with Express to build a full CRUD RESTful API.