node.js - node - npm body-parser

¿Cómo puedo usar body-parser con LoopBack?

Question

Veo que LoopBack tiene el middleware Express 3.x incorporado. De hecho, body-parser está en loopback/node_modules . Pero no puedo averiguar cómo usarlo como middleware. Nunca he trabajado con Express 3.x, así que quizás sea solo eso. require no funciona, obviamente, a menos que instale body-parser como una dependencia en mi proyecto.

¿Qué debo hacer en server.js para usar el analizador corporal para que los formularios web se req.params en req.params ? Eso es lo que hace, ¿verdad?

Answer 1

Basado en esta respuesta https://stackoverflow.com/a/29813184/605586 de Ben Carlson, usted tiene que

npm install --save body-parser multer

Luego en su server.js requieren los módulos:

var bodyParser = require(''body-parser'');
var multer = require(''multer'');

y usarlos antes de app.start:

app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
app.use(multer().any()); // for parsing multipart/form-data

Entonces puedes crear un método remoto:

App.incoming = function (req, cb) {
console.log(req);
// the files are available as req.files.
// the body fields are available in req.body
cb(null, ''Hey there, '' + req.body.sender);
}
App.remoteMethod(
''incoming'',
{
accepts: [
{
arg: ''req'', type: ''object'', http: function (ctx) {
return ctx.req;
}
}],
returns: { arg: ''summary'', type: ''string'' }
}
);

Usando esto, puede cargar archivos y campos de datos adicionales para realizar un bucle de retorno con multipart / form-data.

Answer 2

Después de horas de frustración, lo agregué a middleware.json así:

"parse": {
"body-parser#json": {},
"body-parser#urlencoded": {"params": { "extended": true }}
}

Se instala como una dependencia. Ahora tengo datos de formulario en req.body en mis rutas. Mi server/boot/routes.js ve así:

module.exports = function(app) {
app.post(''/mailing_list'', function(req, res) {
console.log(req.body.email);
res.send({"status": 1, "message": "Successfully added to mailing list."})
});
}

Answer 3

Estoy publicando esto sólo con fines informativos. Me encontré con este mismo problema y encontré que esto también funciona. Puede agregar un archivo en el directorio server / boot / con lo siguiente:

var bodyParser = require(''body-parser'');
module.exports = function(app) {
app.use(bodyParser.urlencoded({ extended: true }));
}

Por supuesto, tienes que instalar el paquete ejecutando:

npm install --save body-parser

Eso guardará el paquete en el directorio node_modules. Si desea que sea lo primero que se ejecute, puede iniciar el nombre del archivo con un "0", ya que estos se cargan en orden alfabético.

Dicho esto, me parece que es más "correcto" y elegante utilizar el enfoque de configuración de middleware mencionado anteriormente que este, pero lo comparto en el caso de que alguien más lo encuentre útil.

Answer 4

Estoy usando loopback 2.14.0:

Para utilizar el analizador de cuerpo en sus rutas de arranque personalizadas, solo debe:

1) instalar body-parser npm install body-parser --save

2) Registrar el módulo en middleware.json.

"parse": {
"body-parser#json": {},
"body-parser#urlencoded": {"params": { "extended": true }}
},

No hay necesidad de requerir la configuración del analizador en server.js, el loopback lo hace por usted cuando registra el middleware.

Tenga en cuenta que el analizador de cuerpo ahora está instalado en su directorio "node_modules" de origen, así como en el directorio de módulos de loopback.

Si es posible, intente registrar métodos remotos personalizados como se describe en la documentación de bucle invertido .

Registrar rutas de esta manera le da acceso al analizador de cuerpo de loopback de manera inmediata y es la implementación más "limpia".

Answer 5

Solo para ser más claros sobre lo que se necesita para que esto funcione (¡porque todavía luché por un tiempo después de encontrar esta respuesta!), Aquí están los pasos que tomé:

Como se describe anteriormente, en $ APP_HOME / server / middleware.json, agregue el analizador de cuerpo a la sección "analizar":

{
"initial:before": {
"loopback#favicon": {}
},
"initial": {
"compression": {},
"cors": {
"params": {
"origin": true,
"credentials": true,
"maxAge": 86400
}
}
},
"session": {
},
"auth": {
},
"parse": {
"body-parser#json": {},
"body-parser#urlencoded": {"params": { "extended": true }}
},
"routes": {
},
"files": {
},
"final": {
"loopback#urlNotFound": {}
},
"final:after": {
"errorhandler": {}
}
}

