DEV Community: Luiz Calaça

Custom error handling in a REST API using TypeScript, Express.js, Joi validation, and object-oriented programming

Luiz Calaça — Sat, 27 Jul 2024 12:06:56 +0000

Hi, Devs!

Building a robust and maintainable REST API requires careful consideration of error handling, validation, and structure. In this article, we'll explore how to set up a custom error handling mechanism in a REST API using TypeScript, Express.js, Joi for validation, and principles of object-oriented programming (OOP). We'll structure our project as follows:

Scructure:

---src
-----middlewares
--------ErrorHanlder.ts
-----models
--------User.ts
-----repository
--------UserRepository.ts
-----routes
--------UserRouter.ts
-----controllers
--------UserController.ts
-----services
--------UserService.ts
-----validations
--------UserValidation.ts
---app.ts
---server.ts

Setting Up the Project

mkdir rest-api
cd rest-api
npm init -y
npm install express typescript @types/node @types/express ts-node-dev
npx tsc --init

Middleware for Error Handling

// src/middlewares/ErrorHandler.ts
import { Request, Response, NextFunction } from 'express';

class ErrorHandler extends Error {
  statusCode: number;
  message: string;

  constructor(statusCode: number, message: string) {
    super();
    this.statusCode = statusCode;
    this.message = message;
  }
}

const handleError = (err: ErrorHandler, req: Request, res: Response, next: NextFunction) => {
  const { statusCode, message } = err;
  res.status(statusCode).json({
    status: 'error',
    statusCode,
    message,
  });
};

export { ErrorHandler, handleError };

User Model

// src/models/User.ts
export interface User {
  id: number;
  name: string;
  email: string;
}

User Repository

// src/repository/UserRepository.ts
import { User } from '../models/User';

class UserRepository {
  private users: User[] = [];

  findAll(): User[] {
    return this.users;
  }

  findById(id: number): User | undefined {
    return this.users.find(user => user.id === id);
  }

  create(user: User): User {
    this.users.push(user);
    return user;
  }
}

export default new UserRepository();

User Service

// src/services/UserService.ts
import UserRepository from '../repository/UserRepository';
import { User } from '../models/User';
import { ErrorHandler } from '../middlewares/ErrorHandler';

class UserService {
  getAllUsers(): User[] {
    return UserRepository.findAll();
  }

  getUserById(id: number): User | undefined {
    const user = UserRepository.findById(id);
    if (!user) {
      throw new ErrorHandler(404, 'User not found');
    }
    return user;
  }

  createUser(user: User): User {
    const { error } = userSchema.validate(user);
    if (error) {
      throw new ErrorHandler(400, error.details[0].message);
    }
    return UserRepository.create(user);
  }
}

export default new UserService();

User Validation

// src/validations/UserValidation.ts
import Joi from 'joi';

const userSchema = Joi.object({
  id: Joi.number().required(),
  name: Joi.string().required(),
  email: Joi.string().email().required(),
});

export { userSchema };

User Controller

// src/controllers/UserController.ts
import { Request, Response, NextFunction } from 'express';
import UserService from '../services/UserService';
import { ErrorHandler } from '../middlewares/ErrorHandler';

class UserController {
  getAllUsers(req: Request, res: Response, next: NextFunction) {
    try {
      const users = UserService.getAllUsers();
      res.json(users);
    } catch (error) {
      next(error);
    }
  }

  getUserById(req: Request, res: Response, next: NextFunction) {
    try {
      const user = UserService.getUserById(parseInt(req.params.id));
      res.json(user);
    } catch (error) {
      next(error);
    }
  }

  createUser(req: Request, res: Response, next: NextFunction) {
    try {
      const user = UserService.createUser(req.body);
      res.status(201).json(user);
    } catch (error) {
      next(error);
    }
  }
}

export default new UserController();

User Routes

// src/routes/UserRouter.ts
import { Router } from 'express';
import UserController from '../controllers/UserController';

const router = Router();

