@verdaccio/server/build/server.js

server logic

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _compression = _interopRequireDefault(require("compression"));
var _cors = _interopRequireDefault(require("cors"));
var _debug = _interopRequireDefault(require("debug"));
var _express = _interopRequireDefault(require("express"));
var _lodash = _interopRequireDefault(require("lodash"));
var _verdaccioAudit = _interopRequireDefault(require("verdaccio-audit"));
var _api = _interopRequireDefault(require("@verdaccio/api"));
var _auth = require("@verdaccio/auth");
var _config = require("@verdaccio/config");
var _core = require("@verdaccio/core");
var _loaders = require("@verdaccio/loaders");
var _logger = require("@verdaccio/logger");
var _middleware = require("@verdaccio/middleware");
var _store = require("@verdaccio/store");
var _web = _interopRequireDefault(require("@verdaccio/web"));
var _debug2 = _interopRequireDefault(require("./debug"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const debug = (0, _debug.default)('verdaccio:server');
const {
  version
} = require('../package.json');
const defineAPI = async function (config, storage) {
  var _config$server;
  const auth = new _auth.Auth(config);
  await auth.init();
  const app = (0, _express.default)();
  // run in production mode by default, just in case
  // it shouldn't make any difference anyway
  app.set('env', process.env.NODE_ENV || 'production');
  if ((_config$server = config.server) !== null && _config$server !== void 0 && _config$server.trustProxy) {
    app.set('trust proxy', config.server.trustProxy);
  }
  app.use((0, _cors.default)());
  app.use((0, _middleware.rateLimit)(config.serverSettings.rateLimit));
  const errorReportingMiddlewareWrap = (0, _middleware.errorReportingMiddleware)(_logger.logger);

  // Router setup
  app.use((0, _middleware.log)(_logger.logger));
  app.use(errorReportingMiddlewareWrap);
  app.use((0, _middleware.userAgent)(config));
  app.use((0, _compression.default)());
  app.get('/favicon.ico', function (req, res, next) {
    req.url = '/-/static/favicon.png';
    next();
  });

  // Hook for tests only
  if (config._debug) {
    (0, _debug2.default)(app, config.configPath);
  }
  const plugins = await (0, _loaders.asyncLoadPlugin)(config.middlewares, {
    config,
    logger: _logger.logger
  }, function (plugin) {
    return typeof plugin.register_middlewares !== 'undefined';
  });
  if (plugins.length === 0) {
    _logger.logger.info('none middleware plugins has been defined, adding audit middleware by default');
    // @ts-ignore
    plugins.push(new _verdaccioAudit.default({
      enabled: true,
      strict_ssl: true
    }, {
      config,
      logger: _logger.logger
    }));
  }
  plugins.forEach(plugin => {
    plugin.register_middlewares(app, auth, storage);
  });

  // For  npm request
  // @ts-ignore
  app.use((0, _api.default)(config, auth, storage));

  // For WebUI & WebUI API
  if (_lodash.default.get(config, 'web.enable', true)) {
    app.use((_req, res, next) => {
      res.locals.app_version = version !== null && version !== void 0 ? version : '';
      next();
    });
    const middleware = await (0, _web.default)(config, auth, storage);
    app.use(middleware);
  } else {
    app.get('/', function (req, res, next) {
      next(_core.errorUtils.getNotFound(_core.API_ERROR.WEB_DISABLED));
    });
  }

  // Catch 404
  app.get('/*', function (req, res, next) {
    next(_core.errorUtils.getNotFound('resource not found'));
  });
  app.use(function (err, req, res, next) {
    if (_lodash.default.isError(err)) {
      if (err.code === 'ECONNABORT' && res.statusCode === _core.HTTP_STATUS.NOT_MODIFIED) {
        return next();
      }
      if (_lodash.default.isFunction(res.locals.report_error) === false) {
        // in case of very early error this middleware may not be loaded before error is generated
        // fixing that
        errorReportingMiddlewareWrap(req, res, _lodash.default.noop);
      }
      res.locals.report_error(err);
    } else {
      // Fall to Middleware.final
      return next(err);
    }
  });
  app.use(_middleware.final);
  return app;
};
var startServer = async function startServer(configHash) {
  debug('start server');
  const config = new _config.Config({
    ...configHash
  });
  // register middleware plugins
  debug('loaded filter plugin');
  // @ts-ignore
  const storage = new _store.Storage(config);
  try {
    // waits until init calls have been initialized
    debug('storage init start');
    await storage.init(config);
    debug('storage init end');
  } catch (err) {
    _logger.logger.error({
      error: err.msg
    }, 'storage has failed: @{error}');
    throw new Error(err);
  }
  return await defineAPI(config, storage);
};
exports.default = startServer;
//# sourceMappingURL=server.js.map