A pré-história era essa questão.
Revisei o validationMiddlewaremétodo assim:
export async function validationMiddleware<T extends object>(
dtoClass: new () => T,
validateTarget: string,
req: Request,
res: Response,
next: NextFunction,
) {
const dtoInstance = new dtoClass();
const request = {
body: req.body,
query: req.query,
params: req.params,
};
Object.assign(dtoInstance, request[validateTarget as keyof typeof request]);
//request[validateTarget as keyof typeof request] = dtoInstance;
const errors: ValidationError[] = await validate(dtoInstance, {
forbidUnknownValues: true,
whitelist: true,
forbidNonWhitelisted: true,
});
if (errors.length > 0) {
const validationErrors = errors.map((error) => ({
[error.property]: Object.values(error.constraints || {}),
}));
const errorMessage = 'Invalid data provided';
const errorResponse = { message: errorMessage, errors: validationErrors };
return res.status(422).json(errorResponse);
}
next();
}
Então no roteador eu fiz isso:
userRoutes.post('/users/signup', (req, res, next) => {
validationMiddleware(CreateUserDto, 'body', req, res, next);
userController.signUp(req, res);
});
Mas se eu quiser postar nesta rota, recebo o erro Cannot set headers after they are sent to the client, se o objeto postado não tiver erro de validação. Se tiver algum, recebo os erros no Postman, mas também, neste caso, o método do controlador é executado.
Fiz uma pesquisa e entendi que envio a resposta duas vezes. Uma vez no validationMiddlewaremétodo e outra no signUpmétodo.
Para superar isso, tentei o seguinte:
- resolver o
validateresultado para evitar ter uma função assíncrona e ter um fluxo síncrono - introduza uma
hasErrorvariável e retorne-a, e se não for verdadeira, chame o método do controlador - se não houver erros, então em uma
elsechamada de declaraçãonext() - use
returnapós enviar a resposta para encerrar o middleware
Sem sucesso. Qual é então o problema?
EDITAR
Agora, eu retrabalhei a função:
export function validationMiddleware<T extends object>(
dtoClass: new () => T,
validateTarget: string,
req: Request,
res: Response,
next: NextFunction,
) {
console.log('validation');
let hasErrors = false;
const dtoInstance = new dtoClass();
const request = {
body: req.body,
query: req.query,
params: req.params,
};
Object.assign(dtoInstance, request[validateTarget as keyof typeof request]);
//request[validateTarget as keyof typeof request] = dtoInstance;
//const errors: ValidationError[] = [];
validate(dtoInstance, {
forbidUnknownValues: true,
whitelist: true,
forbidNonWhitelisted: true,
}).then((errors) => {
if (errors.length > 0) {
const validationErrors = errors.map((error) => ({
[error.property]: Object.values(error.constraints || {}),
}));
const errorMessage = 'Invalid data provided';
const errorResponse = { message: errorMessage, errors: validationErrors };
res.status(422).json(errorResponse);
} else {
next();
}
});
}
Não há mais asynce await. Eu leio o valor da promessa e, se houver algum erro, envio para o cliente; caso contrário, vou para o próximo middleware (controlador).
Mas também neste caso, o controlador é executado. Se esta for uma maneira errada, como devo resolver? O que eu quero alcançar é o seguinte:
- validar a solicitação recebida
- se houver erros, envie para o cliente
- caso contrário, execute a lógica do controlador
Eu poderia escrever a lógica de validação no controlador, mas acho que isso não seria tão limpo, é por isso que estou tentando usar uma função separada fora do controlador.
O problema é que a validação (resolvendo a promessa) acontece após a invocação do método do controlador. Eu sei disso, mas como resolver isso? A validatefunção da class-validatorbiblioteca retorna um Promise.
EDIÇÃO 2:
Descobriu-se que a validatefunção também possui uma variante de sincronização. Então:
const dtoInstance = new dtoClass();
const request = {
body: req.body,
query: req.query,
params: req.params,
};
Object.assign(dtoInstance, request[validateTarget as keyof typeof request]);
//request[validateTarget as keyof typeof request] = dtoInstance;
const errors: ValidationError[] = validateSync(dtoInstance, {
forbidUnknownValues: true,
whitelist: true,
forbidNonWhitelisted: true,
});
if (errors.length > 0) {
console.log('validation');
const validationErrors = errors.map((error) => ({
[error.property]: Object.values(error.constraints || {}),
}));
const errorMessage = 'Invalid data provided';
const errorResponse = { message: errorMessage, errors: validationErrors };
res.status(422).json(errorResponse);
}
return errors.length > 0;
E no percurso:
userRoutes.post('/users/signup', (req, res, next) => {
if (!validationMiddleware(CreateUserDto, 'body', req, res, next))
userController.signUp(req, res);
});
Agora funciona como esperado.
Isso parece um problema de design.
validationMiddlewareFoi convertido de um middleware Express, como no post anterior, para um híbrido que ainda depende de parâmetros de middleware, embora não seja um middleware. Não é necessário tornar a validação síncrona neste caso. O uso de promessas brutas em vez deasync..awaitsoluções resolve problemas de digitação, mas carece de um tratamento de erros consistente.Uma maneira mais limpa seria delegar a ordem de execução à pilha de middleware do Express; a variante anterior
validationMiddlewareprecisa de uma correção para ser compatível com as tipagens TypeScript do Express:Isso resulta em
nexte, portanto,signUpnão sendo chamado em caso de erro.Outra maneira é implementar o tratamento de erros globalmente e implementar uma classe de erro personalizada semelhante a esta . A função de validação pode ser totalmente convertida de um middleware e não está vinculada aos detalhes de implementação do middleware:
Isso depende da capacidade do Express 5 de lidar com erros de promessas rejeitadas .