router.get('/users', UserController.getAllUsers);
router.get('/users/:id', UserController.getUserById);
router.post('/users', UserController.createUser);

export default router;

Application Entry Point

// src/app.ts
import express from 'express';
import UserRouter from './routes/UserRouter';
import { handleError } from './middlewares/ErrorHandler';

const app = express();

app.use(express.json());
app.use('/api', UserRouter);
app.use(handleError);

export default app;

Server Setup

// src/server.ts
import app from './app';

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

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

By structuring our project using TypeScript, Express.js, Joi, and OOP principles, we achieve a clean and maintainable codebase. The custom error handling middleware provides a consistent way to manage errors across the application, while the validation logic ensures data integrity. This setup can serve as a solid foundation for more complex applications.

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Good Practices Using Node.js + Sequelize with TypeScript

Luiz Calaça — Fri, 26 Jul 2024 19:19:18 +0000

Node.js combined with Sequelize offers a powerful stack for building robust backend applications. When using TypeScript, you can leverage static typing to catch errors at compile time, enhancing code quality and maintainability. This article will guide you through some best practices for integrating Node.js, Sequelize, and TypeScript effectively.

Setting Up Your Project

First, ensure you have Node.js installed on your system. Then, initialize a new project and install the necessary dependencies:

mkdir my-project && cd my-project
npm init -y
npm install express sequelize typescript ts-node @types/node @types/express --save-dev

Create a tsconfig.json file to configure TypeScript options:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

Defining Models with Sequelize

Sequelize models define the structure of your database tables. With TypeScript, you can benefit from type safety and autocompletion. Here's how to define a simple model:

// src/models/User.ts
import { Model, DataTypes } from 'sequelize';
import { Sequelize } from 'sequelize-typescript';

export class User extends Model {
  public id!: number;
  public name!: string;
}

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'postgres' // or 'mysql', 'sqlite', etc.
});

User.init({
  id: {
    type: DataTypes.INTEGER.UNSIGNED,
    autoIncrement: true,
    primaryKey: true
  },
  name: {
    type: DataTypes.STRING,
    allowNull: false
  }
}, {
  tableName: 'users',
  sequelize
});

Creating Express Routes

Express routes handle HTTP requests. By defining them in TypeScript, you get the benefits of static typing and better tooling support:

// src/routes/users.ts
import express, { Request, Response } from 'express';
import { User } from '../models/User';

const router = express.Router();

router.get('/', async (req: Request, res: Response) => {
  const users = await User.findAll();
  res.json(users);
});

export default router;

Middleware and Error Handling

Middleware functions can be typed to ensure they receive the correct parameters and return the expected values. Error handling middleware should also be properly typed:

// src/middleware/errorHandler.ts
import { NextFunction, Request, Response } from 'express';

export function errorHandler(err: Error, req: Request, res: Response, next: NextFunction) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
}

Don't forget to add this middleware to your Express app:

// src/app.ts
import express from 'express';
import errorHandler from './middleware/errorHandler';
import usersRouter from './routes/users';

const app = express();
app.use(express.json());
app.use('/api/users', usersRouter);
app.use(errorHandler);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Integrating Node.js, Sequelize, and TypeScript allows you to build scalable and maintainable backend applications. By following these best practices, such as setting up your project correctly, defining models with type safety, creating typed Express routes, and implementing proper error handling, you can enhance your development workflow and produce higher-quality code. Remember to keep your dependencies up-to-date and explore Sequelize's advanced features for even more efficient database operations.

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Interesting middlewares in Node.js and Express.js API for security

Luiz Calaça — Thu, 24 Nov 2022 13:34:26 +0000

Hi, Devs!

Look at this piece of code into the main app.js and its middlewares:

const express = require('express');
const app = express();
const cors = require('cors')
const helmet = require("helmet");
const morgan = require("morgan")
const rateLimit = require("express-rate-limit")

