¿Cómo hacer una llamada REST remota dentro de Node.js? cualquier rizo?

En Node.js , aparte de usar el proceso hijo para hacer una llamada CURL , ¿hay alguna forma de hacer una llamada CURL a la API REST del servidor remoto y obtener los datos de retorno?

También necesito configurar el encabezado de la solicitud para la llamada REST remota , y también consultar la cadena en GET (o POST).

Encuentro este: http://blog.nodejitsu.com/jsdom-jquery-in-5-lines-on-nodejs

pero no muestra ninguna manera de POSTAR la cadena de consulta.

Mirar 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();

¿Qué tal usar Request? - Cliente HTTP simplificado .

Editar febrero de 2020: la solicitud ha quedado en desuso, por lo que probablemente ya no deba usarla.

Aquí hay un OBTENER:

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 también quería una POST:

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

Mira 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);
});

Uso node-fetch porque usa la API familiar fetch () (si eres un desarrollador web ) . fetch () es la nueva forma de hacer solicitudes HTTP arbitrarias desde el navegador.

Sí, sé que esta es una pregunta de nodo js, ​​pero ¿no queremos reducir la cantidad de desarrolladores de API que deben memorizar y comprender, y mejorar la reutilización de nuestro código JavaScript? Fetch es un estándar ¿qué tal si convergemos en eso?

La otra cosa buena de fetch () es que devuelve una Promesa de JavaScript , por lo que puede escribir código asíncrono como este:

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 reemplaza XMLHTTPRequest . Aquí hay más información .

He estado usando restler para hacer llamadas de servicios web, funciona como encanto y es bastante ordenado.

Axios

Un ejemplo (axios_example.js) usando Axios en 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);

Asegúrese de que en el directorio de su proyecto haga:

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

Luego puede probar la API REST de Node.js utilizando su navegador en: http://localhost:5000/search?queryStr=xxxxxxxxx

Del mismo modo, puede publicar, como:

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

Superagente

Del mismo modo, puede usar SuperAgent.

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

Y si quieres hacer autenticación básica:

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));
});

Árbitro:

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

Para usar las funciones más recientes de Async / Await

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

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

//código

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);
}

otro ejemplo: debe instalar el módulo de solicitud para ese

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);
});

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());
  });

});

No encontré ninguno con cURL, así que escribí un contenedor alrededor de node-libcurl y puedo encontrarlo en https://www.npmjs.com/package/vps-rest-client .

Hacer una POST es así:

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 tiene Node.js 4.4+, eche un vistazo a reqclient , le permite hacer llamadas y registrar las solicitudes en cURL estilo , para que pueda verificar y reproducir fácilmente las llamadas fuera de la aplicación.

Devuelve objetos Promesa en lugar de pasar devoluciones de llamada simples, para que pueda manejar el resultado de una manera más "fashion" , encadenando el resultado fácilmente y manejar los errores de una manera estándar. También elimina muchas configuraciones repetitivas en cada solicitud: URL base, tiempo de espera, formato de tipo de contenido, encabezados predeterminados, parámetros y enlaces de consulta en la URL, y características básicas de caché.

Este es un ejemplo de cómo inicializarlo, hacer una llamada y registrar la operación con estilo 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"});

Esto iniciará sesión en la consola ...

[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

Y cuando se devuelve la respuesta ...

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

Este es un ejemplo de cómo manejar la respuesta con el objeto de promesa:

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

Por supuesto, se puede instalar con: npm install reqclient.

Puede usar curlrequest para configurar fácilmente la hora de la solicitud que desea hacer ... incluso puede configurar encabezados en las opciones para " falsificar " una llamada del navegador.

Advertencia: a partir del 11 de febrero de 2020, la solicitud está en desuso.

Si implementa con datos de formulario, para obtener más información ( 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);
});

Encontré que el superagente es realmente útil, es muy simple, por ejemplo

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