node-telegram-util 0.0.1-security → 0.69.0

package/lib/telegramPolling.js

@@ -0,0 +1,237 @@
+'use strict';
+
+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; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+var errors = require('./errors');
+var debug = require('debug')('node-telegram-bot-api');
+var deprecate = require('./utils').deprecate;
+var ANOTHER_WEB_HOOK_USED = 409;
+
+var TelegramBotPolling = (function () {
+  /**
+   * Handles polling against the Telegram servers.
+   * @param  {TelegramBot} bot
+   * @see https://core.telegram.org/bots/api#getting-updates
+   */
+
+  function TelegramBotPolling(bot) {
+    _classCallCheck(this, TelegramBotPolling);
+
+    this.bot = bot;
+    this.options = typeof bot.options.polling === 'boolean' ? {} : bot.options.polling;
+    this.options.interval = typeof this.options.interval === 'number' ? this.options.interval : 300;
+    this.options.params = typeof this.options.params === 'object' ? this.options.params : {};
+    this.options.params.offset = typeof this.options.params.offset === 'number' ? this.options.params.offset : 0;
+    this.options.params.timeout = typeof this.options.params.timeout === 'number' ? this.options.params.timeout : 10;
+    if (typeof this.options.timeout === 'number') {
+      deprecate('`options.polling.timeout` is deprecated. Use `options.polling.params` instead.');
+      this.options.params.timeout = this.options.timeout;
+    }
+    this._lastUpdate = 0;
+    this._lastRequest = null;
+    this._abort = false;
+    this._pollingTimeout = null;
+  }
+
+  /**
+   * Start polling
+   * @param  {Object} [options]
+   * @param  {Object} [options.restart]
+   * @return {Promise}
+   */
+
+  _createClass(TelegramBotPolling, [{
+    key: 'start',
+    value: function start() {
+      var _this = this;
+
+      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+      if (this._lastRequest) {
+        if (!options.restart) {
+          return Promise.resolve();
+        }
+        return this.stop({
+          cancel: true,
+          reason: 'Polling restart'
+        }).then(function () {
+          return _this._polling();
+        });
+      }
+      return this._polling();
+    }
+
+    /**
+     * Stop polling
+     * @param  {Object} [options] Options
+     * @param  {Boolean} [options.cancel] Cancel current request
+     * @param  {String} [options.reason] Reason for stopping polling
+     * @return {Promise}
+     */
+  }, {
+    key: 'stop',
+    value: function stop() {
+      var _this2 = this;
+
+      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+      if (!this._lastRequest) {
+        return Promise.resolve();
+      }
+      var lastRequest = this._lastRequest;
+      this._lastRequest = null;
+      clearTimeout(this._pollingTimeout);
+      if (options.cancel) {
+        var reason = options.reason || 'Polling stop';
+        lastRequest.cancel(reason);
+        return Promise.resolve();
+      }
+      this._abort = true;
+      return lastRequest['finally'](function () {
+        _this2._abort = false;
+      });
+    }
+
+    /**
+     * Return `true` if is polling. Otherwise, `false`.
+     */
+  }, {
+    key: 'isPolling',
+    value: function isPolling() {
+      return !!this._lastRequest;
+    }
+
+    /**
+     * Handle error thrown during polling.
+     * @private
+     * @param  {Error} error
+     */
+  }, {
+    key: '_error',
+    value: function _error(error) {
+      if (!this.bot.listeners('polling_error').length) {
+        return console.error('error: [polling_error] %j', error); // eslint-disable-line no-console
+      }
+      return this.bot.emit('polling_error', error);
+    }
+
+    /**
+     * Invokes polling (with recursion!)
+     * @return {Promise} promise of the current request
+     * @private
+     */
+  }, {
+    key: '_polling',
+    value: function _polling() {
+      var _this3 = this;
+
+      this._lastRequest = this._getUpdates().then(function (updates) {
+        _this3._lastUpdate = Date.now();
+        debug('polling data %j', updates);
+        updates.forEach(function (update) {
+          _this3.options.params.offset = update.update_id + 1;
+          debug('updated offset: %s', _this3.options.params.offset);
+          try {
+            _this3.bot.processUpdate(update);
+          } catch (err) {
+            err._processing = true;
+            throw err;
+          }
+        });
+        return null;
+      })['catch'](function (err) {
+        debug('polling error: %s', err.message);
+        if (!err._processing) {
+          return _this3._error(err);
+        }
+        delete err._processing;
+        /*
+         * An error occured while processing the items,
+         * i.e. in `this.bot.processUpdate()` above.
+         * We need to mark the already-processed items
+         * to avoid fetching them again once the application
+         * is restarted, or moves to next polling interval
+         * (in cases where unhandled rejections do not terminate
+         * the process).
+         * See https://github.com/yagop/node-telegram-bot-api/issues/36#issuecomment-268532067
+         */
+        if (!_this3.bot.options.badRejection) {
+          return _this3._error(err);
+        }
+        var opts = {
+          offset: _this3.options.params.offset,
+          limit: 1,
+          timeout: 0
+        };
+        return _this3.bot.getUpdates(opts).then(function () {
+          return _this3._error(err);
+        })['catch'](function (requestErr) {
+          /*
+           * We have been unable to handle this error.
+           * We have to log this to stderr to ensure devops
+           * understands that they may receive already-processed items
+           * on app restart.
+           * We simply can not rescue this situation, emit "error"
+           * event, with the hope that the application exits.
+           */
+          /* eslint-disable no-console */
+          var bugUrl = 'https://github.com/yagop/node-telegram-bot-api/issues/36#issuecomment-268532067';
+          console.error('error: Internal handling of The Offset Infinite Loop failed');
+          console.error('error: Due to error \'' + requestErr + '\'');
+          console.error('error: You may receive already-processed updates on app restart');
+          console.error('error: Please see ' + bugUrl + ' for more information');
+          /* eslint-enable no-console */
+          return _this3.bot.emit('error', new errors.FatalError(err));
+        });
+      })['finally'](function () {
+        if (_this3._abort) {
+          debug('Polling is aborted!');
+        } else {
+          debug('setTimeout for %s miliseconds', _this3.options.interval);
+          _this3._pollingTimeout = setTimeout(function () {
+            return _this3._polling();
+          }, _this3.options.interval);
+        }
+      });
+      return this._lastRequest;
+    }
+
+    /**
+     * Unset current webhook. Used when we detect that a webhook has been set
+     * and we are trying to poll. Polling and WebHook are mutually exclusive.
+     * @see https://core.telegram.org/bots/api#getting-updates
+     * @private
+     */
+  }, {
+    key: '_unsetWebHook',
+    value: function _unsetWebHook() {
+      debug('unsetting webhook');
+      return this.bot._request('setWebHook');
+    }
+
+    /**
+     * Retrieve updates
+     */
+  }, {
+    key: '_getUpdates',
+    value: function _getUpdates() {
+      var _this4 = this;
+
+      debug('polling with options: %j', this.options.params);
+      return this.bot.getUpdates(this.options.params)['catch'](function (err) {
+        if (err.response && err.response.statusCode === ANOTHER_WEB_HOOK_USED) {
+          return _this4._unsetWebHook().then(function () {
+            return _this4.bot.getUpdates(_this4.options.params);
+          });
+        }
+        throw err;
+      });
+    }
+  }]);
+
+  return TelegramBotPolling;
+})();
+
+module.exports = TelegramBotPolling;