const limiter = rateLimit({
    windowMs: 60 * 1000, // 1 minute
    max: 50, // limit each IP to 50 requests per windowMs
    message: "Too many accounts created from this IP, please try again after a minute"
});

app.use(morgan("common")) //just for logs
app.use(helmet());
app.use(cors());
app.use(limiter)
app.use(express.json());
app.get("/", (res, req) => {
    res.status(200).send("Security into a Node.js API")
})

First tip: Use TLS
It's necessary to create a security's and would be the middle between the connection and the data. One is the free TLS certificate from Let’s Encrypt.

☠️ helmet
"Helmet can help protect your app from some well-known web vulnerabilities by setting HTTP headers appropriately." [Docs]

☠️ cors
"CORS is a node.js package for providing a Connect/Express middleware that can be used to enable CORS with various options."
[Docs]

☠️ express-rate-limit
"Use to limit repeated requests to public APIs and/or endpoints such as password reset" [Docs]

That's simple and helps a lot! Code it!

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Pushing a docker container to Amazon Elastic Container Registry

Luiz Calaça — Sun, 06 Nov 2022 14:39:58 +0000

Hi, Devs!

First of all, go to AWS Console and access on search field: Amazon ECR. Access the option view push commands.

Execute the login command in your local console in your machine:

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin<idaws>.dkr.ecr.us-east-1.amazonaws.com

After build your docker image before tag it:

docker build -t <namebuild> .

docker tag <namebuild> <idaws>.dkr.ecr.us-east-1.amazonaws.com/<namebuild>

Now you could push it:

docker push <idaws>.dkr.ecr.us-east-1.amazonaws.com/<namebuild>

You'll see in the list your image, now you could just refers the image name to others AWS services like Kubernetes.

That'all!

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Typescript customized Function handler for exceptions with Node.js and Express.js

Luiz Calaça — Tue, 27 Sep 2022 12:10:19 +0000

Hi, Devs!

First of all, step one is to build the function handler for exceptions, it is necessary because when you use the throw the application's is going to broke, so when you use the try/catch scope and into catch we could use the method below to get the exception.

/middlewares/ErrorHandler.ts

import { NextFunction, Request, Response } from 'express';

class ErrorHandler {

    public static handle(error: Error, _req: Request, res: Response, next: NextFunction) {
        res.status(500).json({ message: error.message });
        next()
    }
}

export { ErrorHandler }

Let's create the app.ts:

/src/app.ts

import express from 'express';
import { ErrorHandler } from './middlewares/ErrorHandler';
import { NextFunction, Request, Response } from 'express';

const app = express();
app.use(express.json());
app.post('/handler', (req: Request, res: Request, next: NextFunction) => {
try{
  if(req.body.number < 0)
    throw new Error('Negative number!');
}catch(error: any) {
 next(error)
}
});
app.use(ErrorHandler.handle); // necessary to be the last middleware to get the exception.

export default app;

Let' create server.ts file to start the API:

import app from './app';

const PORT = process.env.PORT || 3001;
app.listen(PORT, () => 
     console.log(`Running server on port: ${PORT}`));
})

If you pass a negative number for the body request you'll receive an exception and it will treat with the customized handler because the last middleware (ErrorHandler) will get it.

That's all!

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

You don't need VSCode to debug your Node.js app [Google Chrome V8 inspect and debugger breakpoint]

Luiz Calaça — Fri, 26 Aug 2022 01:36:07 +0000

Hi, Devs!

When we look at Node.js documentation there's a interesting option do debug our code and is inspector context

Let'a create a piece of code and let's use a debugger word that means a breakpoint for our debug process.

//index.js

console.log('hello')
setTimeout(() => {
    debugger
    console.log('After debugger breakpoint')
}, 8000)
debugger
console.log('Finished')

For debugger's uses we need to configure one port into an extension of chrome web browser, copy on your web address:

chrome://inspect/

Click on configure and add the localhost:9229 address:

We are going to use the command below to start the debugger:

node --inspect index.js