A continuación, agregué la configuración del analizador a $ APP_HOME / server / server.js:

var loopback = require(''loopback'');
var bodyParser = require(''body-parser'');
var multer = require(''multer'');
var boot = require(''loopback-boot'');
var app = module.exports = loopback();
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
app.use(multer()); // for parsing multipart/form-data
app.start = function() {
...
...
cont''d

Luego, como no quería meterme con las rutas personalizadas, agregué lo siguiente a $ APP_HOME / common / models / model.js:

module.exports = function(Model) {
Model.incoming = function(req, cb) {
cb(null, ''Hey there, '' + req.body.sender);
}
Model.remoteMethod(
''incoming'',
{ accepts: [
{ arg: ''req'', type: ''object'', http: function(ctx) {
return ctx.req;
}
}],
returns: {arg: ''summary'', type: ''string''}
}
);
};

Ahora puedo ejecutar mi aplicación con $> slc run.

Cuando publico en el punto final, ahora se analiza correctamente y todo está bien con el mundo. ¡Espero que esto ayude a alguien más!

Answer 6

También se podría usar el analizador incorporado de framework Express dentro de un bucle de retorno como este, por ejemplo para el análisis de json: app.use(app.loopback.json());

Answer 7

Tengo diferentes resultados de la prueba.

1) Para los tipos json y urlencode, NO es necesario agregar su analizador en middleware.json. Puedo obtener datos de req.body correctamente sin agregar el analizador de cuerpo # json y el analizador de cuerpo # urlencoded. El Loopback ya debería apoyarlos.

Loopback relacionado con el código fuente (creo)

1. in strong-remote repo , rest-adapter.js , there is body-parser for json and urlendcoded
line 35
var json = bodyParser.json;
var urlencoded = bodyParser.urlencoded;
line 315
root.use(urlencoded(urlencodedOptions));
root.use(json(jsonOptions));
2.
remote-object.js
line 33
require(''./rest-adapter'');
line 97
RemoteObjects.prototype.handler = function(nameOrClass, options) {
var Adapter = this.adapter(nameOrClass);
var adapter = new Adapter(this, options);
var handler = adapter.createHandler();
if (handler) {
// allow adapter reference from handler
handler.adapter = adapter;
}
return handler;
};

2) Para el tipo raw, podemos agregar body-parser # raw en la parte "parse" en middleware.json, por supuesto, necesita npm instalar body-parser.

Mi código de prueba:

1.My readable stream is from the file uploadRaw.txt , the content is :
GreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaGreenTeaEeeeend
2. middleware.json
"parse": {
"body-parser#raw": {
"paths": [
"/api/v1/Buckets/?/upload"
]
}
},
3.
it(''application/octet-stream -- upload non-form'', () =>
new Promise((resolve) => {
const options = {
method: ''POST'',
host: testConfig.server.host,
port: testConfig.server.port,
path: ${appconfig.restApiRoot}/Buckets/${TEST_CONTAINER}/upload,
headers: {
''Content-Type'': ''application/octet-stream'',
},
};
const request = http.request(options);
request.on(''error'', (e) => {
logger.debug(problem with request: ${e.message});
});
const readStream = fs.createReadStream(''tests/resources/uploadRaw.txt'');
readStream.pipe(request);
resolve();
}));
4.
Bucket.upload = (req, res, options, cb) => {
logger.debug(''sssssss in uploadFileToContainer'');
fs.writeFile(''/Users/caiyufei/TEA/green.txt'', req.body, (err) => {
if (err) {
logger.debug(''oh, failed to write file'');
return;
}
logger.debug(''green file is saved!'');
});
};
OR
Bucket.upload = (req, res, options, cb) => {
logger.debug(''sssssss in uploadFileToContainer'');
const writeStream = fs.createWriteStream(''/Users/caiyufei/TEA/green.txt'');
const streamOptions = {
highWaterMark: 16384,`enter code here`
encoding: null,
}
streamifier.createReadStream(Buffer.from(req.body), streamOptions).pipe(writeStream);
};
5. package.json
"body-parser": "^1.17.1",
"streamifier": "^0.1.1",