Building RESTful APIs with Express

So, in this section, you learned that:

- REST(Representational State Transfer) defines a set of conventions for creating

HTTP services (CRUD operations):
- POST: to create a resource
- PUT: to update it
- GET: to read it
- DELETE: to delete it

- Express is a simple, minimalistic and lightweight framework for building web

servers.

Startup & installation

mkdir express-demo
npm init -y
npm i express

// Build a web server

const express = require(‘express’);
const app = express();

Ex 1:
const express = require("express");
const app = express();

/* http methods
app.get()
app.put()
app.post()
app.delete()
*/

app.get("/", (req, res) => {

// res.download('index.js') - to download a file from server

res.send("hello world");
});

app.get("/games/cricket", (req, res)=>{

res.send([1,2,3])
})

app.listen(3000, () => console.log("Listening on port 3000...."));

// Listen on port 3000
app.listen(3000, () => console.log(‘Listening…’));- We use Nodemon to watch for
changes in files and automatically restart the node process.

Nodemon – node monitor

npm i -g nodemon
nodemon index.js

// Reading the port from an environment variable

- We can use environment variables to store various settings for an application. To
read an environment variable, we use process.env.
const port = process.env.PORT || 3000;
app.listen(port);

const port = process.env.PORT || 3000;

app.listen(port, () => console.log(`Listening on port ${port}....`));

to set port on local machine: open cmd > set PORT=5000 > nodemon index.js

Route Parameters:
// ex: http://localhost:3000/api/courses/11
app.get("/api/courses/:id", (req, res) => {
res.send(req.params.id);
});

// ex: http://localhost:3000/api/courses/2018/feb
app.get("/api/courses/:year/:month", (req, res) => {
res.send(req.params); // params object
});

// ex: http://localhost:3000/api/courses?sortBy=name
app.get("/api/courses", (req, res) => {
res.send(req.query); // query string
});

app.get("/users", (req, res) => {

res.send(req.originalUrl);
});

// http://localhost:3000/users?name=decdier
app.get("/users", (req, res) => {
res.send(req.query.name);
});

Handling HTTP GET Request

const courses = [
{ id: 1, name: "course1" },
{ id: 2, name: "course2" },
{ id: 3, name: "course3" },
];
app.get("/api/courses", (req, res) => {
res.send(courses);
});

app.get("/api/courses/:id", (req, res) => {

const course = courses.find((c) => c.id === parseInt(req.params.id));
if (!course)
res.status(404).send("The course you are searching was not found");
res.send(course);
});

// Getting all the courses

app.get(‘/api/courses’, (req, res) => {
// To read query string parameters (?sortBy=name)
const sortBy = req.query.sortBy;
// Return the courses res.send(courses);
});

// Getting a single course

app.get(‘/api/courses/:id’, (req, res) => {
const courseId = req.params.id;
// Lookup the course
// If not found, return 404
res.status(404).send(‘Course not found.’);
// Else, return the course object
res.send(course);
});

Handling HTTP POST Request

// run postman => new => select post and paste url => body => raw => {"name": "new
course" } => then send
app.use(express.json()); // express.json() returns middleware and the app.use will
uses it
app.post("/api/courses", (req, res) => {
const course = {
id: courses.length + 1,
name: req.body.name,
};
courses.push(course);
res.send(courses);
});

// Creating a course
app.post(‘/api/courses’, (req, res) => {
// Create the course and return the course object
resn.send(course);
});
Input Validation
app.post("/api/courses", (req, res) => {
if (!req.body.name || req.body.name.length < 3) {
res.status(400).send("There was an error in the name property");
}
const course = {
id: courses.length + 1,
name: req.body.name,
};
courses.push(course);
res.send(courses);
});

Using joi package

- You should never trust data sent by the client. Always validate! Use Joi package
to perform input validation.
// npm i joi
const Joi = require("joi");
app.post("/api/courses", (req, res) => {
const schema = Joi.object({
name: Joi.string().min(3).required(),
});

const result = schema.validate(req.body);

if (result.error) {
res.status(400).send(result.error.details[0].message);
}

const course = {
id: courses.length + 1,
name: req.body.name,
};
courses.push(course);
res.send(courses);
});

