Passo a passo de como configurar uma API Express com rotas, middlewares, testes e tratativa de erro síncrono e assíncrono.

Primeiramente sem testes.

não iremos focar em versões dos módulos.

1. Faça um diretório e entre no mesmo para começarmos.

mkdir my-api-express
cd my-api-express

2. Inicie um módulo node com as configurações padrões.

npm init -y

3. Instale o express junto com o nodemon.

nodemon serve para facilitar na hora de desenvolvimento da API, ele quem vai ficar "ouvindo" arquivos, e após algum arquivo for alterado e salvo o servidor reiniciará automaticamente.

npm i express && npm i -D nodemon

4. Abra o package.json e adicione alguns scripts.

...
  "script": {
    ...
    "start": "node src/server.js",
    "dev": "nodemon src/server.js",
    ...
  }

5. Crie a pasta src onde ficará sua API e a pasta routes onde ficarão as rotas.

mkdir src src/routes

6. Crie, dentro de src os arquivos app.js e server.js.

cd src
touch app.js server.js

7. Abra o app.js e construa a primeira rota. Uma rota apenas para averiguar que o server está saudável.

app.js

const express = require('express');

const app = express();
app.use(express.json());

app.get('/', (req, res) => res.status(200).json({message: "server are working"}));

app.use((req, res) => res.status(404).json({message: "nothing to see here"}));

module.exports = app;

veja que criamos uma rota "default" de status 404 que significa not found para caso, qualquer requisição que não esteja dentro das nossas rotas, seja direcionado para ela.

8. Abra o server.js e construa o server.

server.js

const app = require('./app');

const PORT = 3001;

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

9. Rode o seu servidor com o nodemon.

npm run dev

Pronto! Com isso, você já pode fazer uma requisição GET para localhost:3001 e verá que o servidor já está funcionando.

---

Agora criaremos rotas.

Vamos criar 2 (duas) rotas e 1 (uma) será dinâmica.

10. Na pasta routes crie o arquivo anotherRouter.js.

cd routes
touch anotherRouter.js

10. Dentro de anotherRouter.js vamos criar um router, fazer 2 (duas) rotas e exportar.

anotherRouter.js

const express = require('express');
const route = express.Router();

route.get('/', (req, res) => res.status(200).json({message: "you are on /another."}));

route.get('/:name', (req, res) => {
  const { name } = req.params;
  res.status(200).json({message: `you are on /another/${name}, which is a dynamic route.`});
})

module.exports = route;

11. Agora voltando lá em app.js, importe a rota e use o use para passar a rota que criamos para o servidor adicionando apenas 2 (duas) linhas.

...
const anotherRouter = require('./routes/anotherRouter');
...
app.use('/another', anotherRouter);
...

Atenção! a linha app.use('/another', anotherRouter); deve vir antes de qualquer outra rota existente no arquivo app.js

Pronto! Com isso, você já pode fazer uma requisição GET para localhost:3001/another ou localhost:3001/another/jorel e verá que nossa rota vindo de outro arquivo está funcionando.

---

Agora criaremos testes.

Para criação de testes, usaremos apenas 2 (dois) módulos, Mocha e Chai e 1 (um) plugin do Chai, o Chai-http.

12. Instale os módulos.

instalaremos como dependência de desenvolvimento, já que testes não necessitam na produção.

npm i -D mocha chai chai-http

13. Vá até o arquivo package.json e altere o script de teste.

...
  "scripts": {
    ...
    "test": "mocha tests/**/*.test.js --exit",
    ...
  }

14. Crie, fora da pasta src, a pasta tests e já crie o arquivo app.test.js que será nosso teste.

mkdir tests
cd tests
touch app.test.js

15. Dentro de app.test.js importe as dependências e faça o teste da rota principal, da rota secundária e da rota dinâmica.

app.test.js

const app = require('../src/app');
const chai = require('chai');
const chaiHttp = require('chai-http');

chai.use(chaiHttp);
const { expect } = chai;

describe('Test default route "/"', function() {
  it('If are healthy', async function() {
    const res = await chai.request(app).get('/');

    expect(res.status).to.be.equal(200);
    expect(res.body.message).to.be.equal('server are working');
  });
});

describe('Test route and subroutes of "/another"', function() {
  it('If default are healthy', async function() {
    const res = await chai.request(app).get('/another');

    expect(res.status).to.be.equal(200);
    expect(res.body.message).to.be.equal('you are on /another.');
  });
  it('If dinâmic are healthy', async function() {
    const res = await chai.request(app).get('/another/jorel');

    expect(res.status).to.be.equal(200);
    expect(res.body.message).to.be.equal('you are on /another/jorel, which is a dynamic route.');
  });
});

16. Basta rodar os testes e verificar se está tudo ok.

npm run dev

Atenção! tente quebrar o teste de algum jeito para ter certeza que não é um falso positivo.

Pronto! Com isso finalizamos nossa API Express com rotas dinâmicas e testes.

---

Para aperfeiçoar nossa API, agora criaremos Middlewares com tratativas de erro síncrono.

Vamos criar um middleware onde se for passado hacker para a rota dinâmica, ele recusará e lançará um erro.

17. Dentro de src vamos criar uma pasta middlewares e um middleware com o nome verifyName.js.

mkdir middlewares
cd middlewares
touch verifyName.js

18. Dentro de verifyName.js vamos criar uma tratativa de erro para não aceitar hacker como name.

verifyName.js

const verifyName = (req, res, next) => {
  const { name } = req.params;
  if(name !== 'hacker') return next();
  next({statusCode: 400, message: 'get out! >:[ '})
};

module.exports = verifyName;

19. Dentro de arquivo anotherRouter.js vamos importar e colocar nosso middleware na rota dinâmica.

anotherRouter.js

...
const verifyName = require('../middlewares/verifyName');
...
... router.get('/:name', verifyName, (req, res) => {...
...

20. Volte lá para app.js e vamos criar somente 1 (uma) linha que ira tratar todos os erros passados pelo next.

app.js

...
app.use((err, req, res, next) => res.status(err.statusCode).json({message: `${err.message}`}));

module.exports = app;

Atenção! Essa linha de código deve ficar por último no app.js!

Pronto! Com isso fizemos um middleware e qualquer erro lançado no next virá para nossa tratativa de erro síncrona.

---

Para finalizar nossa API, agora criaremos Middlewares com tratativas de erro assíncrono.

Basta instalar 1 (um) módulo e importar ele no app.js.

21. Instale o express-async-errors.

npm i express-async-errors

22. E no arquivo app.js vamos apenas importar o módulo sem criar variável.

app.js

...
require('express-async-errors');
...

Pronto! Com isso, finalizamos nossa API Express com rotas, middlewares, testes e tratativa de erro síncrono e assíncrono.

---

FIM.