Comment faire un appel REST distant dans Node.js? tout CURL?

Dans Node.js , autre que l'utilisation d'un processus enfant pour effectuer un appel CURL , existe-t-il un moyen de faire un appel CURL à l' API REST du serveur distant et d'obtenir les données de retour?

J'ai également besoin de configurer l'en-tête de la demande pour l' appel REST distant , ainsi que la chaîne de requête dans GET (ou POST).

Je trouve celui-ci: http://blog.nodejitsu.com/jsdom-jquery-in-5-lines-on-nodejs

mais il ne montre aucun moyen de POST la chaîne de requête.

Regarder http.request

var options = {
  host: url,
  port: 80,
  path: '/resource?id=foo&bar=baz',
  method: 'POST'
};

http.request(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  res.setEncoding('utf8');
  res.on('data', function (chunk) {
    console.log('BODY: ' + chunk);
  });
}).end();

Que diriez-vous d'utiliser Request - Client HTTP simplifié .

Edit Février 2020: La demande est obsolète, vous ne devriez donc probablement plus l'utiliser.

Voici un GET:

var request = require('request');
request('http://www.google.com', function (error, response, body) {
    if (!error && response.statusCode == 200) {
        console.log(body) // Print the google web page.
     }
})

OP voulait aussi un POST:

request.post('http://service.com/upload', {form:{key:'value'}})

Regardez http://isolasoftware.it/2012/05/28/call-rest-api-with-node-js/

var https = require('https');

/**
 * HOW TO Make an HTTP Call - GET
 */
// options for GET
var optionsget = {
    host : 'graph.facebook.com', // here only the domain name
    // (no http/https !)
    port : 443,
    path : '/youscada', // the rest of the url with parameters if needed
    method : 'GET' // do GET
};

console.info('Options prepared:');
console.info(optionsget);
console.info('Do the GET call');

// do the GET request
var reqGet = https.request(optionsget, function(res) {
    console.log("statusCode: ", res.statusCode);
    // uncomment it for header details
//  console.log("headers: ", res.headers);


    res.on('data', function(d) {
        console.info('GET result:\n');
        process.stdout.write(d);
        console.info('\n\nCall completed');
    });

});

reqGet.end();
reqGet.on('error', function(e) {
    console.error(e);
});

/**
 * HOW TO Make an HTTP Call - POST
 */
// do a POST request
// create the JSON object
jsonObject = JSON.stringify({
    "message" : "The web of things is approaching, let do some tests to be ready!",
    "name" : "Test message posted with node.js",
    "caption" : "Some tests with node.js",
    "link" : "http://www.youscada.com",
    "description" : "this is a description",
    "picture" : "http://youscada.com/wp-content/uploads/2012/05/logo2.png",
    "actions" : [ {
        "name" : "youSCADA",
        "link" : "http://www.youscada.com"
    } ]
});

// prepare the header
var postheaders = {
    'Content-Type' : 'application/json',
    'Content-Length' : Buffer.byteLength(jsonObject, 'utf8')
};

// the post options
var optionspost = {
    host : 'graph.facebook.com',
    port : 443,
    path : '/youscada/feed?access_token=your_api_key',
    method : 'POST',
    headers : postheaders
};

console.info('Options prepared:');
console.info(optionspost);
console.info('Do the POST call');

// do the POST call
var reqPost = https.request(optionspost, function(res) {
    console.log("statusCode: ", res.statusCode);
    // uncomment it for header details
//  console.log("headers: ", res.headers);

    res.on('data', function(d) {
        console.info('POST result:\n');
        process.stdout.write(d);
        console.info('\n\nPOST completed');
    });
});

// write the json data
reqPost.write(jsonObject);
reqPost.end();
reqPost.on('error', function(e) {
    console.error(e);
});

/**
 * Get Message - GET
 */
// options for GET
var optionsgetmsg = {
    host : 'graph.facebook.com', // here only the domain name
    // (no http/https !)
    port : 443,
    path : '/youscada/feed?access_token=you_api_key', // the rest of the url with parameters if needed
    method : 'GET' // do GET
};