After run the previous command --inspect, in the next step we need to click on inspect button, below the remote target.

And will be open the DevTools:

And you could use the next button on the right of the image above where is writing Debugger paused

You could add some expression on Watch to verify some value and into Scope verify the returns.

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

You need to know about Github CLI

Luiz Calaça — Wed, 24 Aug 2022 22:47:00 +0000

Hi, Devs!

What is GitHub CLI: A Command Line Interface to handle easily: repo clones, pull requests, merges, issues, gists and much others

Documentation: https://cli.github.com/manual/

Installation

//Mac
brew install gh
//Linux
https://github.com/cli/cli/blob/trunk/docs/install_linux.md

Are you going to clone a repo?

gh auth login
gh repo list
gh repo clone <repo_name_from_list>

Yes, you don't need to go to the Github page, all in one CLI tool you could clone a project.

Creating, deleting and configuring a repository

gh repo create

gh repo create <name_of_repo> --public

gh repo create my-project --private --source=. --remote=upstream

gh repo edit --visibility <visibility-string>

gh repo sync

gh repo create --disable-issues=true --public

gh repo list

gh repo delete <name_of_repo>

gh repo clone <name_of_repo>

gh repo fork <name_of_repo>

Locally, you create your project with git init, commit your files and after you should go to the gh repo create and would be created remotely the repo and locally configured with the remote origin:

mkdir project && cd project

git init

gh repo create

Usually, when you are programming you think should be possible to save a piece of code. You can use the Gist:

Creating a gist easily

touch index.js // after create content for it

gh gist create index.js --public

gh gist create -

gh gist edit <gist_id> 

gh gist list --public 

gh gist list --secret

Handling issues

gh issue create

gh issue list

gh issue status

git issue close <#number_issue>

gh list -A "<name_issue>"

Handling Pull requests

gh pr create 

gh pr checkout <name>

gh pr diff <#number_of_pr>

gh review -c -b "nice work"

gh pr close <#number_of_pr> -d

gh pr reopen <#number_of_pr>

gh pr status

If you get started to use certainly you'll see that's so great tool.

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Typescript boilerplate test configuration with mocha, chai and sinon

Luiz Calaça — Thu, 18 Aug 2022 01:25:23 +0000

Hi, Devs!

Let's configure tests with mocha, chai and sinon on Typescript in a few steps.

Lets' start the project:

npm init -y

Now, let's install the packages. Here we also install the types (@types) of each library because we need to use them on Typescript. Usually we need to test some elements that returns one promise, so we need do install chai-as-promised.

npm i -D mocha @types/mocha chai @types/chai 
npm i -D sinon @types/sinon
npm i -D chai-as-promised @types/chai-as-promised

We need to use ts-node library to run our tests, because using Typescript we have to transpile the code. So let's install typescript and ts-node.

npm i -D typescript ts-node

Now put on your package.json the necessary script to run the tests:

"scripts": {
  ...
  "test": "mocha --require ts-node/register tests/**/*.spec.ts --exit"
}

Create one folder with the name tests, into a file with testfirst.spec.ts name and create a simple case:

import { describe } from "mocha";
import { expect } from 'chai';
import chaiAsPromised from 'chai-as-promised';

chai.use(chaiAsPromised);
const expect = chai.expect;

describe('Testing the configuration', () => {
  it('should pass', () => {

  });
});

After you could run:

npm run test

That' all!

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Deploy your React.js app on AWS Amplify

Luiz Calaça — Sun, 07 Aug 2022 00:47:44 +0000

Hi, Devs!

Deploy and CI/CD is always necessary and important for software development cycle. Let's go to learn how to deploy React.js app and its using de AWS Amplify service on cloud?

First you need to create an account on AWS and access the AWS Amplify service. After you could use the search engine on AWS and looking for AWS Amplify. Click on Get started.

Again, click on Get started

Connect with you remote repository, I'm using here Github to versioning my React.js app.

Add your repository.

