Come posso utilizzare body parser con LoopBack?

Question

Vedo che LoopBack ha il middleware Express 3.x integrato. Infatti, body parser è in loopback/node_modules. Ma non riesco a capire come usarlo come middleware. Non ho mai lavorato con Express 3.x, quindi forse è solo quello. require non funziona, ovviamente, a meno che non installi il parser del corpo come dipendenza nel mio progetto.

Cosa devo fare in server.js per utilizzare il parser del corpo in modo che i moduli Web vengano analizzati in req.params? Questo è quello che fa, giusto?

Answer 1

Dopo ore di frustrazione, ho solo aggiunto al middleware.json in questo modo:

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

Si è installato come una dipendenza. Ora ho i dati del modulo in req.body nei miei percorsi. Il mio server/boot/routes.js assomiglia a questo: (! Perché ho ancora lottato per un po 'dopo aver trovato questa risposta)

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 2

Giusto per essere più chiari su quello che serve per ottenere questo lavoro, qui sono i passi che ho preso:

Come descritto in precedenza, a $ app_home/server/middleware.json, aggiungere il corpo-parser alla sezione "analizzare":

{ 
    "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": {} 
    } 
} 

Avanti, ho aggiunto il setup parser per $ 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 

Poi, dato che non ho voglia di pasticciare con percorsi personalizzati, ho aggiunto il seguente a $ app_home/comuni/modelli/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'} 
    } 
); 
}; 

ora posso correre la mia app con $ > slc run.

Quando si invia all'endpoint, ora viene analizzato correttamente e tutto va bene per il mondo. Spero che questo aiuti qualcun'altro!

Answer 3

Sto postando questo solo per scopi informativi. Mi sono imbattuto in questo stesso problema e ho trovato che funziona anche così. È possibile aggiungere un file nella directory/boot/server con il seguente:

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

module.exports = function(app) { 
    app.use(bodyParser.urlencoded({ extended: true })); 
} 

Naturalmente, è necessario installare il pacchetto eseguendo:

npm install --save body-parser 

che salverà il pacchetto sotto le node_modules directory. Se si desidera che sia la prima cosa da eseguire, è possibile avviare il nome del file con uno "0" poiché questi vengono caricati in ordine alfabetico.

Detto questo, immagino sia più "corretto" ed elegante utilizzare l'approccio di configurazione del middleware sopra menzionato rispetto a questo, ma lo condivido nel caso in cui qualcun altro lo trovi utile.

Answer 4

Utilizzo il loopback 2.14.0:

Per fare uso del corpo-parser nei vostri percorsi Bootscript personalizzati si dovrebbe solo bisogno di:

1) Installare il corpo-parser npm install body-parser --save

2) Registrare il modulo di middleware. jSON

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

non v'è alcuna necessità di richiedere l'installazione di parser in server.js, loopback fa questo per voi quando si registra il middleware.

Nota: il parser del corpo ora è installato nella directory "node_modules" di origine e nella directory dei moduli di loopback.

Se possibile, provare a registrare i metodi remoti personalizzati come descritto nello loopback documentation.

La registrazione dei percorsi in questo modo consente di accedere al parser del corpo di loopback e rappresenta l'implementazione "più pulita".

Answer 5

Ho un risultato di test diverso.

1) Per i tipi json e urlencode, non è necessario aggiungere il parser in middleware.json. Posso ottenere correttamente i dati da req.body senza aggiungere body-parser # json e body-parser # urlencoded. Il loopback dovrebbe già supportarli.

il codice sorgente di loopback legati (credo)

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) Per il tipo grezzo, possiamo aggiungere corpo-parser # crudo "analizzare" parte in middleware.json, naturalmente, ha bisogno di npm installare body-parser.

mio codice di prova:

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",