verdaccio/build/lib/up-storage.js

A lightweight private npm proxy registry

"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
    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.FORBIDDEN) {
        const chunks = [];
        readStream.on('data', chunk => chunks.push(chunk));
        readStream.once('end', () => {
          let body;
          const raw = Buffer.concat(chunks);
          if (raw.length > 0) {
            try {
              body = JSON.parse(raw.toString('utf8'));
            } catch {}
          }
          const message = body?.detail || body?.title || body?.message || 'tarball not available: forbidden by uplink';
          stream.emit('error', _utils2.ErrorCode.getForbidden(message));
        });
        return;
      }
      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({
      // prefer the sanitized url (clamped pagination) built by the search
      // endpoint over the raw request url
      uri: options.url || 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","FORBIDDEN","chunks","chunk","push","once","raw","Buffer","concat","detail","title","getForbidden","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    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.FORBIDDEN) {\n        const chunks: Buffer[] = [];\n        readStream.on('data', (chunk: Buffer) => chunks.push(chunk));\n        readStream.once('end', () => {\n          let body: any;\n          const raw = Buffer.concat(chunks);\n          if (raw.length > 0) {\n            try {\n              body = JSON.parse(raw.toString('utf8'));\n            } catch {}\n          }\n          const message =\n            body?.detail ||\n            body?.title ||\n            body?.message ||\n            'tarball not available: forbidden by uplink';\n          stream.emit('error', ErrorCode.getForbidden(message));\n        });\n        return;\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      // prefer the sanitized url (clamped pagination) built by the search\n      // endpoint over the raw request url\n      uri: options.url || 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.g