package/lib/telegramWebHook.js

@@ -0,0 +1,187 @@
+'use strict';
+
+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; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+var errors = require('./errors');
+var debug = require('debug')('node-telegram-bot-api');
+var https = require('https');
+var http = require('http');
+var fs = require('fs');
+var bl = require('bl');
+
+var TelegramBotWebHook = (function () {
+  /**
+   * Sets up a webhook to receive updates
+   * @param  {TelegramBot} bot
+   * @see https://core.telegram.org/bots/api#getting-updates
+   */
+
+  function TelegramBotWebHook(bot) {
+    _classCallCheck(this, TelegramBotWebHook);
+
+    this.bot = bot;
+    this.options = typeof bot.options.webHook === 'boolean' ? {} : bot.options.webHook;
+    this.options.host = this.options.host || '0.0.0.0';
+    this.options.port = this.options.port || 8443;
+    this.options.https = this.options.https || {};
+    this.options.healthEndpoint = this.options.healthEndpoint || '/healthz';
+    this._healthRegex = new RegExp(this.options.healthEndpoint);
+    this._webServer = null;
+    this._open = false;
+    this._requestListener = this._requestListener.bind(this);
+    this._parseBody = this._parseBody.bind(this);
+
+    if (this.options.key && this.options.cert) {
+      debug('HTTPS WebHook enabled (by key/cert)');
+      this.options.https.key = fs.readFileSync(this.options.key);
+      this.options.https.cert = fs.readFileSync(this.options.cert);
+      this._webServer = https.createServer(this.options.https, this._requestListener);
+    } else if (this.options.pfx) {
+      debug('HTTPS WebHook enabled (by pfx)');
+      this.options.https.pfx = fs.readFileSync(this.options.pfx);
+      this._webServer = https.createServer(this.options.https, this._requestListener);
+    } else if (Object.keys(this.options.https).length) {
+      debug('HTTPS WebHook enabled by (https)');
+      this._webServer = https.createServer(this.options.https, this._requestListener);
+    } else {
+      debug('HTTP WebHook enabled');
+      this._webServer = http.createServer(this._requestListener);
+    }
+  }
+
+  /**
+   * Open WebHook by listening on the port
+   * @return {Promise}
+   */
+
+  _createClass(TelegramBotWebHook, [{
+    key: 'open',
+    value: function open() {
+      var _this = this;
+
+      if (this.isOpen()) {
+        return Promise.resolve();
+      }
+      return new Promise(function (resolve, reject) {
+        _this._webServer.listen(_this.options.port, _this.options.host, function () {
+          debug('WebHook listening on port %s', _this.options.port);
+          _this._open = true;
+          return resolve();
+        });
+
+        _this._webServer.once('error', function (err) {
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * Close the webHook
+     * @return {Promise}
+     */
+  }, {
+    key: 'close',
+    value: function close() {
+      var _this2 = this;
+
+      if (!this.isOpen()) {
+        return Promise.resolve();
+      }
+      return new Promise(function (resolve, reject) {
+        _this2._webServer.close(function (error) {
+          if (error) return reject(error);
+          _this2._open = false;
+          return resolve();
+        });
+      });
+    }
+
+    /**
+     * Return `true` if server is listening. Otherwise, `false`.
+     */
+  }, {
+    key: 'isOpen',
+    value: function isOpen() {
+      // NOTE: Since `http.Server.listening` was added in v5.7.0
+      // and we still need to support Node v4,
+      // we are going to fallback to 'this._open'.
+      // The following LOC would suffice for newer versions of Node.js
+      // return this._webServer.listening;
+      return this._open;
+    }
+
+    /**
+     * Handle error thrown during processing of webhook request.
+     * @private
+     * @param  {Error} error
+     */
+  }, {
+    key: '_error',
+    value: function _error(error) {
+      if (!this.bot.listeners('webhook_error').length) {
+        return console.error('error: [webhook_error] %j', error); // eslint-disable-line no-console
+      }
+      return this.bot.emit('webhook_error', error);
+    }
+
+    /**
+     * Handle request body by passing it to 'callback'
+     * @private
+     */
+  }, {
+    key: '_parseBody',
+    value: function _parseBody(error, body) {
+      if (error) {
+        return this._error(new errors.FatalError(error));
+      }
+
+      var data = undefined;
+      try {
+        data = JSON.parse(body.toString());
+      } catch (parseError) {
+        return this._error(new errors.ParseError(parseError.message));
+      }
+
+      return this.bot.processUpdate(data);
+    }
+
+    /**
+     * Listener for 'request' event on server
+     * @private
+     * @see https://nodejs.org/docs/latest/api/http.html#http_http_createserver_requestlistener
+     * @see https://nodejs.org/docs/latest/api/https.html#https_https_createserver_options_requestlistener
+     */
+  }, {
+    key: '_requestListener',
+    value: function _requestListener(req, res) {
+      debug('WebHook request URL: %s', req.url);
+      debug('WebHook request headers: %j', req.headers);
+
+      if (req.url.indexOf(this.bot.token) !== -1) {
+        if (req.method !== 'POST') {
+          debug('WebHook request isn\'t a POST');
+          res.statusCode = 418; // I'm a teabot!
+          res.end();
+        } else {
+          req.pipe(bl(this._parseBody)).on('finish', function () {
+            return res.end('OK');
+          });
+        }
+      } else if (this._healthRegex.test(req.url)) {
+        debug('WebHook health check passed');
+        res.statusCode = 200;
+        res.end('OK');
+      } else {
+        debug('WebHook request unauthorized');
+        res.statusCode = 401;
+        res.end();
+      }
+    }
+  }]);
+
+  return TelegramBotWebHook;
+})();
+
+module.exports = TelegramBotWebHook;

package/lib/utils.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var util = require('util');
+// Native deprecation warning
+exports.deprecate = function (msg) {
+  return util.deprecate(function () {}, msg, 'node-telegram-bot-api')();
+};

package/package.json

@@ -1,6 +1,80 @@
 {
   "name": "node-telegram-util",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "0.69.0",
+  "description": "Telegram Bot API",
+  "main": "./index.js",
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "keywords": [
+    "telegram",
+    "telegram bot",
+    "telegram bot api",
+    "bot"
+  ],
+  "scripts": {
+    "gen-doc": "echo 'WARNING: `npm run gen-doc` is deprecated. Use `npm run doc` instead.' && npm run doc",
+    "doc": "jsdoc2md --files src/telegram.js --template doc/api.hbs > doc/api.md",
+    "build": "babel -d ./lib src",
+    "prepublishOnly": "npm run build",
+    "eslint": "eslint ./src ./test ./examples",
+    "mocha": "mocha",
+    "pretest": "npm run build",
+    "test": "npm run eslint && istanbul cover ./node_modules/mocha/bin/_mocha"
+  },
+  "author": "Yago Pérez <yagoperezs@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=0.12"
+  },
+  "dependencies": {
+    "@cypress/request": "^3.0.1",
+    "@cypress/request-promise": "^5.0.0",
+    "array.prototype.findindex": "^2.0.2",
+    "babel": "^5.8.38",
+    "bl": "^1.2.3",
+    "debug": "^3.2.7",
+    "eventemitter3": "^3.0.0",
+    "file-type": "^3.9.0",
+    "fs": "^0.0.1-security",
+    "https": "^1.0.0",
+    "mime": "^1.6.0",
+    "node-fetch": "^2.7.0",
+    "os": "^0.1.2",
+    "path": "^0.12.7",
+    "pump": "^2.0.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-eslint": "^8.0.3",
+    "babel-plugin-transform-class-properties": "^6.24.1",
+    "babel-plugin-transform-es2015-destructuring": "^6.23.0",
+    "babel-plugin-transform-es2015-parameters": "^6.24.1",
+    "babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",
+    "babel-plugin-transform-es2015-spread": "^6.22.0",
+    "babel-plugin-transform-object-rest-spread": "^6.26.0",
+    "babel-plugin-transform-strict-mode": "^6.24.1",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-register": "^6.26.0",
+    "concat-stream": "^1.6.0",
+    "eslint": "^2.13.1",
+    "eslint-config-airbnb": "^6.2.0",
+    "eslint-plugin-mocha": "^4.11.0",
+    "is": "^3.2.1",
+    "is-ci": "^1.0.10",
+    "istanbul": "^1.1.0-alpha.1",
+    "jsdoc-to-markdown": "^3.0.3",
+    "mocha": "^3.5.3",
+    "mocha-lcov-reporter": "^1.3.0",
+    "node-static": "^0.7.10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yagop/node-telegram-bot-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yagop/node-telegram-bot-api/issues"
+  },
+  "homepage": "https://github.com/yagop/node-telegram-bot-api"
 }

package/src/errors.js

@@ -0,0 +1,65 @@
+exports.BaseError = class BaseError extends Error {
+  /**
+   * @class BaseError
+   * @constructor
+   * @private
+   * @param  {String} code Error code
+   * @param  {String} message Error message
+   */
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+    };
+  }
+};
+
+
+exports.FatalError = class FatalError extends exports.BaseError {
+  /**
+   * Fatal Error. Error code is `"EFATAL"`.
+   * @class FatalError
+   * @constructor
+   * @param  {String|Error} data Error object or message
+   */
+  constructor(data) {
+    const error = (typeof data === 'string') ? null : data;
+    const message = error ? error.message : data;
+    super('EFATAL', message);
+    if (error) this.stack = error.stack;
+  }
+};
+
+
+exports.ParseError = class ParseError extends exports.BaseError {
+  /**
+   * Error during parsing. Error code is `"EPARSE"`.
+   * @class ParseError
+   * @constructor
+   * @param  {String} message Error message
+   * @param  {http.IncomingMessage} response Server response
+   */
+  constructor(message, response) {
+    super('EPARSE', message);
+    this.response = response;
+  }
+};
+
+
+exports.TelegramError = class TelegramError extends exports.BaseError {
+  /**
+   * Error returned from Telegram. Error code is `"ETELEGRAM"`.
+   * @class TelegramError
+   * @constructor
+   * @param  {String} message Error message
+   * @param  {http.IncomingMessage} response Server response
+   */
+  constructor(message, response) {
+    super('ETELEGRAM', message);
+    this.response = response;
+  }
+};