@verdaccio/canary 6.3.2-canary.404363f

package/build/api/endpoint/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _express = _interopRequireDefault(require("express"));
+var _middleware = require("@verdaccio/middleware");
+var _distTags = _interopRequireDefault(require("./api/dist-tags"));
+var _package = _interopRequireDefault(require("./api/package"));
+var _ping = _interopRequireDefault(require("./api/ping"));
+var _publish = _interopRequireDefault(require("./api/publish"));
+var _search = _interopRequireDefault(require("./api/search"));
+var _stars = _interopRequireDefault(require("./api/stars"));
+var _user = _interopRequireDefault(require("./api/user"));
+var _profile = _interopRequireDefault(require("./api/v1/profile"));
+var _search2 = _interopRequireDefault(require("./api/v1/search"));
+var _token = _interopRequireDefault(require("./api/v1/token"));
+var _whoami = _interopRequireDefault(require("./api/whoami"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _default(config, auth, storage) {
+  const app = _express.default.Router();
+
+  // validate all of these params as a package name
+  // this might be too harsh, so ask if it causes trouble
+  app.param('package', _middleware.validatePackage);
+  app.param('filename', _middleware.validateName);
+  app.param('tag', _middleware.validateName);
+  app.param('version', _middleware.validateName);
+  app.param('revision', _middleware.validateName);
+  app.param('token', _middleware.validateName);
+
+  // these can't be safely put into express url for some reason
+  // TODO: For some reason? what reason?
+  app.param('_rev', (0, _middleware.match)(/^-rev$/));
+  app.param('org_couchdb_user', (0, _middleware.match)(/^org\.couchdb\.user:/));
+  app.use(auth.apiJWTmiddleware());
+  app.use(_express.default.json({
+    strict: false,
+    limit: config.max_body_size || '10mb'
+  }));
+  app.use((0, _middleware.antiLoop)(config));
+  // encode / in a scoped package name to be matched as a single parameter in routes
+  app.use(_middleware.encodeScopePackage);
+  (0, _whoami.default)(app);
+  (0, _profile.default)(app, auth, config);
+  (0, _search.default)(app, auth, storage);
+  (0, _user.default)(app, auth, config);
+  (0, _distTags.default)(app, auth, storage);
+  (0, _publish.default)(app, auth, storage, config);
+  (0, _ping.default)(app);
+  (0, _stars.default)(app, storage);
+  (0, _search2.default)(app, auth, storage);
+  (0, _token.default)(app, auth, storage, config);
+  (0, _package.default)(app, auth, storage, config);
+  return app;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/api/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _compression = _interopRequireDefault(require("compression"));
+var _cors = _interopRequireDefault(require("cors"));
+var _express = _interopRequireDefault(require("express"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _auth = require("@verdaccio/auth");
+var _config = require("@verdaccio/config");
+var _core = require("@verdaccio/core");
+var _loaders = require("@verdaccio/loaders");
+var _middleware = require("@verdaccio/middleware");
+var _searchIndexer = require("@verdaccio/search-indexer");
+var _config2 = _interopRequireDefault(require("../lib/config"));
+var _constants = require("../lib/constants");
+var _logger = require("../lib/logger");
+var _storage = _interopRequireDefault(require("../lib/storage"));
+var _utils = require("../lib/utils");
+var _debug = _interopRequireDefault(require("./debug"));
+var _endpoint = _interopRequireDefault(require("./endpoint"));
+var _middleware2 = require("./middleware");
+var _web = _interopRequireDefault(require("./web"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const version = "6.3.2" || 'dev';
+const defineAPI = async function (config, storage) {
+  const auth = new _auth.Auth(config, _logger.logger, {
+    legacyMergeConfigs: true
+  });
+  await auth.init();
+  const app = (0, _express.default)();
+  _searchIndexer.SearchMemoryIndexer.configureStorage(storage);
+  await _searchIndexer.SearchMemoryIndexer.init(_logger.logger);
+  // run in production mode by default, just in case
+  // it shouldn't make any difference anyway
+  app.set('env', process.env.NODE_ENV || 'production');
+
+  // Allow `req.ip` to resolve properly when Verdaccio is behind a proxy or load-balancer
+  // See: https://expressjs.com/en/guide/behind-proxies.html
+  if (config.server?.trustProxy) {
+    app.set('trust proxy', config.server.trustProxy);
+  }
+  app.use((0, _cors.default)());
+
+  // // Router setup
+  app.use((0, _middleware.log)(_logger.logger));
+  app.use((0, _middleware.errorReportingMiddleware)(_logger.logger));
+  if (config.user_agent) {
+    app.use(function (_req, res, next) {
+      res.setHeader('X-Powered-By', (0, _config.getUserAgent)(config.user_agent));
+      next();
+    });
+  } else {
+    app.disable('x-powered-by');
+  }
+  app.use((0, _compression.default)());
+  app.get('/-/static/favicon.ico', (0, _middleware2.serveFavicon)(config));
+
+  // Hook for tests only
+  if (config._debug) {
+    (0, _debug.default)(app, config.configPath);
+  }
+  const plugins = await (0, _loaders.asyncLoadPlugin)(config.middlewares, {
+    config,
+    logger: _logger.logger
+  }, function (plugin) {
+    return typeof plugin.register_middlewares !== 'undefined';
+  }, true, config?.serverSettings?.pluginPrefix ?? 'verdaccio', _core.PLUGIN_CATEGORY.MIDDLEWARE);
+  plugins.forEach(plugin => {
+    plugin.register_middlewares(app, auth, storage);
+  });
+
+  // // For  npm request
+  app.use((0, _endpoint.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 ?? '';
+      next();
+    });
+    const middleware = await (0, _web.default)(config, auth, storage, _logger.logger);
+    app.use(middleware);
+  } else {
+    app.get('/', function (_, __, next) {
+      next(_utils.ErrorCode.getNotFound(_constants.API_ERROR.WEB_DISABLED));
+    });
+  }
+  app.get('/*', function (_, __, next) {
+    next(_utils.ErrorCode.getNotFound(_constants.API_ERROR.FILE_NOT_FOUND));
+  });
+  app.use((0, _middleware.handleError)(_logger.logger));
+  app.use(_middleware.final);
+  return app;
+};
+var _default = exports.default = async function _default(configHash) {
+  const config = new _config2.default(_lodash.default.cloneDeep(configHash));
+  const storage = new _storage.default(config);
+  // waits until init calls have been initialized
+  await storage.init(config);
+  return await defineAPI(config, storage);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_compression","_interopRequireDefault","require","_cors","_express","_lodash","_auth","_config","_core","_loaders","_middleware","_searchIndexer","_config2","_constants","_logger","_storage","_utils","_debug","_endpoint","_middleware2","_web","e","__esModule","default","version","defineAPI","config","storage","auth","Auth","logger","legacyMergeConfigs","init","app","express","SearchMemoryIndexer","configureStorage","set","process","env","NODE_ENV","server","trustProxy","use","cors","log","errorReportingMiddleware","user_agent","_req","res","next","setHeader","getUserAgent","disable","compression","get","serveFavicon","hookDebug","configPath","plugins","asyncLoadPlugin","middlewares","plugin","register_middlewares","serverSettings","pluginPrefix","PLUGIN_CATEGORY","MIDDLEWARE","forEach","apiEndpoint","_","locals","app_version","middleware","webMiddleware","__","ErrorCode","getNotFound","API_ERROR","WEB_DISABLED","FILE_NOT_FOUND","handleError","final","_default","exports","configHash","AppConfig","cloneDeep","Storage"],"sources":["../../src/api/index.ts"],"sourcesContent":["import compression from 'compression';\nimport cors from 'cors';\nimport type { Application } from 'express';\nimport express from 'express';\nimport _ from 'lodash';\n\nimport { Auth } from '@verdaccio/auth';\nimport { getUserAgent } from '@verdaccio/config';\nimport type { pluginUtils } from '@verdaccio/core';\nimport { PLUGIN_CATEGORY } from '@verdaccio/core';\nimport { asyncLoadPlugin } from '@verdaccio/loaders';\nimport { errorReportingMiddleware, final, handleError, log } from '@verdaccio/middleware';\nimport { SearchMemoryIndexer } from '@verdaccio/search-indexer';\nimport type { ConfigYaml, Config as IConfig } from '@verdaccio/types';\n\nimport AppConfig from '../lib/config';\nimport { API_ERROR } from '../lib/constants';\nimport { logger } from '../lib/logger';\nimport Storage from '../lib/storage';\nimport { ErrorCode } from '../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend, $ResponseExtend } from '../types';\nimport hookDebug from './debug';\nimport apiEndpoint from './endpoint';\nimport { serveFavicon } from './middleware';\nimport webMiddleware from './web';\n\nconst version = process.env.PACKAGE_VERSION || 'dev';\n\nconst defineAPI = async function (config: IConfig, storage: Storage): Promise<express.Application> {\n  const auth = new Auth(config, logger, { legacyMergeConfigs: true });\n  await auth.init();\n  const app: Application = express();\n  SearchMemoryIndexer.configureStorage(storage);\n  await SearchMemoryIndexer.init(logger);\n  // run in production mode by default, just in case\n  // it shouldn't make any difference anyway\n  app.set('env', process.env.NODE_ENV || 'production');\n\n  // Allow `req.ip` to resolve properly when Verdaccio is behind a proxy or load-balancer\n  // See: https://expressjs.com/en/guide/behind-proxies.html\n  if (config.server?.trustProxy) {\n    app.set('trust proxy', config.server.trustProxy);\n  }\n\n  app.use(cors());\n\n  // // Router setup\n  app.use(log(logger));\n  app.use(errorReportingMiddleware(logger));\n  if (config.user_agent) {\n    app.use(function (_req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n      res.setHeader('X-Powered-By', getUserAgent(config.user_agent));\n      next();\n    });\n  } else {\n    app.disable('x-powered-by');\n  }\n\n  app.use(compression());\n\n  app.get('/-/static/favicon.ico', serveFavicon(config));\n\n  // Hook for tests only\n  if (config._debug) {\n    hookDebug(app, config.configPath);\n  }\n\n  const plugins: pluginUtils.ExpressMiddleware<IConfig, '', Auth>[] = await asyncLoadPlugin(\n    config.middlewares,\n    {\n      config,\n      logger,\n    },\n    function (plugin) {\n      return typeof plugin.register_middlewares !== 'undefined';\n    },\n    true,\n    config?.serverSettings?.pluginPrefix ?? 'verdaccio',\n    PLUGIN_CATEGORY.MIDDLEWARE\n  );\n\n  plugins.forEach((plugin: any) => {\n    plugin.register_middlewares(app, auth, storage);\n  });\n\n  // // For  npm request\n  app.use(apiEndpoint(config, auth, storage));\n\n  // For WebUI & WebUI API\n  if (_.get(config, 'web.enable', true)) {\n    app.use((_req, res, next) => {\n      res.locals.app_version = version ?? '';\n      next();\n    });\n    const middleware = await webMiddleware(config, auth, storage, logger);\n    app.use(middleware);\n  } else {\n    app.get('/', function (_, __, next: $NextFunctionVer) {\n      next(ErrorCode.getNotFound(API_ERROR.WEB_DISABLED));\n    });\n  }\n\n  app.get('/*', function (_, __, next: $NextFunctionVer) {\n    next(ErrorCode.getNotFound(API_ERROR.FILE_NOT_FOUND));\n  });\n  app.use(handleError(logger));\n  app.use(final);\n\n  return app;\n};\n\nexport default (async function (configHash: ConfigYaml): Promise<express.Application> {\n  const config: IConfig = new AppConfig(_.cloneDeep(configHash));\n\n  const storage = new Storage(config);\n  // waits until init calls have been initialized\n  await storage.init(config);\n  return await defineAPI(config, storage);\n});\n"],"mappings":"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","ignoreList":[]}

package/build/api/middleware.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serveFavicon = serveFavicon;
+var _debug = _interopRequireDefault(require("debug"));
+var _fs = _interopRequireDefault(require("fs"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _path = _interopRequireDefault(require("path"));
+var _url = require("@verdaccio/url");
+var _constants = require("../lib/constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:middleware:favicon');
+function serveFavicon(config) {
+  return function (_req, res) {
+    try {
+      const logoConf = config?.web?.favicon;
+      if (logoConf === '') {
+        debug('favicon disabled');
+        res.status(404);
+      } else if (!_lodash.default.isEmpty(logoConf)) {
+        debug('custom favicon');
+        if ((0, _url.isURL)(logoConf, {
+          require_host: true,
+          require_valid_protocol: true
+        })) {
+          debug('redirect to %o', logoConf);
+          res.redirect(logoConf);
+          return;
+        } else {
+          const faviconPath = _path.default.normalize(logoConf);
+          debug('serving favicon from %o', faviconPath);
+          _fs.default.access(faviconPath, _fs.default.constants.R_OK, err => {
+            if (err) {
+              debug('no read permissions to read: %o, reason:', logoConf, err?.message);
+              return res.status(_constants.HTTP_STATUS.NOT_FOUND).end();
+            } else {
+              res.setHeader('content-type', 'image/x-icon');
+              _fs.default.createReadStream(faviconPath).pipe(res);
+              debug('rendered custom ico');
+            }
+          });
+        }
+      } else {
+        res.setHeader('content-type', 'image/x-icon');
+        _fs.default.createReadStream(_path.default.posix.join(__dirname, './web/html/favicon.ico')).pipe(res);
+        debug('rendered ico');
+      }
+    } catch (err) {
+      debug('error triggered, favicon not found %s', err?.message);
+      res.status(_constants.HTTP_STATUS.NOT_FOUND).end();
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfZGVidWciLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9mcyIsIl9sb2Rhc2giLCJfcGF0aCIsIl91cmwiLCJfY29uc3RhbnRzIiwiZSIsIl9fZXNNb2R1bGUiLCJkZWZhdWx0IiwiZGVidWciLCJidWlsZERlYnVnIiwic2VydmVGYXZpY29uIiwiY29uZmlnIiwiX3JlcSIsInJlcyIsImxvZ29Db25mIiwid2ViIiwiZmF2aWNvbiIsInN0YXR1cyIsIl8iLCJpc0VtcHR5IiwiaXNVUkwiLCJyZXF1aXJlX2hvc3QiLCJyZXF1aXJlX3ZhbGlkX3Byb3RvY29sIiwicmVkaXJlY3QiLCJmYXZpY29uUGF0aCIsInBhdGgiLCJub3JtYWxpemUiLCJmcyIsImFjY2VzcyIsImNvbnN0YW50cyIsIlJfT0siLCJlcnIiLCJtZXNzYWdlIiwiSFRUUF9TVEFUVVMiLCJOT1RfRk9VTkQiLCJlbmQiLCJzZXRIZWFkZXIiLCJjcmVhdGVSZWFkU3RyZWFtIiwicGlwZSIsInBvc2l4Iiwiam9pbiIsIl9fZGlybmFtZSJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvbWlkZGxld2FyZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgYnVpbGREZWJ1ZyBmcm9tICdkZWJ1Zyc7XG5pbXBvcnQgZnMgZnJvbSAnZnMnO1xuaW1wb3J0IF8gZnJvbSAnbG9kYXNoJztcbmltcG9ydCBwYXRoIGZyb20gJ3BhdGgnO1xuXG5pbXBvcnQgdHlwZSB7IENvbmZpZyB9IGZyb20gJ0B2ZXJkYWNjaW8vdHlwZXMnO1xuaW1wb3J0IHsgaXNVUkwgfSBmcm9tICdAdmVyZGFjY2lvL3VybCc7XG5cbmltcG9ydCB7IEhUVFBfU1RBVFVTIH0gZnJvbSAnLi4vbGliL2NvbnN0YW50cyc7XG5pbXBvcnQgdHlwZSB7ICRSZXF1ZXN0RXh0ZW5kLCAkUmVzcG9uc2VFeHRlbmQgfSBmcm9tICcuLi90eXBlcyc7XG5cbmNvbnN0IGRlYnVnID0gYnVpbGREZWJ1ZygndmVyZGFjY2lvOm1pZGRsZXdhcmU6ZmF2aWNvbicpO1xuXG5leHBvcnQgZnVuY3Rpb24gc2VydmVGYXZpY29uKGNvbmZpZzogQ29uZmlnKSB7XG4gIHJldHVybiBmdW5jdGlvbiAoX3JlcTogJFJlcXVlc3RFeHRlbmQsIHJlczogJFJlc3BvbnNlRXh0ZW5kKSB7XG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IGxvZ29Db25mOiBzdHJpbmcgPSBjb25maWc/LndlYj8uZmF2aWNvbiBhcyBzdHJpbmc7XG4gICAgICBpZiAobG9nb0NvbmYgPT09ICcnKSB7XG4gICAgICAgIGRlYnVnKCdmYXZpY29uIGRpc2FibGVkJyk7XG4gICAgICAgIHJlcy5zdGF0dXMoNDA0KTtcbiAgICAgIH0gZWxzZSBpZiAoIV8uaXNFbXB0eShsb2dvQ29uZikpIHtcbiAgICAgICAgZGVidWcoJ2N1c3RvbSBmYXZpY29uJyk7XG4gICAgICAgIGlmIChcbiAgICAgICAgICBpc1VSTChsb2dvQ29uZiwge1xuICAgICAgICAgICAgcmVxdWlyZV9ob3N0OiB0cnVlLFxuICAgICAgICAgICAgcmVxdWlyZV92YWxpZF9wcm90b2NvbDogdHJ1ZSxcbiAgICAgICAgICB9KVxuICAgICAgICApIHtcbiAgICAgICAgICBkZWJ1ZygncmVkaXJlY3QgdG8gJW8nLCBsb2dvQ29uZik7XG4gICAgICAgICAgcmVzLnJlZGlyZWN0KGxvZ29Db25mKTtcbiAgICAgICAgICByZXR1cm47XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgY29uc3QgZmF2aWNvblBhdGggPSBwYXRoLm5vcm1hbGl6ZShsb2dvQ29uZik7XG4gICAgICAgICAgZGVidWcoJ3NlcnZpbmcgZmF2aWNvbiBmcm9tICVvJywgZmF2aWNvblBhdGgpO1xuICAgICAgICAgIGZzLmFjY2VzcyhmYXZpY29uUGF0aCwgZnMuY29uc3RhbnRzLlJfT0ssIChlcnIpID0+IHtcbiAgICAgICAgICAgIGlmIChlcnIpIHtcbiAgICAgICAgICAgICAgZGVidWcoJ25vIHJlYWQgcGVybWlzc2lvbnMgdG8gcmVhZDogJW8sIHJlYXNvbjonLCBsb2dvQ29uZiwgZXJyPy5tZXNzYWdlKTtcbiAgICAgICAgICAgICAgcmV0dXJuIHJlcy5zdGF0dXMoSFRUUF9TVEFUVVMuTk9UX0ZPVU5EKS5lbmQoKTtcbiAgICAgICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICAgIHJlcy5zZXRIZWFkZXIoJ2NvbnRlbnQtdHlwZScsICdpbWFnZS94LWljb24nKTtcbiAgICAgICAgICAgICAgZnMuY3JlYXRlUmVhZFN0cmVhbShmYXZpY29uUGF0aCkucGlwZShyZXMpO1xuICAgICAgICAgICAgICBkZWJ1ZygncmVuZGVyZWQgY3VzdG9tIGljbycpO1xuICAgICAgICAgICAgfVxuICAgICAgICAgIH0pO1xuICAgICAgICB9XG4gICAgICB9IGVsc2Uge1xuICAgICAgICByZXMuc2V0SGVhZGVyKCdjb250ZW50LXR5cGUnLCAnaW1hZ2UveC1pY29uJyk7XG4gICAgICAgIGZzLmNyZWF0ZVJlYWRTdHJlYW0ocGF0aC5wb3NpeC5qb2luKF9fZGlybmFtZSwgJy4vd2ViL2h0bWwvZmF2aWNvbi5pY28nKSkucGlwZShyZXMpO1xuICAgICAgICBkZWJ1ZygncmVuZGVyZWQgaWNvJyk7XG4gICAgICB9XG4gICAgfSBjYXRjaCAoZXJyOiBhbnkpIHtcbiAgICAgIGRlYnVnKCdlcnJvciB0cmlnZ2VyZWQsIGZhdmljb24gbm90IGZvdW5kICVzJywgZXJyPy5tZXNzYWdlKTtcbiAgICAgIHJlcy5zdGF0dXMoSFRUUF9TVEFUVVMuTk9UX0ZPVU5EKS5lbmQoKTtcbiAgICB9XG4gIH07XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLElBQUFBLE1BQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFDLEdBQUEsR0FBQUYsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFFLE9BQUEsR0FBQUgsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFHLEtBQUEsR0FBQUosc0JBQUEsQ0FBQUMsT0FBQTtBQUdBLElBQUFJLElBQUEsR0FBQUosT0FBQTtBQUVBLElBQUFLLFVBQUEsR0FBQUwsT0FBQTtBQUErQyxTQUFBRCx1QkFBQU8sQ0FBQSxXQUFBQSxDQUFBLElBQUFBLENBQUEsQ0FBQUMsVUFBQSxHQUFBRCxDQUFBLEtBQUFFLE9BQUEsRUFBQUYsQ0FBQTtBQUcvQyxNQUFNRyxLQUFLLEdBQUcsSUFBQUMsY0FBVSxFQUFDLDhCQUE4QixDQUFDO0FBRWpELFNBQVNDLFlBQVlBLENBQUNDLE1BQWMsRUFBRTtFQUMzQyxPQUFPLFVBQVVDLElBQW9CLEVBQUVDLEdBQW9CLEVBQUU7SUFDM0QsSUFBSTtNQUNGLE1BQU1DLFFBQWdCLEdBQUdILE1BQU0sRUFBRUksR0FBRyxFQUFFQyxPQUFpQjtNQUN2RCxJQUFJRixRQUFRLEtBQUssRUFBRSxFQUFFO1FBQ25CTixLQUFLLENBQUMsa0JBQWtCLENBQUM7UUFDekJLLEdBQUcsQ0FBQ0ksTUFBTSxDQUFDLEdBQUcsQ0FBQztNQUNqQixDQUFDLE1BQU0sSUFBSSxDQUFDQyxlQUFDLENBQUNDLE9BQU8sQ0FBQ0wsUUFBUSxDQUFDLEVBQUU7UUFDL0JOLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQztRQUN2QixJQUNFLElBQUFZLFVBQUssRUFBQ04sUUFBUSxFQUFFO1VBQ2RPLFlBQVksRUFBRSxJQUFJO1VBQ2xCQyxzQkFBc0IsRUFBRTtRQUMxQixDQUFDLENBQUMsRUFDRjtVQUNBZCxLQUFLLENBQUMsZ0JBQWdCLEVBQUVNLFFBQVEsQ0FBQztVQUNqQ0QsR0FBRyxDQUFDVSxRQUFRLENBQUNULFFBQVEsQ0FBQztVQUN0QjtRQUNGLENBQUMsTUFBTTtVQUNMLE1BQU1VLFdBQVcsR0FBR0MsYUFBSSxDQUFDQyxTQUFTLENBQUNaLFFBQVEsQ0FBQztVQUM1Q04sS0FBSyxDQUFDLHlCQUF5QixFQUFFZ0IsV0FBVyxDQUFDO1VBQzdDRyxXQUFFLENBQUNDLE1BQU0sQ0FBQ0osV0FBVyxFQUFFRyxXQUFFLENBQUNFLFNBQVMsQ0FBQ0MsSUFBSSxFQUFHQyxHQUFHLElBQUs7WUFDakQsSUFBSUEsR0FBRyxFQUFFO2NBQ1B2QixLQUFLLENBQUMsMENBQTBDLEVBQUVNLFFBQVEsRUFBRWlCLEdBQUcsRUFBRUMsT0FBTyxDQUFDO2NBQ3pFLE9BQU9uQixHQUFHLENBQUNJLE1BQU0sQ0FBQ2dCLHNCQUFXLENBQUNDLFNBQVMsQ0FBQyxDQUFDQyxHQUFHLENBQUMsQ0FBQztZQUNoRCxDQUFDLE1BQU07Y0FDTHRCLEdBQUcsQ0FBQ3VCLFNBQVMsQ0FBQyxjQUFjLEVBQUUsY0FBYyxDQUFDO2NBQzdDVCxXQUFFLENBQUNVLGdCQUFnQixDQUFDYixXQUFXLENBQUMsQ0FBQ2MsSUFBSSxDQUFDekIsR0FBRyxDQUFDO2NBQzFDTCxLQUFLLENBQUMscUJBQXFCLENBQUM7WUFDOUI7VUFDRixDQUFDLENBQUM7UUFDSjtNQUNGLENBQUMsTUFBTTtRQUNMSyxHQUFHLENBQUN1QixTQUFTLENBQUMsY0FBYyxFQUFFLGNBQWMsQ0FBQztRQUM3Q1QsV0FBRSxDQUFDVSxnQkFBZ0IsQ0FBQ1osYUFBSSxDQUFDYyxLQUFLLENBQUNDLElBQUksQ0FBQ0MsU0FBUyxFQUFFLHdCQUF3QixDQUFDLENBQUMsQ0FBQ0gsSUFBSSxDQUFDekIsR0FBRyxDQUFDO1FBQ25GTCxLQUFLLENBQUMsY0FBYyxDQUFDO01BQ3ZCO0lBQ0YsQ0FBQyxDQUFDLE9BQU91QixHQUFRLEVBQUU7TUFDakJ2QixLQUFLLENBQUMsdUNBQXVDLEVBQUV1QixHQUFHLEVBQUVDLE9BQU8sQ0FBQztNQUM1RG5CLEdBQUcsQ0FBQ0ksTUFBTSxDQUFDZ0Isc0JBQVcsQ0FBQ0MsU0FBUyxDQUFDLENBQUNDLEdBQUcsQ0FBQyxDQUFDO0lBQ3pDO0VBQ0YsQ0FBQztBQUNIIiwiaWdub3JlTGlzdCI6W119

package/build/api/web/api/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _express = require("express");
+var _middleware = require("@verdaccio/middleware");
+var _utils = require("../../../lib/utils");
+var _package = _interopRequireDefault(require("./package"));
+var _search = _interopRequireDefault(require("./search"));
+var _user = _interopRequireDefault(require("./user"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = (auth, storage, config) => {
+  const router = (0, _express.Router)();
+  router.use((0, _middleware.rateLimit)({
+    windowMs: 2 * 60 * 1000,
+    // 2  minutes
+    max: 5000,
+    // limit each IP to 1000 requests per windowMs
+    ...config?.web?.rateLimit
+  }));
+  router.use((0, _package.default)(storage, auth, config));
+  router.use((0, _search.default)(storage, auth));
+  if ((0, _utils.hasLogin)(config)) {
+    router.use((0, _user.default)(auth, storage));
+  }
+  return router;
+};
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/api/web/api/package.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _express = require("express");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _config = require("@verdaccio/config");
+var _middleware = require("@verdaccio/middleware");
+var _tarball = require("@verdaccio/tarball");
+var _utils = require("@verdaccio/utils");
+var _constants = require("../../../lib/constants");
+var _logger = require("../../../lib/logger");
+var _utils2 = require("../../../lib/utils");
+var _utils3 = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const getOrder = (order = 'asc') => {
+  return order === 'asc';
+};
+function addPackageWebApi(storage, auth, config) {
+  /* eslint new-cap:off */
+  const pkgRouter = (0, _express.Router)();
+  const can = (0, _middleware.allow)(auth, {
+    beforeAll: (params, message) => {
+      _logger.logger.debug(params, message);
+    },
+    afterAll: (params, message) => _logger.logger.debug(params, message)
+  });
+  const checkAllow = (name, remoteUser) => new Promise((resolve, reject) => {
+    try {
+      const isLoginEnabled = _lodash.default.isNil(config?.web?.login) || config?.web?.login === true;
+      const anonymousRemoteUser = (0, _config.createAnonymousRemoteUser)();
+      const remoteUserAccess = !isLoginEnabled ? anonymousRemoteUser : remoteUser;
+      auth.allow_access({
+        packageName: name
+      }, remoteUserAccess, (err, allowed) => {
+        if (err) {
+          resolve(false);
+        }
+        resolve(allowed);
+      });
+    } catch (err) {
+      reject(err);
+    }
+  });
+
+  // Get list of all visible package
+  pkgRouter.get((0, _utils3.wrapPath)(_middleware.WebUrls.packages_all), function (req, res, next) {
+    storage.getLocalDatabase(async function (err, packages) {
+      if (err) {
+        throw err;
+      }
+      async function processPackages(packages = []) {
+        const permissions = [];
+        const packgesCopy = packages.slice();
+        for (const pkg of packgesCopy) {
+          const pkgCopy = {
+            ...pkg
+          };
+          pkgCopy.author = (0, _utils.formatAuthor)(pkg.author);
+          try {
+            const isAllowed = await checkAllow(pkg.name, req.remote_user);
+            if (isAllowed) {
+              if (config.web) {
+                pkgCopy.author.avatar = (0, _utils.generateGravatarUrl)(pkgCopy.author.email, config.web.gravatar);
+              }
+              if (!_lodash.default.isNil(pkgCopy.dist) && !_lodash.default.isNull(pkgCopy.dist.tarball)) {
+                pkgCopy.dist.tarball = (0, _tarball.getLocalRegistryTarballUri)(pkgCopy.dist.tarball, pkg.name, {
+                  protocol: req.protocol,
+                  headers: req.headers,
+                  host: req.hostname
+                }, config.url_prefix);
+              }
+              permissions.push(pkgCopy);
+            }
+          } catch (err) {
+            _logger.logger.error({
+              name: pkg.name,
+              error: err
+            }, 'permission process for @{name} has failed: @{error}');
+            throw err;
+          }
+        }
+        return permissions;
+      }
+      const order = config.web ? getOrder(config.web?.sort_packages) : true;
+      try {
+        next((0, _utils2.sortByName)(await processPackages(packages), order));
+      } catch (error) {
+        next(_utils2.ErrorCode.getInternalError(error.message));
+      }
+    });
+  });
+
+  // Get package readme
+  pkgRouter.get([(0, _utils3.wrapPath)(_middleware.WebUrls.readme_package_scoped_version), (0, _utils3.wrapPath)(_middleware.WebUrls.readme_package_version)], can('access'), function (req, res, next) {
+    const rawScope = req.params.scope; // May include '@'
+    const scope = rawScope ? rawScope.slice(1) : null; // Remove '@' if present
+    const packageName = scope ? (0, _utils2.addScope)(scope, req.params.package) : req.params.package;
+    storage.getPackage({
+      name: packageName,
+      uplinksLook: true,
+      req,
+      callback: function (err, info) {
+        if (err) {
+          return next(err);
+        }
+        res.set(_constants.HEADER_TYPE.CONTENT_TYPE, _constants.HEADERS.TEXT_PLAIN);
+        next((0, _utils2.parseReadme)(info.name, info.readme));
+      }
+    });
+  });
+  pkgRouter.get([(0, _utils3.wrapPath)(_middleware.WebUrls.sidebar_scopped_package), (0, _utils3.wrapPath)(_middleware.WebUrls.sidebar_package)], can('access'), function (req, res, next) {
+    const rawScope = req.params.scope; // May include '@'
+    const scope = rawScope ? rawScope.slice(1) : null; // Remove '@' if present
+    const packageName = scope ? (0, _utils2.addScope)(scope, req.params.package) : req.params.package;
+    storage.getPackage({
+      name: packageName,
+      uplinksLook: true,
+      keepUpLinkData: true,
+      req,
+      callback: function (err, info) {
+        if (_lodash.default.isNil(err)) {
+          const {
+            v
+          } = req.query;
+          let sideBarInfo = _lodash.default.clone(info);
+          sideBarInfo.versions = (0, _tarball.convertDistRemoteToLocalTarballUrls)(info, {
+            protocol: req.protocol,
+            headers: req.headers,
+            host: req.hostname
+          }, config.url_prefix).versions;
+          if ((0, _utils2.isVersionValid)(info, v)) {
+            // @ts-ignore
+            sideBarInfo.latest = sideBarInfo.versions[v];
+            sideBarInfo.latest.author = (0, _utils.formatAuthor)(sideBarInfo.latest.author);
+          } else {
+            sideBarInfo.latest = sideBarInfo.versions[info[_constants.DIST_TAGS].latest];
+            if (sideBarInfo?.latest) {
+              sideBarInfo.latest.author = (0, _utils.formatAuthor)(sideBarInfo.latest.author);
+            } else {
+              res.status(_constants.HTTP_STATUS.NOT_FOUND);
+              res.end();
+              return;
+            }
+          }
+          sideBarInfo = (0, _utils2.deleteProperties)(['readme', '_attachments', '_rev', 'name'], sideBarInfo);
+          if (config.web) {
+            sideBarInfo = (0, _utils.addGravatarSupport)(sideBarInfo, config.web.gravatar);
+          } else {
+            sideBarInfo = (0, _utils.addGravatarSupport)(sideBarInfo);
+          }
+          next(sideBarInfo);
+        } else {
+          res.status(_constants.HTTP_STATUS.NOT_FOUND);
+          res.end();
+        }
+      }
+    });
+  });
+  return pkgRouter;
+}
+var _default = exports.default = addPackageWebApi;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_express","require","_lodash","_interopRequireDefault","_config","_middleware","_tarball","_utils","_constants","_logger","_utils2","_utils3","e","__esModule","default","getOrder","order","addPackageWebApi","storage","auth","config","pkgRouter","Router","can","allow","beforeAll","params","message","logger","debug","afterAll","checkAllow","name","remoteUser","Promise","resolve","reject","isLoginEnabled","_","isNil","web","login","anonymousRemoteUser","createAnonymousRemoteUser","remoteUserAccess","allow_access","packageName","err","allowed","get","wrapPath","WebUrls","packages_all","req","res","next","getLocalDatabase","packages","processPackages","permissions","packgesCopy","slice","pkg","pkgCopy","author","formatAuthor","isAllowed","remote_user","avatar","generateGravatarUrl","email","gravatar","dist","isNull","tarball","getLocalRegistryTarballUri","protocol","headers","host","hostname","url_prefix","push","error","sort_packages","sortByName","ErrorCode","getInternalError","readme_package_scoped_version","readme_package_version","rawScope","scope","addScope","package","getPackage","uplinksLook","callback","info","set","HEADER_TYPE","CONTENT_TYPE","HEADERS","TEXT_PLAIN","parseReadme","readme","sidebar_scopped_package","sidebar_package","keepUpLinkData","v","query","sideBarInfo","clone","versions","convertDistRemoteToLocalTarballUrls","isVersionValid","latest","DIST_TAGS","status","HTTP_STATUS","NOT_FOUND","end","deleteProperties","addGravatarSupport","_default","exports"],"sources":["../../../../src/api/web/api/package.ts"],"sourcesContent":["import { Router } from 'express';\nimport _ from 'lodash';\n\nimport type { Auth } from '@verdaccio/auth';\nimport { createAnonymousRemoteUser } from '@verdaccio/config';\nimport { WebUrls, allow } from '@verdaccio/middleware';\nimport {\n  convertDistRemoteToLocalTarballUrls,\n  getLocalRegistryTarballUri,\n} from '@verdaccio/tarball';\nimport type { Config, Manifest, RemoteUser } from '@verdaccio/types';\nimport { addGravatarSupport, formatAuthor, generateGravatarUrl } from '@verdaccio/utils';\n\nimport { DIST_TAGS, HEADERS, HEADER_TYPE, HTTP_STATUS } from '../../../lib/constants';\nimport { logger } from '../../../lib/logger';\nimport type Storage from '../../../lib/storage';\nimport {\n  ErrorCode,\n  addScope,\n  deleteProperties,\n  isVersionValid,\n  parseReadme,\n  sortByName,\n} from '../../../lib/utils';\nimport type {\n  $NextFunctionVer,\n  $RequestExtend,\n  $ResponseExtend,\n  $SidebarPackage,\n} from '../../../types';\nimport { wrapPath } from './utils';\n\nconst getOrder = (order = 'asc') => {\n  return order === 'asc';\n};\n\nexport type PackcageExt = Manifest & { author: any; dist?: { tarball: string } };\n\nfunction addPackageWebApi(storage: Storage, auth: Auth, config: Config): Router {\n  /* eslint new-cap:off */\n  const pkgRouter = Router();\n  const can = allow(auth, {\n    beforeAll: (params, message) => {\n      logger.debug(params, message);\n    },\n    afterAll: (params, message) => logger.debug(params, message),\n  });\n\n  const checkAllow = (name, remoteUser): Promise<boolean> =>\n    new Promise((resolve, reject): void => {\n      try {\n        const isLoginEnabled = _.isNil(config?.web?.login) || config?.web?.login === true;\n        const anonymousRemoteUser: RemoteUser = createAnonymousRemoteUser();\n        const remoteUserAccess = !isLoginEnabled ? anonymousRemoteUser : remoteUser;\n        auth.allow_access({ packageName: name }, remoteUserAccess, (err, allowed): void => {\n          if (err) {\n            resolve(false);\n          }\n          resolve(allowed as boolean);\n        });\n      } catch (err) {\n        reject(err);\n      }\n    });\n\n  // Get list of all visible package\n  pkgRouter.get(\n    wrapPath(WebUrls.packages_all),\n    function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n      storage.getLocalDatabase(async function (err, packages): Promise<void> {\n        if (err) {\n          throw err;\n        }\n\n        async function processPackages(packages: PackcageExt[] = []): Promise<any> {\n          const permissions: PackcageExt[] = [];\n          const packgesCopy = packages.slice();\n          for (const pkg of packgesCopy) {\n            const pkgCopy = { ...pkg };\n            pkgCopy.author = formatAuthor(pkg.author);\n            try {\n              const isAllowed = await checkAllow(pkg.name, req.remote_user);\n              if (isAllowed) {\n                if (config.web) {\n                  pkgCopy.author.avatar = generateGravatarUrl(\n                    pkgCopy.author.email,\n                    config.web.gravatar\n                  );\n                }\n                if (!_.isNil(pkgCopy.dist) && !_.isNull(pkgCopy.dist.tarball)) {\n                  pkgCopy.dist.tarball = getLocalRegistryTarballUri(\n                    pkgCopy.dist.tarball,\n                    pkg.name,\n                    { protocol: req.protocol, headers: req.headers as any, host: req.hostname },\n                    config.url_prefix\n                  );\n                }\n                permissions.push(pkgCopy);\n              }\n            } catch (err) {\n              logger.error(\n                { name: pkg.name, error: err },\n                'permission process for @{name} has failed: @{error}'\n              );\n              throw err;\n            }\n          }\n\n          return permissions;\n        }\n\n        const order: boolean = config.web ? getOrder(config.web?.sort_packages) : true;\n\n        try {\n          next(sortByName(await processPackages(packages), order));\n        } catch (error: any) {\n          next(ErrorCode.getInternalError(error.message));\n        }\n      });\n    }\n  );\n\n  // Get package readme\n  pkgRouter.get(\n    [wrapPath(WebUrls.readme_package_scoped_version), wrapPath(WebUrls.readme_package_version)],\n    can('access'),\n    function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n      const rawScope = req.params.scope; // May include '@'\n      const scope = rawScope ? rawScope.slice(1) : null; // Remove '@' if present\n      const packageName = scope ? addScope(scope, req.params.package) : req.params.package;\n\n      storage.getPackage({\n        name: packageName,\n        uplinksLook: true,\n        req,\n        callback: function (err, info): void {\n          if (err) {\n            return next(err);\n          }\n\n          res.set(HEADER_TYPE.CONTENT_TYPE, HEADERS.TEXT_PLAIN);\n          next(parseReadme(info.name, info.readme));\n        },\n      });\n    }\n  );\n\n  pkgRouter.get(\n    [wrapPath(WebUrls.sidebar_scopped_package), wrapPath(WebUrls.sidebar_package)],\n    can('access'),\n    function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n      const rawScope = req.params.scope; // May include '@'\n      const scope = rawScope ? rawScope.slice(1) : null; // Remove '@' if present\n      const packageName: string = scope ? addScope(scope, req.params.package) : req.params.package;\n\n      storage.getPackage({\n        name: packageName,\n        uplinksLook: true,\n        keepUpLinkData: true,\n        req,\n        callback: function (err: Error, info: $SidebarPackage): void {\n          if (_.isNil(err)) {\n            const { v } = req.query;\n            let sideBarInfo: any = _.clone(info);\n            sideBarInfo.versions = convertDistRemoteToLocalTarballUrls(\n              info,\n              { protocol: req.protocol, headers: req.headers as any, host: req.hostname },\n              config.url_prefix\n            ).versions;\n            if (isVersionValid(info, v)) {\n              // @ts-ignore\n              sideBarInfo.latest = sideBarInfo.versions[v];\n              sideBarInfo.latest.author = formatAuthor(sideBarInfo.latest.author);\n            } else {\n              sideBarInfo.latest = sideBarInfo.versions[info[DIST_TAGS].latest];\n              if (sideBarInfo?.latest) {\n                sideBarInfo.latest.author = formatAuthor(sideBarInfo.latest.author);\n              } else {\n                res.status(HTTP_STATUS.NOT_FOUND);\n                res.end();\n                return;\n              }\n            }\n            sideBarInfo = deleteProperties(['readme', '_attachments', '_rev', 'name'], sideBarInfo);\n            if (config.web) {\n              sideBarInfo = addGravatarSupport(sideBarInfo, config.web.gravatar);\n            } else {\n              sideBarInfo = addGravatarSupport(sideBarInfo);\n            }\n            next(sideBarInfo);\n          } else {\n            res.status(HTTP_STATUS.NOT_FOUND);\n            res.end();\n          }\n        },\n      });\n    }\n  );\n\n  return pkgRouter;\n}\n\nexport default addPackageWebApi;\n"],"mappings":"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","ignoreList":[]}

package/build/api/web/api/search.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _express = require("express");
+var _middleware = require("@verdaccio/middleware");
+var _searchIndexer = require("@verdaccio/search-indexer");
+var _constants = require("../../../lib/constants");
+var _utils = require("./utils");
+function addSearchWebApi(storage, auth) {
+  /* eslint new-cap:off */
+  const route = (0, _express.Router)();
+  // Search package
+  route.get((0, _utils.wrapPath)(_middleware.WebUrls.search), async function (req, _res, next) {
+    const term = req.params.anything;
+    const indexer = await _searchIndexer.SearchMemoryIndexer.query(term);
+    const packages = [];
+    const results = indexer.hits;
+    const getPackageInfo = function (i) {
+      storage.getPackage({
+        name: results[i].id,
+        uplinksLook: false,
+        callback: (err, entry) => {
+          if (!err && entry) {
+            auth.allow_access({
+              packageName: entry.name
+            }, req.remote_user, function (err, allowed) {
+              if (err || !allowed) {
+                return;
+              }
+              packages.push(entry.versions[entry[_constants.DIST_TAGS].latest]);
+            });
+          }
+          if (i >= results.length - 1) {
+            next(packages);
+          } else {
+            getPackageInfo(i + 1);
+          }
+        }
+      });
+    };
+    if (results.length) {
+      getPackageInfo(0);
+    } else {
+      next([]);
+    }
+  });
+  return route;
+}
+var _default = exports.default = addSearchWebApi;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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