javascript - tablas - Cómo hacer que el superagente sea una promesa

promises javascript w3schools

Question

He estado aprendiendo Nodo / Javascript, usando promesas desde el comienzo (no sé cómo no usar promesas y, a menudo, me pregunto cómo se llevan los demás sin ellas).

Así que a veces necesito "promisificar" cosas simples como leer un archivo con fs :

var readFile = function(path) {
    return new Promise(function(fulfill, reject) {
        fs.readFile(path, function(err, data) {
            if (err) { reject(err); }
            else { fulfill(data); }
        });
    });
};

Y eso ha estado funcionando genial. Ahora necesito hacer lo mismo con el superagent , pero el estilo de encadenamiento que usa me tiene atascado.

var request = require(''superagent'');
request.get(...).set(...).set(...).end(callback);  // stuck!

Me gustaría reemplazar el método end() (o ignorarlo y agregar un nuevo método) con uno que devuelva una promesa. Algo como esto...

var endQ = function() {
    return new Promise(function(fulfill, reject) {
        this.end(function(err, res) {     // "this" is the problem!
            if (err) { reject(err); }
            else { fulfill(res); }
        });
    });
};

// then I could say this:
request.get(...).set(...).set(...).endQ().then(function(res) {
    // happiness
}).catch(function(err) {
    // sad about the error, but so happy about the promise!
});

Esta pregunta aquí tiene todo tipo de consejos sobre cómo agregar métodos a los objetos, pero es difícil ver lo que es definitivo. Estaba especialmente preocupado por esta respuesta . Gran parte del asesoramiento se centra en comenzar con la "clase" del objeto y agregar la función a .prototype . Algo como esto....

// this part doesn''t make sense
var requestInstance = new Request();   // no such thing in request as far as I know
requestInstance.prototype.endQ = endQ; // would be great, but no

Ver mi problema? Quiero el equivalente JS de "subclasificar" la "clase" de solicitud y agregar un método, pero dado que es un módulo, necesito tratar la clase de solicitud como más o menos opaca.

Answer 1

En primer lugar, el superagente ya es compatible con las promesas :

request.get(...).set(...).set(...).then(response => {
    // handle it here
});

Tenga en cuenta que a diferencia de regular then , then aquí no es una promesa, sino que en realidad invoca la solicitud y actúa perezosamente.

Segundo, lo que quieres hacer es bastante simple:

Object.getPrototypeOf(request.get(...)).endQ = function() { // get to prototype and define
  /* your code here */
};

Esto es lo que el propio superagente hace:

exports.then = function then(resolve, reject) {
  if (!this._fullfilledPromise) {
    var self = this;
    this._fullfilledPromise = new Promise(function(innerResolve, innerReject){
      self.end(function(err, res){
        if (err) innerReject(err); else innerResolve(res);
      });
    });
  }
  return this._fullfilledPromise.then(resolve, reject);
}