Handling HTTP PUT Request

app.put("/api/courses/:id", (req, res) => {
const schema = Joi.object({
name: Joi.string().min(3).required(),
});

const { error } = schema.validate(req.body);

if (error) {
res.status(400).send(error.details[0].message);
return;
}

const course = courses.find((c) => c.id === parseInt(req.params.id));

 if (!course) {
res.status(404).send("The course you are searching was not found");
}
course.name = req.body.name;
res.send(courses);
});

// Updating a course
app.put(‘/api/courses/:id’, (req, res) => {
// If course not found, return 404, otherwise update it
// and return the updated object.
});

Handling HTTP DELETE Request

app.delete("/api/courses/:id", (req, res) => {
const course = courses.find((c) => c.id === parseInt(req.params.id));
if (!course)
return res.status(404).send("The course you are searching was not found");

const index = courses.indexOf(course)

courses.splice(index, 1)
res.send(courses);
});

// Deleting a course
app.delete(‘/api/courses/:id’, (req, res) => {
// If course not found, return 404, otherwise delete it
// and return the deleted object.
});

// Writing routes in a separate folder using express.Router()

// router.route method:
Express: Advanced Topics
So, in this section, you learned that:
- A middleware function is a function that takes a request object and either
terminates the request/response cycle or passes control to another middleware
function.

In the server, REQUEST PROCESSING PIPELINE

=>Request=>midlleware functions: [json() => route()] => response

Ex1: here middleware function hadle the “/” route

app.get(
"/",
// => route handler function
(req, res) => {
res.send("welcome to vidly demo");
}
);

Ex2:
app.use(express.json());
// the express.json() will return middleware function
// it will parse the req, if there was a body in the req , then it will set
req.body

Ex3:
Ex4:
- You can create custom middleware for cross-cutting concerns, such as logging,
authentication, etc.

// Custom middleware (applied on all routes)

app.use(function(req, res, next)) {
// …
next();
}

app.use(function (req, res, next) {

console.log("Logging.....");
next();
});

app.use(function (req, res, next) {

console.log("Authentication");
next();
});

Ex 3: router.param middleware
Express has a few built-in middleware functions:

- json(): to parse the body of requests with a JSON payload

- urlencoded(): to parse the body of requests with URL-encoded payload
 express.urlencoded({ extended: true }) is a middleware in Express.js used for
parsing data from HTML forms submitted via the POST method.
 Use: It extracts form data from the request body, making it accessible in req.body.
This is essential when handling user inputs, such as login credentials or form
submissions, in an Express.js application.

- static(): to serve static files, like to view html pages,..

app.use(express.json());
app.use(express.urlencoded({ extended: true })); // to access body of the req
app.use(express.static("public")); // http://localhost:3000/readme.txt

Third party middleware functions:

https://expressjs.com/en/resources/middleware.html

app.use(helmet());
app.use(morgan("tiny"));

// Custom middleware (applied on routes starting with /api/admin)

app.use(‘/api/admin’, function(req, res, next)) {
// …
next();
}

Environment:
- We can detect the environment in which our Node application is running
(development, production, etc) using process.env.NODE_ENV and
app.get(‘env’). - The config package gives us an elegant way to store
configuration settings for
our applications.

console.log(process.env.NODE_ENV); // undefined
console.log(app.get("env")); // by default development

- We can use the debug package to add debugging information to an application.

Prefer this approach to console.log() statements.

/*
set NODE_ENV=production
*/
if (app.get("env") === "development") {
app.use(morgan("tiny"));
console.log("morgan enabled...");
}
Configuration:
// npm i config
const config = require("config");

Folder: config > default.json:

{
"name": "My Express App"
}

Congif > development.json:

{
"name": "My Express App - Development",
"mail" : {
"host" : "dev-ser-mail"
}
}

Config > production.json:

