Tengo un problema desde ayer con mi aplicación node express.
Lo que quiero hacer es lo siguiente:
Middleware 1, paso 1 (solicitud de análisis): analice los datos multiparte/formulario en req.body con formidable y haga lo que quiera hacer con los datos (tal validación), luego vaya al paso 2 si todo va bien.
Middleware 2, paso 2 (cargar archivo): Cargar archivo con formidable (ya siendo analizado)
Problemas:
Sé que hay una función de filtro, pero realmente quiero tener dos middlewares separados.
Express middleware
const formidable = require('formidable'); // parse request module.exports.middleware1 = async (req, res, next) => { const form = formidable({ multiples: true }); form.parse(req, (err, fields, files) => { if (err) { next(err); return; } // request parsed // do what I want to do with the fields (such validation) console.log(fields) next() }); } // upload file module.exports.middleware2 = async (req, res, next) => { const options = { uploadDir: 'test', keepExtensions: true, maxFiles: 1, filename: function (name, ext, part, form) { return name }, filter: function ({name, originalFilename, mimetype}) { return true } } const form = formidable(options); form.parse(req, (err, fields, files) => { if (err) { next(err); return; } // file uploaded, go to controller next() }); }aplicación frontal
publishPost: function () { let formData = new FormData() const post = { filters: { ...this.postFilters }, details: { ...this.postDetails } } formData.append('post', JSON.stringify(post)) formData.append('file', this.postMedia.file) postService.createOne(formData).then((res) => { if (res) { postServiceStatus.createOneDone() } }); }Si alguien tiene una idea, estaría agradecido!
¡Finalmente encontré una solución a mi problema!
Creé un controlador de errores global que maneja todos los errores en mi API, y cuando un error está relacionado con mi ruta donde creé el archivo (en el primer middleware), elimino el archivo con la información pasada en req.file.
const fs = require('fs') const { DEFAULT_API_PATH } = process.env /** * Handle middlewares errors * @param {Object} err error object * @param {String} err.type type of error (service affected by the error) * @param {String} err.error original error * @param {String} err.message returned error * @param {Number} err.status error status * @returns */ module.exports = async (err, req, res, next) => { if (err.error) console.log(err.error) // Delete file if (req.path === `${DEFAULT_API_PATH}/posts/create` && req.file) { if (fs.existsSync(req.file.path)) { fs.unlinkSync(req.file.path, function (err) { console.log(err) }); } } if (err.type && err.type === 'database') return res.status(err.status || 400).send({ error: err.message || 'Une erreur innatendue s\'est produite avec la base de données. Veuillez réessayer dans un instant.' }) else if (err.type && err.type === 'server') return res.status(err.status || 400).send({ error: err.message || 'Une erreur innatendue s\'est produite avec le serveur. Veuillez réessayer dans un instant.' }) return res.status(err.status || 400).send({ error: err.message || 'Une erreur innatendue s\'est produite. Veuillez réessayer dans un instant.' }) }El servidor puede consumir una solicitud entrante solo una vez, porque el cliente transmite el cuerpo de la solicitud y el protocolo HTTP no permite que el servidor solicite un "rebobinado" del cliente.
La idea de multer and formidable es escribir el archivo en uploadDir a medida que se consume la solicitud . Si no desea hacer eso en el primer middleware, debe almacenar el archivo en una variable de Javascript (por ejemplo, res.locals.uploadedFile ) y escribirlo usted mismo en uploadDir en el segundo middleware. Pero, ¿cuál sería la ventaja de eso? La memoria principal es más cara que el espacio en disco.
¿Por qué insistes en dos middlewares separados?