In that step you could click on Next ou copy the code and put it on your project. It's better click on next e carry on because automatically that file will run on your project connected.

If you click on Advanced Setting you could put all environment variables and use your Docker image if you desire, in that case you need to push your imagem do Docker Hub and so on inform the link in that field. And click next.

Almost there and now we need to review and next to deploy.

The deploy has initialized and after that steps you app will available using the url below of your branch like the image here.

Click on your URL and see you app already deployed.

That' all and easy steps!

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

How to create a Node.js project from zero with good practices?

Luiz Calaça — Tue, 19 Jul 2022 22:24:58 +0000

Hi, Devs!

How to create your Node.js project? What is important to organize to masterize? So, let's see necessary things to build your initial project, code quality, manutenability and scalability

Spoiler: At the final there's a github boilerplate repo with all configurations.

Let's go!

Basic
npm init -y
Creating our package.json to manage our packages.

Git alias
That's cool thing that you can use to optmize your commits, It's always necessary add and commit? So, why don't you automatize with just one command instead of two? Git alias pretty formatting can help us too showing in a better way the git console output.
[alias] c = !git add --all && git commit -m

Look at here my gist to handle completely alias like that.

Conventional Commits Linter
npm install git-commit-msg-linter

Here's the git linter to force us to use the Conventional Commits pattern

fix
feature
docs
chore
tests
style
refactor

Git
After you run git init already add the .gitignore and into there folders like:

node_modules
dist
coverage

Husky and lintStaged for code quality
Below is the .lintstagedrc.json configuration to add into project root folder. It garantees that commit will be done just before fix all lint problems and all tests ok.

{
    "*.ts": [
        "eslint 'src/**' --fix",
        "npm run test:staged"
        "git add"
    ]
}

And here .huskyrc.json to garantee esling running before to commit:

{
    "hooks":{
        "pre-commit": "eslint"
    }
}

Javascript Standard Style and eslint
We need to know about standard JS, just use eslint if has just Javascript files, but if you are using Typescript you could use and plugin ESlint on VSCode.

Configuring scripts on you package.json
You could configure your scripts and already all prepared to use.

  "scripts": {
    "lint": "npx eslint .",
    "test": "jest"
  },

Library Testing
If necessary install Jest or Mocha, chain, sinon for unit tests. Frisby for test integrations and Cypress for End2End tests.

Docker
Certainly you neeed to add docker-compose.yml with yours infrastructure (database and other services)

version: '3.1'

services:

  mongo:
    image: mongo
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: example

  mongo-express:
    image: mongo-express
    restart: always
    ports:
      - 8081:8081
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: root
      ME_CONFIG_MONGODB_ADMINPASSWORD: example
      ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/

Software Architecture
If you are gonna use such as DDD + Clean Architecture, you could create the folders with its hierarchy.

Get all the article here
Complete Boilerplate with that all configurations
Link: https://github.com/luizcalaca/node-typescript-boilerplate-configuration

Contacts
https://www.buymeacoffee.com/calaca

Do your first AWS Lambda Serverless Node.js API

Luiz Calaça — Sat, 02 Jul 2022 01:28:24 +0000

Hi, Devs!

First we need to install

serverless framework
create your account on AWS

Let's create a folder:

$ mkdir node-aws
```



Go into that folder and run:



```
$ cd node-aws
$ serverless
```



Now is going to appear some questions after you choosed the AWS - Node.js - HTTP API:



```
? What do you want to call this project? **aws-node-api**

✔ Project successfully created in aws-node-api folder

? What org do you want to add this service to? **[Skip]**

