@verdaccio/canary 6.3.2-canary.404363f

package/build/lib/up-storage.js

@@ -0,0 +1,605 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _request = _interopRequireDefault(require("@cypress/request"));
+var _JSONStream = _interopRequireDefault(require("JSONStream"));
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _stream = _interopRequireDefault(require("stream"));
+var _url = _interopRequireDefault(require("url"));
+var _zlib = _interopRequireDefault(require("zlib"));
+var _streams = require("@verdaccio/streams");
+var _utils = require("@verdaccio/utils");
+var _constants = require("./constants");
+var _logger = require("./logger");
+var _utils2 = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:proxy');
+const encode = function (thing) {
+  return encodeURIComponent(thing).replace(/^%40/, '@');
+};
+const jsonContentType = _constants.HEADERS.JSON;
+const contentTypeAccept = `${jsonContentType};`;
+
+/**
+ * Just a helper (`config[key] || default` doesn't work because of zeroes)
+ */
+const setConfig = (config, key, def) => {
+  return _lodash.default.isNil(config[key]) === false ? config[key] : def;
+};
+
+/**
+ * Implements Storage interface
+ * (same for storage.js, local-storage.js, up-storage.js)
+ */
+class ProxyStorage {
+  // FIXME: upname is assigned to each instance
+  // @ts-ignore
+
+  // FIXME: proxy can be boolean or object, something smells here
+  // @ts-ignore
+
+  // @ts-ignore
+
+  /**
+   * Constructor
+   * @param {*} config
+   * @param {*} mainConfig
+   */
+  constructor(config, mainConfig) {
+    this.config = config;
+    this.failed_requests = 0;
+    // @ts-ignore
+    this.userAgent = mainConfig.user_agent ?? 'hidden';
+    this.ca = config.ca;
+    this.logger = _logger.logger;
+    this.server_id = mainConfig.server_id;
+    this.url = _url.default.parse(this.config.url);
+    this._setupProxy(this.url.hostname, config, mainConfig, this.url.protocol === 'https:');
+    this.config.url = this.config.url.replace(/\/$/, '');
+    if (this.config.timeout && Number(this.config.timeout) >= 1000) {
+      this.logger.warn(['Too big timeout value: ' + this.config.timeout, 'We changed time format to nginx-like one', '(see http://nginx.org/en/docs/syntax.html)', 'so please update your config accordingly'].join('\n'));
+    }
+
+    // a bunch of different configurable timers
+    this.maxage = (0, _utils2.parseInterval)(setConfig(this.config, 'maxage', '2m'));
+    this.timeout = (0, _utils2.parseInterval)(setConfig(this.config, 'timeout', '30s'));
+    this.max_fails = Number(setConfig(this.config, 'max_fails', 2));
+    this.fail_timeout = (0, _utils2.parseInterval)(setConfig(this.config, 'fail_timeout', '5m'));
+    this.strict_ssl = Boolean(setConfig(this.config, 'strict_ssl', true));
+    this.agent_options = setConfig(this.config, 'agent_options', {
+      keepAlive: true,
+      maxSockets: 40,
+      maxFreeSockets: 10
+    });
+  }
+
+  /**
+   * Fetch an asset.
+   * @param {*} options
+   * @param {*} cb
+   * @return {Request}
+   */
+  request(options, cb) {
+    let json;
+    if (this._statusCheck() === false) {
+      const streamRead = new _stream.default.Readable();
+      process.nextTick(function () {
+        if (cb) {
+          cb(_utils2.ErrorCode.getInternalError(_constants.API_ERROR.UPLINK_OFFLINE));
+        }
+        streamRead.emit('error', _utils2.ErrorCode.getInternalError(_constants.API_ERROR.UPLINK_OFFLINE));
+      });
+      streamRead._read = function () {};
+      // preventing 'Uncaught, unspecified "error" event'
+      streamRead.on('error', function () {});
+      return streamRead;
+    }
+    const self = this;
+    const headers = this._setHeaders(options);
+    this._addProxyHeaders(options.req, headers);
+    this._overrideWithUpLinkConfigHeaders(headers);
+    const method = options.method || 'GET';
+    const uri = options.uri_full || this.config.url + options.uri;
+    self.logger.info({
+      method: method,
+      uri: uri
+    }, "making request: '@{method} @{uri}'");
+    if ((0, _utils2.isObject)(options.json)) {
+      json = JSON.stringify(options.json);
+      headers['Content-Type'] = headers['Content-Type'] || _constants.HEADERS.JSON;
+    }
+    const requestCallback = cb ? function (err, res, body) {
+      let error;
+      const responseLength = err ? 0 : body.length;
+      processBody();
+      logActivity();
+      cb(err, res, body);
+
+      /**
+       * Perform a decode.
+       */
+      function processBody() {
+        if (err) {
+          error = err.message;
+          return;
+        }
+        if (options.json && res.statusCode < 300) {
+          try {
+            body = JSON.parse(body.toString(_constants.CHARACTER_ENCODING.UTF8));
+          } catch (_err) {
+            body = {};
+            err = _err;
+            error = err.message;
+          }
+        }
+        if (!err && (0, _utils2.isObject)(body)) {
+          if (_lodash.default.isString(body.error)) {
+            error = body.error;
+          }
+        }
+      }
+      /**
+       * Perform a log.
+       */
+      function logActivity() {
+        let message = "@{!status}, req: '@{request.method} @{request.url}'";
+        message += error ? ', error: @{!error}' : ', bytes: @{bytes.in}/@{bytes.out}';
+        self.logger.http({
+          err: err || undefined,
+          // if error is null/false change this to undefined so it wont log
+          request: {
+            method: method,
+            url: uri
+          },
+          status: res != null ? res.statusCode : 'ERR',
+          error: error,
+          bytes: {
+            in: json ? json.length : 0,
+            out: responseLength || 0
+          }
+        }, message);
+      }
+    } : undefined;
+    let requestOptions = {
+      url: uri,
+      method: method,
+      headers: headers,
+      body: json,
+      proxy: this.proxy,
+      encoding: null,
+      gzip: true,
+      timeout: this.timeout,
+      strictSSL: this.strict_ssl,
+      agentOptions: this.agent_options
+    };
+    if (this.ca) {
+      requestOptions = Object.assign({}, requestOptions, {
+        ca: this.ca
+      });
+    }
+    const req = (0, _request.default)(requestOptions, requestCallback);
+    let statusCalled = false;
+    req.on('response', function (res) {
+      // FIXME: _verdaccio_aborted seems not used
+      // @ts-ignore
+      if (!req._verdaccio_aborted && !statusCalled) {
+        statusCalled = true;
+        self._statusCheck(true);
+      }
+      if (_lodash.default.isNil(requestCallback) === false) {
+        (function do_log() {
+          const message = "@{!status}, req: '@{request.method} @{request.url}' (streaming)";
+          self.logger.http({
+            request: {
+              method: method,
+              url: uri
+            },
+            status: _lodash.default.isNull(res) === false ? res.statusCode : 'ERR'
+          }, message);
+        })();
+      }
+    });
+    req.on('error', function (err) {
+      // FIXME: _verdaccio_aborted seems not used
+      debug('_verdaccio_aborted: %o', err);
+      if (!req._verdaccio_aborted && !statusCalled) {
+        statusCalled = true;
+        self._statusCheck(false);
+      }
+    });
+    return req;
+  }
+
+  /**
+   * Set default headers.
+   * @param {Object} options
+   * @return {Object}
+   * @private
+   */
+  _setHeaders(options) {
+    const headers = options.headers || {};
+    const accept = _constants.HEADERS.ACCEPT;
+    const acceptEncoding = _constants.HEADERS.ACCEPT_ENCODING;
+    const userAgent = _constants.HEADERS.USER_AGENT;
+    headers[accept] = headers[accept] || contentTypeAccept;
+    headers[acceptEncoding] = headers[acceptEncoding] || 'gzip';
+    // registry.npmjs.org will only return search result if user-agent include string 'npm'
+    headers[userAgent] = this.userAgent ? `npm (${this.userAgent})` : options.req?.get('user-agent');
+    return this._setAuth(headers);
+  }
+
+  /**
+   * Validate configuration auth and assign Header authorization
+   * @param {Object} headers
+   * @return {Object}
+   * @private
+   */
+  _setAuth(headers) {
+    const {
+      auth
+    } = this.config;
+    if (_lodash.default.isNil(auth) || headers[_constants.HEADERS.AUTHORIZATION]) {
+      return headers;
+    }
+    if (_lodash.default.isObject(auth) === false && _lodash.default.isObject(auth.token) === false) {
+      this._throwErrorAuth('Auth invalid');
+    }
+
+    // get NPM_TOKEN http://blog.npmjs.org/post/118393368555/deploying-with-npm-private-modules
+    // or get other variable export in env
+    // https://github.com/verdaccio/verdaccio/releases/tag/v2.5.0
+    let token;
+    const tokenConf = auth;
+    if (_lodash.default.isNil(tokenConf.token) === false && _lodash.default.isString(tokenConf.token)) {
+      token = tokenConf.token;
+    } else if (_lodash.default.isNil(tokenConf.token_env) === false) {
+      if (_lodash.default.isString(tokenConf.token_env)) {
+        token = process.env[tokenConf.token_env];
+      } else if (_lodash.default.isBoolean(tokenConf.token_env) && tokenConf.token_env) {
+        token = process.env.NPM_TOKEN;
+      } else {
+        this.logger.error(_constants.ERROR_CODE.token_required);
+        this._throwErrorAuth(_constants.ERROR_CODE.token_required);
+      }
+    } else {
+      token = process.env.NPM_TOKEN;
+    }
+    if (_lodash.default.isNil(token)) {
+      this._throwErrorAuth(_constants.ERROR_CODE.token_required);
+    }
+
+    // define type Auth allow basic and bearer
+    const type = tokenConf.type || _constants.TOKEN_BASIC;
+    this._setHeaderAuthorization(headers, type, token);
+    return headers;
+  }
+
+  /**
+   * @param {string} message
+   * @throws {Error}
+   * @private
+   */
+  _throwErrorAuth(message) {
+    this.logger.error(message);
+    throw new Error(message);
+  }
+
+  /**
+   * Assign Header authorization with type authentication
+   * @param {Object} headers
+   * @param {string} type
+   * @param {string} token
+   * @private
+   */
+  _setHeaderAuthorization(headers, type, token) {
+    const _type = type.toLowerCase();
+    if ([_constants.TOKEN_BEARER.toLowerCase(), _constants.TOKEN_BASIC.toLowerCase()].includes(_type) === false) {
+      this._throwErrorAuth(`Auth type '${_type}' not allowed`);
+    }
+    type = _lodash.default.upperFirst(type);
+    headers[_constants.HEADERS.AUTHORIZATION] = (0, _utils.buildToken)(type, token);
+  }
+
+  /**
+   * It will add or override specified headers from config file.
+   *
+   * Eg:
+   *
+   * uplinks:
+   npmjs:
+   url: https://registry.npmjs.org/
+   headers:
+   Accept: "application/vnd.npm.install-v2+json; q=1.0"
+   verdaccio-staging:
+   url: https://mycompany.com/npm
+   headers:
+   Accept: "application/json"
+   authorization: "Basic YourBase64EncodedCredentials=="
+    * @param {Object} headers
+   * @private
+   */
+  _overrideWithUpLinkConfigHeaders(headers) {
+    if (!this.config.headers) {
+      return headers;
+    }
+
+    // add/override headers specified in the config
+    /* eslint guard-for-in: 0 */
+    for (const key in this.config.headers) {
+      headers[key] = this.config.headers[key];
+    }
+  }
+
+  /**
+   * Determine whether can fetch from the provided URL
+   * @param {*} url
+   * @return {Boolean}
+   */
+  isUplinkValid(url) {
+    const urlParsed = _url.default.parse(url);
+    const isHTTPS = urlDomainParsed => urlDomainParsed.protocol === 'https:' && (urlParsed.port === null || urlParsed.port === '443');
+    const getHost = urlDomainParsed => isHTTPS(urlDomainParsed) ? urlDomainParsed.hostname : urlDomainParsed.host;
+    const isMatchProtocol = urlParsed.protocol === this.url.protocol;
+    const isMatchHost = getHost(urlParsed) === getHost(this.url);
+    // @ts-ignore
+    const isMatchPath = urlParsed.path.indexOf(this.url.path) === 0;
+    return isMatchProtocol && isMatchHost && isMatchPath;
+  }
+
+  /**
+   * Get a remote package metadata
+   * @param {*} name package name
+   * @param {*} options request options, eg: eTag.
+   * @param {*} callback
+   */
+  getRemoteMetadata(name, options, callback) {
+    const headers = {};
+    if (_lodash.default.isNil(options.etag) === false) {
+      headers['If-None-Match'] = options.etag;
+      headers[_constants.HEADERS.ACCEPT] = contentTypeAccept;
+    }
+    this.request({
+      uri: `/${encode(name)}`,
+      json: true,
+      headers: headers,
+      req: options.req
+    }, (err, res, body) => {
+      if (err) {
+        return callback(err);
+      }
+      if (res.statusCode === _constants.HTTP_STATUS.NOT_FOUND) {
+        return callback(_utils2.ErrorCode.getNotFound(_constants.API_ERROR.NOT_PACKAGE_UPLINK));
+      }
+      if (!(res.statusCode >= _constants.HTTP_STATUS.OK && res.statusCode < _constants.HTTP_STATUS.MULTIPLE_CHOICES)) {
+        const error = _utils2.ErrorCode.getInternalError(`${_constants.API_ERROR.BAD_STATUS_CODE}: ${res.statusCode}`);
+        error.remoteStatus = res.statusCode;
+        return callback(error);
+      }
+      callback(null, body, res.headers.etag);
+    });
+  }
+
+  /**
+   * Fetch a tarball from the uplink.
+   * @param {String} url
+   * @return {Stream}
+   */
+  fetchTarball(url) {
+    const stream = new _streams.ReadTarball({});
+    let current_length = 0;
+    let expected_length;
+    stream.abort = () => {};
+    const readStream = this.request({
+      uri_full: url,
+      encoding: null,
+      headers: {
+        Accept: contentTypeAccept
+      }
+    });
+    readStream.on('response', function (res) {
+      if (res.statusCode === _constants.HTTP_STATUS.NOT_FOUND) {
+        return stream.emit('error', _utils2.ErrorCode.getNotFound(_constants.API_ERROR.NOT_FILE_UPLINK));
+      }
+      if (!(res.statusCode >= _constants.HTTP_STATUS.OK && res.statusCode < _constants.HTTP_STATUS.MULTIPLE_CHOICES)) {
+        return stream.emit('error', _utils2.ErrorCode.getInternalError(`bad uplink status code: ${res.statusCode}`));
+      }
+      if (res.headers[_constants.HEADER_TYPE.CONTENT_LENGTH]) {
+        expected_length = res.headers[_constants.HEADER_TYPE.CONTENT_LENGTH];
+        stream.emit(_constants.HEADER_TYPE.CONTENT_LENGTH, res.headers[_constants.HEADER_TYPE.CONTENT_LENGTH]);
+      }
+      readStream.pipe(stream);
+    });
+    readStream.on('error', function (err) {
+      stream.emit('error', err);
+    });
+    readStream.on('data', function (data) {
+      current_length += data.length;
+    });
+    readStream.on('end', function (data) {
+      if (data) {
+        current_length += data.length;
+      }
+      if (expected_length && current_length != expected_length) {
+        stream.emit('error', _utils2.ErrorCode.getInternalError(_constants.API_ERROR.CONTENT_MISMATCH));
+      }
+    });
+    return stream;
+  }
+
+  /**
+   * Perform a stream search.
+   * @param {*} options request options
+   * @return {Stream}
+   */
+  search(options) {
+    const transformStream = new _stream.default.PassThrough({
+      objectMode: true
+    });
+    const requestStream = this.request({
+      uri: options.req.url,
+      req: options.req,
+      headers: {
+        // query for search
+        referer: options.req.get('referer')
+      }
+    });
+    const parsePackage = pkg => {
+      if ((0, _utils2.isObjectOrArray)(pkg)) {
+        transformStream.emit('data', pkg);
+      }
+    };
+    requestStream.on('response', res => {
+      if (!String(res.statusCode).match(/^2\d\d$/)) {
+        return transformStream.emit('error', _utils2.ErrorCode.getInternalError(`bad status code ${res.statusCode} from uplink`));
+      }
+
+      // See https://github.com/request/request#requestoptions-callback
+      // Request library will not decode gzip stream.
+      let jsonStream;
+      if (res.headers[_constants.HEADER_TYPE.CONTENT_ENCODING] === _constants.HEADERS.GZIP) {
+        jsonStream = res.pipe(_zlib.default.createUnzip());
+      } else {
+        jsonStream = res;
+      }
+      jsonStream.pipe(_JSONStream.default.parse('*')).on('data', parsePackage);
+      jsonStream.on('end', () => {
+        transformStream.emit('end');
+      });
+    });
+    requestStream.on('error', err => {
+      transformStream.emit('error', err);
+    });
+    transformStream.abort = () => {
+      // FIXME: this is clearly a potential issue
+      // there is no abort method on Stream.Readable
+      // @ts-ignore
+      requestStream.abort();
+      transformStream.emit('end');
+    };
+    return transformStream;
+  }
+
+  /**
+   * Add proxy headers.
+   * FIXME: object mutations, it should return an new object
+   * @param {*} req the http request
+   * @param {*} headers the request headers
+   */
+  _addProxyHeaders(req, headers) {
+    if (req) {
+      // Only submit X-Forwarded-For field if we don't have a proxy selected
+      // in the config file.
+      //
+      // Otherwise misconfigured proxy could return 407:
+      // https://github.com/rlidwka/sinopia/issues/254
+      //
+      // FIXME: proxy logic is odd, something is wrong here.
+      // @ts-ignore
+      if (!this.proxy) {
+        headers['x-forwarded-for'] = (req.get('x-forwarded-for') ? req.get('x-forwarded-for') + ', ' : '') + req.connection.remoteAddress;
+      }
+    }
+
+    // always attach Via header to avoid loops, even if we're not proxying
+    headers['via'] = req && req.get('via') ? req.get('via') + ', ' : '';
+    headers['via'] += '1.1 ' + this.server_id + ' (Verdaccio)';
+  }
+
+  /**
+   * Check whether the remote host is available.
+   * @param {*} alive
+   * @return {Boolean}
+   */
+  _statusCheck(alive) {
+    if (arguments.length === 0) {
+      return this._ifRequestFailure() === false;
+    }
+    if (alive) {
+      if (this.failed_requests >= this.max_fails) {
+        this.logger.warn({
+          host: this.url.host
+        }, 'host @{host} is back online');
+      }
+      this.failed_requests = 0;
+    } else {
+      this.failed_requests++;
+      if (this.failed_requests === this.max_fails) {
+        this.logger.warn({
+          host: this.url.host
+        }, 'host @{host} is now offline');
+      }
+    }
+    this.last_request_time = Date.now();
+  }
+
+  /**
+   * If the request failure.
+   * @return {boolean}
+   * @private
+   */
+  _ifRequestFailure() {
+    return this.failed_requests >= this.max_fails && Math.abs(Date.now() - this.last_request_time) < this.fail_timeout;
+  }
+
+  /**
+   * Set up a proxy.
+   * @param {*} hostname
+   * @param {*} config
+   * @param {*} mainconfig
+   * @param {*} isHTTPS
+   */
+  _setupProxy(hostname, config, mainconfig, isHTTPS) {
+    let noProxyList;
+    const proxy_key = isHTTPS ? 'https_proxy' : 'http_proxy';
+
+    // get http_proxy and no_proxy configs
+    if (proxy_key in config) {
+      this.proxy = config[proxy_key];
+    } else if (proxy_key in mainconfig) {
+      this.proxy = mainconfig[proxy_key];
+    }
+    if ('no_proxy' in config) {
+      noProxyList = config.no_proxy;
+    } else if ('no_proxy' in mainconfig) {
+      noProxyList = mainconfig.no_proxy;
+    }
+
+    // use wget-like algorithm to determine if proxy shouldn't be used
+    if (hostname[0] !== '.') {
+      hostname = '.' + hostname;
+    }
+    if (_lodash.default.isString(noProxyList) && noProxyList.length) {
+      noProxyList = noProxyList.split(',');
+    }
+    if (_lodash.default.isArray(noProxyList)) {
+      for (let i = 0; i < noProxyList.length; i++) {
+        let noProxyItem = noProxyList[i];
+        if (noProxyItem[0] !== '.') {
+          noProxyItem = '.' + noProxyItem;
+        }
+        if (hostname.lastIndexOf(noProxyItem) === hostname.length - noProxyItem.length) {
+          if (this.proxy) {
+            debug('not using proxy for %o, excluded by %o rule', this.url.href, noProxyItem);
+            // @ts-ignore
+            this.proxy = false;
+          }
+          break;
+        }
+      }
+    }
+
+    // if it's non-string (i.e. "false"), don't use it
+    if (_lodash.default.isString(this.proxy) === false) {
+      // @ts-ignore
+      delete this.proxy;
+    } else {
+      debug('using proxy %o for %o', this.url.href, this.proxy);
+    }
+  }
+}
+var _default = exports.default = ProxyStorage;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_request","_interopRequireDefault","require","_JSONStream","_debug","_lodash","_stream","_url","_zlib","_streams","_utils","_constants","_logger","_utils2","e","__esModule","default","debug","buildDebug","encode","thing","encodeURIComponent","replace","jsonContentType","HEADERS","JSON","contentTypeAccept","setConfig","config","key","def","_","isNil","ProxyStorage","constructor","mainConfig","failed_requests","userAgent","user_agent","ca","logger","server_id","url","URL","parse","_setupProxy","hostname","protocol","timeout","Number","warn","join","maxage","parseInterval","max_fails","fail_timeout","strict_ssl","Boolean","agent_options","keepAlive","maxSockets","maxFreeSockets","request","options","cb","json","_statusCheck","streamRead","Stream","Readable","process","nextTick","ErrorCode","getInternalError","API_ERROR","UPLINK_OFFLINE","emit","_read","on","self","headers","_setHeaders","_addProxyHeaders","req","_overrideWithUpLinkConfigHeaders","method","uri","uri_full","info","isObject","stringify","requestCallback","err","res","body","error","responseLength","length","processBody","logActivity","message","statusCode","toString","CHARACTER_ENCODING","UTF8","_err","isString","http","undefined","status","bytes","in","out","requestOptions","proxy","encoding","gzip","strictSSL","agentOptions","Object","assign","statusCalled","_verdaccio_aborted","do_log","isNull","accept","ACCEPT","acceptEncoding","ACCEPT_ENCODING","USER_AGENT","get","_setAuth","auth","AUTHORIZATION","token","_throwErrorAuth","tokenConf","token_env","env","isBoolean","NPM_TOKEN","ERROR_CODE","token_required","type","TOKEN_BASIC","_setHeaderAuthorization","Error","_type","toLowerCase","TOKEN_BEARER","includes","upperFirst","buildToken","isUplinkValid","urlParsed","isHTTPS","urlDomainParsed","port","getHost","host","isMatchProtocol","isMatchHost","isMatchPath","path","indexOf","getRemoteMetadata","name","callback","etag","HTTP_STATUS","NOT_FOUND","getNotFound","NOT_PACKAGE_UPLINK","OK","MULTIPLE_CHOICES","BAD_STATUS_CODE","remoteStatus","fetchTarball","stream","ReadTarball","current_length","expected_length","abort","readStream","Accept","NOT_FILE_UPLINK","HEADER_TYPE","CONTENT_LENGTH","pipe","data","CONTENT_MISMATCH","search","transformStream","PassThrough","objectMode","requestStream","referer","parsePackage","pkg","isObjectOrArray","String","match","jsonStream","CONTENT_ENCODING","GZIP","zlib","createUnzip","JSONStream","connection","remoteAddress","alive","arguments","_ifRequestFailure","last_request_time","Date","now","Math","abs","mainconfig","noProxyList","proxy_key","no_proxy","split","isArray","i","noProxyItem","lastIndexOf","href","_default","exports"],"sources":["../../src/lib/up-storage.ts"],"sourcesContent":["import request from '@cypress/request';\nimport JSONStream from 'JSONStream';\nimport buildDebug from 'debug';\nimport _ from 'lodash';\nimport Stream from 'stream';\nimport URL, { UrlWithStringQuery } from 'url';\nimport zlib from 'zlib';\n\nimport { ReadTarball } from '@verdaccio/streams';\nimport { Callback, Config, Headers, Logger, Package, UpLinkConf } from '@verdaccio/types';\nimport { buildToken } from '@verdaccio/utils';\n\nimport {\n  API_ERROR,\n  CHARACTER_ENCODING,\n  ERROR_CODE,\n  HEADERS,\n  HEADER_TYPE,\n  HTTP_STATUS,\n  TOKEN_BASIC,\n  TOKEN_BEARER,\n} from './constants';\nimport { logger } from './logger';\nimport { ErrorCode, isObject, isObjectOrArray, parseInterval } from './utils';\n\nconst debug = buildDebug('verdaccio:proxy');\n\nconst encode = function (thing): string {\n  return encodeURIComponent(thing).replace(/^%40/, '@');\n};\n\nconst jsonContentType = HEADERS.JSON;\nconst contentTypeAccept = `${jsonContentType};`;\n\n/**\n * Just a helper (`config[key] || default` doesn't work because of zeroes)\n */\nconst setConfig = (config, key, def): string => {\n  return _.isNil(config[key]) === false ? config[key] : def;\n};\n\n/**\n * Implements Storage interface\n * (same for storage.js, local-storage.js, up-storage.js)\n */\nclass ProxyStorage {\n  public config: UpLinkConf;\n  public failed_requests: number;\n  public userAgent: string;\n  public ca: string | void;\n  public logger: Logger;\n  public server_id: string;\n  public url: any;\n  public maxage: number;\n  public timeout: number;\n  public max_fails: number;\n  public fail_timeout: number;\n  public agent_options: any;\n  // FIXME: upname is assigned to each instance\n  // @ts-ignore\n  public upname: string;\n  // FIXME: proxy can be boolean or object, something smells here\n  // @ts-ignore\n  public proxy: string | void;\n  // @ts-ignore\n  public last_request_time: number | null;\n  public strict_ssl: boolean;\n\n  /**\n   * Constructor\n   * @param {*} config\n   * @param {*} mainConfig\n   */\n  public constructor(config: UpLinkConf, mainConfig: Config) {\n    this.config = config;\n    this.failed_requests = 0;\n    // @ts-ignore\n    this.userAgent = mainConfig.user_agent ?? 'hidden';\n    this.ca = config.ca;\n    this.logger = logger;\n    this.server_id = mainConfig.server_id;\n\n    this.url = URL.parse(this.config.url);\n\n    this._setupProxy(this.url.hostname, config, mainConfig, this.url.protocol === 'https:');\n\n    this.config.url = this.config.url.replace(/\\/$/, '');\n\n    if (this.config.timeout && Number(this.config.timeout) >= 1000) {\n      this.logger.warn(\n        [\n          'Too big timeout value: ' + this.config.timeout,\n          'We changed time format to nginx-like one',\n          '(see http://nginx.org/en/docs/syntax.html)',\n          'so please update your config accordingly',\n        ].join('\\n')\n      );\n    }\n\n    // a bunch of different configurable timers\n    this.maxage = parseInterval(setConfig(this.config, 'maxage', '2m'));\n    this.timeout = parseInterval(setConfig(this.config, 'timeout', '30s'));\n    this.max_fails = Number(setConfig(this.config, 'max_fails', 2));\n    this.fail_timeout = parseInterval(setConfig(this.config, 'fail_timeout', '5m'));\n    this.strict_ssl = Boolean(setConfig(this.config, 'strict_ssl', true));\n    this.agent_options = setConfig(this.config, 'agent_options', {\n      keepAlive: true,\n      maxSockets: 40,\n      maxFreeSockets: 10,\n    });\n  }\n\n  /**\n   * Fetch an asset.\n   * @param {*} options\n   * @param {*} cb\n   * @return {Request}\n   */\n  private request(options: any, cb?: Callback): Stream.Readable {\n    let json;\n\n    if (this._statusCheck() === false) {\n      const streamRead = new Stream.Readable();\n\n      process.nextTick(function (): void {\n        if (cb) {\n          cb(ErrorCode.getInternalError(API_ERROR.UPLINK_OFFLINE));\n        }\n        streamRead.emit('error', ErrorCode.getInternalError(API_ERROR.UPLINK_OFFLINE));\n      });\n\n      streamRead._read = function (): void {};\n      // preventing 'Uncaught, unspecified \"error\" event'\n      streamRead.on('error', function (): void {});\n      return streamRead;\n    }\n\n    const self = this;\n    const headers: Headers = this._setHeaders(options);\n\n    this._addProxyHeaders(options.req, headers);\n    this._overrideWithUpLinkConfigHeaders(headers);\n\n    const method = options.method || 'GET';\n    const uri = options.uri_full || this.config.url + options.uri;\n\n    self.logger.info(\n      {\n        method: method,\n        uri: uri,\n      },\n      \"making request: '@{method} @{uri}'\"\n    );\n\n    if (isObject(options.json)) {\n      json = JSON.stringify(options.json);\n      headers['Content-Type'] = headers['Content-Type'] || HEADERS.JSON;\n    }\n\n    const requestCallback = cb\n      ? function (err, res, body): void {\n          let error;\n          const responseLength = err ? 0 : body.length;\n\n          processBody();\n          logActivity();\n\n          cb(err, res, body);\n\n          /**\n           * Perform a decode.\n           */\n          function processBody(): void {\n            if (err) {\n              error = err.message;\n              return;\n            }\n\n            if (options.json && res.statusCode < 300) {\n              try {\n                body = JSON.parse(body.toString(CHARACTER_ENCODING.UTF8));\n              } catch (_err) {\n                body = {};\n                err = _err;\n                error = err.message;\n              }\n            }\n\n            if (!err && isObject(body)) {\n              if (_.isString(body.error)) {\n                error = body.error;\n              }\n            }\n          }\n          /**\n           * Perform a log.\n           */\n          function logActivity(): void {\n            let message = \"@{!status}, req: '@{request.method} @{request.url}'\";\n            message += error ? ', error: @{!error}' : ', bytes: @{bytes.in}/@{bytes.out}';\n            self.logger.http(\n              {\n                err: err || undefined, // if error is null/false change this to undefined so it wont log\n                request: { method: method, url: uri },\n                status: res != null ? res.statusCode : 'ERR',\n                error: error,\n                bytes: {\n                  in: json ? json.length : 0,\n                  out: responseLength || 0,\n                },\n              },\n              message\n            );\n          }\n        }\n      : undefined;\n    let requestOptions: request.OptionsWithUrl = {\n      url: uri,\n      method: method,\n      headers: headers,\n      body: json,\n      proxy: this.proxy,\n      encoding: null,\n      gzip: true,\n      timeout: this.timeout,\n      strictSSL: this.strict_ssl,\n      agentOptions: this.agent_options,\n    };\n\n    if (this.ca) {\n      requestOptions = Object.assign({}, requestOptions, {\n        ca: this.ca,\n      });\n    }\n\n    const req = request(requestOptions, requestCallback);\n\n    let statusCalled = false;\n    req.on('response', function (res): void {\n      // FIXME: _verdaccio_aborted seems not used\n      // @ts-ignore\n      if (!req._verdaccio_aborted && !statusCalled) {\n        statusCalled = true;\n        self._statusCheck(true);\n      }\n\n      if (_.isNil(requestCallback) === false) {\n        (function do_log(): void {\n          const message = \"@{!status}, req: '@{request.method} @{request.url}' (streaming)\";\n          self.logger.http(\n            {\n              request: {\n                method: method,\n                url: uri,\n              },\n              status: _.isNull(res) === false ? res.statusCode : 'ERR',\n            },\n            message\n          );\n        })();\n      }\n    });\n    req.on('error', function (err): void {\n      // FIXME: _verdaccio_aborted seems not used\n      debug('_verdaccio_aborted: %o', err);\n      if (!req._verdaccio_aborted && !statusCalled) {\n        statusCalled = true;\n        self._statusCheck(false);\n      }\n    });\n\n    return req;\n  }\n\n  /**\n   * Set default headers.\n   * @param {Object} options\n   * @return {Object}\n   * @private\n   */\n  private _setHeaders(options: any): Headers {\n    const headers = options.headers || {};\n    const accept = HEADERS.ACCEPT;\n    const acceptEncoding = HEADERS.ACCEPT_ENCODING;\n    const userAgent = HEADERS.USER_AGENT;\n\n    headers[accept] = headers[accept] || contentTypeAccept;\n    headers[acceptEncoding] = headers[acceptEncoding] || 'gzip';\n    // registry.npmjs.org will only return search result if user-agent include string 'npm'\n    headers[userAgent] = this.userAgent\n      ? `npm (${this.userAgent})`\n      : options.req?.get('user-agent');\n\n    return this._setAuth(headers);\n  }\n\n  /**\n   * Validate configuration auth and assign Header authorization\n   * @param {Object} headers\n   * @return {Object}\n   * @private\n   */\n  private _setAuth(headers: any): Headers {\n    const { auth } = this.config;\n\n    if (_.isNil(auth) || headers[HEADERS.AUTHORIZATION]) {\n      return headers;\n    }\n\n    if (_.isObject(auth) === false && _.isObject((auth as any).token) === false) {\n      this._throwErrorAuth('Auth invalid');\n    }\n\n    // get NPM_TOKEN http://blog.npmjs.org/post/118393368555/deploying-with-npm-private-modules\n    // or get other variable export in env\n    // https://github.com/verdaccio/verdaccio/releases/tag/v2.5.0\n    let token: any;\n    const tokenConf: any = auth;\n\n    if (_.isNil(tokenConf.token) === false && _.isString(tokenConf.token)) {\n      token = tokenConf.token;\n    } else if (_.isNil(tokenConf.token_env) === false) {\n      if (_.isString(tokenConf.token_env)) {\n        token = process.env[tokenConf.token_env];\n      } else if (_.isBoolean(tokenConf.token_env) && tokenConf.token_env) {\n        token = process.env.NPM_TOKEN;\n      } else {\n        this.logger.error(ERROR_CODE.token_required);\n        this._throwErrorAuth(ERROR_CODE.token_required);\n      }\n    } else {\n      token = process.env.NPM_TOKEN;\n    }\n\n    if (_.isNil(token)) {\n      this._throwErrorAuth(ERROR_CODE.token_required);\n    }\n\n    // define type Auth allow basic and bearer\n    const type = tokenConf.type || TOKEN_BASIC;\n    this._setHeaderAuthorization(headers, type, token);\n\n    return headers;\n  }\n\n  /**\n   * @param {string} message\n   * @throws {Error}\n   * @private\n   */\n  private _throwErrorAuth(message: string): Error {\n    this.logger.error(message);\n    throw new Error(message);\n  }\n\n  /**\n   * Assign Header authorization with type authentication\n   * @param {Object} headers\n   * @param {string} type\n   * @param {string} token\n   * @private\n   */\n  private _setHeaderAuthorization(headers: any, type: string, token: any): void {\n    const _type: string = type.toLowerCase();\n\n    if ([TOKEN_BEARER.toLowerCase(), TOKEN_BASIC.toLowerCase()].includes(_type) === false) {\n      this._throwErrorAuth(`Auth type '${_type}' not allowed`);\n    }\n\n    type = _.upperFirst(type);\n    headers[HEADERS.AUTHORIZATION] = buildToken(type, token);\n  }\n\n  /**\n   * It will add or override specified headers from config file.\n   *\n   * Eg:\n   *\n   * uplinks:\n   npmjs:\n   url: https://registry.npmjs.org/\n   headers:\n   Accept: \"application/vnd.npm.install-v2+json; q=1.0\"\n   verdaccio-staging:\n   url: https://mycompany.com/npm\n   headers:\n   Accept: \"application/json\"\n   authorization: \"Basic YourBase64EncodedCredentials==\"\n\n   * @param {Object} headers\n   * @private\n   */\n  private _overrideWithUpLinkConfigHeaders(headers: Headers): any {\n    if (!this.config.headers) {\n      return headers;\n    }\n\n    // add/override headers specified in the config\n    /* eslint guard-for-in: 0 */\n    for (const key in this.config.headers) {\n      headers[key] = this.config.headers[key];\n    }\n  }\n\n  /**\n   * Determine whether can fetch from the provided URL\n   * @param {*} url\n   * @return {Boolean}\n   */\n  public isUplinkValid(url: string): boolean {\n    const urlParsed: UrlWithStringQuery = URL.parse(url);\n    const isHTTPS = (urlDomainParsed: URL): boolean =>\n      urlDomainParsed.protocol === 'https:' &&\n      (urlParsed.port === null || urlParsed.port === '443');\n    const getHost = (urlDomainParsed): boolean =>\n      isHTTPS(urlDomainParsed) ? urlDomainParsed.hostname : urlDomainParsed.host;\n    const isMatchProtocol: boolean = urlParsed.protocol === this.url.protocol;\n    const isMatchHost: boolean = getHost(urlParsed) === getHost(this.url);\n    // @ts-ignore\n    const isMatchPath: boolean = urlParsed.path.indexOf(this.url.path) === 0;\n\n    return isMatchProtocol && isMatchHost && isMatchPath;\n  }\n\n  /**\n   * Get a remote package metadata\n   * @param {*} name package name\n   * @param {*} options request options, eg: eTag.\n   * @param {*} callback\n   */\n  public getRemoteMetadata(name: string, options: any, callback: Callback): void {\n    const headers = {};\n    if (_.isNil(options.etag) === false) {\n      headers['If-None-Match'] = options.etag;\n      headers[HEADERS.ACCEPT] = contentTypeAccept;\n    }\n\n    this.request(\n      {\n        uri: `/${encode(name)}`,\n        json: true,\n        headers: headers,\n        req: options.req,\n      },\n      (err, res, body): void => {\n        if (err) {\n          return callback(err);\n        }\n        if (res.statusCode === HTTP_STATUS.NOT_FOUND) {\n          return callback(ErrorCode.getNotFound(API_ERROR.NOT_PACKAGE_UPLINK));\n        }\n        if (!(res.statusCode >= HTTP_STATUS.OK && res.statusCode < HTTP_STATUS.MULTIPLE_CHOICES)) {\n          const error = ErrorCode.getInternalError(\n            `${API_ERROR.BAD_STATUS_CODE}: ${res.statusCode}`\n          );\n\n          error.remoteStatus = res.statusCode;\n          return callback(error);\n        }\n        callback(null, body, res.headers.etag);\n      }\n    );\n  }\n\n  /**\n   * Fetch a tarball from the uplink.\n   * @param {String} url\n   * @return {Stream}\n   */\n  public fetchTarball(url: string) {\n    const stream = new ReadTarball({});\n    let current_length = 0;\n    let expected_length;\n\n    stream.abort = () => {};\n    const readStream = this.request({\n      uri_full: url,\n      encoding: null,\n      headers: {\n        Accept: contentTypeAccept,\n      },\n    });\n\n    readStream.on('response', function (res: any) {\n      if (res.statusCode === HTTP_STATUS.NOT_FOUND) {\n        return stream.emit('error', ErrorCode.getNotFound(API_ERROR.NOT_FILE_UPLINK));\n      }\n      if (!(res.statusCode >= HTTP_STATUS.OK && res.statusCode < HTTP_STATUS.MULTIPLE_CHOICES)) {\n        return stream.emit(\n          'error',\n          ErrorCode.getInternalError(`bad uplink status code: ${res.statusCode}`)\n        );\n      }\n      if (res.headers[HEADER_TYPE.CONTENT_LENGTH]) {\n        expected_length = res.headers[HEADER_TYPE.CONTENT_LENGTH];\n        stream.emit(HEADER_TYPE.CONTENT_LENGTH, res.headers[HEADER_TYPE.CONTENT_LENGTH]);\n      }\n\n      readStream.pipe(stream);\n    });\n\n    readStream.on('error', function (err) {\n      stream.emit('error', err);\n    });\n    readStream.on('data', function (data) {\n      current_length += data.length;\n    });\n    readStream.on('end', function (data) {\n      if (data) {\n        current_length += data.length;\n      }\n      if (expected_length && current_length != expected_length) {\n        stream.emit('error', ErrorCode.getInternalError(API_ERROR.CONTENT_MISMATCH));\n      }\n    });\n    return stream;\n  }\n\n  /**\n   * Perform a stream search.\n   * @param {*} options request options\n   * @return {Stream}\n   */\n  public search(options: any) {\n    const transformStream: any = new Stream.PassThrough({ objectMode: true });\n    const requestStream: Stream.Readable = this.request({\n      uri: options.req.url,\n      req: options.req,\n      headers: {\n        // query for search\n        referer: options.req.get('referer'),\n      },\n    });\n\n    const parsePackage = (pkg: Package): void => {\n      if (isObjectOrArray(pkg)) {\n        transformStream.emit('data', pkg);\n      }\n    };\n\n    requestStream.on('response', (res): void => {\n      if (!String(res.statusCode).match(/^2\\d\\d$/)) {\n        return transformStream.emit(\n          'error',\n          ErrorCode.getInternalError(`bad status code ${res.statusCode} from uplink`)\n        );\n      }\n\n      // See https://github.com/request/request#requestoptions-callback\n      // Request library will not decode gzip stream.\n      let jsonStream;\n      if (res.headers[HEADER_TYPE.CONTENT_ENCODING] === HEADERS.GZIP) {\n        jsonStream = res.pipe(zlib.createUnzip());\n      } else {\n        jsonStream = res;\n      }\n      jsonStream.pipe(JSONStream.parse('*')).on('data', parsePackage);\n      jsonStream.on('end', (): void => {\n        transformStream.emit('end');\n      });\n    });\n\n    requestStream.on('error', (err: Error): void => {\n      transformStream.emit('error', err);\n    });\n\n    transformStream.abort = (): void => {\n      // FIXME: this is clearly a potential issue\n      // there is no abort method on Stream.Readable\n      // @ts-ignore\n      requestStream.abort();\n      transformStream.emit('end');\n    };\n\n    return transformStream;\n  }\n\n  /**\n   * Add proxy headers.\n   * FIXME: object mutations, it should return an new object\n   * @param {*} req the http request\n   * @param {*} headers the request headers\n   */\n  private _addProxyHeaders(req: any, headers: any): void {\n    if (req) {\n      // Only submit X-Forwarded-For field if we don't have a proxy selected\n      // in the config file.\n      //\n      // Otherwise misconfigured proxy could return 407:\n      // https://github.com/rlidwka/sinopia/issues/254\n      //\n      // FIXME: proxy logic is odd, something is wrong here.\n      // @ts-ignore\n      if (!this.proxy) {\n        headers['x-forwarded-for'] =\n          (req.get('x-forwarded-for') ? req.get('x-forwarded-for') + ', ' : '') +\n          req.connection.remoteAddress;\n      }\n    }\n\n    // always attach Via header to avoid loops, even if we're not proxying\n    headers['via'] = req && req.get('via') ? req.get('via') + ', ' : '';\n\n    headers['via'] += '1.1 ' + this.server_id + ' (Verdaccio)';\n  }\n\n  /**\n   * Check whether the remote host is available.\n   * @param {*} alive\n   * @return {Boolean}\n   */\n  private _statusCheck(alive?: boolean): boolean | void {\n    if (arguments.length === 0) {\n      return this._ifRequestFailure() === false;\n    }\n    if (alive) {\n      if (this.failed_requests >= this.max_fails) {\n        this.logger.warn(\n          {\n            host: this.url.host,\n          },\n          'host @{host} is back online'\n        );\n      }\n      this.failed_requests = 0;\n    } else {\n      this.failed_requests++;\n      if (this.failed_requests === this.max_fails) {\n        this.logger.warn(\n          {\n            host: this.url.host,\n          },\n          'host @{host} is now offline'\n        );\n      }\n    }\n\n    this.last_request_time = Date.now();\n  }\n\n  /**\n   * If the request failure.\n   * @return {boolean}\n   * @private\n   */\n  private _ifRequestFailure(): boolean {\n    return (\n      this.failed_requests >= this.max_fails &&\n      Math.abs(Date.now() - (this.last_request_time as number)) < this.fail_timeout\n    );\n  }\n\n  /**\n   * Set up a proxy.\n   * @param {*} hostname\n   * @param {*} config\n   * @param {*} mainconfig\n   * @param {*} isHTTPS\n   */\n  private _setupProxy(\n    hostname: string,\n    config: UpLinkConf,\n    mainconfig: Config,\n    isHTTPS: boolean\n  ): void {\n    let noProxyList;\n    const proxy_key: string = isHTTPS ? 'https_proxy' : 'http_proxy';\n\n    // get http_proxy and no_proxy configs\n    if (proxy_key in config) {\n      this.proxy = config[proxy_key];\n    } else if (proxy_key in mainconfig) {\n      this.proxy = mainconfig[proxy_key];\n    }\n    if ('no_proxy' in config) {\n      noProxyList = config.no_proxy;\n    } else if ('no_proxy' in mainconfig) {\n      noProxyList = mainconfig.no_proxy;\n    }\n\n    // use wget-like algorithm to determine if proxy shouldn't be used\n    if (hostname[0] !== '.') {\n      hostname = '.' + hostname;\n    }\n\n    if (_.isString(noProxyList) && noProxyList.length) {\n      noProxyList = noProxyList.split(',');\n    }\n\n    if (_.isArray(noProxyList)) {\n      for (let i = 0; i < noProxyList.length; i++) {\n        let noProxyItem = noProxyList[i];\n        if (noProxyItem[0] !== '.') {\n          noProxyItem = '.' + noProxyItem;\n        }\n        if (hostname.lastIndexOf(noProxyItem) === hostname.length - noProxyItem.length) {\n          if (this.proxy) {\n            debug('not using proxy for %o, excluded by %o rule', this.url.href, noProxyItem);\n            // @ts-ignore\n            this.proxy = false;\n          }\n          break;\n        }\n      }\n    }\n\n    // if it's non-string (i.e. \"false\"), don't use it\n    if (_.isString(this.proxy) === false) {\n      // @ts-ignore\n      delete this.proxy;\n    } else {\n      debug('using proxy %o for %o', this.url.href, this.proxy);\n    }\n  }\n}\n\nexport default ProxyStorage;\n"],"mappings":"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","ignoreList":[]}