Middlewares

Middlewares são funções que tem acesso direto à requisição, e, na estrutura do Valor, são chamados antes do Method.

O Valor utiliza a API do Express para middlewares, então, se quiser saber mais sobre ele, acesse a documentação oficial do Express sobre middlewares.

Criando um middleware

Antes de criar um middleware, é importante que você entenda o que são os objetos Request (req), Response (res) e NextFunction (next) do Express.

Um breve resumo:

• req contém os dados da requisição feita pelo cliente (headers, body, etc.);
• res contém um conjunto de métodos para gerar a resposta para o cliente (status, send, etc.);
• next quando executada, informa que a próxima ação pode ser executada.

Exemplo de middleware que verifica se o cliente está apto a prosseguir com a solicitação:

import { Request, Response, NextFunction } from 'express'
import Token from '@services/Token.service'

export const Auth = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
  // verifica se o cliente enviou o header Authorization
  const hasAuthorizationToken = req.headers.hasOwnProperty('authorization')
  if (!hasAuthorizationToken) {
    return res.status(401).send({ message: 'Token not provided' })
  }

  // verifica se o token está formatado corretamente
  const [, token] = req.headers.authorization.split(' ')
  if (!token) {
    return res.status(401).send({ message: 'Malformatted token' })
  }

  // verifica se o token é válido (pode ser decodificado)
  const tokenIsValid = Token.decode(token)
  if (!tokenIsValid) {
    return res.status(401).send({ message: 'Invalid token' })
  }

  // verifica se aquele token tem permissão para executar aquele endpoint (ACL)
  const hasPermissionToExecuteEndpoint = Token.hasPermission(token, req.originalUrl)
  if (!hasPermissionToExecuteEndpoint) {
    return res.status(403).send({ message: 'Forbidden' })
  }

  // passa para frente
  next()
}

Utilizando um middleware em um endpoint

Existem dois tipos de middlewares: os globais e os injetados.

• Globais: São middlewares que são inseridos automaticamente em todos os módulos, sem exceção.
• Injetados: São middlewares que são injetados manualmente dentro de cada endpoint.

Registrando um middleware global

Registrar um middleware global é muito simples. Basta acessar o arquivo index.ts dentro do diretório @middlewares, importar o middleware desejado e exportá-lo dentro do array de middlewares globais:

import RateLimit from './RateLimit.middleware'
+import CustomMiddleware from './Custom.middleware'

export default [
  RateLimit,
+  CustomMiddleware
]

É só isso. =)

Injetando um middleware em um endpoint específico

Injetar um middleware em um endpoint específico também é fácil.

1. Acessar o arquivo Module.endpoints.ts;
2. Importe o middleware no topo do arquivo;
3. Adicione dentro da chave '@middlewares' do endpoint desejado.

+import { loginLimiter } from '@middlewares/RateLimit.middleware'

export default [
  // ...outros endpoints
  {
    'route': '/login',
    'method': 'post',
    'description': 'login user in',
+   '@middlewares': [ loginLimiter ],
    '@controller': {
      'method': 'login',
      'params': ['body.credentials']
    }
  }
]

Observação: a chave '@middlewares' precisa ser um Array e ela não é enviada na auto-documentação.