? Do you want to deploy now? **No**
```



---

Open your folder that was created and now we can look at:

![Handler AWS Serverless](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/g89r9djgmvat3gq6bf25.png)

When we use `serverless deploy` our application is going to start the process on AWS, and we go there and see the queue on CloudFormation. You can use search tool and find all the services below.

![search tool on AWS](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5v1fno9fweoh0fc4l0im.png)

**CloudFormation**
It organize a queue of services processing to deploy our service. when we run `serverless deploy` there is a folder `.serverless` with Cloudformation informations do deploy. AWS CloudFormation has a template for this Serverless application. Look at below the events created by that service.
![CloudFormation Event](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/guywiwkuxx30dg8kgg1o.png)

**AWS IAM**
User management. You can verify yours users.

**AWS Lambda**
It was created a function called aws-node-api-dev-hello because into our `handler.js` there's a function called hello and it is configured on `serverless.yml`. Look at below:
![serverless.yml and handler.js](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x774c4pxfdxmlhegx82v.png)

**S3**
Data storage on AWS, and it is created a bucket after our deploy with serverless framework.
![S3](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/24evbgeqq03vbirnsrmy.png)

**API Gateway**
The API Gateway service helps us to create an excellent pattern to access our API. It show us all the routes of the system and here we can add Authorization, CORS configurations and create new routes.

![API Gateway](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gt0egwhu122g8yact34d.png)

When we access the Lambda service we can see the API Gateway in a pipe clicking on **Functions -> choose the function that we created -> Function overview**:

![AWS Lambda - API Gateway](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xvtzt4wja9r6hcz353iq.png)

**CloudWatch**
Monitoring the API with a couple metrics

![AWS CloudWatch](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7m33sdqt3iofq9xjn3df.png)

At the final we have the URL to access our API: https://h5c2vw466m.execute-api.us-east-1.amazonaws.com/

**You can find the URL looking for API Gateway service in search tool and click on the project name that we created.**



**Contacts**
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

You need to know about req and res objects to build an API in Node.js using Express.js

Luiz Calaça — Fri, 10 Jun 2022 00:07:17 +0000

Hi, Devs!

We can have req and res objects into Express.js, they are used to handle the request and response using HTTP protocol and its verbs and status code.

Remember! We have some HTTP verbs and they can do some actions and return some status code.

Informational responses (100–199)
Successful responses (200–299)
Redirection messages (300–399)
Client error responses (400–499)
Server error responses (500–599)

Let's assume a bit code to show Express.js and its response (res) and request (req) object:



const express = require('express');
const cors = require('cors');
const app = express();
const bodyParser = require('body-parser')

app.use(cors())
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: false }))

app.post('/example', handleCreate); //save with req.body data
app.get('/example/search/', handleSearch); //find the data
app.get('/example/:id', handleFindById); //find by an id

app.listen(3000, () => {
  console.log('Running on 3000');
});

Let's see the examples:

req.body
It's populated when you use body-parsing middleware such as body-parser. And response here is just send the result from the database.

endpoint: app.post('/example', handleCreate);
http verb: POST
URL example: http://localhost:3000/example
Status: 201



async function handleCreate(req, res) {
  console.log(req.body)
  const {name, age} = req.body
  const result = await database.create(name, age)
  res.status(201).send(result);
}

req.params
if you have the route /example/:id, then the “id” property is available as req.params.name ou using destructuring like below. And here the response is sending the status and the data in JSON format.

endpoint: app.get('/example/:id', handleFindById);
http verb: GET
URL example: http://localhost:3000/example/1
Status: 200
Response: res.status(200).json(result)



async function handleFindById(req, res) {
  const { id } = req.params //or req.params.id
  const result = await database.findById(id)
  res.status(200).json(result);
}

req.query
This property is an object containing a property for each query string parameter in the route, as well using when we have more than one parameter to share on url, because we can get the value of ?name=Calaca&age=32&live=Brazil&leve=senior. And the response here is sending status 200 and result from database.

endpoint: app.get('/example/search', handleSearch);
http verb: GET
URL example: http://localhost:3000/example/search?name=Calaca
Status response: 200



async function handleSearch(req, res) {
  const {name} = req.query
  const result = await database.findByName(name)
  res.status(200).send(result);
}

req.headers

Simple and effective.

Contacts
Email: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca