proxy-source/lib/index.js

Get a verified working proxy according to you filters.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ProxySourceNonePassed = exports.ProxySourceEmpty = exports.ProxySource = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _proxyLists = require('proxy-lists');

var _proxyLists2 = _interopRequireDefault(_proxyLists);

var _proxyVerifier = require('proxy-verifier');

var _proxyVerifier2 = _interopRequireDefault(_proxyVerifier);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ProxySourceEmpty = function (_Error) {
  _inherits(ProxySourceEmpty, _Error);

  function ProxySourceEmpty(message) {
    _classCallCheck(this, ProxySourceEmpty);

    var _this = _possibleConstructorReturn(this, (ProxySourceEmpty.__proto__ || Object.getPrototypeOf(ProxySourceEmpty)).call(this, message));

    _this.name = _this.constructor.name;
    return _this;
  }

  return ProxySourceEmpty;
}(Error);

var ProxySourceNonePassed = function (_Error2) {
  _inherits(ProxySourceNonePassed, _Error2);

  function ProxySourceNonePassed(message) {
    _classCallCheck(this, ProxySourceNonePassed);

    var _this2 = _possibleConstructorReturn(this, (ProxySourceNonePassed.__proto__ || Object.getPrototypeOf(ProxySourceNonePassed)).call(this, message));

    _this2.name = _this2.constructor.name;
    return _this2;
  }

  return ProxySourceNonePassed;
}(Error);

var ProxySource = function () {
  function ProxySource(options) {
    var _this3 = this;

    _classCallCheck(this, ProxySource);

    this.options = Object.assign({
      check: {}
    }, options);

    this.maxResponse = this.options.maxResponse || 3000;
    this.timeout = this.options.timeout || 30000;

    this.check = Object.assign({
      anonymityLevel: false,
      protocols: false,
      tunneling: false,
      speed: false
    }, this.options.check);

    this.proxies = [];
    this.count = 0;
    this.dismissed = 0;

    this.getProxies = function () {
      return new Promise(function (resolve) {
        var proxies = [];
        var proxyGetter = _proxyLists2.default.getProxies(_this3.options);
        var timeout = setTimeout(function () {
          resolve(proxies);
        }, _this3.timeout);
        proxyGetter.on('data', function (data) {
          proxies = proxies.concat(data);
          _this3.count += data.length;
        });
        proxyGetter.once('end', function () {
          clearTimeout(timeout);
          resolve(proxies);
        });
      });
    };

    this.getRandom = function () {
      if (_this3.proxies.length > 0) {
        var random = Math.floor(Math.random() * _this3.proxies.length);
        var chosen = _this3.proxies.splice(random, 1)[0];

        return chosen;
      }

      throw new ProxySourceEmpty('Probably there is no proxy matching your criteria');
    };

    this.testAll = function (proxy) {
      return new Promise(function (resolve, reject) {
        var reqOptions = {
          requestOptions: {}
        };
        if (_this3.check.speed) {
          reqOptions.requestOptions.timeout = _this3.maxResponse;
        }

        _proxyVerifier2.default.testAll(proxy, reqOptions, function (error, results) {
          if (error) return reject();

          return resolve(results);
        });
      });
    };

    this.test = function () {
      var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(proxy) {
        var _check, tunnel, protocols, results, keys, i;

        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _check = _this3.check, tunnel = _check.tunnel, protocols = _check.protocols;

                if (!(!proxy.ipAddress || !proxy.port)) {
                  _context.next = 3;
                  break;
                }

                return _context.abrupt('return', false);

              case 3:
                _context.prev = 3;
                _context.next = 6;
                return _this3.testAll(proxy);

              case 6:
                results = _context.sent;

                if (!tunnel) {
                  _context.next = 10;
                  break;
                }

                if (results.tunnel.ok) {
                  _context.next = 10;
                  break;
                }

                return _context.abrupt('return', false);

              case 10:
                if (!protocols) {
                  _context.next = 19;
                  break;
                }

                keys = Object.keys(results.protocols);
                i = 0;

              case 13:
                if (!(i < keys.length)) {
                  _context.next = 19;
                  break;
                }

                if (results.protocols[keys[i]].ok) {
                  _context.next = 16;
                  break;
                }

                return _context.abrupt('return', false);

              case 16:
                i += 1;
                _context.next = 13;
                break;

              case 19:
                _context.next = 24;
                break;

              case 21:
                _context.prev = 21;
                _context.t0 = _context['catch'](3);
                return _context.abrupt('return', false);

              case 24:
                return _context.abrupt('return', true);

              case 25:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, _this3, [[3, 21]]);
      }));

      return function (_x) {
        return _ref.apply(this, arguments);
      };
    }();

    this.sanitizeProxies = function (proxies) {
      var sanitized = [];
      var checked = [];

      for (var i = 0; i < proxies.length; i += 1) {
        var current = proxies[i];
        var unique = current.ipAddress + ':' + current.port;
        if (checked.indexOf(unique) < 0) {
          checked.push(unique);
          sanitized.push(current);
        }
      }

      return sanitized;
    };
  }

  _createClass(ProxySource, [{
    key: 'initialize',
    value: function () {
      var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
        var proxies, sanitizedProxies;
        return regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.getProxies();

              case 2:
                proxies = _context2.sent;
                sanitizedProxies = this.sanitizeProxies(proxies);

                this.proxies = sanitizedProxies;

              case 5:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function initialize() {
        return _ref2.apply(this, arguments);
      }

      return initialize;
    }()
  }, {
    key: 'get',
    value: function () {
      var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
        var current, result;
        return regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                if (!(this.proxies.length > 0)) {
                  _context3.next = 12;
                  break;
                }

              case 1:
                if (!(this.proxies.length > 0)) {
                  _context3.next = 11;
                  break;
                }

                current = this.getRandom();
                _context3.next = 5;
                return this.test(current);

              case 5:
                result = _context3.sent;

                if (!result) {
                  _context3.next = 8;
                  break;
                }

                return _context3.abrupt('return', current);

              case 8:

                this.dismissed += 1;
                _context3.next = 1;
                break;

              case 11:
                throw new ProxySourceNonePassed('No proxy server passed the tests');

              case 12:
                throw new ProxySourceEmpty('Probably there is no proxy matching your criteria');

              case 13:
              case 'end':
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function get() {
        return _ref3.apply(this, arguments);
      }

      return get;
    }()
  }]);

  return ProxySource;
}();

exports.ProxySource = ProxySource;
exports.ProxySourceEmpty = ProxySourceEmpty;
exports.ProxySourceNonePassed = ProxySourceNonePassed;