{
"name": "My Express App - Production",
"mail": {
"host": "pro-ser-mail"
}
}

Config > custom-environment-variables.json:

{
"mail": {
"password": "app_password"
}
}

Index.js
console.log("App name: " + config.get("name"));
console.log("mail: " + config.get("mail.host"));
console.log("App Password: " + config.get("mail.password"));
// set app_password=1234

Debugging:
// npm i debug
const startupDebbuger = require("debug")("app:startup");
const dbDebugger = require("debug")("app:db");
const morgan = require("morgan");
const express = require("express");
const app = express();

if (app.get("env") === "development") {

app.use(morgan("tiny"));
 startupDebbuger("morgan enabled...");
}

// some db work...
dbDebugger("Connected to db");

const port = process.env.PORT || 3000;

app.listen(port, () => console.log(`Listening on port ${port}....`));

// set DEBUG=app:startup
// set DEBUG=app:db
// set DEBUG=app:*

Templating Engine:

- To return HTML markup to the client, use a templating engine. There are various
templating engines available out there. Pug, EJS and Mustache are the most
popular ones.

Ex1: pug

Views > index.pug

html
head
title= title
body
h1= message

index.js

// npm i pug
const morgan = require("morgan");
const express = require("express");
const app = express();

if (app.get("env") === "development") {

app.use(morgan("tiny"));
}

app.set("view engine", "pug");

app.set("views", "./views");

app.get("/", (req, res) => {

res.render("index", { title: "My Express App", message: "Hello" });
});

const port = process.env.PORT || 3000;

app.listen(port, () => console.log(`Listening on port ${port}....`));

Ex2: ejs

index.js
Database Integration:
https://expressjs.com/en/guide/database-integration.html

Structuring Express Application:

Middleware> logger.js

function log(req, res, next) {

 console.log("Logging.....");
next();
}

module.exports = log;

routes > genres.js

const express = require('express')

const router = express.Router()
const Joi = require("joi");

const genres = [
{ id: 1, genre: "Action" },
{ id: 2, genre: "Horror" },
{ id: 3, genre: "comedy" },
{ id: 4, genre: "sci-fi" },
];

router.use(express.json());

router.get("/", (req, res) => {

res.send(genres);
});

router.post("/", (req, res) => {

const schema = Joi.object({
genre: Joi.string().min(3).required(),
});
const result = schema.validate(req.body);

if (result.error)
return res.status(400).send(result.error.details[0].message);

genres.push({
id: genres.length + 1,
genre: result.value.genre,
});
res.send(genres);
});

router.put("/:id", (req, res) => {

const { id } = req.params;
const genreIndex = genres.findIndex((g) => g.id === parseInt(id));

if (genreIndex === -1)

return res.status(404).send("The genre ID you are searching is not found");

const schema = Joi.object({

genre: Joi.string().min(3).required(),
});
const result = schema.validate(req.body);

if (result.error)
 return res.status(400).send(result.error.details[0].message);

genres[genreIndex].genre = result.value.genre;

res.send(genres);
});

router.delete("/:id", (req, res) => {

const { id } = req.params;
const genreById = genres.findIndex((g) => g.id === parseInt(id));
if (genreById === -1)
return res.status(404).send("The genre ID you are searching is not found");
genres.splice(genreById, 1);
res.send(genres);
});

router.get("/:id", (req, res) => {

const { id } = req.params;
const genreById = genres.find((g) => g.id === parseInt(id));
if (!genreById)
return res.status(404).send("The genre ID you are searching is not found");
res.send(genreById);
});

module.exports = router

routes > home.js

const express = require("express");

const home = express.Router();

home.get("/", (req, res) => {

res.send("welcome to vidly demo");
});

module.exports = home

index.js

const express = require("express");

const app = express();
const genres = require("./routes/genres");
const home = require("./routes/home");
const log = require("./middleware/logger");

app.use(log);

app.use("/", home);
app.use("/api/genres", genres);

const port = process.env.PORT || 3000;

app.listen(port, () => console.log(`The connection is running on ${port}`));