console.info('Options prepared:');
console.info(optionsgetmsg);
console.info('Do the GET call');

// do the GET request
var reqGet = https.request(optionsgetmsg, function(res) {
    console.log("statusCode: ", res.statusCode);
    // uncomment it for header details
//  console.log("headers: ", res.headers);


    res.on('data', function(d) {
        console.info('GET result after POST:\n');
        process.stdout.write(d);
        console.info('\n\nCall completed');
    });

});

reqGet.end();
reqGet.on('error', function(e) {
    console.error(e);
});

J'utilise node-fetch car il utilise l' API fetch () familière (si vous êtes un développeur Web ) . fetch () est la nouvelle façon de faire des requêtes HTTP arbitraires depuis le navigateur.

Oui, je sais que c'est une question node js, mais ne voulons-nous pas réduire le nombre de développeurs d'API à mémoriser et comprendre, et améliorer la réutilisation de notre code javascript? Fetch est une norme, alors pourquoi ne pas converger vers cela?

L'autre avantage de fetch () est qu'il renvoie une promesse javascript , vous pouvez donc écrire du code async comme ceci:

let fetch = require('node-fetch');

fetch('http://localhost', {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{}'
}).then(response => {
  return response.json();
}).catch(err => {console.log(err);});

Fetch remplace XMLHTTPRequest . Voici quelques informations supplémentaires .

J'utilise Restler pour faire des appels de services Web , fonctionne comme du charme et est assez soigné.

Axios

Un exemple (axios_example.js) utilisant Axios dans Node.js:

const axios = require('axios');
const express = require('express');
const app = express();
const port = process.env.PORT || 5000;

app.get('/search', function(req, res) {
    let query = req.query.queryStr;
    let url = `https://your.service.org?query=${query}`;

    axios({
        method:'get',
        url,
        auth: {
            username: 'the_username',
            password: 'the_password'
        }
    })
    .then(function (response) {
        res.send(JSON.stringify(response.data));
    })
    .catch(function (error) {
        console.log(error);
    });
});

var server = app.listen(port);

Assurez-vous que dans le répertoire de votre projet vous faites:

npm init
npm install express
npm install axios
node axios_example.js

Vous pouvez ensuite tester l'API REST Node.js à l'aide de votre navigateur à l'adresse: http://localhost:5000/search?queryStr=xxxxxxxxx

De même, vous pouvez faire des publications, telles que:

axios({
  method: 'post',
  url: 'https://your.service.org/user/12345',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
});

SuperAgent

De même, vous pouvez utiliser SuperAgent.

superagent.get('https://your.service.org?query=xxxx')
.end((err, response) => {
    if (err) { return console.log(err); }
    res.send(JSON.stringify(response.body));
});

Et si vous souhaitez effectuer une authentification de base:

superagent.get('https://your.service.org?query=xxxx')
.auth('the_username', 'the_password')
.end((err, response) => {
    if (err) { return console.log(err); }
    res.send(JSON.stringify(response.body));
});

Réf:

• https://github.com/axios/axios
• https://www.twilio.com/blog/2017/08/http-requests-in-node-js.html

Pour utiliser les dernières fonctionnalités Async / Await

https://www.npmjs.com/package/request-promise-native

npm install --save request
npm install --save request-promise-native

//code

async function getData (){
    try{
          var rp = require ('request-promise-native');
          var options = {
          uri:'https://reqres.in/api/users/2',
          json:true
        };

        var response = await rp(options);
        return response;
    }catch(error){
        throw error;
    }        
}

try{
    console.log(getData());
}catch(error){
    console.log(error);
}

var http = require('http');
var url = process.argv[2];

http.get(url, function(response) {
  var finalData = "";

  response.on("data", function (data) {
    finalData += data.toString();
  });

  response.on("end", function() {
    console.log(finalData.length);
    console.log(finalData.toString());
  });

});

Avertissement: à partir du 11 février 2020, la demande est entièrement obsolète.

