@verdaccio/canary 6.3.2-canary.404363f

package/build/lib/logger/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+exports.setup = setup;
+var _debug = _interopRequireDefault(require("debug"));
+var _logger = require("@verdaccio/logger");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let logger = exports.logger = void 0;
+const debug = (0, _debug.default)('verdaccio:logger');
+function setup(options) {
+  debug('setup logger with options %o', options);
+  if (!logger) {
+    debug('logger not initialized, setting up');
+    exports.logger = logger = (0, _logger.setup)(options);
+    debug('logger initialized');
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfZGVidWciLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9sb2dnZXIiLCJlIiwiX19lc01vZHVsZSIsImRlZmF1bHQiLCJsb2dnZXIiLCJleHBvcnRzIiwiZGVidWciLCJjcmVhdGVEZWJ1ZyIsInNldHVwIiwib3B0aW9ucyIsInNldHVwTW9kdWxlIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9sb2dnZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGNyZWF0ZURlYnVnIGZyb20gJ2RlYnVnJztcblxuaW1wb3J0IHsgc2V0dXAgYXMgc2V0dXBNb2R1bGUgfSBmcm9tICdAdmVyZGFjY2lvL2xvZ2dlcic7XG5pbXBvcnQgeyBMb2dnZXIgfSBmcm9tICdAdmVyZGFjY2lvL3R5cGVzJztcblxubGV0IGxvZ2dlcjogTG9nZ2VyO1xuXG5jb25zdCBkZWJ1ZyA9IGNyZWF0ZURlYnVnKCd2ZXJkYWNjaW86bG9nZ2VyJyk7XG5cbnR5cGUgU2V0dXBNb2R1bGVPcHRpb25zID0gUGFyYW1ldGVyczx0eXBlb2Ygc2V0dXBNb2R1bGU+WzBdO1xuXG5leHBvcnQgZnVuY3Rpb24gc2V0dXAob3B0aW9uczogU2V0dXBNb2R1bGVPcHRpb25zKTogdm9pZCB7XG4gIGRlYnVnKCdzZXR1cCBsb2dnZXIgd2l0aCBvcHRpb25zICVvJywgb3B0aW9ucyk7XG4gIGlmICghbG9nZ2VyKSB7XG4gICAgZGVidWcoJ2xvZ2dlciBub3QgaW5pdGlhbGl6ZWQsIHNldHRpbmcgdXAnKTtcbiAgICBsb2dnZXIgPSBzZXR1cE1vZHVsZShvcHRpb25zKTtcbiAgICBkZWJ1ZygnbG9nZ2VyIGluaXRpYWxpemVkJyk7XG4gIH1cbn1cblxuZXhwb3J0IHsgbG9nZ2VyIH07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQSxJQUFBQSxNQUFBLEdBQUFDLHNCQUFBLENBQUFDLE9BQUE7QUFFQSxJQUFBQyxPQUFBLEdBQUFELE9BQUE7QUFBeUQsU0FBQUQsdUJBQUFHLENBQUEsV0FBQUEsQ0FBQSxJQUFBQSxDQUFBLENBQUFDLFVBQUEsR0FBQUQsQ0FBQSxLQUFBRSxPQUFBLEVBQUFGLENBQUE7QUFHekQsSUFBSUcsTUFBYyxHQUFBQyxPQUFBLENBQUFELE1BQUE7QUFFbEIsTUFBTUUsS0FBSyxHQUFHLElBQUFDLGNBQVcsRUFBQyxrQkFBa0IsQ0FBQztBQUl0QyxTQUFTQyxLQUFLQSxDQUFDQyxPQUEyQixFQUFRO0VBQ3ZESCxLQUFLLENBQUMsOEJBQThCLEVBQUVHLE9BQU8sQ0FBQztFQUM5QyxJQUFJLENBQUNMLE1BQU0sRUFBRTtJQUNYRSxLQUFLLENBQUMsb0NBQW9DLENBQUM7SUFDM0NELE9BQUEsQ0FBQUQsTUFBQSxHQUFBQSxNQUFNLEdBQUcsSUFBQU0sYUFBVyxFQUFDRCxPQUFPLENBQUM7SUFDN0JILEtBQUssQ0FBQyxvQkFBb0IsQ0FBQztFQUM3QjtBQUNGIiwiaWdub3JlTGlzdCI6W119

package/build/lib/metadata-utils.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeVersions = mergeVersions;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _semver = _interopRequireDefault(require("semver"));
+var _constants = require("./constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Function gets a local info and an info from uplinks and tries to merge it
+ exported for unit tests only.
+  * @param {*} local
+  * @param {*} up
+  * @param {*} config
+  * @static
+  */
+function mergeVersions(local, up) {
+  // copy new versions to a cache
+  // NOTE: if a certain version was updated, we can't refresh it reliably
+  for (const i in up.versions) {
+    if (_lodash.default.isNil(local.versions[i])) {
+      local.versions[i] = up.versions[i];
+    }
+  }
+  for (const i in up[_constants.DIST_TAGS]) {
+    if (local[_constants.DIST_TAGS][i] !== up[_constants.DIST_TAGS][i]) {
+      if (!local[_constants.DIST_TAGS][i] || _semver.default.lte(local[_constants.DIST_TAGS][i], up[_constants.DIST_TAGS][i])) {
+        local[_constants.DIST_TAGS][i] = up[_constants.DIST_TAGS][i];
+      }
+      if (i === 'latest' && local[_constants.DIST_TAGS][i] === up[_constants.DIST_TAGS][i]) {
+        // if remote has more fresh package, we should borrow its readme
+        local.readme = up.readme;
+      }
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/run-server.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createServerFactory = createServerFactory;
+exports.runServer = runServer;
+var _constants = _interopRequireDefault(require("constants"));
+var _debug = _interopRequireDefault(require("debug"));
+var _fs = _interopRequireDefault(require("fs"));
+var _http = _interopRequireDefault(require("http"));
+var _https = _interopRequireDefault(require("https"));
+var _lodash = require("lodash");
+var _config = require("@verdaccio/config");
+var _index = _interopRequireDefault(require("../api/index"));
+var _experiments = require("./experiments");
+var _logger = require("./logger");
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:run-server');
+
+/**
+ * Exposes a server factory to be instantiated programmatically.
+ *
+    const app = await runServer(); // default configuration
+    const app = await runServer('./config/config.yaml');
+    const app = await runServer({ configuration });
+    app.listen(4000, (event) => {
+      // do something
+    });
+ * @param config
+ */
+async function runServer(config, options) {
+  const configurationParsed = (0, _config.getConfigParsed)(config);
+  (0, _utils.initLogger)(configurationParsed);
+  // merge flags and experiments for backward compatibility
+  const flags = {
+    ...(configurationParsed?.flags || {}),
+    ...(configurationParsed?.experiments || {})
+  };
+  (0, _experiments.displayExperimentsInfoBox)(flags);
+  const listen = options?.listenArg ?? configurationParsed?.listen;
+  const address = (0, _config.getListenAddress)(listen, _logger.logger);
+  const app = await (0, _index.default)(configurationParsed);
+  return createServerFactory(configurationParsed, address, app);
+}
+
+/**
+ * Return a native HTTP/HTTPS server instance
+ * @param config
+ * @param addr
+ * @param app
+ */
+function createServerFactory(config, addr, app) {
+  let serverFactory;
+  if (addr.proto === 'https') {
+    debug('https enabled');
+    try {
+      let httpsOptions = {
+        // disable insecure SSLv2 and SSLv3
+        secureOptions: _constants.default.SSL_OP_NO_SSLv2 | _constants.default.SSL_OP_NO_SSLv3
+      };
+      const keyCertConfig = config.https;
+      const pfxConfig = config.https;
+
+      // https must either have key and cert or a pfx and (optionally) a passphrase
+      if (!(keyCertConfig.key && keyCertConfig.cert || pfxConfig.pfx)) {
+        throw Error('bad format https configuration');
+      }
+      if (pfxConfig.pfx) {
+        const {
+          pfx,
+          passphrase
+        } = pfxConfig;
+        httpsOptions = (0, _lodash.assign)(httpsOptions, {
+          pfx: _fs.default.readFileSync(pfx),
+          passphrase: passphrase || ''
+        });
+      } else {
+        const {
+          key,
+          cert,
+          ca
+        } = keyCertConfig;
+        httpsOptions = (0, _lodash.assign)(httpsOptions, {
+          key: _fs.default.readFileSync(key),
+          cert: _fs.default.readFileSync(cert),
+          ...(ca && {
+            ca: _fs.default.readFileSync(ca)
+          })
+        });
+      }
+      // TODO: enable http2 as feature
+      // if (config.server.http2) <-- check if force http2
+      serverFactory = _https.default.createServer(httpsOptions, app);
+    } catch (err) {
+      _logger.logger.fatal({
+        err: err
+      }, 'cannot create server: @{err.message}');
+      process.exit(2);
+    }
+  } else {
+    // http
+    debug('http enabled');
+    serverFactory = _http.default.createServer(app);
+  }
+  if (config.server && typeof config.server.keepAliveTimeout !== 'undefined' &&
+  // @ts-ignore
+  config.server.keepAliveTimeout !== 'null') {
+    // library definition for node is not up to date (doesn't contain recent 8.0 changes)
+    serverFactory.keepAliveTimeout = config.server.keepAliveTimeout * 1000;
+  }
+  // FIXE: I could not find the reason of this code.
+  unlinkAddressPath(addr);
+  return serverFactory;
+}
+function unlinkAddressPath(addr) {
+  if (addr.path && _fs.default.existsSync(addr.path)) {
+    _fs.default.unlinkSync(addr.path);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_constants","_interopRequireDefault","require","_debug","_fs","_http","_https","_lodash","_config","_index","_experiments","_logger","_utils","e","__esModule","default","debug","buildDebug","runServer","config","options","configurationParsed","getConfigParsed","initLogger","flags","experiments","displayExperimentsInfoBox","listen","listenArg","address","getListenAddress","logger","app","endPointAPI","createServerFactory","addr","serverFactory","proto","httpsOptions","secureOptions","constants","SSL_OP_NO_SSLv2","SSL_OP_NO_SSLv3","keyCertConfig","https","pfxConfig","key","cert","pfx","Error","passphrase","assign","fs","readFileSync","ca","createServer","err","fatal","process","exit","http","server","keepAliveTimeout","unlinkAddressPath","path","existsSync","unlinkSync"],"sources":["../../src/lib/run-server.ts"],"sourcesContent":["import constants from 'constants';\nimport buildDebug from 'debug';\nimport fs from 'fs';\nimport http from 'http';\nimport https from 'https';\nimport { assign } from 'lodash';\n\nimport { getConfigParsed, getListenAddress } from '@verdaccio/config';\nimport { ConfigYaml, HttpsConfKeyCert, HttpsConfPfx } from '@verdaccio/types';\n\nimport endPointAPI from '../api/index';\nimport { displayExperimentsInfoBox } from './experiments';\nimport { logger } from './logger';\nimport { initLogger } from './utils';\n\nconst debug = buildDebug('verdaccio:run-server');\n\n/**\n * Exposes a server factory to be instantiated programmatically.\n *\n    const app = await runServer(); // default configuration\n    const app = await runServer('./config/config.yaml');\n    const app = await runServer({ configuration });\n    app.listen(4000, (event) => {\n      // do something\n    });\n * @param config\n */\nexport async function runServer(\n  config?: string | ConfigYaml,\n  options?: { listenArg?: string }\n): Promise<any> {\n  const configurationParsed = getConfigParsed(config);\n\n  initLogger(configurationParsed);\n  // merge flags and experiments for backward compatibility\n  const flags = {\n    ...(configurationParsed?.flags || {}),\n    ...(configurationParsed?.experiments || {}),\n  };\n  displayExperimentsInfoBox(flags);\n\n  const listen = options?.listenArg ?? configurationParsed?.listen;\n  const address = getListenAddress(listen, logger);\n\n  const app = await endPointAPI(configurationParsed);\n  return createServerFactory(configurationParsed, address, app);\n}\n\n/**\n * Return a native HTTP/HTTPS server instance\n * @param config\n * @param addr\n * @param app\n */\nexport function createServerFactory(config: ConfigYaml, addr, app) {\n  let serverFactory;\n  if (addr.proto === 'https') {\n    debug('https enabled');\n    try {\n      let httpsOptions = {\n        // disable insecure SSLv2 and SSLv3\n        secureOptions: constants.SSL_OP_NO_SSLv2 | constants.SSL_OP_NO_SSLv3,\n      };\n\n      const keyCertConfig = config.https as HttpsConfKeyCert;\n      const pfxConfig = config.https as HttpsConfPfx;\n\n      // https must either have key and cert or a pfx and (optionally) a passphrase\n      if (!((keyCertConfig.key && keyCertConfig.cert) || pfxConfig.pfx)) {\n        throw Error('bad format https configuration');\n      }\n\n      if (pfxConfig.pfx) {\n        const { pfx, passphrase } = pfxConfig;\n        httpsOptions = assign(httpsOptions, {\n          pfx: fs.readFileSync(pfx),\n          passphrase: passphrase || '',\n        });\n      } else {\n        const { key, cert, ca } = keyCertConfig;\n        httpsOptions = assign(httpsOptions, {\n          key: fs.readFileSync(key),\n          cert: fs.readFileSync(cert),\n          ...(ca && {\n            ca: fs.readFileSync(ca),\n          }),\n        });\n      }\n      // TODO: enable http2 as feature\n      // if (config.server.http2) <-- check if force http2\n      serverFactory = https.createServer(httpsOptions, app);\n    } catch (err: any) {\n      logger.fatal({ err: err }, 'cannot create server: @{err.message}');\n      process.exit(2);\n    }\n  } else {\n    // http\n    debug('http enabled');\n    serverFactory = http.createServer(app);\n  }\n\n  if (\n    config.server &&\n    typeof config.server.keepAliveTimeout !== 'undefined' &&\n    // @ts-ignore\n    config.server.keepAliveTimeout !== 'null'\n  ) {\n    // library definition for node is not up to date (doesn't contain recent 8.0 changes)\n    serverFactory.keepAliveTimeout = config.server.keepAliveTimeout * 1000;\n  }\n  // FIXE: I could not find the reason of this code.\n  unlinkAddressPath(addr);\n\n  return serverFactory;\n}\n\nfunction unlinkAddressPath(addr) {\n  if (addr.path && fs.existsSync(addr.path)) {\n    fs.unlinkSync(addr.path);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/lib/storage-utils.js

@@ -0,0 +1,282 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WHITELIST = void 0;
+exports.checkPackageLocal = checkPackageLocal;
+exports.checkPackageRemote = checkPackageRemote;
+exports.cleanUpLinksRef = cleanUpLinksRef;
+exports.cleanUpReadme = cleanUpReadme;
+exports.convertAbbreviatedManifest = convertAbbreviatedManifest;
+exports.generatePackageTemplate = generatePackageTemplate;
+exports.generateRevision = generateRevision;
+exports.getLatestReadme = getLatestReadme;
+exports.hasInstallScript = hasInstallScript;
+exports.isPublishablePackage = isPublishablePackage;
+exports.mergeUplinkTimeIntoLocal = mergeUplinkTimeIntoLocal;
+exports.normalizePackage = normalizePackage;
+exports.prepareSearchPackage = prepareSearchPackage;
+exports.publishPackage = publishPackage;
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _core = require("@verdaccio/core");
+var _searchIndexer = require("@verdaccio/search-indexer");
+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:storage-utils');
+function generatePackageTemplate(name) {
+  return {
+    // standard things
+    name,
+    versions: {},
+    time: {},
+    [_constants.USERS]: {},
+    [_constants.DIST_TAGS]: {},
+    _uplinks: {},
+    _distfiles: {},
+    _attachments: {},
+    _rev: ''
+  };
+}
+
+/**
+ * Normalize package properties, tags, revision id.
+ * @param {Object} pkg package reference.
+ */
+function normalizePackage(pkg) {
+  const pkgProperties = ['versions', 'dist-tags', '_distfiles', '_attachments', '_uplinks', 'time'];
+  pkgProperties.forEach(key => {
+    const pkgProp = pkg[key];
+    if (_lodash.default.isNil(pkgProp) || (0, _utils2.isObject)(pkgProp) === false) {
+      pkg[key] = {};
+    }
+  });
+  if (_lodash.default.isString(pkg._rev) === false) {
+    pkg._rev = _constants.STORAGE.DEFAULT_REVISION;
+  }
+  if (_lodash.default.isString(pkg._id) === false) {
+    pkg._id = pkg.name;
+  }
+
+  // normalize dist-tags
+  (0, _utils2.normalizeDistTags)(pkg);
+  return pkg;
+}
+function generateRevision(rev) {
+  const _rev = rev.split('-');
+  return (+_rev[0] || 0) + 1 + '-' + (0, _utils.generateRandomHexString)();
+}
+function getLatestReadme(pkg) {
+  const versions = pkg['versions'] || {};
+  const distTags = pkg[_constants.DIST_TAGS] || {};
+  // FIXME: here is a bit tricky add the types
+  const latestVersion = distTags['latest'] ? versions[distTags['latest']] || {} : {};
+  let readme = _lodash.default.trim(pkg.readme || latestVersion.readme || '');
+  if (readme) {
+    return readme;
+  }
+
+  // In case of empty readme - trying to get ANY readme in the following order: 'next','beta','alpha','test','dev','canary'
+  const readmeDistTagsPriority = ['next', 'beta', 'alpha', 'test', 'dev', 'canary'];
+  readmeDistTagsPriority.map(function (tag) {
+    if (readme) {
+      return readme;
+    }
+    const version = distTags[tag] ? versions[distTags[tag]] || {} : {};
+    readme = _lodash.default.trim(version.readme || readme);
+  });
+  return readme;
+}
+function cleanUpReadme(version) {
+  if (_lodash.default.isNil(version) === false) {
+    // @ts-ignore
+    delete version.readme;
+  }
+  return version;
+}
+const WHITELIST = exports.WHITELIST = ['_rev', 'name', 'versions', 'dist-tags', 'readme', 'time', '_id', 'users'];
+function cleanUpLinksRef(keepUpLinkData, result) {
+  const propertyToKeep = [...WHITELIST];
+  if (keepUpLinkData === true) {
+    propertyToKeep.push('_uplinks');
+  }
+  for (const i in result) {
+    if (propertyToKeep.indexOf(i) === -1) {
+      // Remove sections like '_uplinks' from response
+      delete result[i];
+    }
+  }
+  return result;
+}
+
+/**
+ * Check whether a package it is already a local package
+ * @param {*} name
+ * @param {*} localStorage
+ */
+async function checkPackageLocal(name, localStorage) {
+  try {
+    const results = await localStorage.getPackageMetadataAsync(name);
+    if (results) {
+      throw _utils2.ErrorCode.getConflict(_constants.API_ERROR.PACKAGE_EXIST);
+    }
+  } catch (err) {
+    if (err.status === _constants.HTTP_STATUS.NOT_FOUND) {
+      return;
+    }
+    throw err;
+  }
+}
+function publishPackage(name, metadata, localStorage) {
+  return new Promise((resolve, reject) => {
+    localStorage.addPackage(name, metadata, (err, latest) => {
+      if (!_lodash.default.isNull(err)) {
+        return reject(err);
+      } else if (!_lodash.default.isUndefined(latest)) {
+        _searchIndexer.SearchMemoryIndexer.add(latest).catch(reason => {
+          debug('indexer has failed on add item %o', reason);
+          _logger.logger.error('indexer has failed on add item');
+        });
+      }
+      return resolve();
+    });
+  });
+}
+function checkPackageRemote(name, isAllowPublishOffline, syncMetadata) {
+  return new Promise((resolve, reject) => {
+    syncMetadata(name, null, {}, (err, packageJsonLocal, upLinksErrors) => {
+      // something weird
+      if (err && err.status !== _constants.HTTP_STATUS.NOT_FOUND) {
+        return reject(err);
+      }
+
+      // checking package exist already
+      if (_lodash.default.isNil(packageJsonLocal) === false) {
+        return reject(_utils2.ErrorCode.getConflict(_constants.API_ERROR.PACKAGE_EXIST));
+      }
+      for (let errorItem = 0; errorItem < upLinksErrors.length; errorItem++) {
+        // checking error
+        // if uplink fails with a status other than 404, we report failure
+        if (_lodash.default.isNil(upLinksErrors[errorItem][0]) === false) {
+          if (upLinksErrors[errorItem][0].status !== _constants.HTTP_STATUS.NOT_FOUND) {
+            if (isAllowPublishOffline) {
+              return resolve();
+            }
+            return reject(_utils2.ErrorCode.getServiceUnavailable(_constants.API_ERROR.UPLINK_OFFLINE_PUBLISH));
+          }
+        }
+      }
+      return resolve();
+    });
+  });
+}
+
+// tested on v6
+function mergeUplinkTimeIntoLocal(cacheManifest, remoteManifest) {
+  if ('time' in remoteManifest) {
+    // remote override cache time conflicts
+    return {
+      ...cacheManifest,
+      time: {
+        ...cacheManifest.time,
+        ...remoteManifest.time
+      }
+    };
+  }
+  return cacheManifest;
+}
+function prepareSearchPackage(data, time) {
+  const latest = _core.pkgUtils.getLatest(data);
+  if (latest && data.versions[latest]) {
+    const version = data.versions[latest];
+    const versions = {
+      [latest]: 'latest'
+    };
+    const pkg = {
+      name: version.name,
+      description: version.description,
+      [_constants.DIST_TAGS]: {
+        latest
+      },
+      maintainers: version.maintainers || [version.author].filter(Boolean),
+      author: version.author,
+      repository: version.repository,
+      readmeFilename: version.readmeFilename || '',
+      homepage: version.homepage,
+      keywords: version.keywords,
+      time: {
+        modified: time
+      },
+      bugs: version.bugs,
+      license: version.license,
+      versions
+    };
+    return pkg;
+  }
+}
+
+/**
+ * Check whether the package metadta has enough data to be published
+ * @param pkg metadata
+ */
+function isPublishablePackage(pkg) {
+  const keys = Object.keys(pkg);
+  return keys.includes('versions');
+}
+function hasInstallScript(version) {
+  if (version?.scripts) {
+    const scripts = Object.keys(version.scripts);
+    return scripts.find(item => {
+      return ['install', 'preinstall', 'postinstall'].includes(item);
+    }) !== undefined;
+  }
+  return false;
+}
+function convertAbbreviatedManifest(manifest) {
+  const abbreviatedVersions = Object.keys(manifest.versions).reduce((acc, version) => {
+    const _version = manifest.versions[version];
+    // This should be align with this document
+    // https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md#abbreviated-version-object
+    const _version_abbreviated = {
+      name: _version.name,
+      version: _version.version,
+      description: _version.description,
+      deprecated: _version.deprecated,
+      bin: _version.bin,
+      dist: _version.dist,
+      engines: _version.engines,
+      cpu: _version.cpu,
+      os: _version.os,
+      funding: _version.funding,
+      directories: _version.directories,
+      dependencies: _version.dependencies,
+      devDependencies: _version.devDependencies,
+      peerDependencies: _version.peerDependencies,
+      peerDependenciesMeta: _version.peerDependenciesMeta,
+      optionalDependencies: _version.optionalDependencies,
+      bundleDependencies: _version.bundleDependencies,
+      // npm cli specifics
+      _hasShrinkwrap: _version._hasShrinkwrap,
+      hasInstallScript: hasInstallScript(_version)
+    };
+    acc[version] = _version_abbreviated;
+    return acc;
+  }, {});
+  const convertedManifest = {
+    name: manifest['name'],
+    [_constants.DIST_TAGS]: manifest[_constants.DIST_TAGS],
+    versions: abbreviatedVersions,
+    // @ts-ignore
+    modified: manifest?.time?.modified,
+    // NOTE: special case for pnpm https://github.com/pnpm/rfcs/pull/2
+    time: manifest?.time
+  };
+
+  // @ts-ignore
+  return convertedManifest;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_lodash","_core","_searchIndexer","_utils","_constants","_logger","_utils2","e","__esModule","default","debug","createDebug","generatePackageTemplate","name","versions","time","USERS","DIST_TAGS","_uplinks","_distfiles","_attachments","_rev","normalizePackage","pkg","pkgProperties","forEach","key","pkgProp","_","isNil","isObject","isString","STORAGE","DEFAULT_REVISION","_id","normalizeDistTags","generateRevision","rev","split","generateRandomHexString","getLatestReadme","distTags","latestVersion","readme","trim","readmeDistTagsPriority","map","tag","version","cleanUpReadme","WHITELIST","exports","cleanUpLinksRef","keepUpLinkData","result","propertyToKeep","push","i","indexOf","checkPackageLocal","localStorage","results","getPackageMetadataAsync","ErrorCode","getConflict","API_ERROR","PACKAGE_EXIST","err","status","HTTP_STATUS","NOT_FOUND","publishPackage","metadata","Promise","resolve","reject","addPackage","latest","isNull","isUndefined","SearchMemoryIndexer","add","catch","reason","logger","error","checkPackageRemote","isAllowPublishOffline","syncMetadata","packageJsonLocal","upLinksErrors","errorItem","length","getServiceUnavailable","UPLINK_OFFLINE_PUBLISH","mergeUplinkTimeIntoLocal","cacheManifest","remoteManifest","prepareSearchPackage","data","pkgUtils","getLatest","description","maintainers","author","filter","Boolean","repository","readmeFilename","homepage","keywords","modified","bugs","license","isPublishablePackage","keys","Object","includes","hasInstallScript","scripts","find","item","undefined","convertAbbreviatedManifest","manifest","abbreviatedVersions","reduce","acc","_version","_version_abbreviated","deprecated","bin","dist","engines","cpu","os","funding","directories","dependencies","devDependencies","peerDependencies","peerDependenciesMeta","optionalDependencies","bundleDependencies","_hasShrinkwrap","convertedManifest"],"sources":["../../src/lib/storage-utils.ts"],"sourcesContent":["import createDebug from 'debug';\nimport _ from 'lodash';\n\nimport { pkgUtils } from '@verdaccio/core';\nimport { SearchMemoryIndexer } from '@verdaccio/search-indexer';\nimport { AbbreviatedManifest, AbbreviatedVersions, Manifest, Version } from '@verdaccio/types';\nimport { generateRandomHexString } from '@verdaccio/utils';\n\nimport { API_ERROR, DIST_TAGS, HTTP_STATUS, STORAGE, USERS } from './constants';\nimport LocalStorage from './local-storage';\nimport { logger } from './logger';\nimport { ErrorCode, isObject, normalizeDistTags } from './utils';\n\nconst debug = createDebug('verdaccio:storage-utils');\n\nexport function generatePackageTemplate(name: string): Manifest {\n  return {\n    // standard things\n    name,\n    versions: {},\n    time: {},\n    [USERS]: {},\n    [DIST_TAGS]: {},\n    _uplinks: {},\n    _distfiles: {},\n    _attachments: {},\n    _rev: '',\n  };\n}\n\n/**\n * Normalize package properties, tags, revision id.\n * @param {Object} pkg package reference.\n */\nexport function normalizePackage(pkg: Manifest): Manifest {\n  const pkgProperties = ['versions', 'dist-tags', '_distfiles', '_attachments', '_uplinks', 'time'];\n\n  pkgProperties.forEach((key): void => {\n    const pkgProp = pkg[key];\n\n    if (_.isNil(pkgProp) || isObject(pkgProp) === false) {\n      pkg[key] = {};\n    }\n  });\n\n  if (_.isString(pkg._rev) === false) {\n    pkg._rev = STORAGE.DEFAULT_REVISION;\n  }\n\n  if (_.isString(pkg._id) === false) {\n    pkg._id = pkg.name;\n  }\n\n  // normalize dist-tags\n  normalizeDistTags(pkg);\n\n  return pkg;\n}\n\nexport function generateRevision(rev: string): string {\n  const _rev = rev.split('-');\n\n  return (+_rev[0] || 0) + 1 + '-' + generateRandomHexString();\n}\n\nexport function getLatestReadme(pkg: Manifest): string {\n  const versions = pkg['versions'] || {};\n  const distTags = pkg[DIST_TAGS] || {};\n  // FIXME: here is a bit tricky add the types\n  const latestVersion: Version | any = distTags['latest'] ? versions[distTags['latest']] || {} : {};\n  let readme = _.trim(pkg.readme || latestVersion.readme || '');\n  if (readme) {\n    return readme;\n  }\n\n  // In case of empty readme - trying to get ANY readme in the following order: 'next','beta','alpha','test','dev','canary'\n  const readmeDistTagsPriority = ['next', 'beta', 'alpha', 'test', 'dev', 'canary'];\n  readmeDistTagsPriority.map(function (tag): string | void {\n    if (readme) {\n      return readme;\n    }\n    const version: Version | any = distTags[tag] ? versions[distTags[tag]] || {} : {};\n    readme = _.trim(version.readme || readme);\n  });\n  return readme;\n}\n\nexport function cleanUpReadme(version: Version): Version {\n  if (_.isNil(version) === false) {\n    // @ts-ignore\n    delete version.readme;\n  }\n\n  return version;\n}\n\nexport const WHITELIST = [\n  '_rev',\n  'name',\n  'versions',\n  'dist-tags',\n  'readme',\n  'time',\n  '_id',\n  'users',\n];\n\nexport function cleanUpLinksRef(keepUpLinkData: boolean, result: Manifest): Manifest {\n  const propertyToKeep = [...WHITELIST];\n  if (keepUpLinkData === true) {\n    propertyToKeep.push('_uplinks');\n  }\n\n  for (const i in result) {\n    if (propertyToKeep.indexOf(i) === -1) {\n      // Remove sections like '_uplinks' from response\n      delete result[i];\n    }\n  }\n\n  return result;\n}\n\n/**\n * Check whether a package it is already a local package\n * @param {*} name\n * @param {*} localStorage\n */\nexport async function checkPackageLocal(name: string, localStorage: LocalStorage): Promise<void> {\n  try {\n    const results = await localStorage.getPackageMetadataAsync(name);\n    if (results) {\n      throw ErrorCode.getConflict(API_ERROR.PACKAGE_EXIST);\n    }\n  } catch (err: any) {\n    if (err.status === HTTP_STATUS.NOT_FOUND) {\n      return;\n    }\n    throw err;\n  }\n}\n\nexport function publishPackage(\n  name: string,\n  metadata: any,\n  localStorage: LocalStorage\n): Promise<void> {\n  return new Promise((resolve, reject): void => {\n    localStorage.addPackage(name, metadata, (err, latest): void => {\n      if (!_.isNull(err)) {\n        return reject(err);\n      } else if (!_.isUndefined(latest)) {\n        SearchMemoryIndexer.add(latest).catch((reason) => {\n          debug('indexer has failed on add item %o', reason);\n          logger.error('indexer has failed on add item');\n        });\n      }\n      return resolve();\n    });\n  });\n}\n\nexport function checkPackageRemote(\n  name: string,\n  isAllowPublishOffline: boolean,\n  syncMetadata: any\n): Promise<void> {\n  return new Promise((resolve, reject): void => {\n    syncMetadata(name, null, {}, (err, packageJsonLocal, upLinksErrors): void => {\n      // something weird\n      if (err && err.status !== HTTP_STATUS.NOT_FOUND) {\n        return reject(err);\n      }\n\n      // checking package exist already\n      if (_.isNil(packageJsonLocal) === false) {\n        return reject(ErrorCode.getConflict(API_ERROR.PACKAGE_EXIST));\n      }\n\n      for (let errorItem = 0; errorItem < upLinksErrors.length; errorItem++) {\n        // checking error\n        // if uplink fails with a status other than 404, we report failure\n        if (_.isNil(upLinksErrors[errorItem][0]) === false) {\n          if (upLinksErrors[errorItem][0].status !== HTTP_STATUS.NOT_FOUND) {\n            if (isAllowPublishOffline) {\n              return resolve();\n            }\n\n            return reject(ErrorCode.getServiceUnavailable(API_ERROR.UPLINK_OFFLINE_PUBLISH));\n          }\n        }\n      }\n\n      return resolve();\n    });\n  });\n}\n\n// tested on v6\nexport function mergeUplinkTimeIntoLocal(cacheManifest: Manifest, remoteManifest: Manifest): any {\n  if ('time' in remoteManifest) {\n    // remote override cache time conflicts\n    return { ...cacheManifest, time: { ...cacheManifest.time, ...remoteManifest.time } };\n  }\n\n  return cacheManifest;\n}\n\nexport function prepareSearchPackage(data: Manifest, time: unknown): any {\n  const latest = pkgUtils.getLatest(data);\n\n  if (latest && data.versions[latest]) {\n    const version: Version = data.versions[latest];\n    const versions: any = { [latest]: 'latest' };\n    const pkg: any = {\n      name: version.name,\n      description: version.description,\n      [DIST_TAGS]: { latest },\n      maintainers: version.maintainers || [version.author].filter(Boolean),\n      author: version.author,\n      repository: version.repository,\n      readmeFilename: version.readmeFilename || '',\n      homepage: version.homepage,\n      keywords: version.keywords,\n      time: {\n        modified: time,\n      },\n      bugs: version.bugs,\n      license: version.license,\n      versions,\n    };\n\n    return pkg;\n  }\n}\n\n/**\n * Check whether the package metadta has enough data to be published\n * @param pkg metadata\n */\nexport function isPublishablePackage(pkg: Manifest): boolean {\n  const keys: string[] = Object.keys(pkg);\n\n  return keys.includes('versions');\n}\n\nexport function hasInstallScript(version: Version) {\n  if (version?.scripts) {\n    const scripts = Object.keys(version.scripts);\n    return (\n      scripts.find((item) => {\n        return ['install', 'preinstall', 'postinstall'].includes(item);\n      }) !== undefined\n    );\n  }\n  return false;\n}\n\nexport function convertAbbreviatedManifest(manifest: Manifest): AbbreviatedManifest {\n  const abbreviatedVersions = Object.keys(manifest.versions).reduce(\n    (acc: AbbreviatedVersions, version: string) => {\n      const _version = manifest.versions[version];\n      // This should be align with this document\n      // https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md#abbreviated-version-object\n      const _version_abbreviated = {\n        name: _version.name,\n        version: _version.version,\n        description: _version.description,\n        deprecated: _version.deprecated,\n        bin: _version.bin,\n        dist: _version.dist,\n        engines: _version.engines,\n        cpu: _version.cpu,\n        os: _version.os,\n        funding: _version.funding,\n        directories: _version.directories,\n        dependencies: _version.dependencies,\n        devDependencies: _version.devDependencies,\n        peerDependencies: _version.peerDependencies,\n        peerDependenciesMeta: _version.peerDependenciesMeta,\n        optionalDependencies: _version.optionalDependencies,\n        bundleDependencies: _version.bundleDependencies,\n        // npm cli specifics\n        _hasShrinkwrap: _version._hasShrinkwrap,\n        hasInstallScript: hasInstallScript(_version),\n      };\n      acc[version] = _version_abbreviated;\n      return acc;\n    },\n    {}\n  );\n\n  const convertedManifest = {\n    name: manifest['name'],\n    [DIST_TAGS]: manifest[DIST_TAGS],\n    versions: abbreviatedVersions,\n    // @ts-ignore\n    modified: manifest?.time?.modified,\n    // NOTE: special case for pnpm https://github.com/pnpm/rfcs/pull/2\n    time: manifest?.time,\n  };\n\n  // @ts-ignore\n  return convertedManifest;\n}\n"],"mappings":"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","ignoreList":[]}