Un autre exemple - vous devez installer le module de requête pour cela

var request = require('request');
function get_trustyou(trust_you_id, callback) {
    var options = {
        uri : 'https://api.trustyou.com/hotels/'+trust_you_id+'/seal.json',
        method : 'GET'
    }; 
    var res = '';
    request(options, function (error, response, body) {
        if (!error && response.statusCode == 200) {
            res = body;
        }
        else {
            res = 'Not Found';
        }
        callback(res);
    });
}

get_trustyou("674fa44c-1fbd-4275-aa72-a20f262372cd", function(resp){
    console.log(resp);
});

Je n'en ai trouvé aucun avec cURL, j'ai donc écrit un wrapper autour de node-libcurl et peut être trouvé à https://www.npmjs.com/package/vps-rest-client .

Faire un POST, c'est comme ça:

var host = 'https://api.budgetvm.com/v2/dns/record';
var key = 'some___key';
var domain_id = 'some___id';

var rest = require('vps-rest-client');
var client = rest.createClient(key, {
  verbose: false
});

var post = {
  domain: domain_id,
  record: 'test.example.net',
  type: 'A',
  content: '111.111.111.111'
};

client.post(host, post).then(function(resp) {
  console.info(resp);

  if (resp.success === true) {
    // some action
  }
  client.close();
}).catch((err) => console.info(err));

Si vous avez Node.js 4.4+, jetez un œil à reqclient , il vous permet de faire des appels et de consigner les requêtes en style cURL , afin que vous puissiez facilement vérifier et reproduire les appels en dehors de l'application.

Renvoie des objets Promise au lieu de transmettre des rappels simples, de sorte que vous pouvez gérer le résultat d'une manière plus "fashion" , enchaîner le résultat facilement et gérer les erreurs de manière standard. Supprime également de nombreuses configurations standard à chaque demande: URL de base, délai d'expiration, format du type de contenu, en-têtes par défaut, paramètres et liaison de requête dans l'URL et fonctionnalités de base du cache.

Voici un exemple de la façon de l'initialiser, de faire un appel et de consigner l'opération avec le style curl :

var RequestClient = require("reqclient").RequestClient;
var client = new RequestClient({
    baseUrl:"http://baseurl.com/api/", debugRequest:true, debugResponse:true});
client.post("client/orders", {"client": 1234, "ref_id": "A987"},{"x-token": "AFF01XX"});

Cela se connectera à la console ...

[Requesting client/orders]-> -X POST http://baseurl.com/api/client/orders -d '{"client": 1234, "ref_id": "A987"}' -H '{"x-token": "AFF01XX"}' -H Content-Type:application/json

Et quand la réponse est retournée ...

[Response   client/orders]<- Status 200 - {"orderId": 1320934}

Voici un exemple de gestion de la réponse avec l'objet de promesse:

client.get("reports/clients")
  .then(function(response) {
    // Do something with the result
  }).catch(console.error);  // In case of error ...

Bien sûr, il peut être installé avec: npm install reqclient.

Vous pouvez utiliser curlrequest pour définir facilement l'heure de la demande que vous souhaitez faire ... vous pouvez même définir des en-têtes dans les options pour " simuler " un appel de navigateur.

Avertissement: à partir du 11 février 2020, la demande est entièrement obsolète.

Si vous implémentez avec form-data, pour plus d'informations ( https://tanaikech.github.io/2017/07/27/multipart-post-request-using-node.js ):

var fs = require('fs');
var request = require('request');
request.post({
  url: 'https://slack.com/api/files.upload',
  formData: {
    file: fs.createReadStream('sample.zip'),
    token: '### access token ###',
    filetype: 'zip',
    filename: 'samplefilename',
    channels: 'sample',
    title: 'sampletitle',
  },
}, function (error, response, body) {
  console.log(body);
});

J'ai trouvé superagent vraiment utile, c'est très simple par exemple

const superagent=require('superagent')
superagent
.get('google.com')
.set('Authorization','Authorization object')
.set('Accept','application/json')